What is convertValues in generated models.ts?

[SuspiciousLookingOwl]

I have a simple Go method that's being exposed to the frontend, it looks like this:

type Nested struct {
	Id int `json:"id"`
}

type Args struct {
	Name   string `json:"name"`
	Nested Nested `json:"nested"`
}

func (a *App) Example(args Args) {
   // ...
}

The generated typescript code on models.ts and App.d.ts looks like this

// App.d.ts
export function Example(arg1: main.Args): void;

// models.ts
export namespace main {
	export class Nested {
		id: number;

		static createFrom(source: any = {}) {
			return new Nested(source);
		}

		constructor(source: any = {}) {
		        // ...
		}
	}
	export class Args {
		name: string;
		// Go type: Nested
		nested: any;

		static createFrom(source: any = {}) {
			return new Args(source);
		}

		constructor(source: any = {}) {
		        // ..
		}

		convertValues(a: any, classs: any, asMap = false): any {
			// ...
		}
	}
}

My questions are:

1. What is convertValues on main.Nested? When I'm trying to call Example method from the frontend, it requires me to pass convertValues as the args

import {Example} from "path/to/wailsjs/go/main/App";

Example({
    name: "...",
    nested: { id: 1 }
    // convertValues is required to be passed here since it's part of the `main.Args` properties
});

forcing me to create a new Args instance instead like this:

import {Example} from "path/to/wailsjs/go/main/App";
import {main} from "path/to/wailsjs/go/models";

Example(new main.Args({
    name: "...",
    nested: { id: 1 }
}));

but then I lost typing feature because main.Args's constructor parameter is any.

2. Why is nested property in Args is any instead of main.Nested?

[leaanthony]

You absolutely do not need to use convertValues. It's a method used internally when passing an object to the constructor. I just use new Classname() and have never needed to call convertValues.

[SuspiciousLookingOwl]

I can do that but I lost any typing feature because the constructor type of the class is any

export class Args {
		name: string;
		// Go type: Nested
		nested: any;

                // source type is any
		constructor(source: any = {}) {
		        // ..
		}

		convertValues(a: any, classs: any, asMap = false): any {
			// ...
		}
	}

[leaanthony]

If you set the members directly then you will still have typing.

[SuspiciousLookingOwl]

You mean like this?

const args = new main.Args();
args.name = "...";
args.nested = new main.Nested();
args.nested.id = 1;

Example(args);

That should work, but I wish there are cleaner ways to do it (with typing support), like

Example(main.Args.createFrom({ 
    name: "...",
    nested: { id: 1 }
}))

or

Example({
    name: "...",
    nested: { id: 1 }
})

I ended up creating my own mapper for cleaner code

type RawArgs<T> = Omit<T, "convertValues">;

const example = (args: RawArgs<main.Args>) => Example(main.Args.createFrom(args));

so I can call it like this

example({
    name: "...",
    nested: { id: 1 }
})

I have one more unanswered question, is there any reason why Args.nested type is any instead of main.Nested?

[leaanthony]

The library we used for this decided that you can pass nothing, a string, an array or an object into the constructor to build the object. Now, I'm not a TS guru, but could we simply have something like this for the constructor? Something like source: [Args = {}|any]

Do you have any suggestions?

Regarding the any type instead of Args.nested, you normally get that for structs with no exported fields or no json tags. If you have both then I suggest you raise a bug.

[SuspiciousLookingOwl]

You can do

constructor(source: Args | any = {}) {
    // ..
}

but this won't solve the issue because typescript sees Args as on object that needs to have 3 keys:

type Args = {
    name: string;
    nested: Nested;
    convertValues: (a: any, classs: any, asMap = false) => any; // 
}

While Args struct actually only have 2 keys (name and nested).

I don't know if this is possible / easy to do from Go side, but to my knowledge, the ideal solution will be:

1. Create a separate interface that only contains the typing of the represented Go's struct
2. Use that interface for createFrom and constructor parameter's type

for example, if the Go's code looks like this:

type Nested struct {
	Id int `json:"id"`
}

type Args struct {
	Name   string `json:"name"`
	Nested Nested `json:"nested"`
}

func (a *App) Example(args Args) {
   // ...
}

the generated typescript code will look like this:

// App.d.ts
function Example(arg1: main.Args): void;

// models.ts
export namespace main {
  export interface NestedProps { // converted type from Nested struct in Go
    id: number;
  }
  export class Nested {
    id: number;

    static createFrom(source: NestedProps) {
      return new Nested(source);
    }

    constructor(source: NestedProps | string) {
      if (typeof source === "string") source = JSON.parse(source) as NestedProps;

      this.id = source["id"];
    }
  }

  export interface ArgsProps { // converted type from Args struct in Go
    name: string;
    nested: NestedProps;
  }
  export class Args {
    name: string;
    // Go type: Nested
    nested: Nested;

    static createFrom(source: ArgsProps) {
      return new Args(source);
    }

    constructor(source: ArgsProps | string) {
      if (typeof source === "string") source = JSON.parse(source) as ArgsProps;

      this.name = source["name"];
      this.nested = this.convertValues(source["nested"], Nested);
    }

    convertValues(a: any, classs: any, asMap = false): any {
      // ...
    }
  }
}

// usage
Example(main.Args.createFrom({
  name: "foo",
  nested: {
    id: 1,
  },
}));