Intégration d'un point d'entrée GraphQL et d'un connecteur pour

PostgreSQL

- Possibilité de migrer le schéma de la base de données via drapeau
- Génération du code GraphQL avec https://gqlgen.com/

cmd/server/container.go

@@ -4,8 +4,12 @@ import (
 	"context"
 	"net/http"
 
+	"forge.cadoles.com/Cadoles/daddy/internal/migration"
+	"gitlab.com/wpetit/goweb/cqrs"
+
+	"forge.cadoles.com/Cadoles/daddy/internal/database"
+
 	"gitlab.com/wpetit/goweb/logger"
-	"gitlab.com/wpetit/goweb/template/html"
 
 	"forge.cadoles.com/Cadoles/daddy/internal/config"
 	oidc "forge.cadoles.com/wpetit/goweb-oidc"
@@ -14,7 +18,6 @@ import (
 	"gitlab.com/wpetit/goweb/service"
 	"gitlab.com/wpetit/goweb/service/build"
 	"gitlab.com/wpetit/goweb/service/session"
-	"gitlab.com/wpetit/goweb/service/template"
 	"gitlab.com/wpetit/goweb/session/gorilla"
 )
 
@@ -67,11 +70,6 @@ func getServiceContainer(ctx context.Context, conf *config.Config) (*service.Con
 		gorilla.ServiceProvider("daddy", cookieStore),
 	)
 
-	// Create and expose template service provider
-	ctn.Provide(template.ServiceName, html.ServiceProvider(
-		conf.HTTP.TemplateDir,
-	))
-
 	// Create and expose config service provider
 	ctn.Provide(config.ServiceName, config.ServiceProvider(conf))
 
@@ -86,5 +84,21 @@ func getServiceContainer(ctx context.Context, conf *config.Config) (*service.Con
 		oidc.WithScopes("email", "openid"),
 	))
 
+	ctn.Provide(database.ServiceName, database.ServiceProvider(conf.Database.DSN))
+
+	dbpool, err := database.From(ctn)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not retrieve database service")
+	}
+
+	versionResolver := database.NewVersionResolver(dbpool)
+	if err := versionResolver.Init(ctx); err != nil {
+		return nil, errors.Wrap(err, "could not initialize database version resolver")
+	}
+
+	ctn.Provide(migration.ServiceName, migration.ServiceProvider(versionResolver))
+
+	ctn.Provide(cqrs.ServiceName, cqrs.ServiceProvider())
+
 	return ctn, nil
 }

cmd/server/cqrs.go

@@ -0,0 +1,11 @@
+package main
+
+import "gitlab.com/wpetit/goweb/service"
+
+func initCommands(ctn *service.Container) error {
+	return nil
+}
+
+func initQueries(ctn *service.Container) error {
+	return nil
+}

cmd/server/main.go

@@ -27,6 +27,7 @@ var (
 	workdir    = ""
 	dumpConfig = false
 	version    = false
+	migrate    = ""
 )
 
 // nolint: gochecknoglobals
@@ -42,6 +43,7 @@ func init() {
 	flag.StringVar(&workdir, "workdir", workdir, "working directory")
 	flag.BoolVar(&dumpConfig, "dump-config", dumpConfig, "dump configuration and exit")
 	flag.BoolVar(&version, "version", version, "show version and exit")
+	flag.StringVar(&migrate, "migrate", migrate, "migrate data schema version and exit, possible values: latest, down, up")
 }
 
 func main() {
@@ -137,6 +139,37 @@ func main() {
 		)
 	}
 
+	ctx = container.WithContainer(ctx, ctn)
+
+	if migrate != "" {
+		if err := applyMigration(ctx, ctn); err != nil {
+			logger.Fatal(
+				ctx,
+				"could not apply migration",
+				logger.E(err),
+			)
+		}
+
+		os.Exit(0)
+	}
+
+	// Init commands and queries
+	if err := initCommands(ctn); err != nil {
+		logger.Fatal(
+			ctx,
+			"could not init commands",
+			logger.E(err),
+		)
+	}
+
+	if err := initQueries(ctn); err != nil {
+		logger.Fatal(
+			ctx,
+			"could not init queries",
+			logger.E(err),
+		)
+	}
+
 	r := chi.NewRouter()
 
 	// Define base middlewares

cmd/server/migration.go

@@ -0,0 +1,100 @@
+package main
+
+import (
+	"context"
+
+	"forge.cadoles.com/Cadoles/daddy/internal/database"
+	"forge.cadoles.com/Cadoles/daddy/internal/migration"
+	"github.com/jackc/pgx/v4"
+	"github.com/pkg/errors"
+	"gitlab.com/wpetit/goweb/logger"
+	"gitlab.com/wpetit/goweb/service"
+)
+
+const (
+	migrateUp     = "up"
+	migrateLatest = "latest"
+	migrateDown   = "down"
+)
+
+func applyMigration(ctx context.Context, ctn *service.Container) error {
+	migr, err := migration.From(ctn)
+	if err != nil {
+		return err
+	}
+
+	// Register available migrations
+	migr.Register(
+		m000initialSchema(),
+	)
+
+	currentVersion, err := migr.CurrentVersion(ctx)
+	if err != nil {
+		return errors.Wrap(err, "could not retrieve current data schema version")
+	}
+
+	switch migrate {
+	case migrateUp:
+		if err := migr.Up(ctx); err != nil {
+			return errors.Wrap(err, "could not apply up migration")
+		}
+
+	case migrateLatest:
+		latestVersion, err := migr.LatestVersion()
+		if err != nil {
+			return errors.Wrap(err, "could not retrieve latest data schema version")
+		}
+
+		logger.Info(
+			ctx,
+			"migrating data schema to latest version",
+			logger.F("currentVersion", currentVersion),
+			logger.F("latestVersion", latestVersion),
+		)
+
+		// Execute migration to latest available version
+		if err := migr.Latest(ctx); err != nil {
+			return errors.Wrap(err, "could not migrate to latest data schema")
+		}
+
+	case migrateDown:
+		if err := migr.Down(ctx); err != nil {
+			return errors.Wrap(err, "could not apply down migration")
+		}
+
+	default:
+		return errors.Errorf("unknown migration command: '%s'", migrate)
+	}
+
+	logger.Info(
+		ctx,
+		"migration completed",
+	)
+
+	return nil
+}
+
+func m000initialSchema() migration.Migration {
+	return database.NewMigration(
+		"00_initial_schema",
+		func(ctx context.Context, tx pgx.Tx) error {
+			_, err := tx.Exec(ctx, `
+			CREATE TABLE users (
+				id SERIAL PRIMARY KEY,
+				name TEXT,
+				email TEXT NOT NULL,
+				CONSTRAINT unique_email unique(email)
+			);
+			`)
+
+			return err
+		},
+		func(ctx context.Context, tx pgx.Tx) error {
+			_, err := tx.Exec(ctx, `
+			DROP TABLE users;
+			`)
+
+			return err
+		},
+	)
+}