aperturedb

type BaseDB struct {
	*sql.DB

	*sqlc.Queries
}

type BatchedLNCSessionsDB interface {
	LNCSessionsDB

	BatchedTx[LNCSessionsDB]
}

type BatchedOnionDB interface {
	OnionDB

	BatchedTx[OnionDB]
}

type BatchedQuerier interface {
	// Querier is the underlying query source, this is in place so we can
	// pass a BatchedQuerier implementation directly into objects that
	// create a batched version of the normal methods they need.
	sqlc.Querier

	// BeginTx creates a new database transaction given the set of
	// transaction options.
	BeginTx(ctx context.Context, options TxOptions) (*sql.Tx, error)
}

type BatchedSecretsDB interface {
	SecretsDB

	BatchedTx[SecretsDB]
}

type BatchedTx[Q any] interface {
	// ExecTx will execute the passed txBody, operating upon generic
	// parameter Q (usually a storage interface) in a single transaction.
	// The set of TxOptions are passed in in order to allow the caller to
	// specify if a transaction should be read-only and optionally what
	// type of concurrency control should be used.
	ExecTx(ctx context.Context, txOptions TxOptions,
		txBody func(Q) error) error
}

type ErrSQLUniqueConstraintViolation struct {
	DBError error
}

type ErrSerializationError struct {
	DBError error
}

type LNCSessionsDB interface {
	// InsertLNCSession inserts a new session into the database.
	InsertSession(ctx context.Context, arg NewLNCSession) error

	// GetLNCSession returns the session tagged with the given passphrase
	// entropy.
	GetSession(ctx context.Context,
		passphraseEntropy []byte) (sqlc.LncSession, error)

	// SetRemotePubKey sets the remote public key for the session.
	SetRemotePubKey(ctx context.Context,
		arg SetRemoteParams) error

	// SetExpiry sets the expiry for the session.
	SetExpiry(ctx context.Context, arg SetExpiryParams) error
}

type LNCSessionsDBTxOptions struct {
	// contains filtered or unexported fields
}

type LNCSessionsStore struct {
	// contains filtered or unexported fields
}

type NewLNCSession = sqlc.InsertSessionParams

type NewOnionPrivateKey = sqlc.UpsertOnionParams

type NewSecret = sqlc.InsertSecretParams

type OnionDB interface {
	// UpsertOnion inserts a new onion private key into the database. If
	// the onion private key already exists in the db this is a NOOP
	// operation.
	UpsertOnion(ctx context.Context, arg NewOnionPrivateKey) error

	// SelectOnionPrivateKey selects the onion private key from the
	// database.
	SelectOnionPrivateKey(ctx context.Context) ([]byte, error)

	// DeleteOnionPrivateKey deletes the onion private key from the
	// database.
	DeleteOnionPrivateKey(ctx context.Context) error
}

type OnionDBTxOptions struct {
	// contains filtered or unexported fields
}

type OnionStore struct {
	// contains filtered or unexported fields
}

type PostgresConfig struct {
	SkipMigrations     bool   `long:"skipmigrations" description:"Skip applying migrations on startup."`
	Host               string `long:"host" description:"Database server hostname."`
	Port               int    `long:"port" description:"Database server port."`
	User               string `long:"user" description:"Database user."`
	Password           string `long:"password" description:"Database user's password."`
	DBName             string `long:"dbname" description:"Database name to use."`
	MaxOpenConnections int32  `long:"maxconnections" description:"Max open connections to keep alive to the database server."`
	RequireSSL         bool   `long:"requiressl" description:"Whether to require using SSL (mode: require) when connecting to the server."`
}

type PostgresStore struct {
	*BaseDB
	// contains filtered or unexported fields
}

type QueryCreator[Q any] func(*sql.Tx) Q

type SecretsDB interface {
	// InsertSecret inserts a new secret into the database.
	InsertSecret(ctx context.Context, arg NewSecret) (int32, error)

	// GetSecretByHash returns the secret that corresponds to the given
	// hash.
	GetSecretByHash(ctx context.Context, hash []byte) ([]byte, error)

	// DeleteSecretByHash removes the secret that corresponds to the given
	// hash.
	DeleteSecretByHash(ctx context.Context, hash []byte) (int64, error)
}

type SecretsDBTxOptions struct {
	// contains filtered or unexported fields
}

type SecretsStore struct {
	// contains filtered or unexported fields
}

type SetExpiryParams = sqlc.SetExpiryParams

type SetRemoteParams = sqlc.SetRemotePubKeyParams

type SqliteConfig struct {
	// SkipMigrations if true, then all the tables will be created on start
	// up if they don't already exist.
	SkipMigrations bool `long:"skipmigrations" description:"Skip applying migrations on startup."`

	// DatabaseFileName is the full file path where the database file can be
	// found.
	DatabaseFileName string `long:"dbfile" description:"The full path to the database."`
}

type SqliteStore struct {
	*BaseDB
	// contains filtered or unexported fields
}

type TestPgFixture struct {
	// contains filtered or unexported fields
}

type TransactionExecutor[Query any] struct {
	BatchedQuerier
	// contains filtered or unexported fields
}

type Tx interface {
	// Commit commits the database transaction, an error should be returned
	// if the commit isn't possible.
	Commit() error

	// Rollback rolls back an incomplete database transaction.
	// Transactions that were able to be committed can still call this as a
	// noop.
	Rollback() error
}

type TxExecutorOption func(*txExecutorOptions)

type TxOptions interface {
	// ReadOnly returns true if the transaction should be read only.
	ReadOnly() bool
}