gormdb

type Cfg struct {
	// Driver is DriverSqlite or DriverPostgres.
	Driver   string
	Sqlite   SqliteCfg
	Postgres PostgresCfg
	// Logger receives GORM's log output; nil keeps GORM's default logger.
	Logger gormlogger.Interface
	// NamingStrategy maps structs and fields to table and column names; nil
	// keeps GORM's default (snake_case, plural table names).
	NamingStrategy schema.Namer
	// NowFunc returns the time GORM writes to CreatedAt and UpdatedAt; nil
	// keeps GORM's default, the local time.
	NowFunc func() time.Time
	// SkipDefaultTransaction stops GORM from wrapping each Create, Update and
	// Delete in a transaction of its own.
	SkipDefaultTransaction bool
}

type Drivers struct {
	Sqlite   SqliteDriver
	Postgres PostgresDriver
}

type PostgresCfg struct {
	// Host is a host name, an IP address or the directory of a Unix socket,
	// without a port (see Port) and, for IPv6, without brackets.
	Host string
	Port int // zero means 5432
	// User may be empty: libpq's defaults (PGUSER, the OS user) then apply,
	// and Password, if set, is still sent.
	User     string
	Password string
	DbName   string
	// SslMode is libpq's sslmode: disable, allow, prefer, require, verify-ca
	// or verify-full; empty means "require".
	SslMode string
	// ConnectTimeout bounds how long opening a connection may take, so Open
	// fails fast against an unreachable host; zero means 10s. It is sent in
	// whole seconds, rounded up.
	ConnectTimeout time.Duration
	// MaxOpenConns, MaxIdleConns and ConnMaxLifetime tune the connection pool
	// (see database/sql); zero keeps database/sql's default: no limit on open
	// connections, 2 idle ones, no maximum lifetime.
	MaxOpenConns    int
	MaxIdleConns    int
	ConnMaxLifetime time.Duration
	// Params are extra connection parameters, such as application_name,
	// search_path or default_query_exec_mode. They must not repeat one of the
	// fields above (host, port, user, password, dbname, sslmode,
	// connect_timeout).
	Params map[string]string
}

type PostgresDriver interface {
	// OpenDB returns a connection pool for cfg, already validated. The
	// shipped driver connects with cfg.DSN(); another may read the fields
	// and build the pool its own way. Like sql.Open it must not connect yet.
	// Open sets MaxOpenConns, MaxIdleConns and ConnMaxLifetime on the result.
	OpenDB(cfg PostgresCfg) (*sql.DB, error)
	// Dialector wraps an open connection pool. Translate must keep the
	// original error.
	Dialector(conn gorm.ConnPool) gorm.Dialector
}

type SqliteCfg struct {
	// Path of the database file, or ":memory:" for an in-memory database (one
	// connection, no read pool). It is a filesystem path, never a URI: a path
	// starting with "file:" is rejected. Its directory is created when missing; keep
	// the file in a directory of its own, SQLite writes -wal and -shm files
	// next to it.
	Path string
	// BusyTimeout is how long a connection waits for a lock held by another
	// one before failing with SQLITE_BUSY; zero means 5s. SQLite counts in
	// whole milliseconds: it is rounded down, to at least 1ms and at most
	// 2^31-1 ms (about 24 days). It must not be negative.
	BusyTimeout time.Duration
	// Readers is the size of the read-only connection pool; zero means 10.
	// ":memory:" has no read pool, so it must stay zero there.
	Readers int
	// Pragmas are extra pragmas, name to value, such as "synchronous":
	// "NORMAL" or "cache_size": "-20000". Every connection runs them, the
	// writer and each reader, as most pragmas are per-connection settings; a
	// db.Exec("PRAGMA ...") would reach a single pooled connection. A name is
	// a plain identifier and a value an identifier or an integer, so nothing
	// else can reach the DSN. busy_timeout, foreign_keys, journal_mode and
	// locking_mode are rejected: Open and the drivers set them. A pragma that
	// writes to the database file (user_version, application_id) fails on
	// the read-only readers; run it once with db.Exec.
	Pragmas map[string]string
}

type SqliteDriver interface {
	// OpenDB returns a connection pool for dsn, a file: URI or
	// ":memory:?...", whose query holds the parameters below. Like sql.Open
	// it must not connect yet.
	OpenDB(dsn string) (*sql.DB, error)
	// WriterParams returns the writer's DSN query parameters in the driver's
	// own format: busy timeout, foreign keys, WAL and an immediate
	// transaction lock. ReaderParams returns a reader's: busy timeout and
	// foreign keys only. Each call returns a map the caller may keep.
	WriterParams(busyTimeout time.Duration) url.Values
	ReaderParams(busyTimeout time.Duration) url.Values
	// PragmaParams returns the DSN query parameters that make every
	// connection opened by OpenDB run the extra pragmas (SqliteCfg.Pragmas,
	// already validated). Open adds them to the writer's and the readers'
	// parameters. Each call returns a map the caller may keep.
	PragmaParams(pragmas map[string]string) url.Values
	// Dialector wraps an open connection pool. Translate must keep the
	// original error.
	Dialector(conn gorm.ConnPool) gorm.Dialector
}