How to ignore certain methods in bindings?

[fairking]

I have api services which look like this:

type BooksApiService struct {
	ctx context.Context
	srv *di_plus.ServiceProvider
}

func (a *BooksApiService) Init(ctx context.Context, srv *di_plus.ServiceProvider) {
	a.ctx = ctx
	a.srv = srv
}

func (a *BooksApiService) Get(id string) (*mods.BookItem, error) {
}

func (a *BooksApiService) Set(book *mods.BookResult) (string, error) {
}

func (a *BooksApiService) Delete(id string) (bool, error) {
}

And then I pass my services as bindings main.go:

	// Create an instance of the app structure
	app := NewApp([]interface{}{
		&services.BookApiService{},
		&services.StudentApiService{},
		&services.WorkerApiService{},
	})

	// Create application with options
	err := wails.Run(&options.App{
                ...
		OnStartup:        app.startup,
		Bind:             app.bindings,
	})

The question is how can I prevent from binding/generating Init() method in typescript?

[leaanthony]

You could use a NewBooksApiService(ctx context.Context, srv *di_plus.ServiceProvider) *BooksApiService method rather than Init.

[leaanthony]

One option:

func InitBooksApiService(a *BooksApiService, ctx context.Context, srv *di_plus.ServiceProvider) {
	a.ctx = ctx
	a.srv = srv
}

This is more a Go / how to structure an app question. If you really want to do this then just remove the bindings from the generated file. They're only helpers at the end of the day.

[fairking]

Tricky one.

1. BooksApiService comes from the separate package, so its fields ctx and srv are private. It is also used in various other apps including web ones.
2. I use IApiService which contains Init, so with your solution it won't be possible.

Never mind, I was thinking that there is some trick which allows to ignore someof the methods. That was my primary question.

Thanks @leaanthony

[leaanthony]

Just remove them from the bindings 😅

[fairking]

I just ignore them. So far the typescript does not complain about such Init methods.

[leaanthony]

Thanks for raising this though. We can think about this scenario for v3's static analysis approach.

Perhaps we could have a BindAndIgnore field that accepts structs and a list of methods to ignore on them:

// ...
Bind: []any,
BindAndIgnore: []struct{ 
   Bind: any, 
   Ignore: []string,
},

[KiddoV]

I would like to be able to do this too. Sometimes, I need to ignore certain methods, such as the initialize method of the struct.

[leaanthony]

How would you see this working?

[KiddoV]

NVM, I did not read your response and @fairking's code clearly. Sorry! 😁
You were right, we should do something like this so the Init method will not be exposed in the frontend:

func Init(ctx context.Context, srv *di_plus.ServiceProvider) (*BooksApiService) {}
//Instead of
func (a *BooksApiService) Init(ctx context.Context, srv *di_plus.ServiceProvider)