Merge pull request 'dev-centralize' (#1) from dev-centralize into main

Reviewed-on: #1

application/application.go

@@ -7,8 +7,9 @@ import (
 	"log/slog"
 	"os/signal"
 
-	"git.flexabyte.io/flexabyte/go-slogd/slogd"
 	"github.com/spf13/cobra"
+
+	"git.flexabyte.io/flexabyte/go-kit/slogd"
 )
 
 type Application interface {
@@ -42,41 +43,21 @@ func (a *application) ExecuteContext(ctx context.Context) error {
 	// Result channel for command output
 	chExe := make(chan error)
 
-	// Run the application command
+	// Run the application command using the signal context and output channel
 	a.config.Logger.LogAttrs(ctx, slogd.LevelTrace, "executing application context")
 	go func(ctx context.Context, chErr chan error) {
 		chErr <- a.cmd.ExecuteContext(ctx)
 	}(sigCtx, chExe)
 
 	// Wait for command output or a shutdown signal
-	var err error
 	select {
-	// sigCtx.Done() returns a channel that will have a message when the context is canceled.
-	// Alternatively, chExe will receive the response from the execution context if the application finishes.
-	case <-sigCtx.Done():
+	case <-sigCtx.Done(): // sigCtx.Done() returns a channel that will have a message when the context is canceled.
 		sigCancel()
-
-		// Adapt the shutdown scenario if a graceful shutdown period is configured
-		switch a.config.EnableGracefulShutdown && a.config.ShutdownTimeout > 0 {
-		case true:
-			a.config.Logger.LogAttrs(ctx, slogd.LevelTrace, "gracefully shutting down application")
-			if err = a.gracefulShutdown(ctx); !errors.Is(err, context.DeadlineExceeded) {
-				a.config.Logger.LogAttrs(ctx, slogd.LevelTrace, "graceful shutdown completed with error", slog.Any("error", err))
-				return err
-			}
-			a.config.Logger.LogAttrs(ctx, slogd.LevelTrace, "graceful shutdown completed")
-			return nil
-		case false:
-			a.config.Logger.LogAttrs(ctx, slogd.LevelTrace, "immediately shutting down application")
-			return nil
-		}
-	case err = <-chExe:
+		return a.handleShutdownSignal(ctx)
+	case err := <-chExe: // Alternatively, chExe will receive the response from the execution context if the application finishes.
 		a.config.Logger.LogAttrs(ctx, slogd.LevelTrace, "application terminated successfully")
 		return err
 	}
-
-	a.config.Logger.LogAttrs(ctx, slogd.LevelTrace, "application terminated unexpectedly")
-	return nil
 }
 
 func (a *application) gracefulShutdown(ctx context.Context) error {
@@ -90,10 +71,37 @@ func (a *application) gracefulShutdown(ctx context.Context) error {
 	defer sigCancel() // Ensure that this gets called.
 
 	select {
-	case <-shutdownCtx.Done():
+	case <-shutdownCtx.Done(): // Timeout exceeded
 		return shutdownCtx.Err()
-	case <-sigCtx.Done():
+	case <-sigCtx.Done(): // Received additional shutdown signal to forcefully exit
+		fmt.Println("exiting...")
 		sigCancel()
-		return nil
+		return fmt.Errorf("process killed")
+	}
+}
+
+func (a *application) handleGracefulShutdown(ctx context.Context) error {
+	a.config.Logger.LogAttrs(ctx, slogd.LevelTrace, "gracefully shutting down application")
+
+	var err error
+	if err = a.gracefulShutdown(ctx); !errors.Is(err, context.DeadlineExceeded) {
+		a.config.Logger.LogAttrs(ctx, slogd.LevelWarn, "graceful shutdown failed", slog.Any("error", err))
+		return nil
+	}
+
+	a.config.Logger.LogAttrs(ctx, slogd.LevelTrace, "graceful shutdown completed")
+	return nil
+}
+
+func (a *application) handleShutdownSignal(ctx context.Context) error {
+	// Adapt the shutdown scenario if a graceful shutdown period is configured
+	switch a.config.EnableGracefulShutdown && a.config.ShutdownTimeout > 0 {
+	case true:
+		return a.handleGracefulShutdown(ctx)
+	case false:
+		a.config.Logger.LogAttrs(ctx, slogd.LevelTrace, "immediately shutting down application")
+		return nil
+	default:
+		panic("cannot handle shutdown signal")
 	}
 }

application/commander.go

@@ -12,7 +12,7 @@ type Command struct {
 	Configure   func(c *cobra.Command)
 }
 
-func (c Command) Initialize(f func(c *cobra.Command)) *cobra.Command {
+func (c Command) Initialize(f func(cmd *cobra.Command)) *cobra.Command {
 	if f != nil {
 		f(c.Command)
 	}

application/config.go

@@ -24,7 +24,7 @@ type Config struct {
 	PersistentPostRunE       []func(cmd *cobra.Command, args []string) error // collection of PostRunE functions
 	ShutdownSignals          []os.Signal
 	ShutdownTimeout          time.Duration
-	SubCommands              []Command
+	SubCommands              []Commander
 	SubCommandInitializeFunc func(cmd *cobra.Command)
 	ValidArgs                []string
 }
@@ -48,7 +48,7 @@ func (c Config) getRootCommand() (*cobra.Command, error) {
 		Long:               long,
 		PersistentPreRunE:  persistentPreRunFuncE,
 		PersistentPostRunE: persistentPostRunFuncE,
-		RunE:               runFuncE,
+		RunE:               RunCatchFuncE,
 		SilenceErrors:      true,
 		SilenceUsage:       true,
 	}
@@ -69,9 +69,9 @@ func (c Config) getRootCommand() (*cobra.Command, error) {
 	return cmd, nil
 }
 
-func (c Config) ParseVersion() (semver.Version, error) {
-	return semver.Parse(c.Version.Full)
-}
+// func (c Config) ParseVersion() (semver.Version, error) {
+// 	return semver.Parse(c.Version.Full)
+// }
 
 func (c Config) RegisterCommand(cmd Commander, f func(*cobra.Command)) {
 	appCmd.AddCommand(cmd.Initialize(f))
@@ -99,6 +99,10 @@ func (c Config) Validate() error {
 		return errors.New("title is required")
 	}
 
+	if c.Logger == nil {
+		return errors.New("logger is required")
+	}
+
 	var err error
 	if _, err = semver.Parse(c.Version.Full); err != nil {
 		return fmt.Errorf("invalid version: %s", c.Version)

application/globals.go

@@ -1,6 +1,7 @@
 package application
 
 import (
+	"fmt"
 	"io"
 	"log/slog"
 	"os"
@@ -11,7 +12,7 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 
-	"git.flexabyte.io/flexabyte/go-slogd/slogd"
+	"git.flexabyte.io/flexabyte/go-kit/slogd"
 )
 
 var DefaultShutdownSignals = []os.Signal{syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP, syscall.SIGQUIT}
@@ -22,25 +23,23 @@ var (
 	persistentPreRunE  []func(cmd *cobra.Command, args []string) error // collection of PreRunE functions
 	persistentPostRunE []func(cmd *cobra.Command, args []string) error // collection of PostRunE functions
 	outWriter          io.Writer                                       = os.Stdout
-	// version            semver.Version
 )
 
-func helpFuncE(cmd *cobra.Command, args []string) error {
+func SubCommandInitializePrintNameFunc(cmd *cobra.Command) {
+	fmt.Println("Initializing:", cmd.Name())
+}
+
+func HelpFuncE(cmd *cobra.Command, args []string) error {
 	return cmd.Help()
 }
 
 func normalizeFunc(f *pflag.FlagSet, name string) pflag.NormalizedName {
-	// switch name {
-	// case "no-color":
-	// 	name = "log-type"
-	// 	break
-	// }
 	return pflag.NormalizedName(name)
 }
 
 func persistentPreRunFuncE(cmd *cobra.Command, args []string) error {
 	slogd.SetLevel(slogd.Level(logLevelFlag))
-	// if slogd.ActiveHandler() == slogd_colored.HandlerColor && noColorFlag {
+
 	if slogd.ActiveHandler() != slogd.HandlerJSON && noColorFlag {
 		slogd.UseHandler(slogd.HandlerText)
 		cmd.SetContext(slogd.WithContext(cmd.Context()))
@@ -57,10 +56,10 @@ func persistentPreRunFuncE(cmd *cobra.Command, args []string) error {
 	}
 
 	// Make sure that we show the app help if no commands or flags are passed
-	if cmd.CalledAs() == appName && runtime.FuncForPC(reflect.ValueOf(cmd.RunE).Pointer()).Name() == runtime.FuncForPC(reflect.ValueOf(runFuncE).Pointer()).Name() {
-		slogd.FromContext(cmd.Context()).LogAttrs(cmd.Context(), slogd.LevelTrace, "overriding command", slog.String("old_function", runtime.FuncForPC(reflect.ValueOf(cmd.RunE).Pointer()).Name()), slog.String("new_function", runtime.FuncForPC(reflect.ValueOf(helpFuncE).Pointer()).Name()))
+	if cmd.CalledAs() == appName && runtime.FuncForPC(reflect.ValueOf(cmd.RunE).Pointer()).Name() == runtime.FuncForPC(reflect.ValueOf(RunCatchFuncE).Pointer()).Name() {
+		slogd.FromContext(cmd.Context()).LogAttrs(cmd.Context(), slogd.LevelTrace, "overriding command", slog.String("old_function", runtime.FuncForPC(reflect.ValueOf(cmd.RunE).Pointer()).Name()), slog.String("new_function", runtime.FuncForPC(reflect.ValueOf(HelpFuncE).Pointer()).Name()))
 
-		cmd.RunE = helpFuncE
+		cmd.RunE = HelpFuncE
 		return nil
 	}
 
@@ -102,7 +101,7 @@ func persistentPostRunFuncE(cmd *cobra.Command, args []string) error {
 	return nil
 }
 
-// appRunE is an empty catch function to allow overrides through persistentPreRunE
-func runFuncE(cmd *cobra.Command, args []string) error {
+// RunCatchFuncE is an empty catch function to allow overrides through persistentPreRunE
+func RunCatchFuncE(cmd *cobra.Command, args []string) error {
 	return nil
 }

application/logging.go

@@ -3,8 +3,9 @@ package application
 import (
 	"log/slog"
 
-	"git.flexabyte.io/flexabyte/go-slogd/slogd"
 	"github.com/spf13/cobra"
+
+	"git.flexabyte.io/flexabyte/go-kit/slogd"
 )
 
 const (

application/version.go

@@ -5,8 +5,6 @@ import (
 	"fmt"
 
 	"github.com/spf13/cobra"
-
-	"git.flexabyte.io/flexabyte/go-kit/semver"
 )
 
 const (
@@ -48,10 +46,10 @@ func configureVersionFlag(cmd *cobra.Command, v Version) {
 	addVersionFlag(cmd)
 }
 
-func printVersion(v semver.Version) string {
+func printVersion(v Version) string {
 	var output string
 	if !verboseFlag {
-		output = v.String()
+		output = v.Full
 	}
 
 	if jsonOutputFlag {
@@ -65,27 +63,20 @@ func printVersion(v semver.Version) string {
 	}
 	return fmt.Sprintf(
 		"Full: %s\nBranch: %s\nTag: %s\nCommit: %s\nCommit date: %s\nBuild date: %s\nMajor: %s\nMinor: %s\nPatch: %s\nPreRelease: %s\n",
-		version.Full,
-		version.Branch,
-		version.Tag,
-		version.Commit,
-		version.CommitDate,
-		version.BuildDate,
-		version.Major,
-		version.Minor,
-		version.Patch,
-		version.PreRelease,
+		v.Full,
+		v.Branch,
+		v.Tag,
+		v.Commit,
+		v.CommitDate,
+		v.BuildDate,
+		v.Major,
+		v.Minor,
+		v.Patch,
+		v.PreRelease,
 	)
 }
 
 func versionRunFuncE(cmd *cobra.Command, args []string) error {
-	var v semver.Version
-	var err error
-	if v, err = semver.Parse(version.Full); err != nil {
-		return err
-	}
-	if _, err = fmt.Fprintln(outWriter, printVersion(v)); err != nil {
-		return err
-	}
-	return nil
+	_, err := fmt.Fprintln(outWriter, printVersion(version))
+	return err
 }

examples/application/simple/main.go

@@ -5,14 +5,13 @@ import (
 	"log/slog"
 	"net/http"
 	"os"
-	"syscall"
 	"time"
 
-	"git.flexabyte.io/flexabyte/go-slogd/slogd"
 	"github.com/spf13/cobra"
 
 	"git.flexabyte.io/flexabyte/go-kit/application"
 	"git.flexabyte.io/flexabyte/go-kit/httpd"
+	"git.flexabyte.io/flexabyte/go-kit/slogd"
 )
 
 var (
@@ -55,18 +54,15 @@ func main() {
 		EnableGracefulShutdown: true,
 		Logger:                 slogd.Logger(),
 		OverrideRunE: func(cmd *cobra.Command, args []string) error {
-			// fmt.Println("overrideRunE")
-			// time.Sleep(1 * time.Second)
-			// fmt.Println("overrideRunE done")
 			mux := http.NewServeMux()
 			mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 				slogd.FromContext(r.Context()).LogAttrs(r.Context(), slogd.LevelInfo, "request received", slog.String("method", r.Method), slog.String("url", r.URL.String()), slog.String("user-agent", r.UserAgent()))
 			})
-			return httpd.RunHttpServer(cmd.Context(), slogd.FromContext(cmd.Context()), "127.0.0.1", 28000, mux, 1*time.Second)
+			return httpd.RunHttpServer(cmd.Context(), slogd.Logger(), "127.0.0.1", 28000, mux, 5*time.Second)
 		},
 		PersistentPreRunE:        nil,
 		PersistentPostRunE:       nil,
-		ShutdownSignals:          []os.Signal{syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP, syscall.SIGQUIT},
+		ShutdownSignals:          application.DefaultShutdownSignals,
 		ShutdownTimeout:          5 * time.Second,
 		SubCommands:              nil,
 		SubCommandInitializeFunc: nil,

examples/sqr/embeddedSqlWithRepository/assets/migrations/01_demo.up.sql

@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS demo
+(
+    id   INTEGER NOT NULL
+        CONSTRAINT p_id
+            PRIMARY KEY AUTOINCREMENT,
+    name TEXT    NOT NULL
+        CONSTRAINT u_name
+            UNIQUE
+                ON CONFLICT FAIL
+);
+
+INSERT INTO demo (name)
+VALUES ('item1')

examples/sqr/embeddedSqlWithRepository/assets/statements/demo/deleteById.sql

@@ -0,0 +1,3 @@
+DELETE
+FROM demo
+WHERE id == ?

examples/sqr/embeddedSqlWithRepository/assets/statements/demo/deleteByName.sql

@@ -0,0 +1,3 @@
+DELETE
+FROM demo
+WHERE name == ?

examples/sqr/embeddedSqlWithRepository/assets/statements/demo/insert.sql

@@ -0,0 +1,3 @@
+INSERT INTO demo (name)
+VALUES (?)
+RETURNING id

examples/sqr/embeddedSqlWithRepository/assets/statements/demo/list.sql

@@ -0,0 +1,2 @@
+SELECT *
+FROM demo

examples/sqr/embeddedSqlWithRepository/assets/statements/test/list.sql

@@ -0,0 +1,2 @@
+SELECT *
+FROM test

examples/sqr/embeddedSqlWithRepository/go.mod

@@ -0,0 +1,27 @@
+module embeddedSql
+
+go 1.24.2
+
+toolchain go1.24.3
+
+require (
+	git.flexabyte.io/flexabyte/go-kit v0.0.0-20250521190905-eff54c777985
+	github.com/golang-migrate/migrate/v4 v4.18.2
+)
+
+require (
+	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/hashicorp/errwrap v1.1.0 // indirect
+	github.com/hashicorp/go-multierror v1.1.1 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/ncruces/go-strftime v0.1.9 // indirect
+	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	go.uber.org/atomic v1.11.0 // indirect
+	golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac // indirect
+	golang.org/x/sys v0.30.0 // indirect
+	modernc.org/libc v1.61.13 // indirect
+	modernc.org/mathutil v1.7.1 // indirect
+	modernc.org/memory v1.8.2 // indirect
+	modernc.org/sqlite v1.35.0 // indirect
+)

examples/sqr/embeddedSqlWithRepository/go.sum

@@ -0,0 +1,68 @@
+git.flexabyte.io/flexabyte/go-kit v0.0.0-20250521190905-eff54c777985 h1:Q9mYadYgRyb0i89T2fvzJlViGMiKosUvBrBpK8pd/6w=
+git.flexabyte.io/flexabyte/go-kit v0.0.0-20250521190905-eff54c777985/go.mod h1:dZ04ub68ACYiSHUrF+7mq4xg4xL/0C3MvnIUEfahdiU=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/golang-migrate/migrate/v4 v4.18.2 h1:2VSCMz7x7mjyTXx3m2zPokOY82LTRgxK1yQYKo6wWQ8=
+github.com/golang-migrate/migrate/v4 v4.18.2/go.mod h1:2CM6tJvn2kqPXwnXO/d3rAQYiyoIm180VsO8PRX6Rpk=
+github.com/google/pprof v0.0.0-20240409012703-83162a5b38cd h1:gbpYu9NMq8jhDVbvlGkMFWCjLFlqqEZjEmObmhUy6Vo=
+github.com/google/pprof v0.0.0-20240409012703-83162a5b38cd/go.mod h1:kf6iHlnVGwgKolg33glAes7Yg/8iWP8ukqeldJSO7jw=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
+github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
+github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
+github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
+github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
+github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
+go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
+golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac h1:l5+whBCLH3iH2ZNHYLbAe58bo7yrN4mVcnkHDYz5vvs=
+golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac/go.mod h1:hH+7mtFmImwwcMvScyxUhjuVHR3HGaDPMn9rMSUUbxo=
+golang.org/x/mod v0.23.0 h1:Zb7khfcRGKk+kqfxFaP5tZqCnDZMjC5VtUBs87Hr6QM=
+golang.org/x/mod v0.23.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
+golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
+golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/tools v0.30.0 h1:BgcpHewrV5AUp2G9MebG4XPFI1E2W41zU1SaqVA9vJY=
+golang.org/x/tools v0.30.0/go.mod h1:c347cR/OJfw5TI+GfX7RUPNMdDRRbjvYTS0jPyvsVtY=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+modernc.org/cc/v4 v4.24.4 h1:TFkx1s6dCkQpd6dKurBNmpo+G8Zl4Sq/ztJ+2+DEsh0=
+modernc.org/cc/v4 v4.24.4/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
+modernc.org/ccgo/v4 v4.23.16 h1:Z2N+kk38b7SfySC1ZkpGLN2vthNJP1+ZzGZIlH7uBxo=
+modernc.org/ccgo/v4 v4.23.16/go.mod h1:nNma8goMTY7aQZQNTyN9AIoJfxav4nvTnvKThAeMDdo=
+modernc.org/fileutil v1.3.0 h1:gQ5SIzK3H9kdfai/5x41oQiKValumqNTDXMvKo62HvE=
+modernc.org/fileutil v1.3.0/go.mod h1:XatxS8fZi3pS8/hKG2GH/ArUogfxjpEKs3Ku3aK4JyQ=
+modernc.org/gc/v2 v2.6.3 h1:aJVhcqAte49LF+mGveZ5KPlsp4tdGdAOT4sipJXADjw=
+modernc.org/gc/v2 v2.6.3/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=
+modernc.org/libc v1.61.13 h1:3LRd6ZO1ezsFiX1y+bHd1ipyEHIJKvuprv0sLTBwLW8=
+modernc.org/libc v1.61.13/go.mod h1:8F/uJWL/3nNil0Lgt1Dpz+GgkApWh04N3el3hxJcA6E=
+modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
+modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
+modernc.org/memory v1.8.2 h1:cL9L4bcoAObu4NkxOlKWBWtNHIsnnACGF/TbqQ6sbcI=
+modernc.org/memory v1.8.2/go.mod h1:ZbjSvMO5NQ1A2i3bWeDiVMxIorXwdClKE/0SZ+BMotU=
+modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8=
+modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
+modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
+modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
+modernc.org/sqlite v1.35.0 h1:yQps4fegMnZFdphtzlfQTCNBWtS0CZv48pRpW3RFHRw=
+modernc.org/sqlite v1.35.0/go.mod h1:9cr2sicr7jIaWTBKQmAxQLfBv9LL0su4ZTEV+utt3ic=
+modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=
+modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=
+modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
+modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=

examples/sqr/embeddedSqlWithRepository/main.go

@@ -0,0 +1,124 @@
+package main
+
+import (
+	"database/sql"
+	"embed"
+	"errors"
+	"fmt"
+
+	"git.flexabyte.io/flexabyte/go-kit/sqr"
+	"github.com/golang-migrate/migrate/v4"
+	"github.com/golang-migrate/migrate/v4/database"
+	"github.com/golang-migrate/migrate/v4/database/sqlite"
+	"github.com/golang-migrate/migrate/v4/source"
+	"github.com/golang-migrate/migrate/v4/source/iofs"
+)
+
+//go:embed assets/migrations/*
+var migrationFs embed.FS
+
+//go:embed assets/statements/*
+var statementsFS embed.FS
+
+var db *sql.DB
+
+var r *sqr.Repository
+
+func main() {
+	var err error
+
+	fmt.Println("Create in-memory database and run migrations:")
+	// Create in-memory demo database
+	if err = initialize(); err != nil {
+		panic(err)
+	}
+
+	// Create query repository from embedded files
+	if r, err = sqr.NewFromFs(statementsFS, "assets/statements"); err != nil {
+		panic(err)
+	}
+	fmt.Println("")
+
+	fmt.Println("Fetch statements from repository:")
+	var query string
+	if query, err = r.Get("demo", "list"); err != nil {
+		panic(err)
+	}
+	fmt.Println("Query:", query)
+
+	if query, err = r.Get("demo", "insert"); err != nil {
+		panic(err)
+	}
+	fmt.Println("Query:", query)
+	fmt.Println("")
+
+	fmt.Println("Run insert statement:")
+	var stmtInsert *sql.Stmt
+	if stmtInsert, err = sqr.Prepare(db, r, "demo", "insert"); err != nil {
+		panic(err)
+	}
+
+	var res int
+	if err = stmtInsert.QueryRow("item2").Scan(&res); err != nil {
+		panic(err)
+	}
+	fmt.Println("Successfully inserted into database, returned id:", res)
+
+	fmt.Println("")
+	fmt.Println("Run list statement:")
+	var stmtQuery *sql.Stmt
+	if stmtQuery, err = sqr.Prepare(db, r, "demo", "list"); err != nil {
+		fmt.Println("Error preparing statement")
+	}
+
+	if stmtQuery == nil {
+		panic(errors.New("statement not found"))
+	}
+
+	var rows *sql.Rows
+	if rows, err = stmtQuery.Query(); err != nil {
+		fmt.Println("Error querying statement")
+	}
+	if rows != nil {
+		for rows.Next() {
+			var id int
+			var name string
+			if err = rows.Scan(&id, &name); err != nil {
+				fmt.Println("Error scanning row")
+			}
+			fmt.Println("Output", id, name)
+		}
+	}
+
+}
+
+func initialize() error {
+	var err error
+	db, err = sql.Open("sqlite", ":memory:")
+	if err != nil {
+		fmt.Println("Error opening database")
+		return err
+	}
+
+	var src source.Driver
+	if src, err = iofs.New(migrationFs, "assets/migrations"); err != nil {
+		fmt.Println("Error opening migrations source")
+		return err
+	}
+
+	var driver database.Driver
+	if driver, err = sqlite.WithInstance(db, &sqlite.Config{}); err != nil {
+		fmt.Println("Error opening migrations destination")
+		return err
+	}
+
+	var m *migrate.Migrate
+	if m, err = migrate.NewWithInstance("fs", src, "sqlite", driver); err != nil {
+		return err
+	}
+
+	if err = m.Up(); err != nil && !errors.Is(err, migrate.ErrNoChange) {
+		return err
+	}
+	return nil
+}

examples/sqr/embeddedSqlWithoutRepository/assets/migrations/01_demo.up.sql

@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS demo
+(
+    id   INTEGER NOT NULL
+        CONSTRAINT p_id
+            PRIMARY KEY AUTOINCREMENT,
+    name TEXT    NOT NULL
+        CONSTRAINT u_name
+            UNIQUE
+                ON CONFLICT FAIL
+);
+
+INSERT INTO demo (name)
+VALUES ('item1')

examples/sqr/embeddedSqlWithoutRepository/assets/statements/demo/deleteById.sql

@@ -0,0 +1,3 @@
+DELETE
+FROM demo
+WHERE id == ?

examples/sqr/embeddedSqlWithoutRepository/assets/statements/demo/deleteByName.sql

@@ -0,0 +1,3 @@
+DELETE
+FROM demo
+WHERE name == ?

examples/sqr/embeddedSqlWithoutRepository/assets/statements/demo/insert.sql

@@ -0,0 +1,3 @@
+INSERT INTO demo (name)
+VALUES (?)
+RETURNING id

examples/sqr/embeddedSqlWithoutRepository/assets/statements/demo/list.sql

@@ -0,0 +1,2 @@
+SELECT *
+FROM demo

examples/sqr/embeddedSqlWithoutRepository/assets/statements/test/list.sql

@@ -0,0 +1,2 @@
+SELECT *
+FROM test

examples/sqr/embeddedSqlWithoutRepository/go.mod

@@ -0,0 +1,27 @@
+module embeddedSql
+
+go 1.24.2
+
+toolchain go1.24.3
+
+require (
+	git.flexabyte.io/flexabyte/go-kit v0.0.0-20250521190905-eff54c777985
+	github.com/golang-migrate/migrate/v4 v4.18.3
+)
+
+require (
+	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/hashicorp/errwrap v1.1.0 // indirect
+	github.com/hashicorp/go-multierror v1.1.1 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/ncruces/go-strftime v0.1.9 // indirect
+	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	go.uber.org/atomic v1.11.0 // indirect
+	golang.org/x/exp v0.0.0-20250506013437-ce4c2cf36ca6 // indirect
+	golang.org/x/sys v0.33.0 // indirect
+	modernc.org/libc v1.65.7 // indirect
+	modernc.org/mathutil v1.7.1 // indirect
+	modernc.org/memory v1.11.0 // indirect
+	modernc.org/sqlite v1.37.1 // indirect
+)

examples/sqr/embeddedSqlWithoutRepository/go.sum

@@ -0,0 +1,68 @@
+git.flexabyte.io/flexabyte/go-kit v0.0.0-20250521190905-eff54c777985 h1:Q9mYadYgRyb0i89T2fvzJlViGMiKosUvBrBpK8pd/6w=
+git.flexabyte.io/flexabyte/go-kit v0.0.0-20250521190905-eff54c777985/go.mod h1:dZ04ub68ACYiSHUrF+7mq4xg4xL/0C3MvnIUEfahdiU=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/golang-migrate/migrate/v4 v4.18.3 h1:EYGkoOsvgHHfm5U/naS1RP/6PL/Xv3S4B/swMiAmDLs=
+github.com/golang-migrate/migrate/v4 v4.18.3/go.mod h1:99BKpIi6ruaaXRM1A77eqZ+FWPQ3cfRa+ZVy5bmWMaY=
+github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs=
+github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
+github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
+github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
+github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
+github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
+github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
+go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
+golang.org/x/exp v0.0.0-20250506013437-ce4c2cf36ca6 h1:y5zboxd6LQAqYIhHnB48p0ByQ/GnQx2BE33L8BOHQkI=
+golang.org/x/exp v0.0.0-20250506013437-ce4c2cf36ca6/go.mod h1:U6Lno4MTRCDY+Ba7aCcauB9T60gsv5s4ralQzP72ZoQ=
+golang.org/x/mod v0.24.0 h1:ZfthKaKaT4NrhGVZHO1/WDTwGES4De8KtWO0SIbNJMU=
+golang.org/x/mod v0.24.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
+golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ=
+golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/tools v0.33.0 h1:4qz2S3zmRxbGIhDIAgjxvFutSvH5EfnsYrRBj0UI0bc=
+golang.org/x/tools v0.33.0/go.mod h1:CIJMaWEY88juyUfo7UbgPqbC8rU2OqfAV1h2Qp0oMYI=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+modernc.org/cc/v4 v4.26.1 h1:+X5NtzVBn0KgsBCBe+xkDC7twLb/jNVj9FPgiwSQO3s=
+modernc.org/cc/v4 v4.26.1/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
+modernc.org/ccgo/v4 v4.28.0 h1:rjznn6WWehKq7dG4JtLRKxb52Ecv8OUGah8+Z/SfpNU=
+modernc.org/ccgo/v4 v4.28.0/go.mod h1:JygV3+9AV6SmPhDasu4JgquwU81XAKLd3OKTUDNOiKE=
+modernc.org/fileutil v1.3.1 h1:8vq5fe7jdtEvoCf3Zf9Nm0Q05sH6kGx0Op2CPx1wTC8=
+modernc.org/fileutil v1.3.1/go.mod h1:HxmghZSZVAz/LXcMNwZPA/DRrQZEVP9VX0V4LQGQFOc=
+modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=
+modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=
+modernc.org/libc v1.65.7 h1:Ia9Z4yzZtWNtUIuiPuQ7Qf7kxYrxP1/jeHZzG8bFu00=
+modernc.org/libc v1.65.7/go.mod h1:011EQibzzio/VX3ygj1qGFt5kMjP0lHb0qCW5/D/pQU=
+modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
+modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
+modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI=
+modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=
+modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8=
+modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
+modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
+modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
+modernc.org/sqlite v1.37.1 h1:EgHJK/FPoqC+q2YBXg7fUmES37pCHFc97sI7zSayBEs=
+modernc.org/sqlite v1.37.1/go.mod h1:XwdRtsE1MpiBcL54+MbKcaDvcuej+IYSMfLN6gSKV8g=
+modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=
+modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=
+modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
+modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=

examples/sqr/embeddedSqlWithoutRepository/main.go

@@ -0,0 +1,116 @@
+package main
+
+import (
+	"database/sql"
+	"embed"
+	"errors"
+	"fmt"
+
+	"git.flexabyte.io/flexabyte/go-kit/sqr"
+	"github.com/golang-migrate/migrate/v4"
+	"github.com/golang-migrate/migrate/v4/database"
+	"github.com/golang-migrate/migrate/v4/database/sqlite"
+	"github.com/golang-migrate/migrate/v4/source"
+	"github.com/golang-migrate/migrate/v4/source/iofs"
+)
+
+//go:embed assets/migrations/*
+var migrationFs embed.FS
+
+//go:embed assets/statements/*
+var statementsFS embed.FS
+
+var db *sql.DB
+
+func main() {
+	var err error
+
+	fmt.Println("Create in-memory database and run migrations:")
+	// Create in-memory demo database
+	if err = initialize(); err != nil {
+		panic(err)
+	}
+
+	fmt.Println("Fetch demo list query from filesystem:")
+	var query string
+	if query, err = sqr.LoadQueryFromFs(statementsFS, "assets/statements", "demo", "list"); err != nil {
+		panic(err)
+	}
+	fmt.Println("Query:", query)
+
+	if query, err = sqr.LoadQueryFromFs(statementsFS, "assets/statements", "demo", "insert"); err != nil {
+		panic(err)
+	}
+	fmt.Println("Query:", query)
+	fmt.Println("")
+
+	fmt.Println("Run insert statement:")
+	var stmtInsert *sql.Stmt
+	if stmtInsert, err = sqr.PrepareFromFs(db, statementsFS, "assets/statements", "demo", "insert"); err != nil {
+		panic(err)
+	}
+
+	var res int
+	if err = stmtInsert.QueryRow("item2").Scan(&res); err != nil {
+		panic(err)
+	}
+	fmt.Println("Successfully inserted into database, returned id:", res)
+
+	fmt.Println("")
+	fmt.Println("Run list statement:")
+	var stmtQuery *sql.Stmt
+	if stmtQuery, err = sqr.PrepareFromFs(db, statementsFS, "assets/statements", "demo", "list"); err != nil {
+		fmt.Println("Error preparing statement")
+	}
+
+	if stmtQuery == nil {
+		panic(errors.New("statement not found"))
+	}
+
+	var rows *sql.Rows
+	if rows, err = stmtQuery.Query(); err != nil {
+		fmt.Println("Error querying statement")
+	}
+	if rows != nil {
+		for rows.Next() {
+			var id int
+			var name string
+			if err = rows.Scan(&id, &name); err != nil {
+				fmt.Println("Error scanning row")
+			}
+			fmt.Println("Output", id, name)
+		}
+	}
+
+}
+
+func initialize() error {
+	var err error
+	db, err = sql.Open("sqlite", ":memory:")
+	if err != nil {
+		fmt.Println("Error opening database")
+		return err
+	}
+
+	var src source.Driver
+	if src, err = iofs.New(migrationFs, "assets/migrations"); err != nil {
+		fmt.Println("Error opening migrations source")
+		return err
+	}
+
+	var driver database.Driver
+	if driver, err = sqlite.WithInstance(db, &sqlite.Config{}); err != nil {
+		fmt.Println("Error opening migrations destination")
+		return err
+	}
+
+	var m *migrate.Migrate
+	if m, err = migrate.NewWithInstance("fs", src, "sqlite", driver); err != nil {
+		return err
+	}
+
+	if err = m.Up(); err != nil && !errors.Is(err, migrate.ErrNoChange) {
+		return err
+	}
+	return nil
+}

go.mod

@@ -3,15 +3,14 @@ module git.flexabyte.io/flexabyte/go-kit
 go 1.24.2
 
 require (
-	git.flexabyte.io/flexabyte/go-slogd v0.0.0-20250428200220-8e65f81d9450
+	github.com/samber/slog-formatter v1.2.0
+	github.com/samber/slog-multi v1.4.0
 	github.com/spf13/cobra v1.9.1
 	github.com/spf13/pflag v1.0.6
 )
 
 require (
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/samber/lo v1.49.1 // indirect
-	github.com/samber/slog-formatter v1.2.0 // indirect
-	github.com/samber/slog-multi v1.4.0 // indirect
-	golang.org/x/text v0.24.0 // indirect
+	github.com/samber/lo v1.50.0 // indirect
+	golang.org/x/text v0.26.0 // indirect
 )

go.sum

@@ -1,9 +1,3 @@
-git.flexabyte.io/flexabyte/go-slogd v0.0.0-20250416190113-64c1cac4d274 h1:aR9nV87ivzOTdUiGJSRry0XxegEVkiPPUx5NPz7YD3U=
-git.flexabyte.io/flexabyte/go-slogd v0.0.0-20250416190113-64c1cac4d274/go.mod h1:rL08OHw4aycfjkZOS8pBfLapeG3IZHxIInW29hVVSrI=
-git.flexabyte.io/flexabyte/go-slogd v0.0.0-20250422113213-08cde7c3729c h1:8ZVNJJ/LNbu4aWozJ6wj0ZOZFeuqRh1xSyQRh+Cq1yM=
-git.flexabyte.io/flexabyte/go-slogd v0.0.0-20250422113213-08cde7c3729c/go.mod h1:rL08OHw4aycfjkZOS8pBfLapeG3IZHxIInW29hVVSrI=
-git.flexabyte.io/flexabyte/go-slogd v0.0.0-20250428200220-8e65f81d9450 h1:VCstITW9pMgR5EnSLU83UiK7llLOguFLAo26VOOnzrI=
-git.flexabyte.io/flexabyte/go-slogd v0.0.0-20250428200220-8e65f81d9450/go.mod h1:rL08OHw4aycfjkZOS8pBfLapeG3IZHxIInW29hVVSrI=
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -12,8 +6,8 @@ github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLf
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/samber/lo v1.49.1 h1:4BIFyVfuQSEpluc7Fua+j1NolZHiEHEpaSEKdsH0tew=
-github.com/samber/lo v1.49.1/go.mod h1:dO6KHFzUKXgP8LDhU0oI8d2hekjXnGOu0DB8Jecxd6o=
+github.com/samber/lo v1.50.0 h1:XrG0xOeHs+4FQ8gJR97zDz5uOFMW7OwFWiFVzqopKgY=
+github.com/samber/lo v1.50.0/go.mod h1:RjZyNk6WSnUFRKK6EyOhsRJMqft3G+pg7dCWHQCWvsc=
 github.com/samber/slog-formatter v1.2.0 h1:gTSHm4CxyySyhcxRkzk21CSKbGCdZVipbRMhINkNtQU=
 github.com/samber/slog-formatter v1.2.0/go.mod h1:hgjhSd5Vf69XCOnVp0UW0QHCxJ8iDEm/qASjji6FNoI=
 github.com/samber/slog-multi v1.4.0 h1:pwlPMIE7PrbTHQyKWDU+RIoxP1+HKTNOujk3/kdkbdg=
@@ -26,6 +20,10 @@ github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOf
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
 golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=
+golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

httpd/httpd.go

@@ -3,12 +3,14 @@ package httpd
 import (
 	"context"
 	"errors"
+	"fmt"
 	"log/slog"
+	"net"
 	"net/http"
 	"strconv"
 	"time"
 
-	"git.flexabyte.io/flexabyte/go-slogd/slogd"
+	"git.flexabyte.io/flexabyte/go-kit/slogd"
 )
 
 func RunHttpServer(ctx context.Context, log *slog.Logger, listenAddress string, port int, h http.Handler, shutdownTimeout time.Duration) error {
@@ -16,39 +18,14 @@ func RunHttpServer(ctx context.Context, log *slog.Logger, listenAddress string,
 		Addr:    listenAddress + ":" + strconv.Itoa(port),
 		Handler: h}
 
-	return run(ctx, s, log, shutdownTimeout)
-}
+	log.LogAttrs(ctx, slogd.LevelTrace, "starting http server", slog.String("listenAddress", fmt.Sprintf("http://%s", s.Addr)))
 
-func RunSocketHttpServer(ctx context.Context, log *slog.Logger, socketPath string, h http.Handler, shutdownTimeout time.Duration) error {
-	s := &http.Server{
-		Handler: h}
+	shutdownCtx, shutdownCancel := context.WithCancel(ctx)
+	defer shutdownCancel()
 
-	return run(ctx, s, log, shutdownTimeout)
-}
-
-func run(ctx context.Context, s *http.Server, log *slog.Logger, shutdownTimeout time.Duration) error {
-	log.LogAttrs(ctx, slogd.LevelTrace, "starting http server", slog.String("listenAddress", s.Addr))
+	// Run goroutine to handle graceful shutdown
 	idleConnectionsClosed := make(chan struct{})
-
-	runCtx, runCancel := context.WithCancel(ctx)
-	defer runCancel()
-
-	go func(ctx context.Context) {
-		log.LogAttrs(ctx, slogd.LevelTrace, "awaiting shutdown signal for http server", slog.String("listenAddress", s.Addr))
-		<-ctx.Done()
-
-		shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), shutdownTimeout)
-		defer shutdownCancel()
-
-		log.LogAttrs(shutdownCtx, slogd.LevelTrace, "shutting down http server", slog.String("listenAddress", s.Addr))
-		// We received an interrupt signal, shut down.
-		if err := s.Shutdown(shutdownCtx); err != nil {
-			// Error from closing listeners, or context timeout:
-			log.LogAttrs(ctx, slogd.LevelTrace, "shutting down http server failed", slog.String("listenAddress", s.Addr), slog.Any("error", err))
-		}
-		log.LogAttrs(shutdownCtx, slogd.LevelTrace, "shutting down http server completed", slog.String("listenAddress", s.Addr))
-		close(idleConnectionsClosed)
-	}(runCtx)
+	go shutdown(shutdownCtx, log, s, shutdownTimeout, idleConnectionsClosed)
 
 	var err error
 	if err = s.ListenAndServe(); !errors.Is(err, http.ErrServerClosed) {
@@ -60,3 +37,54 @@ func run(ctx context.Context, s *http.Server, log *slog.Logger, shutdownTimeout
 	<-idleConnectionsClosed
 	return err
 }
+
+func RunSocketHttpServer(ctx context.Context, log *slog.Logger, socketPath string, h http.Handler, shutdownTimeout time.Duration) error {
+	s := &http.Server{
+		Handler: h}
+
+	log.LogAttrs(ctx, slogd.LevelTrace, "starting http server", slog.String("socket", s.Addr))
+
+	shutdownCtx, shutdownCancel := context.WithCancel(ctx)
+	defer shutdownCancel()
+
+	// Run goroutine to handle graceful shutdown
+	idleConnectionsClosed := make(chan struct{})
+	go shutdown(shutdownCtx, log, s, shutdownTimeout, idleConnectionsClosed)
+
+	var err error
+	var config = new(net.ListenConfig)
+	var socket net.Listener
+
+	if socket, err = config.Listen(ctx, "unix", socketPath); err != nil {
+		log.LogAttrs(ctx, slogd.LevelError, "failed to listen on socket", slog.String("error", err.Error()))
+		return err
+	}
+
+	if err = s.Serve(socket); err != nil && !errors.Is(err, http.ErrServerClosed) {
+		// Error starting or closing listener:
+		log.LogAttrs(ctx, slogd.LevelError, "http server start failed", slog.String("error", err.Error()))
+		return err
+	}
+
+	<-idleConnectionsClosed
+	return err
+}
+
+func shutdown(ctx context.Context, log *slog.Logger, s *http.Server, shutdownTimeout time.Duration, idleConnectionsClosed chan struct{}) {
+	log.LogAttrs(ctx, slogd.LevelTrace, "awaiting shutdown signal for http server", slog.String("listenAddress", s.Addr))
+	<-ctx.Done()
+
+	// When shutdown signal is received, create a new context with the configured shutdown timeout
+	shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), shutdownTimeout)
+	defer shutdownCancel()
+
+	log.LogAttrs(shutdownCtx, slogd.LevelTrace, "shutdown signal received for http server", slog.String("listenAddress", s.Addr))
+	time.Sleep(2 * time.Second)
+	// We received an interrupt signal, shut down.
+	if err := s.Shutdown(shutdownCtx); err != nil {
+		// Error from closing listeners, or context timeout:
+		log.LogAttrs(ctx, slogd.LevelTrace, "shutdown for http server failed", slog.String("listenAddress", s.Addr), slog.Any("error", err))
+	}
+	log.LogAttrs(shutdownCtx, slogd.LevelTrace, "shutdown for http server completed", slog.String("listenAddress", s.Addr))
+	close(idleConnectionsClosed)
+}

slogd/disabledHandler.go

@@ -0,0 +1,32 @@
+package slogd
+
+import (
+	"context"
+	"log/slog"
+)
+
+func newDisabledHandler() slog.Handler {
+	return &disabledHandler{}
+}
+
+func registerDisabledHandler(activate bool) {
+	RegisterSink(handlerDisabled, newDisabledHandler(), activate)
+}
+
+type disabledHandler struct{}
+
+func (h *disabledHandler) Handle(ctx context.Context, r slog.Record) error {
+	return nil
+}
+
+func (h *disabledHandler) Enabled(ctx context.Context, level slog.Level) bool {
+	return false
+}
+
+func (h *disabledHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
+	return h
+}
+
+func (h *disabledHandler) WithGroup(group string) slog.Handler {
+	return h
+}

slogd/jsonHandler.go

@@ -0,0 +1,10 @@
+package slogd
+
+import (
+	"io"
+	"log/slog"
+)
+
+func RegisterJSONHandler(w io.Writer, activate bool) {
+	RegisterSink(HandlerJSON, slog.NewJSONHandler(w, HandlerOptions()), activate)
+}

slogd/level.go

@@ -0,0 +1,56 @@
+package slogd
+
+import (
+	"log/slog"
+	"strings"
+)
+
+const (
+	LevelTrace   = slog.Level(-8)
+	LevelDebug   = slog.LevelDebug
+	LevelInfo    = slog.LevelInfo
+	LevelNotice  = slog.Level(2)
+	LevelWarn    = slog.LevelWarn
+	LevelError   = slog.LevelError
+	LevelFatal   = slog.Level(12)
+	LevelDefault = LevelInfo
+)
+
+var levelNames = map[slog.Leveler]string{
+	LevelTrace:  "TRACE",
+	LevelDebug:  "DEBUG",
+	LevelInfo:   "INFO",
+	LevelNotice: "NOTICE",
+	LevelWarn:   "WARN",
+	LevelError:  "ERROR",
+	LevelFatal:  "FATAL",
+}
+
+func ReplaceAttrs(groups []string, a slog.Attr) slog.Attr {
+	if a.Key == slog.LevelKey {
+		a.Value = slog.StringValue(LevelName(a.Value.Any().(slog.Level)))
+	}
+	return a
+}
+
+func Level(l string) slog.Level {
+	mux.Lock()
+	defer mux.Unlock()
+	for k, v := range levelNames {
+		if strings.ToUpper(l) == v {
+			return k.Level()
+		}
+	}
+	return LevelDefault
+}
+
+func LevelName(l slog.Level) string {
+	mux.Lock()
+	defer mux.Unlock()
+	for k, v := range levelNames {
+		if k == l {
+			return v
+		}
+	}
+	return levelNames[LevelDefault]
+}

slogd/slogd.go

@@ -0,0 +1,148 @@
+package slogd
+
+import (
+	"context"
+	"log/slog"
+	"sync"
+
+	slogformatter "github.com/samber/slog-formatter"
+	slogmulti "github.com/samber/slog-multi"
+)
+
+const (
+	HandlerText     string = "text"
+	HandlerJSON     string = "json"
+	handlerDisabled string = "disabled"
+)
+
+const (
+	FlowFanOut Flow = iota
+	FlowPipeline
+	FlowRouting
+	FlowFailOver
+	FlowLoadBalancing
+)
+
+type Flow int
+
+var (
+	ctxKey = contextKey{}
+)
+var (
+	handlers      = make(map[string]slog.Handler)
+	activeHandler string
+	level         = new(slog.LevelVar)
+	formatters    []slogformatter.Formatter
+	middlewares   []slogmulti.Middleware
+	source        bool
+	logger        *slog.Logger
+	mux           = &sync.Mutex{}
+)
+
+func ActiveHandler() string {
+	mux.Lock()
+	defer mux.Unlock()
+	return activeHandler
+}
+
+func key() contextKey {
+	return ctxKey
+}
+
+func Disable() {
+	UseHandler(handlerDisabled)
+}
+
+func FromContext(ctx context.Context) *slog.Logger {
+	if l, ok := ctx.Value(key()).(*slog.Logger); ok {
+		return l
+	}
+	return Logger()
+}
+
+func GetLevel() slog.Level {
+	return level.Level()
+}
+
+func GetLevelString() string {
+	return level.String()
+}
+
+func HandlerOptions() *slog.HandlerOptions {
+	return &slog.HandlerOptions{
+		AddSource:   source,
+		Level:       level,
+		ReplaceAttr: ReplaceAttrs,
+	}
+}
+
+func Init(l slog.Level, addSource bool) {
+	level.Set(l)
+	source = addSource
+}
+
+func Logger() *slog.Logger {
+	mux.Lock()
+	defer mux.Unlock()
+
+	if logger == nil {
+		logger = slog.New(handlers[handlerDisabled])
+	}
+	return logger
+}
+
+func SetLevel(l slog.Level) {
+	mux.Lock()
+	defer mux.Unlock()
+	level.Set(l)
+}
+
+func RegisterFormatter(f slogformatter.Formatter) {
+	mux.Lock()
+	defer mux.Unlock()
+	formatters = append(formatters, f)
+}
+
+func RegisterMiddleware(h slogmulti.Middleware) {
+	mux.Lock()
+	defer mux.Unlock()
+	middlewares = append(middlewares, h)
+}
+
+func RegisterSink(name string, h slog.Handler, activate bool) {
+	mux.Lock()
+	handlers[name] = h
+	mux.Unlock()
+
+	if activate {
+		UseHandler(name)
+	}
+}
+
+func UseHandler(name string) {
+	mux.Lock()
+	defer mux.Unlock()
+	if _, ok := handlers[name]; !ok {
+		Logger().LogAttrs(context.Background(), LevelError, "could not find handler", slog.String("name", name))
+		return
+	}
+
+	formatterPipe := slogformatter.NewFormatterMiddleware(formatters...)
+	pipe := slogmulti.Pipe(middlewares...).Pipe(formatterPipe)
+	handler := slogmulti.Fanout(handlers[name])
+
+	logger = slog.New(pipe.Handler(handler))
+	activeHandler = name
+}
+
+func WithContext(ctx context.Context) context.Context {
+	return context.WithValue(ctx, key(), Logger())
+}
+
+func init() {
+	// RegisterFormatter(LevelFormatter())
+	// RegisterMiddleware(NewLevelMiddleware())
+	registerDisabledHandler(true)
+}
+
+type contextKey struct{}

slogd/textHandler.go

@@ -0,0 +1,10 @@
+package slogd
+
+import (
+	"io"
+	"log/slog"
+)
+
+func RegisterTextHandler(w io.Writer, activate bool) {
+	RegisterSink(HandlerText, slog.NewTextHandler(w, HandlerOptions()), activate)
+}

sqr/README.md

@@ -0,0 +1,135 @@
+# go-sql-sqr - SQL Query Repository for Go
+
+This library enables the use of centralized storage for all SQL queries used in an application.
+You can either choose to load all queries into a repository, or load them from a filesystem as necessary.
+
+The main intention is to embed a directory structure into the binary as ```embed.FS```, which can then used in the
+application.
+
+[![Go Reference](https://pkg.go.dev/badge/github.com/jantytgat/go-sql-sqr.svg)](https://pkg.go.dev/github.com/jantytgat/go-sql-sqr)
+
+---
+
+## Basics
+
+### Add the package to your project
+
+```bash
+go get git.flexabyte.io/flexabyte/go-kit
+```
+
+### Import
+Next, you can manually add the import statement to your ```.go```-file, or have it added automatically when using it.
+
+```text
+import git.flexabyte.io/flexabyte/go-kit/sqr
+```
+
+### Embed assets containing queries.
+
+> [!IMPORTANT]  
+> The root folder embedded in the application cannot have nested directories.  
+> This means that the directory structure is limited to 1 level of collections, each containing a set of text files with
+> a ```.sql``` extension.
+>
+> Files with another extension will fail to load!
+
+Let's assume to following directory structure in an embedded filesystem:
+
+```
+/assets
+|-- /queries
+    |-- collection1
+    |   |-- create.sql
+    |   |-- read.sql
+    |   |-- update.sql
+    |   |-- delete.sql
+    |-- collection2
+        |-- list.sql
+```
+
+You can now embed the statement files as follows:
+
+```go
+//go:embed assets/queries/*
+var f embed.FS
+```
+
+### With repository
+
+#### Create a new repository
+
+```go
+// Create query repository from embedded files
+var r *sqr.Repository
+if r, err = sqr.NewFromFs(f, "assets/queries"); err != nil {
+    panic(err)
+}
+```
+
+#### Load a query from the repository
+
+Now the repository has been initialized, we can get a query from a collection:
+
+```go
+var query string
+if query, err = r.Get("collection1", "create"); err != nil {
+    panic(err)
+}
+fmt.Println("Query:", query)
+```
+
+### Without repository
+
+If you don't want to initialize a repository, but rather choose to load SQL queries straight from the filesystem, you
+can do so as follows:
+
+```go
+var query string
+if query, err = sqr.LoadQueryFromFs(f, "assets/queries", "collection2", "list"); err != nil {
+    panic(err)
+}
+```
+
+## Prepared statements
+
+We also provide the means to create prepared statements for the queries, either with or without using a repository, as
+long as a ```Preparer``` is passed into the functions.
+
+```go
+type Preparer interface {
+	Prepare(query string) (*sql.Stmt, error)
+}
+```
+For example:
+
+- *sql.Db
+- *sql.Tx
+
+```go
+func Prepare[T Preparer](t T, r *Repository, collectionName, queryName string) (*sql.Stmt, error) {}
+func PrepareFromFs[T Preparer](t T, f fs.FS, rootPath, collectionName, queryName string) (*sql.Stmt, error) {}
+```
+
+### With repository
+
+```go
+var createStmt *sql.Stmt
+if createStmt, err = sqr.Prepare(db, r, "collection1", "create"); err != nil {
+    panic(err)
+}
+```
+
+### Without repository
+
+```go
+var createStmt *sql.Stmt
+if createStmt, err = sqr.PrepareFromFs(db, f, "assets/queries", "collection1", "create"); err != nil {
+    panic(err)
+}
+```
+
+## Examples
+Two examples are available:
+- embbededSqlWithRepository
+- embeddedSqlWithoutRepository

sqr/collection.go

@@ -0,0 +1,36 @@
+package sqr
+
+import (
+	"fmt"
+)
+
+// newCollection creates a new collection with the supplied name and returns it to the caller.
+func newCollection(name string) collection {
+	return collection{
+		name:    name,
+		queries: make(map[string]string),
+	}
+}
+
+type collection struct {
+	name    string
+	queries map[string]string
+}
+
+// add adds a query to the collection.
+func (c *collection) add(name, query string) error {
+	if _, ok := c.queries[name]; ok {
+		return fmt.Errorf("query %s already exists", name)
+	}
+	c.queries[name] = query
+	return nil
+}
+
+// get retrieves a query from the collection by name.
+// If the query name cannot be found, get() returns an empty string and an error.
+func (c *collection) get(name string) (string, error) {
+	if _, ok := c.queries[name]; !ok {
+		return "", fmt.Errorf("query %s not found in collection %s", name, c.name)
+	}
+	return c.queries[name], nil
+}

sqr/collection_test.go

@@ -0,0 +1,162 @@
+package sqr
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_collection_add(t *testing.T) {
+	type fields struct {
+		name    string
+		queries map[string]string
+	}
+
+	type args struct {
+		name  string
+		query string
+	}
+
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		wantErr bool
+	}{
+		{
+			name: "good",
+			fields: fields{
+				name: "test1",
+				queries: map[string]string{
+					"query1": "queryString1",
+					"query2": "queryString2",
+				},
+			},
+			args: args{
+				name:  "query3",
+				query: "queryString3",
+			},
+			wantErr: false,
+		},
+		{
+			name: "bad",
+			fields: fields{
+				name: "test1",
+				queries: map[string]string{
+					"query1": "queryString1",
+					"query2": "queryString2",
+				},
+			},
+			args: args{
+				name:  "query2",
+				query: "queryString2",
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := &collection{
+				name:    tt.fields.name,
+				queries: tt.fields.queries,
+			}
+			if err := c.add(tt.args.name, tt.args.query); (err != nil) != tt.wantErr {
+				t.Errorf("add() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func Test_collection_get(t *testing.T) {
+	type fields struct {
+		name    string
+		queries map[string]string
+	}
+	type args struct {
+		name string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		want    string
+		wantErr bool
+	}{
+		{
+			name: "good",
+			fields: fields{
+				name: "test1",
+				queries: map[string]string{
+					"query1": "queryString1",
+					"query2": "queryString2",
+				},
+			},
+			args: args{
+				name: "query1",
+			},
+			want:    "queryString1",
+			wantErr: false,
+		},
+		{
+			name: "bad",
+			fields: fields{
+				name: "test1",
+				queries: map[string]string{
+					"query1": "queryString1",
+					"query2": "queryString2",
+				},
+			},
+			args: args{
+				name: "query3",
+			},
+			want:    "",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := &collection{
+				name:    tt.fields.name,
+				queries: tt.fields.queries,
+			}
+			got, err := c.get(tt.args.name)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("get() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("get() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_newCollection(t *testing.T) {
+	type args struct {
+		name string
+	}
+	tests := []struct {
+		name string
+		args args
+		want collection
+	}{
+		{
+			name: "test1",
+			args: args{
+				name: "test1",
+			},
+			want: collection{
+				name:    "test1",
+				queries: make(map[string]string),
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := newCollection(tt.args.name); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("newCollection() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

sqr/loader.go

@@ -0,0 +1,30 @@
+package sqr
+
+import (
+	"embed"
+	"fmt"
+	"io/fs"
+	"path"
+	"path/filepath"
+)
+
+// LoadQueryFromFs retrieves a query from a filesystem.
+// It needs the root path to start the search from, as well as a collection name and a query name.
+// The collection name equals to a direct directory name in the root path.
+// The query name is the file name (without extension) to load the contents from.
+// It returns and empty string and an error if the file cannot be found.
+func LoadQueryFromFs(f fs.FS, rootPath, collectionName, queryName string) (string, error) {
+	var err error
+	var contents []byte
+	switch f.(type) {
+	case embed.FS:
+		if contents, err = fs.ReadFile(f, path.Join(rootPath, collectionName, queryName)+".sql"); err != nil {
+			return "", fmt.Errorf("failed to read file %s: %w", path.Join(rootPath, collectionName, queryName)+".sql", err)
+		}
+	default:
+		if contents, err = fs.ReadFile(f, filepath.Join(rootPath, collectionName, queryName)+".sql"); err != nil {
+			return "", fmt.Errorf("failed to read file %s: %w", filepath.Join(rootPath, collectionName, queryName)+".sql", err)
+		}
+	}
+	return string(contents), nil
+}

sqr/preparer.go

@@ -0,0 +1,76 @@
+package sqr
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"io/fs"
+)
+
+// Preparer defines the interface to create a prepared statement.
+type Preparer interface {
+	Prepare(query string) (*sql.Stmt, error)
+	PrepareContext(ctx context.Context, query string) (*sql.Stmt, error)
+}
+
+// Prepare creates a prepared statement for the supplied Preparer by looking up a query in the supplied repository.
+// It returns an nil pointer and an error if either the query cannot be found in the supplied repository, or the statement preparation fails.
+func Prepare[T Preparer](t T, r *Repository, collectionName, queryName string) (*sql.Stmt, error) {
+	if r == nil {
+		return nil, errors.New("repository is nil")
+	}
+
+	var err error
+	var query string
+
+	if query, err = r.Get(collectionName, queryName); err != nil {
+		return nil, err
+	}
+	return t.Prepare(query)
+}
+
+// Prepare creates a prepared statement for the supplied Preparer by looking up a query in the supplied repository using a context.
+// It returns an nil pointer and an error if either the query cannot be found in the supplied repository, or the statement preparation fails.
+func PrepareContext[T Preparer](ctx context.Context, t T, r *Repository, collectionName, queryName string) (*sql.Stmt, error) {
+	if r == nil {
+		return nil, errors.New("repository is nil")
+	}
+
+	var err error
+	var query string
+
+	if query, err = r.Get(collectionName, queryName); err != nil {
+		return nil, err
+	}
+	return t.PrepareContext(ctx, query)
+}
+
+// PrepareFromFs creates a prepared statement for the supplied Preparer by looking up a query in the supplied filesystem.
+// It returns an nil pointer and an error if either the query cannot be found in the supplied filesystem, or the statement preparation fails.
+func PrepareFromFs[T Preparer](t T, f fs.FS, rootPath, collectionName, queryName string) (*sql.Stmt, error) {
+	if f == nil {
+		return nil, errors.New("invalid filesystem")
+	}
+	var err error
+	var query string
+
+	if query, err = LoadQueryFromFs(f, rootPath, collectionName, queryName); err != nil {
+		return nil, err
+	}
+	return t.Prepare(query)
+}
+
+// PrepareFromFs creates a prepared statement for the supplied Preparer by looking up a query in the supplied filesystem using a context.
+// It returns an nil pointer and an error if either the query cannot be found in the supplied filesystem, or the statement preparation fails.
+func PrepareFromFsContext[T Preparer](ctx context.Context, t T, f fs.FS, rootPath, collectionName, queryName string) (*sql.Stmt, error) {
+	if f == nil {
+		return nil, errors.New("invalid filesystem")
+	}
+	var err error
+	var query string
+
+	if query, err = LoadQueryFromFs(f, rootPath, collectionName, queryName); err != nil {
+		return nil, err
+	}
+	return t.PrepareContext(ctx, query)
+}

sqr/repository.go

@@ -0,0 +1,191 @@
+// Package queryrepo enables the use of centralized storage for all SQL queries used in an application.
+package sqr
+
+import (
+	"context"
+	"database/sql"
+	"embed"
+	"errors"
+	"fmt"
+	"io/fs"
+	"path"
+	"path/filepath"
+	"strings"
+	"sync"
+)
+
+// NewFromFs creates a new repository using a filesystem.
+// It takes a filesystem and a root path to start loading files from and returns an error if files cannot be loaded.
+func NewFromFs(f fs.FS, rootPath string) (*Repository, error) {
+	repo := &Repository{
+		queries: make(map[string]collection),
+	}
+
+	return repo, loadFromFs(repo, f, rootPath)
+}
+
+// A Repository stores multiple collections of queries in a map for later use.
+// Queries can either be retrieved by their name, or be used to create a prepared statement.
+type Repository struct {
+	queries map[string]collection
+	mux     sync.Mutex
+}
+
+// add adds the supplied collection to the repository.
+// It returns an error if the collection already exists.
+func (r *Repository) add(c collection) error {
+	r.mux.Lock()
+	defer r.mux.Unlock()
+
+	if _, ok := r.queries[c.name]; ok {
+		return fmt.Errorf("collection %s already exists", c.name)
+	}
+	r.queries[c.name] = c
+	return nil
+}
+
+// DbPrepare creates a prepared statement for the supplied database handle.
+// It takes a collection name and query name to look up the query to create the prepared statement.
+func (r *Repository) DbPrepare(db *sql.DB, collectionName, queryName string) (*sql.Stmt, error) {
+	if db == nil {
+		return nil, errors.New("db is nil")
+	}
+
+	var err error
+	var query string
+
+	if query, err = r.Get(collectionName, queryName); err != nil {
+		return nil, err
+	}
+	return db.Prepare(query)
+}
+
+// DbPrepareContext creates a prepared statement for the supplied database handle using a context.
+// It takes a collection name and query name to look up the query to create the prepared statement.
+func (r *Repository) DbPrepareContext(ctx context.Context, db *sql.DB, collectionName, queryName string) (*sql.Stmt, error) {
+	if db == nil {
+		return nil, errors.New("db is nil")
+	}
+
+	var err error
+	var query string
+
+	if query, err = r.Get(collectionName, queryName); err != nil {
+		return nil, err
+	}
+
+	return db.PrepareContext(ctx, query)
+}
+
+// Get retrieves the supplied query from the repository.
+// It takes a collection name and a query name to perform the lookup and returns an empty string and an error if the query cannot be found
+// in the collection.
+func (r *Repository) Get(collectionName, queryName string) (string, error) {
+	r.mux.Lock()
+	defer r.mux.Unlock()
+
+	if s, ok := r.queries[collectionName]; ok {
+		return s.get(queryName)
+	}
+	return "", fmt.Errorf("collection %s not found", collectionName)
+}
+
+// TxPrepare creates a prepared statement for the supplied in-progress database transaction.
+// It takes a collection name and query name to look up the query to create the prepared statement.
+func (r *Repository) TxPrepare(tx *sql.Tx, collectionName, queryName string) (*sql.Stmt, error) {
+	if tx == nil {
+		return nil, errors.New("tx is nil")
+	}
+	var err error
+	var statement string
+
+	if statement, err = r.Get(collectionName, queryName); err != nil {
+		return nil, err
+	}
+
+	return tx.Prepare(statement)
+}
+
+// TxPrepare creates a prepared statement for the supplied in-progress database transaction using a context.
+// It takes a collection name and query name to look up the query to create the prepared statement.
+func (r *Repository) TxPrepareContext(ctx context.Context, tx *sql.Tx, collectionName, queryName string) (*sql.Stmt, error) {
+	if tx == nil {
+		return nil, errors.New("tx is nil")
+	}
+	var err error
+	var statement string
+
+	if statement, err = r.Get(collectionName, queryName); err != nil {
+		return nil, err
+	}
+
+	return tx.PrepareContext(ctx, statement)
+}
+
+// loadFromFs looks for directories in the root path to create collections for.
+// If a directory is found, it loads all the files in the subdirectory and adds the returned collection to the repository.
+func loadFromFs(r *Repository, f fs.FS, rootPath string) error {
+	if r == nil {
+		return errors.New("repository is nil")
+	}
+
+	if f == nil {
+		return errors.New("filesystem is nil")
+	}
+
+	var err error
+	var files []fs.DirEntry
+	if files, err = fs.ReadDir(f, rootPath); err != nil {
+		return err
+	}
+
+	for _, file := range files {
+		if file.IsDir() {
+			var c collection
+			if c, err = loadFilesFromDir(f, rootPath, file.Name()); err != nil {
+				return err
+			}
+
+			if err = r.add(c); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// loadFilesFromDir loads all the files in the directory and returns a collection of queries.
+func loadFilesFromDir(f fs.FS, rootPath, dirName string) (collection, error) {
+	var err error
+	var c = newCollection(dirName)
+	var fullPath string
+
+	switch f.(type) {
+	case embed.FS:
+		fullPath = path.Join(rootPath, dirName)
+	default:
+		fullPath = filepath.Join(rootPath, dirName)
+
+	}
+
+	var files []fs.DirEntry
+	if files, err = fs.ReadDir(f, fullPath); err != nil {
+		return c, err
+	}
+
+	for _, file := range files {
+		if file.IsDir() {
+			return c, fmt.Errorf("nested directories are not supported, %s is a directory in %s", file.Name(), fullPath)
+		}
+
+		var contents string
+		if contents, err = LoadQueryFromFs(f, rootPath, dirName, strings.TrimSuffix(file.Name(), filepath.Ext(file.Name()))); err != nil {
+			return c, err
+		}
+
+		if err = c.add(strings.TrimSuffix(file.Name(), filepath.Ext(file.Name())), contents); err != nil {
+			return c, err
+		}
+	}
+	return c, nil
+}