postgresql

type Database struct {
	Name               string `json:"name"`
	Owner              string `json:"owner"`
	Template           string `json:"template"`
	Encoding           string `json:"encoding"`
	Collation          string `json:"collation"`
	LcCtype            string `json:"lcCtype"`
	TablespaceName     string `json:"tablespaceName"`
	ConnectionLimit    int    `json:"connectionLimit"`
	IsTemplate         bool   `json:"isTemplate"`
	DisableConnections bool   `json:"disableConnections"`

	// Do not error if trying to create a database that already exists
	// Instead, read the existing and return
	UseExisting bool `json:"useExisting"`
}

type Databases struct {
	DbOpener DbOpener
}

type DbInfo struct {
	DbVersion         semver.Version
	SupportedFeatures Features
	IsSuperuser       bool
	CurrentUser       string
}

type DbOpener interface {
	OpenDatabase(dbName string) (*sql.DB, error)
}

type DefaultGrant struct {
	Id       string `json:"id"`
	Role     string `json:"role"`
	Target   string `json:"target"`
	Database string `json:"database"`
}

type DefaultGrantKey struct {
	Role     string
	Target   string
	Database string
}

type DefaultGrants struct {
	DbOpener DbOpener
}

type FeatureName uint

type Features map[FeatureName]bool

type NoopRevoker struct {
}

type Publication struct {
	Name     string `json:"name"`
	Database string `json:"database"`

	AllTables bool               `json:"allTables"`
	Schemas   []string           `json:"schemas"`
	Tables    []PublicationTable `json:"tables"`

	// Do not error if trying to create a publication that already exists
	// Instead, reconcile the existing publication's membership and return
	UseExisting bool `json:"useExisting"`
}

type PublicationKey struct {
	Database string
	Name     string
}

type PublicationTable struct {
	Schema string `json:"schema"`
	Name   string `json:"name"`
}

type Publications struct {
	DbOpener DbOpener
}

type ReplicationSlot struct {
	Name     string `json:"name"`
	Database string `json:"database"`
	// Plugin is the logical decoding output plugin, defaults to `pgoutput`
	Plugin string `json:"plugin"`

	// Active reports whether a consumer is currently streaming from this slot (read-only)
	Active bool `json:"active"`

	// Do not error if trying to create a slot that already exists
	// Instead, read the existing and return
	UseExisting bool `json:"useExisting"`
}

type ReplicationSlotKey struct {
	Database string
	Name     string
}

type ReplicationSlots struct {
	DbOpener DbOpener
}

type Revoker interface {
	Revoke(db *sql.DB) error
}

type Role struct {
	Name     string `json:"name"`
	Password string `json:"password"`
	// Do not error if trying to create a role that already exists
	// Instead, read the existing, set the password, and return
	UseExisting bool `json:"useExisting"`
	// SkipPasswordUpdate informs Create to skip updating the role's password if the role already exists
	SkipPasswordUpdate bool `json:"-"`

	MemberOf   []string       `json:"memberOf"`
	Attributes RoleAttributes `json:"attributes"`
}

type RoleAttributes struct {
	CreateDb   bool `json:"createDb"`
	CreateRole bool `json:"createRole"`
	// Replication allows the role to initiate streaming replication and to create/drop replication slots
	// This is required for logical replication consumers (e.g. Datastream)
	Replication bool `json:"replication"`
}

type RoleMember struct {
	// Member receives all the permissions for Target
	Member string `json:"member"`

	// Target is the role that gains an additional Member
	Target string `json:"target"`

	// WithAdminOption permits Member to grant it to others
	WithAdminOption bool `json:"withAdminOption"`

	// Do not error if trying to create a role membership that already exists
	// Instead, return the existing
	UseExisting bool `json:"useExisting"`
}

type RoleMemberKey struct {
	Member string
	Target string
}

type RoleMembers struct {
	DbOpener DbOpener
}

type Roles struct {
	DbOpener DbOpener
}

type SchemaPrivilege struct {
	Role     string `json:"role"`
	Database string `json:"database"`
}

type SchemaPrivilegeKey struct {
	Role     string
	Database string
}

type SchemaPrivileges struct {
	DbOpener DbOpener
}

type Settings struct {
	Version     string `json:"version"`
	CurrentUser string `json:"currentUser"`
	IsSuperuser bool   `json:"isSuperuser"`

	// WalLevel is `logical` when logical replication is available
	// On cloud sql, this is controlled by the `cloudsql.logical_decoding` database flag (requires an instance restart)
	WalLevel string `json:"walLevel"`

	MaxReplicationSlots  int `json:"maxReplicationSlots"`
	MaxWalSenders        int `json:"maxWalSenders"`
	UsedReplicationSlots int `json:"usedReplicationSlots"`
}

type SettingsReader struct {
	DbOpener DbOpener
}

type Store struct {
	Databases        *Databases
	Roles            *Roles
	RoleMembers      *RoleMembers
	DefaultGrants    *DefaultGrants
	SchemaPrivileges *SchemaPrivileges
	TablePrivileges  *TablePrivileges
	Publications     *Publications
	ReplicationSlots *ReplicationSlots
	Settings         *SettingsReader

	sync.Mutex
	// contains filtered or unexported fields
}

type TablePrivilege struct {
	Id       string `json:"id"`
	Database string `json:"database"`
	// Schema is the schema to grant on, or `*` for every non-system schema in the database
	Schema string `json:"schema"`
	Role   string `json:"role"`

	// Privileges defaults to `["SELECT"]`
	Privileges []string `json:"privileges"`

	// IncludeFuture also grants the privileges on tables created later, via ALTER DEFAULT PRIVILEGES
	IncludeFuture bool `json:"includeFuture"`
	// FutureFromRoles lists the roles whose future tables are covered by IncludeFuture
	// Default privileges only apply to objects created by a specific role, so covering an application's future tables
	// requires naming the role that creates them -- an empty list only covers tables created by the admin user itself
	FutureFromRoles []string `json:"futureFromRoles"`
	// FutureFromTableOwners adds every role that currently owns a table in the schema to FutureFromRoles
	FutureFromTableOwners bool `json:"futureFromTableOwners"`

	// GrantConnect also grants CONNECT on the database
	GrantConnect bool `json:"grantConnect"`
}

type TablePrivilegeKey struct {
	Database string
	Schema   string
	Role     string
}

type TablePrivileges struct {
	DbOpener DbOpener
}

type TempGrant struct {
	Tx          *sql.Tx
	Role        string
	CurrentUser string
}

type TempGrants struct {
	Tx          *sql.Tx
	Roles       []string
	CurrentUser string
}