repo

type DBBackups interface {
	MoveToBackup() (string, error)
	CopyToBackup() (string, error)
	RestoreFromMostRecentBackup() (string, error)
}

type DBEntity interface {
	Handle() *sql.DB    // (noun) the handle to the DB
	Type() D.DB_type    // DB_SQLite ("sqlite", equiv.to "sqlite3")
	Path() string       // file/URL (or dir/URL, if uses multiple files)
	IsURL() bool        // false for a local SQLite file
	IsSingleFile() bool // true for SQLite
}

type DBGetting interface {
	OpenAtPath(string) (string, error)
	NewAtPath(string) (string, error)
	OpenExistingAtPath(string) (string, error)
}

type DBImplementation interface {
	DBImplementationName() D.DB_type // "sqlite"
}

type GenericRepo[T any] interface {
	Create(T) T
	GetAll() []T
	GetByID(uint) (T, error)
	UpdateByID(uint, T) (T, error)
	DeleteByID(uint) (bool, error)
	GetSome(string) []T
}

type QueryRunner interface {
	RunQuery0(*RU.QuerySpec) (any, error)   // ie. Exec()
	RunQuery1(*RU.QuerySpec) (any, error)   // One row, like by_ID
	RunQueryN(*RU.QuerySpec) ([]any, error) // Multiple rows
}

type RepoAppTables interface {
	// SetAppTables specifies the schemata of the specified app's
	// tables, which this interface creates and/or manages. Multiple
	// calls, whether with tables previously specified or not before
	// seen do not conflict; if a table name is repeated but with a
	// different schema, the result is undefined.
	SetAppTables(string, []RU.TableDescriptor) error
	// EmptyAllTables deletes (app-level) data from the app's tables
	// but does not delete any tables (i.e. no DROP TABLE are done).
	EmptyAppTables() error
	// CreateTables creates the app's tables per already-supplied
	// schema(ta); if the tables exist, they are emptied of data.
	CreateAppTables() error
}

type SessionLifecycle interface {
	// Open is called on an existing repo file, and can be called
	// multiple times in a sessions, so it should not pragma-style
	// initialization; however, options passed in the connection
	// string (such as SQLite's "...?foreign_keys=on") are kosher.
	Open() error
	// TODO:? return it, for use or understanding
	// InitString() string
	// IsOpen pings the DB as a health check.
	IsOpen() bool
	// Verify runs app-level sanity & consistency checks (but things
	// like foreign key integtrity should be delegated to DB setup).
	Verify() error
	Flush() error
	// Close remembers the path (like os.File does).
	Close() error
}

type SimpleRepo interface {
	DBImplementation // "sqlite"
	DBEntity         // path, open, isOpen, etc.
	DBBackups        // cp, mv, restoreFrom
	SessionLifecycle // open, close, etc.
	StatementBuilder // using struct RU.QuerySpec
	QueryRunner      // return 0,1,N rows
}

type StatementBuilder interface {
	BuildQueryStmt(*RU.QuerySpec) (string, error)
	BuildCreateTableStmt(*RU.TableDescriptor) (string, error)
}

type TypedRepo[T any] struct {
	// contains filtered or unexported fields
}

type TypedRepoer[T any] interface {
	Add(T) (int, error)
	Mod(T) error
	Del(T) error
	GetByID(int) error
	ModByID(int) error
	DelByID(int) error
	GetAll() ([]T, []error)
	AddAll([]T) ([]int, []error)
	ModAll([]T) ([]T, []error)
	DelAll([]T) []error
	DelAllByID([]int) []error
}

type UntypedRepoer interface {
	GetByID() (any, error)
	Add(any) (int, error)
	ModByID(any) error
}

type Zork struct {
	I int
	S string
}