How to handle incompatible concrete return types between an interface and types that implement it in golang?

I am still learning Go and I decided to use Domain Driven Design with interfaces. I want to support mysql, postgresql and sqlite by choosing the engine at run time depending on the execution environment. Since all the db actions are the same regardless of the engine, I decided to use sqlc to generate the db code.

Now I am having a bit of a problem, where I am trying to create an boundary interface Storer to sit between the consumers and engines and expose db actions to the consumers. It is not working because of incompatible return types that the Storer exposes and those that the engines return for each action (method).

Here is an example sqlite implementation of FindUserById action that is supposed to return a user object:

package sqlite

/* Begin sqlc generated code */
type User struct {
	ID        string
	FirstName string
	LastName  sql.NullString
	CreatedAt sql.NullTime
}

// findUserById is an sql statement
func (q *Queries) FindUserById(ctx context.Context, id string) (User, error) {
	row := q.db.QueryRowContext(ctx, findUserById, id)
	var i User
	err := row.Scan(
		&i.ID,
		&i.FirstName,
		&i.LastName,
		&i.CreatedAt,
	)
	return i, err
}

/* end sqlc generated code */

func (u *User) GetFirstName() string {
    return u.FirstName
}


func NewUserStorer() *Queries { ... }

and here is the storage package that has the UserStorer interface:

package storage
import "time.Time"

type User struct {
	ID        string
	FirstName string
	LastName  string
	CreatedAt time.Time
}
func (u *User) GetFirstName() string {
    return u.FirstName
}
type UserStorer interface {
    FindUserById(ctx context.Context, id string) (User, error)
}

Lastly, here is the main package with aUserStorer consumer:

package main

import "MyProject/storage"
import "MyProject/storage/sqlite"
import "fmt"

func ShowFirstName(s storage.UserStorer, id string) {
    u, _ := s.FindUserById(id) //assuming the user exists
    fmt.Println(u.GetFirstName())
}

func main(){
    store := sqlute.NewUserStorer()
    id := "abc123"
    ShowFirstName(store, id)
}

Now when I try to call ShowFirstName, I get this error:

cannot use store (variable of type *sqlite.Queries) as storage.UserStorer value in argument to ShowFirstName: *sqlite.Queries does not implement storage.UserStorer(wrong type for method FindUserById)
		have FindUserById(context.Context, string) (sqlite.User, error)
		want FindUserById(context.Context, sql.NullString) (storage.User, error)compilerInvalidIfaceAssign

I tried changing the storage.User type to be an interface with only the GetFirstName() method, but that did not work.
How do I ensure that the return types are the same, and I can swap out sqlite for psql without changing the consumers? I cannot change the code and files generated by sqlc to fit the type requirements, and I don't want to write the code it generates manually for maintainability reasons and to avoid sql related errors and bugs.

As mentioned in the comments, User type defined by sqlc in the sqlite package is not the same as the User type defined in the storage package. This is because sqlc generates its own User type with fields that match the columns in the database table, whereas the User type in the storage package has fields that match your domain model.

To solve this problem, we can define a separate User type in your application's domain model that maps to the User type generated by sqlc. You can then use this domain model User type in your UserStorer interface and in your application's code. Here, we are adapting one interface to another so that two incompatible interfaces can work together (Adapter Pattern).

package main

// Write imports here

// Define a domain model User type (storage pkg) that maps to the User type generated by sqlc
type User struct {
	ID        string
	FirstName string
	LastName  sql.NullString
	CreatedAt sql.NullTime
}

// Define a UserMapper interface that maps between sqlc User type and domain model User type
type UserMapper interface {
	FromDB(u *sqlite.User) *storage.User
	ToDB(u *storage.User) *sqlite.User
}

// Implement the UserMapper interface
type sqliteUserMapper struct{}

func (m *sqliteUserMapper) FromDB(u *sqlite.User) *storage.User {
	return &storage.User{
		ID:        u.ID,
		FirstName: u.FirstName,
		LastName:  u.LastName.String,
		CreatedAt: u.CreatedAt.Time,
	}
}
func (m *sqliteUserMapper) ToDB(u *storage.User) *sqlite.User {
	return &sqlite.User{
		ID:        u.ID,
		FirstName: u.FirstName,
		LastName:  sql.NullString{String: u.LastName, Valid: u.LastName != ""},
		CreatedAt: sql.NullTime{Time: u.CreatedAt, Valid: !u.CreatedAt.IsZero()},
	}
}

// Modify your UserStorer interface to use the domain model User type
type UserStorer interface {
	FindUserById(ctx context.Context, id string) (*User, error)
}

// Update your sqlite implementation of FindUserById to use the domain model User type and the UserMapper
func (q *Queries) FindUserById(ctx context.Context, id string) (*storage.User, error) {
	row := q.db.QueryRowContext(ctx, findUserById, id)
	var u sqlite.User
	err := row.Scan(&u.ID, &u.FirstName, &u.LastName, &u.CreatedAt)
	if err != nil {
		return nil, err
	}
	return q.mapper.FromDB(&u), nil
}

// Update your ShowFirstName function to use the domain model User type
func ShowFirstName(s storage.UserStorer, id string) {
	u, _ := s.FindUserById(context.Background(), id) //assuming the user exists
	fmt.Println(u.GetFirstName())
}

// Instantiate your sqlite UserStorer with a UserMapper
func NewUserStorer(mapper storage.UserMapper) *Queries {
	return &Queries{
		db:     db,
		mapper: mapper,
	}
}

func main() {
    // all functions in pkg main to understand the logical order of implementation
	mapper := &sqliteUserMapper{}
	store := sqlite.NewUserStorer(mapper)
	id := "abc123"
	ShowFirstName(store, id)
}