15319368397

Committed 29 May 2025 08:08AM UTC coverage: 36.849% (-0.1%) from 36.981%

Build # 15319368397

Build Type

push

github

Committed by

stephenafamo

Commit Message

Import libsql driver in sqlite test

Run Details

8035 of 21805 relevant lines covered (36.85%)

185.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/gen/bobgen-sql/driver/sql.go

package driver

import (
        "context"
        "database/sql"
        "fmt"
        "io/fs"
        "os"
        "path/filepath"

        embeddedpostgres "github.com/fergusstrange/embedded-postgres"
        "github.com/lib/pq"
        "github.com/stephenafamo/bob/gen"
        helpers "github.com/stephenafamo/bob/gen/bobgen-helpers"
        mysqlDriver "github.com/stephenafamo/bob/gen/bobgen-mysql/driver"
        psqlDriver "github.com/stephenafamo/bob/gen/bobgen-psql/driver"
        sqliteDriver "github.com/stephenafamo/bob/gen/bobgen-sqlite/driver"
        "github.com/stephenafamo/bob/gen/drivers"
        "github.com/testcontainers/testcontainers-go"
        mysqltest "github.com/testcontainers/testcontainers-go/modules/mysql"
)

type Config struct {
        // What dialect to generate with
        // psql | mysql | sqlite
        Dialect string
        // Glob pattern to match migration files
        Pattern string
        // Folders containing query files
        Queries []string `yaml:"queries"`
        // The database schemas to generate models for
        Schemas []string
        // The name of this schema will not be included in the generated models
        // a context value can then be used to set the schema at runtime
        // useful for multi-tenant setups
        SharedSchema string `yaml:"shared_schema"`
        // List of tables that will be included. Others are ignored
        Only map[string][]string
        // List of tables that will be should be ignored. Others are included
        Except map[string][]string
        // How many tables to fetch in parallel
        Concurrency int
        // Which UUID package to use (gofrs or google)
        UUIDPkg string `yaml:"uuid_pkg"`
        // Which `database/sql` driver to use (the full module name)
        DriverName string `yaml:"driver_name"`

        Output    string
        Pkgname   string
        NoFactory bool `yaml:"no_factory"`

        fs fs.FS
}

func RunPostgres(ctx context.Context, state *gen.State[any], config Config) error {
        d, err := getPsqlDriver(ctx, config)
        if err != nil {
                return fmt.Errorf("getting psql driver: %w", err)
        }

        return gen.Run(ctx, state, d)
}

func getPsqlDriver(ctx context.Context, config Config) (psqlDriver.Interface, error) {
        port, err := helpers.GetFreePort()
        if err != nil {
                return nil, fmt.Errorf("could not get a free port: %w", err)
        }

        dbConfig := embeddedpostgres.
                DefaultConfig().
                RuntimePath(filepath.Join(os.TempDir(), "bobgen_sql")).
                Port(uint32(port))
        dsn := dbConfig.GetConnectionURL() + "?sslmode=disable"

        postgres := embeddedpostgres.NewDatabase(dbConfig)
        if err := postgres.Start(); err != nil {
                return nil, fmt.Errorf("starting embedded postgres: %w", err)
        }
        defer func() {
                if err := postgres.Stop(); err != nil {
                        fmt.Println("Error stopping postgres:", err)
                }
        }()

        db, err := sql.Open("postgres", dsn)
        if err != nil {
                return nil, fmt.Errorf("failed to connect to database: %w", err)
        }
        defer db.Close()

        if err := helpers.Migrate(ctx, db, config.fs, config.Pattern); err != nil {
                return nil, fmt.Errorf("migrating: %w", err)
        }
        db.Close() // close early

        d := wrapDriver(ctx, psqlDriver.New(psqlDriver.Config{
                Config: helpers.Config{
                        Dsn:        dsn,
                        Queries:    config.Queries,
                        Only:       config.Only,
                        Except:     config.Except,
                        DriverName: config.DriverName,
                        Output:     config.Output,
                        Pkgname:    config.Pkgname,
                        NoFactory:  config.NoFactory,
                },
                Schemas:      pq.StringArray(config.Schemas),
                SharedSchema: config.SharedSchema,
                Concurrency:  config.Concurrency,
                UUIDPkg:      config.UUIDPkg,
        }))

        return d, nil
}

func RunMySQL(ctx context.Context, state *gen.State[any], config Config) error {
        d, err := getMySQLDriver(ctx, config)
        if err != nil {
                return fmt.Errorf("getting mysql driver: %w", err)
        }

        return gen.Run(ctx, state, d)
}

func getMySQLDriver(ctx context.Context, config Config) (mysqlDriver.Interface, error) {
        mysqlContainer, err := mysqltest.Run(ctx,
                "mysql:8.0.35",
                mysqltest.WithDatabase("bobgen"),
                mysqltest.WithUsername("root"),
                mysqltest.WithPassword("password"),
        )
        defer func() {
                if err := testcontainers.TerminateContainer(mysqlContainer); err != nil {
                        fmt.Printf("failed to terminate MySQL container: %v\n", err)
                }
        }()
        if err != nil {
                return nil, fmt.Errorf("failed to start container: %w", err)
        }

        dsn, err := mysqlContainer.ConnectionString(ctx, "tls=skip-verify", "multiStatements=true", "parseTime=true")
        if err != nil {
                return nil, fmt.Errorf("failed to get connection string: %w", err)
        }

        db, err := sql.Open("mysql", dsn)
        if err != nil {
                return nil, fmt.Errorf("failed to connect to database: %w", err)
        }
        defer db.Close()

        if err := helpers.Migrate(ctx, db, config.fs, config.Pattern); err != nil {
                return nil, fmt.Errorf("migrating: %w", err)
        }
        db.Close() // close early

        d := wrapDriver(ctx, mysqlDriver.New(mysqlDriver.Config{
                Config: helpers.Config{
                        Dsn:       dsn,
                        Queries:   config.Queries,
                        Only:      config.Only,
                        Except:    config.Except,
                        Output:    config.Output,
                        Pkgname:   config.Pkgname,
                        NoFactory: config.NoFactory,
                },
                Concurrency: config.Concurrency,
        }))

        return d, nil
}

func RunSQLite(ctx context.Context, state *gen.State[any], config Config) error {
        d, err := getSQLiteDriver(ctx, config)
        if err != nil {
                return fmt.Errorf("getting sqlite driver: %w", err)
        }

        return gen.Run(ctx, state, d)
}

func getSQLiteDriver(ctx context.Context, config Config) (sqliteDriver.Interface, error) {
        tmp, err := os.CreateTemp("", "bobgen_sqlite")
        if err != nil {
                return nil, fmt.Errorf("creating temp file: %w", err)
        }
        defer tmp.Close()

        db, err := sql.Open("sqlite", tmp.Name())
        if err != nil {
                return nil, fmt.Errorf("failed to connect to database: %w", err)
        }
        defer db.Close()

        attach := make(map[string]string)
        for _, schema := range config.Schemas {
                tmp, err := os.CreateTemp("", "bobgen_sqlite_"+schema)
                if err != nil {
                        return nil, fmt.Errorf("creating temp file: %w", err)
                }
                defer tmp.Close()

                attach[schema] = tmp.Name()
                _, err = db.ExecContext(ctx, fmt.Sprintf(
                        "attach database '%s' as %s", tmp.Name(), schema,
                ))
                if err != nil {
                        return nil, fmt.Errorf("could not attach %q: %w", schema, err)
                }
        }

        if err := helpers.Migrate(ctx, db, config.fs, config.Pattern); err != nil {
                return nil, fmt.Errorf("migrating: %w", err)
        }
        db.Close() // close early

        d := sqliteDriver.New(sqliteDriver.Config{
                Config: helpers.Config{
                        Dsn:        tmp.Name(),
                        Queries:    config.Queries,
                        DriverName: config.DriverName,
                        Only:       config.Only,
                        Except:     config.Except,
                        Output:     config.Output,
                        Pkgname:    config.Pkgname,
                        NoFactory:  config.NoFactory,
                },
                Attach:       attach,
                SharedSchema: config.SharedSchema,
        })

        return d, nil
}

func wrapDriver[T, C, I any](ctx context.Context, d drivers.Interface[T, C, I]) driver[T, C, I] {
        info, err := d.Assemble(ctx)
        return driver[T, C, I]{d, info, err}
}

type driver[T, C, I any] struct {
        drivers.Interface[T, C, I]
        info *drivers.DBInfo[T, C, I]
        err  error
}

func (d driver[T, C, I]) Assemble(context.Context) (*drivers.DBInfo[T, C, I], error) {
        return d.info, d.err
}

1	package driver
2
3	import (
4	"context"
5	"database/sql"
6	"fmt"
7	"io/fs"
8	"os"
9	"path/filepath"
10
11	embeddedpostgres "github.com/fergusstrange/embedded-postgres"
12	"github.com/lib/pq"
13	"github.com/stephenafamo/bob/gen"
14	helpers "github.com/stephenafamo/bob/gen/bobgen-helpers"
15	mysqlDriver "github.com/stephenafamo/bob/gen/bobgen-mysql/driver"
16	psqlDriver "github.com/stephenafamo/bob/gen/bobgen-psql/driver"
17	sqliteDriver "github.com/stephenafamo/bob/gen/bobgen-sqlite/driver"
18	"github.com/stephenafamo/bob/gen/drivers"
19	"github.com/testcontainers/testcontainers-go"
20	mysqltest "github.com/testcontainers/testcontainers-go/modules/mysql"
21	)
22
23	type Config struct {
24	// What dialect to generate with
25	// psql \| mysql \| sqlite
26	Dialect string
27	// Glob pattern to match migration files
28	Pattern string
29	// Folders containing query files
30	Queries []string `yaml:"queries"`
31	// The database schemas to generate models for
32	Schemas []string
33	// The name of this schema will not be included in the generated models
34	// a context value can then be used to set the schema at runtime
35	// useful for multi-tenant setups
36	SharedSchema string `yaml:"shared_schema"`
37	// List of tables that will be included. Others are ignored
38	Only map[string][]string
39	// List of tables that will be should be ignored. Others are included
40	Except map[string][]string
41	// How many tables to fetch in parallel
42	Concurrency int
43	// Which UUID package to use (gofrs or google)
44	UUIDPkg string `yaml:"uuid_pkg"`
45	// Which `database/sql` driver to use (the full module name)
46	DriverName string `yaml:"driver_name"`
47
48	Output string
49	Pkgname string
50	NoFactory bool `yaml:"no_factory"`
51
52	fs fs.FS
53	}
54
55	func RunPostgres(ctx context.Context, state *gen.State[any], config Config) error {	×
56	d, err := getPsqlDriver(ctx, config)	×
57	if err != nil {	×
58	return fmt.Errorf("getting psql driver: %w", err)	×
59	}	×
60
61	return gen.Run(ctx, state, d)	×
62	}
63
64	func getPsqlDriver(ctx context.Context, config Config) (psqlDriver.Interface, error) {	×
65	port, err := helpers.GetFreePort()	×
66	if err != nil {	×
67	return nil, fmt.Errorf("could not get a free port: %w", err)	×
68	}	×
69
70	dbConfig := embeddedpostgres.	×
71	DefaultConfig().	×
72	RuntimePath(filepath.Join(os.TempDir(), "bobgen_sql")).	×
73	Port(uint32(port))	×
74	dsn := dbConfig.GetConnectionURL() + "?sslmode=disable"	×
75		×
76	postgres := embeddedpostgres.NewDatabase(dbConfig)	×
77	if err := postgres.Start(); err != nil {	×
78	return nil, fmt.Errorf("starting embedded postgres: %w", err)	×
79	}	×
80	defer func() {	×
81	if err := postgres.Stop(); err != nil {	×
82	fmt.Println("Error stopping postgres:", err)	×
83	}	×
84	}()
85
86	db, err := sql.Open("postgres", dsn)	×
87	if err != nil {	×
88	return nil, fmt.Errorf("failed to connect to database: %w", err)	×
89	}	×
90	defer db.Close()	×
91		×
92	if err := helpers.Migrate(ctx, db, config.fs, config.Pattern); err != nil {	×
93	return nil, fmt.Errorf("migrating: %w", err)	×
94	}	×
95	db.Close() // close early	×
96		×
97	d := wrapDriver(ctx, psqlDriver.New(psqlDriver.Config{	×
98	Config: helpers.Config{	×
99	Dsn: dsn,	×
100	Queries: config.Queries,	×
101	Only: config.Only,	×
102	Except: config.Except,	×
103	DriverName: config.DriverName,	×
104	Output: config.Output,	×
105	Pkgname: config.Pkgname,	×
106	NoFactory: config.NoFactory,	×
107	},	×
108	Schemas: pq.StringArray(config.Schemas),	×
109	SharedSchema: config.SharedSchema,	×
110	Concurrency: config.Concurrency,	×
111	UUIDPkg: config.UUIDPkg,	×
112	}))	×
113		×
114	return d, nil	×
115	}
116
117	func RunMySQL(ctx context.Context, state *gen.State[any], config Config) error {	×
118	d, err := getMySQLDriver(ctx, config)	×
119	if err != nil {	×
120	return fmt.Errorf("getting mysql driver: %w", err)	×
121	}	×
122
123	return gen.Run(ctx, state, d)	×
124	}
125
126	func getMySQLDriver(ctx context.Context, config Config) (mysqlDriver.Interface, error) {	×
127	mysqlContainer, err := mysqltest.Run(ctx,	×
128	"mysql:8.0.35",	×
129	mysqltest.WithDatabase("bobgen"),	×
130	mysqltest.WithUsername("root"),	×
131	mysqltest.WithPassword("password"),	×
132	)	×
133	defer func() {	×
134	if err := testcontainers.TerminateContainer(mysqlContainer); err != nil {	×
135	fmt.Printf("failed to terminate MySQL container: %v\n", err)	×
136	}	×
137	}()
138	if err != nil {	×
139	return nil, fmt.Errorf("failed to start container: %w", err)	×
140	}	×
141
142	dsn, err := mysqlContainer.ConnectionString(ctx, "tls=skip-verify", "multiStatements=true", "parseTime=true")	×
143	if err != nil {	×
144	return nil, fmt.Errorf("failed to get connection string: %w", err)	×
145	}	×
146
147	db, err := sql.Open("mysql", dsn)	×
148	if err != nil {	×
149	return nil, fmt.Errorf("failed to connect to database: %w", err)	×
150	}	×
151	defer db.Close()	×
152		×
153	if err := helpers.Migrate(ctx, db, config.fs, config.Pattern); err != nil {	×
154	return nil, fmt.Errorf("migrating: %w", err)	×
155	}	×
156	db.Close() // close early	×
157		×
158	d := wrapDriver(ctx, mysqlDriver.New(mysqlDriver.Config{	×
159	Config: helpers.Config{	×
160	Dsn: dsn,	×
161	Queries: config.Queries,	×
162	Only: config.Only,	×
163	Except: config.Except,	×
164	Output: config.Output,	×
165	Pkgname: config.Pkgname,	×
166	NoFactory: config.NoFactory,	×
167	},	×
168	Concurrency: config.Concurrency,	×
169	}))	×
170		×
171	return d, nil	×
172	}
173
174	func RunSQLite(ctx context.Context, state *gen.State[any], config Config) error {	×
175	d, err := getSQLiteDriver(ctx, config)	×
176	if err != nil {	×
177	return fmt.Errorf("getting sqlite driver: %w", err)	×
178	}	×
179
180	return gen.Run(ctx, state, d)	×
181	}
182
183	func getSQLiteDriver(ctx context.Context, config Config) (sqliteDriver.Interface, error) {	×
184	tmp, err := os.CreateTemp("", "bobgen_sqlite")	×
185	if err != nil {	×
186	return nil, fmt.Errorf("creating temp file: %w", err)	×
187	}	×
188	defer tmp.Close()	×
189		×
190	db, err := sql.Open("sqlite", tmp.Name())	×
191	if err != nil {	×
192	return nil, fmt.Errorf("failed to connect to database: %w", err)	×
193	}	×
194	defer db.Close()	×
195		×
196	attach := make(map[string]string)	×
197	for _, schema := range config.Schemas {	×
198	tmp, err := os.CreateTemp("", "bobgen_sqlite_"+schema)	×
199	if err != nil {	×
200	return nil, fmt.Errorf("creating temp file: %w", err)	×
201	}	×
202	defer tmp.Close()	×
203		×
204	attach[schema] = tmp.Name()	×
205	_, err = db.ExecContext(ctx, fmt.Sprintf(	×
206	"attach database '%s' as %s", tmp.Name(), schema,	×
207	))	×
208	if err != nil {	×
209	return nil, fmt.Errorf("could not attach %q: %w", schema, err)	×
210	}	×
211	}
212
213	if err := helpers.Migrate(ctx, db, config.fs, config.Pattern); err != nil {	×
214	return nil, fmt.Errorf("migrating: %w", err)	×
215	}	×
216	db.Close() // close early	×
217		×
218	d := sqliteDriver.New(sqliteDriver.Config{	×
219	Config: helpers.Config{	×
220	Dsn: tmp.Name(),	×
221	Queries: config.Queries,	×
222	DriverName: config.DriverName,	×
223	Only: config.Only,	×
224	Except: config.Except,	×
225	Output: config.Output,	×
226	Pkgname: config.Pkgname,	×
227	NoFactory: config.NoFactory,	×
228	},	×
229	Attach: attach,	×
230	SharedSchema: config.SharedSchema,	×
231	})	×
232		×
233	return d, nil	×
234	}
235
236	func wrapDriver[T, C, I any](ctx context.Context, d drivers.Interface[T, C, I]) driver[T, C, I] {	×
237	info, err := d.Assemble(ctx)	×
238	return driver[T, C, I]{d, info, err}	×
239	}	×
240
241	type driver[T, C, I any] struct {
242	drivers.Interface[T, C, I]
243	info *drivers.DBInfo[T, C, I]
244	err error
245	}
246
247	func (d driver[T, C, I]) Assemble(context.Context) (*drivers.DBInfo[T, C, I], error) {	×
248	return d.info, d.err	×
249	}	×

stephenafamo / bob / 15319368397

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous