sqlcmig6: add sqlcmig6 package

This commit introduces the `sqlcmig6` package, which at the time of this
commit contains the same queries and models as `sqlc` package.
Importantly though, once the kvdb to sql migration is made available in
production, the `sqlcmig6` package will not change, as it is intended
to represent the sql db as it was at the time of the migration.

The sqlcmig6 package is therefore intended to be used in the kvdb to sql
migration code, as it is will always be compatible with the sql database
when all sql migrations prior to the kvdb to sql migration are applied.

When additional sql migrations are added in the future, they may effect
the `sqlc` package in such a way that the standard `sqlc` queries and
models aren't compatible with kvdb to sql migration code any longer.

By preserving the `sqlcmig6` package, we ensure that the kvdb to sql
migration code can always use the same queries and models that were
available at the time of the migration, even if the `sqlc` package
changes in the future.

Note that the `sqlcmig6` package have not been generated by `sqlc` (the
queries and models are copied from the `sqlc` package), as it is not
intended to be changed in the future.
This commit is contained in:
Viktor Tigerström 2025-07-11 01:16:52 +02:00 committed by Viktor Torstensson
parent 61297e7493
commit 21be674552
No known key found for this signature in database
GPG key ID: 961CC8259AE675D4
11 changed files with 2158 additions and 0 deletions

View file

@ -72,3 +72,10 @@ issues:
- unused
- deadcode
- varcheck
# As the db/sqlcmig6 package has been copied from sqlc generated code,
# but isn't marked as code generated by sqlc, the code line length in the
# package will often exceed the lll/ll limit.
- path: db/sqlcmig6/.*
linters:
- lll
- ll

410
db/sqlcmig6/accounts.sql.go Normal file
View file

@ -0,0 +1,410 @@
package sqlcmig6
import (
"context"
"database/sql"
"time"
)
const addAccountInvoice = `-- name: AddAccountInvoice :exec
INSERT INTO account_invoices (account_id, hash)
VALUES ($1, $2)
`
type AddAccountInvoiceParams struct {
AccountID int64
Hash []byte
}
func (q *Queries) AddAccountInvoice(ctx context.Context, arg AddAccountInvoiceParams) error {
_, err := q.db.ExecContext(ctx, addAccountInvoice, arg.AccountID, arg.Hash)
return err
}
const deleteAccount = `-- name: DeleteAccount :exec
DELETE FROM accounts
WHERE id = $1
`
func (q *Queries) DeleteAccount(ctx context.Context, id int64) error {
_, err := q.db.ExecContext(ctx, deleteAccount, id)
return err
}
const deleteAccountPayment = `-- name: DeleteAccountPayment :exec
DELETE FROM account_payments
WHERE hash = $1
AND account_id = $2
`
type DeleteAccountPaymentParams struct {
Hash []byte
AccountID int64
}
func (q *Queries) DeleteAccountPayment(ctx context.Context, arg DeleteAccountPaymentParams) error {
_, err := q.db.ExecContext(ctx, deleteAccountPayment, arg.Hash, arg.AccountID)
return err
}
const getAccount = `-- name: GetAccount :one
SELECT id, alias, label, type, initial_balance_msat, current_balance_msat, last_updated, expiration
FROM accounts
WHERE id = $1
`
func (q *Queries) GetAccount(ctx context.Context, id int64) (Account, error) {
row := q.db.QueryRowContext(ctx, getAccount, id)
var i Account
err := row.Scan(
&i.ID,
&i.Alias,
&i.Label,
&i.Type,
&i.InitialBalanceMsat,
&i.CurrentBalanceMsat,
&i.LastUpdated,
&i.Expiration,
)
return i, err
}
const getAccountByLabel = `-- name: GetAccountByLabel :one
SELECT id, alias, label, type, initial_balance_msat, current_balance_msat, last_updated, expiration
FROM accounts
WHERE label = $1
`
func (q *Queries) GetAccountByLabel(ctx context.Context, label sql.NullString) (Account, error) {
row := q.db.QueryRowContext(ctx, getAccountByLabel, label)
var i Account
err := row.Scan(
&i.ID,
&i.Alias,
&i.Label,
&i.Type,
&i.InitialBalanceMsat,
&i.CurrentBalanceMsat,
&i.LastUpdated,
&i.Expiration,
)
return i, err
}
const getAccountIDByAlias = `-- name: GetAccountIDByAlias :one
SELECT id
FROM accounts
WHERE alias = $1
`
func (q *Queries) GetAccountIDByAlias(ctx context.Context, alias int64) (int64, error) {
row := q.db.QueryRowContext(ctx, getAccountIDByAlias, alias)
var id int64
err := row.Scan(&id)
return id, err
}
const getAccountIndex = `-- name: GetAccountIndex :one
SELECT value
FROM account_indices
WHERE name = $1
`
func (q *Queries) GetAccountIndex(ctx context.Context, name string) (int64, error) {
row := q.db.QueryRowContext(ctx, getAccountIndex, name)
var value int64
err := row.Scan(&value)
return value, err
}
const getAccountInvoice = `-- name: GetAccountInvoice :one
SELECT account_id, hash
FROM account_invoices
WHERE account_id = $1
AND hash = $2
`
type GetAccountInvoiceParams struct {
AccountID int64
Hash []byte
}
func (q *Queries) GetAccountInvoice(ctx context.Context, arg GetAccountInvoiceParams) (AccountInvoice, error) {
row := q.db.QueryRowContext(ctx, getAccountInvoice, arg.AccountID, arg.Hash)
var i AccountInvoice
err := row.Scan(&i.AccountID, &i.Hash)
return i, err
}
const getAccountPayment = `-- name: GetAccountPayment :one
SELECT account_id, hash, status, full_amount_msat FROM account_payments
WHERE hash = $1
AND account_id = $2
`
type GetAccountPaymentParams struct {
Hash []byte
AccountID int64
}
func (q *Queries) GetAccountPayment(ctx context.Context, arg GetAccountPaymentParams) (AccountPayment, error) {
row := q.db.QueryRowContext(ctx, getAccountPayment, arg.Hash, arg.AccountID)
var i AccountPayment
err := row.Scan(
&i.AccountID,
&i.Hash,
&i.Status,
&i.FullAmountMsat,
)
return i, err
}
const insertAccount = `-- name: InsertAccount :one
INSERT INTO accounts (type, initial_balance_msat, current_balance_msat, last_updated, label, alias, expiration)
VALUES ($1, $2, $3, $4, $5, $6, $7)
RETURNING id
`
type InsertAccountParams struct {
Type int16
InitialBalanceMsat int64
CurrentBalanceMsat int64
LastUpdated time.Time
Label sql.NullString
Alias int64
Expiration time.Time
}
func (q *Queries) InsertAccount(ctx context.Context, arg InsertAccountParams) (int64, error) {
row := q.db.QueryRowContext(ctx, insertAccount,
arg.Type,
arg.InitialBalanceMsat,
arg.CurrentBalanceMsat,
arg.LastUpdated,
arg.Label,
arg.Alias,
arg.Expiration,
)
var id int64
err := row.Scan(&id)
return id, err
}
const listAccountInvoices = `-- name: ListAccountInvoices :many
SELECT account_id, hash
FROM account_invoices
WHERE account_id = $1
`
func (q *Queries) ListAccountInvoices(ctx context.Context, accountID int64) ([]AccountInvoice, error) {
rows, err := q.db.QueryContext(ctx, listAccountInvoices, accountID)
if err != nil {
return nil, err
}
defer rows.Close()
var items []AccountInvoice
for rows.Next() {
var i AccountInvoice
if err := rows.Scan(&i.AccountID, &i.Hash); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listAccountPayments = `-- name: ListAccountPayments :many
SELECT account_id, hash, status, full_amount_msat
FROM account_payments
WHERE account_id = $1
`
func (q *Queries) ListAccountPayments(ctx context.Context, accountID int64) ([]AccountPayment, error) {
rows, err := q.db.QueryContext(ctx, listAccountPayments, accountID)
if err != nil {
return nil, err
}
defer rows.Close()
var items []AccountPayment
for rows.Next() {
var i AccountPayment
if err := rows.Scan(
&i.AccountID,
&i.Hash,
&i.Status,
&i.FullAmountMsat,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listAllAccounts = `-- name: ListAllAccounts :many
SELECT id, alias, label, type, initial_balance_msat, current_balance_msat, last_updated, expiration
FROM accounts
ORDER BY id
`
func (q *Queries) ListAllAccounts(ctx context.Context) ([]Account, error) {
rows, err := q.db.QueryContext(ctx, listAllAccounts)
if err != nil {
return nil, err
}
defer rows.Close()
var items []Account
for rows.Next() {
var i Account
if err := rows.Scan(
&i.ID,
&i.Alias,
&i.Label,
&i.Type,
&i.InitialBalanceMsat,
&i.CurrentBalanceMsat,
&i.LastUpdated,
&i.Expiration,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const setAccountIndex = `-- name: SetAccountIndex :exec
INSERT INTO account_indices (name, value)
VALUES ($1, $2)
ON CONFLICT (name)
DO UPDATE SET value = $2
`
type SetAccountIndexParams struct {
Name string
Value int64
}
func (q *Queries) SetAccountIndex(ctx context.Context, arg SetAccountIndexParams) error {
_, err := q.db.ExecContext(ctx, setAccountIndex, arg.Name, arg.Value)
return err
}
const updateAccountAliasForTests = `-- name: UpdateAccountAliasForTests :one
UPDATE accounts
SET alias = $1
WHERE id = $2
RETURNING id
`
type UpdateAccountAliasForTestsParams struct {
Alias int64
ID int64
}
// NOTE: This query is only intended for testing purposes.
func (q *Queries) UpdateAccountAliasForTests(ctx context.Context, arg UpdateAccountAliasForTestsParams) (int64, error) {
row := q.db.QueryRowContext(ctx, updateAccountAliasForTests, arg.Alias, arg.ID)
var id int64
err := row.Scan(&id)
return id, err
}
const updateAccountBalance = `-- name: UpdateAccountBalance :one
UPDATE accounts
SET current_balance_msat = $1
WHERE id = $2
RETURNING id
`
type UpdateAccountBalanceParams struct {
CurrentBalanceMsat int64
ID int64
}
func (q *Queries) UpdateAccountBalance(ctx context.Context, arg UpdateAccountBalanceParams) (int64, error) {
row := q.db.QueryRowContext(ctx, updateAccountBalance, arg.CurrentBalanceMsat, arg.ID)
var id int64
err := row.Scan(&id)
return id, err
}
const updateAccountExpiry = `-- name: UpdateAccountExpiry :one
UPDATE accounts
SET expiration = $1
WHERE id = $2
RETURNING id
`
type UpdateAccountExpiryParams struct {
Expiration time.Time
ID int64
}
func (q *Queries) UpdateAccountExpiry(ctx context.Context, arg UpdateAccountExpiryParams) (int64, error) {
row := q.db.QueryRowContext(ctx, updateAccountExpiry, arg.Expiration, arg.ID)
var id int64
err := row.Scan(&id)
return id, err
}
const updateAccountLastUpdate = `-- name: UpdateAccountLastUpdate :one
UPDATE accounts
SET last_updated = $1
WHERE id = $2
RETURNING id
`
type UpdateAccountLastUpdateParams struct {
LastUpdated time.Time
ID int64
}
func (q *Queries) UpdateAccountLastUpdate(ctx context.Context, arg UpdateAccountLastUpdateParams) (int64, error) {
row := q.db.QueryRowContext(ctx, updateAccountLastUpdate, arg.LastUpdated, arg.ID)
var id int64
err := row.Scan(&id)
return id, err
}
const upsertAccountPayment = `-- name: UpsertAccountPayment :exec
INSERT INTO account_payments (account_id, hash, status, full_amount_msat)
VALUES ($1, $2, $3, $4)
ON CONFLICT (account_id, hash)
DO UPDATE SET status = $3, full_amount_msat = $4
`
type UpsertAccountPaymentParams struct {
AccountID int64
Hash []byte
Status int16
FullAmountMsat int64
}
func (q *Queries) UpsertAccountPayment(ctx context.Context, arg UpsertAccountPaymentParams) error {
_, err := q.db.ExecContext(ctx, upsertAccountPayment,
arg.AccountID,
arg.Hash,
arg.Status,
arg.FullAmountMsat,
)
return err
}

101
db/sqlcmig6/actions.sql.go Normal file
View file

@ -0,0 +1,101 @@
package sqlcmig6
import (
"context"
"database/sql"
"time"
)
const getAction = `-- name: GetAction :one
SELECT id, session_id, account_id, macaroon_identifier, actor_name, feature_name, action_trigger, intent, structured_json_data, rpc_method, rpc_params_json, created_at, action_state, error_reason
FROM actions
WHERE id = $1
`
func (q *Queries) GetAction(ctx context.Context, id int64) (Action, error) {
row := q.db.QueryRowContext(ctx, getAction, id)
var i Action
err := row.Scan(
&i.ID,
&i.SessionID,
&i.AccountID,
&i.MacaroonIdentifier,
&i.ActorName,
&i.FeatureName,
&i.ActionTrigger,
&i.Intent,
&i.StructuredJsonData,
&i.RpcMethod,
&i.RpcParamsJson,
&i.CreatedAt,
&i.ActionState,
&i.ErrorReason,
)
return i, err
}
const insertAction = `-- name: InsertAction :one
INSERT INTO actions (
session_id, account_id, macaroon_identifier, actor_name, feature_name, action_trigger,
intent, structured_json_data, rpc_method, rpc_params_json, created_at,
action_state, error_reason
) VALUES (
$1, $2, $3, $4, $5, $6,
$7, $8, $9, $10, $11, $12, $13
) RETURNING id
`
type InsertActionParams struct {
SessionID sql.NullInt64
AccountID sql.NullInt64
MacaroonIdentifier []byte
ActorName sql.NullString
FeatureName sql.NullString
ActionTrigger sql.NullString
Intent sql.NullString
StructuredJsonData []byte
RpcMethod string
RpcParamsJson []byte
CreatedAt time.Time
ActionState int16
ErrorReason sql.NullString
}
func (q *Queries) InsertAction(ctx context.Context, arg InsertActionParams) (int64, error) {
row := q.db.QueryRowContext(ctx, insertAction,
arg.SessionID,
arg.AccountID,
arg.MacaroonIdentifier,
arg.ActorName,
arg.FeatureName,
arg.ActionTrigger,
arg.Intent,
arg.StructuredJsonData,
arg.RpcMethod,
arg.RpcParamsJson,
arg.CreatedAt,
arg.ActionState,
arg.ErrorReason,
)
var id int64
err := row.Scan(&id)
return id, err
}
const setActionState = `-- name: SetActionState :exec
UPDATE actions
SET action_state = $1,
error_reason = $2
WHERE id = $3
`
type SetActionStateParams struct {
ActionState int16
ErrorReason sql.NullString
ID int64
}
func (q *Queries) SetActionState(ctx context.Context, arg SetActionStateParams) error {
_, err := q.db.ExecContext(ctx, setActionState, arg.ActionState, arg.ErrorReason, arg.ID)
return err
}

View file

@ -0,0 +1,210 @@
package sqlcmig6
import (
"context"
"database/sql"
"strconv"
"strings"
)
// ActionQueryParams defines the parameters for querying actions.
type ActionQueryParams struct {
SessionID sql.NullInt64
AccountID sql.NullInt64
FeatureName sql.NullString
ActorName sql.NullString
RpcMethod sql.NullString
State sql.NullInt16
EndTime sql.NullTime
StartTime sql.NullTime
GroupID sql.NullInt64
}
// ListActionsParams defines the parameters for listing actions, including
// the ActionQueryParams for filtering and a Pagination struct for
// pagination. The Reversed field indicates whether the results should be
// returned in reverse order based on the created_at timestamp.
type ListActionsParams struct {
ActionQueryParams
Reversed bool
*Pagination
}
// Pagination defines the pagination parameters for listing actions.
type Pagination struct {
NumOffset int32
NumLimit int32
}
// ListActions retrieves a list of actions based on the provided
// ListActionsParams.
func (q *Queries) ListActions(ctx context.Context,
arg ListActionsParams) ([]Action, error) {
query, args := buildListActionsQuery(arg)
rows, err := q.db.QueryContext(ctx, fillPlaceHolders(query), args...)
if err != nil {
return nil, err
}
defer rows.Close()
var items []Action
for rows.Next() {
var i Action
if err := rows.Scan(
&i.ID,
&i.SessionID,
&i.AccountID,
&i.MacaroonIdentifier,
&i.ActorName,
&i.FeatureName,
&i.ActionTrigger,
&i.Intent,
&i.StructuredJsonData,
&i.RpcMethod,
&i.RpcParamsJson,
&i.CreatedAt,
&i.ActionState,
&i.ErrorReason,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
// CountActions returns the number of actions that match the provided
// ActionQueryParams.
func (q *Queries) CountActions(ctx context.Context,
arg ActionQueryParams) (int64, error) {
query, args := buildActionsQuery(arg, true)
row := q.db.QueryRowContext(ctx, query, args...)
var count int64
err := row.Scan(&count)
return count, err
}
// buildActionsQuery constructs a SQL query to retrieve actions based on the
// provided parameters. We do this manually so that if, for example, we have
// a sessionID we are filtering by, then this appears in the query as:
// `WHERE a.session_id = ?` which will properly make use of the underlying
// index. If we were instead to use a single SQLC query, it would include many
// WHERE clauses like:
// "WHERE a.session_id = COALESCE(sqlc.narg('session_id'), a.session_id)".
// This would use the index if run against postres but not when run against
// sqlite.
//
// The 'count' param indicates whether the query should return a count of
// actions that match the criteria or the actions themselves.
func buildActionsQuery(params ActionQueryParams, count bool) (string, []any) {
var (
conditions []string
args []any
)
if params.SessionID.Valid {
conditions = append(conditions, "a.session_id = ?")
args = append(args, params.SessionID.Int64)
}
if params.AccountID.Valid {
conditions = append(conditions, "a.account_id = ?")
args = append(args, params.AccountID.Int64)
}
if params.FeatureName.Valid {
conditions = append(conditions, "a.feature_name = ?")
args = append(args, params.FeatureName.String)
}
if params.ActorName.Valid {
conditions = append(conditions, "a.actor_name = ?")
args = append(args, params.ActorName.String)
}
if params.RpcMethod.Valid {
conditions = append(conditions, "a.rpc_method = ?")
args = append(args, params.RpcMethod.String)
}
if params.State.Valid {
conditions = append(conditions, "a.action_state = ?")
args = append(args, params.State.Int16)
}
if params.EndTime.Valid {
conditions = append(conditions, "a.created_at <= ?")
args = append(args, params.EndTime.Time)
}
if params.StartTime.Valid {
conditions = append(conditions, "a.created_at >= ?")
args = append(args, params.StartTime.Time)
}
if params.GroupID.Valid {
conditions = append(conditions, `
EXISTS (
SELECT 1
FROM sessions s
WHERE s.id = a.session_id AND s.group_id = ?
)`)
args = append(args, params.GroupID.Int64)
}
query := "SELECT a.* FROM actions a"
if count {
query = "SELECT COUNT(*) FROM actions a"
}
if len(conditions) > 0 {
query += " WHERE " + strings.Join(conditions, " AND ")
}
return query, args
}
// buildListActionsQuery constructs a SQL query to retrieve a list of actions
// based on the provided parameters. It builds upon the `buildActionsQuery`
// function, adding pagination and ordering based on the reversed parameter.
func buildListActionsQuery(params ListActionsParams) (string, []interface{}) {
query, args := buildActionsQuery(params.ActionQueryParams, false)
// Determine order direction.
order := "ASC"
if params.Reversed {
order = "DESC"
}
query += " ORDER BY a.created_at " + order
// Maybe paginate.
if params.Pagination != nil {
query += " LIMIT ? OFFSET ?"
args = append(args, params.NumLimit, params.NumOffset)
}
return query, args
}
// fillPlaceHolders replaces all '?' placeholders in the SQL query with
// positional placeholders like $1, $2, etc. This is necessary for
// compatibility with Postgres.
func fillPlaceHolders(query string) string {
var (
sb strings.Builder
argNum = 1
)
for i := range len(query) {
if query[i] != '?' {
sb.WriteByte(query[i])
continue
}
sb.WriteString("$")
sb.WriteString(strconv.Itoa(argNum))
argNum++
}
return sb.String()
}

27
db/sqlcmig6/db.go Normal file
View file

@ -0,0 +1,27 @@
package sqlcmig6
import (
"context"
"database/sql"
)
type DBTX interface {
ExecContext(context.Context, string, ...interface{}) (sql.Result, error)
PrepareContext(context.Context, string) (*sql.Stmt, error)
QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error)
QueryRowContext(context.Context, string, ...interface{}) *sql.Row
}
func New(db DBTX) *Queries {
return &Queries{db: db}
}
type Queries struct {
db DBTX
}
func (q *Queries) WithTx(tx *sql.Tx) *Queries {
return &Queries{
db: tx,
}
}

48
db/sqlcmig6/db_custom.go Normal file
View file

@ -0,0 +1,48 @@
package sqlcmig6
import (
"context"
"github.com/lightningnetwork/lnd/sqldb/v2"
)
// wrappedTX is a wrapper around a DBTX that also stores the database backend
// type.
type wrappedTX struct {
DBTX
backendType sqldb.BackendType
}
// Backend returns the type of database backend we're using.
func (q *Queries) Backend() sqldb.BackendType {
wtx, ok := q.db.(*wrappedTX)
if !ok {
// Shouldn't happen unless a new database backend type is added
// but not initialized correctly.
return sqldb.BackendTypeUnknown
}
return wtx.backendType
}
// NewForType creates a new Queries instance for the given database type.
func NewForType(db DBTX, typ sqldb.BackendType) *Queries {
return &Queries{db: &wrappedTX{db, typ}}
}
// CustomQueries defines a set of custom queries that we define in addition
// to the ones generated by sqlc.
type CustomQueries interface {
// CountActions returns the number of actions that match the provided
// ActionQueryParams.
CountActions(ctx context.Context, arg ActionQueryParams) (int64, error)
// ListActions retrieves a list of actions based on the provided
// ListActionsParams.
ListActions(ctx context.Context,
arg ListActionsParams) ([]Action, error)
// Backend returns the type of the database backend used.
Backend() sqldb.BackendType
}

376
db/sqlcmig6/kvstores.sql.go Normal file
View file

@ -0,0 +1,376 @@
package sqlcmig6
import (
"context"
"database/sql"
)
const deleteAllTempKVStores = `-- name: DeleteAllTempKVStores :exec
DELETE FROM kvstores
WHERE perm = false
`
func (q *Queries) DeleteAllTempKVStores(ctx context.Context) error {
_, err := q.db.ExecContext(ctx, deleteAllTempKVStores)
return err
}
const deleteFeatureKVStoreRecord = `-- name: DeleteFeatureKVStoreRecord :exec
DELETE FROM kvstores
WHERE entry_key = $1
AND rule_id = $2
AND perm = $3
AND group_id = $4
AND feature_id = $5
`
type DeleteFeatureKVStoreRecordParams struct {
Key string
RuleID int64
Perm bool
GroupID sql.NullInt64
FeatureID sql.NullInt64
}
func (q *Queries) DeleteFeatureKVStoreRecord(ctx context.Context, arg DeleteFeatureKVStoreRecordParams) error {
_, err := q.db.ExecContext(ctx, deleteFeatureKVStoreRecord,
arg.Key,
arg.RuleID,
arg.Perm,
arg.GroupID,
arg.FeatureID,
)
return err
}
const deleteGlobalKVStoreRecord = `-- name: DeleteGlobalKVStoreRecord :exec
DELETE FROM kvstores
WHERE entry_key = $1
AND rule_id = $2
AND perm = $3
AND group_id IS NULL
AND feature_id IS NULL
`
type DeleteGlobalKVStoreRecordParams struct {
Key string
RuleID int64
Perm bool
}
func (q *Queries) DeleteGlobalKVStoreRecord(ctx context.Context, arg DeleteGlobalKVStoreRecordParams) error {
_, err := q.db.ExecContext(ctx, deleteGlobalKVStoreRecord, arg.Key, arg.RuleID, arg.Perm)
return err
}
const deleteGroupKVStoreRecord = `-- name: DeleteGroupKVStoreRecord :exec
DELETE FROM kvstores
WHERE entry_key = $1
AND rule_id = $2
AND perm = $3
AND group_id = $4
AND feature_id IS NULL
`
type DeleteGroupKVStoreRecordParams struct {
Key string
RuleID int64
Perm bool
GroupID sql.NullInt64
}
func (q *Queries) DeleteGroupKVStoreRecord(ctx context.Context, arg DeleteGroupKVStoreRecordParams) error {
_, err := q.db.ExecContext(ctx, deleteGroupKVStoreRecord,
arg.Key,
arg.RuleID,
arg.Perm,
arg.GroupID,
)
return err
}
const getFeatureID = `-- name: GetFeatureID :one
SELECT id
FROM features
WHERE name = $1
`
func (q *Queries) GetFeatureID(ctx context.Context, name string) (int64, error) {
row := q.db.QueryRowContext(ctx, getFeatureID, name)
var id int64
err := row.Scan(&id)
return id, err
}
const getFeatureKVStoreRecord = `-- name: GetFeatureKVStoreRecord :one
SELECT value
FROM kvstores
WHERE entry_key = $1
AND rule_id = $2
AND perm = $3
AND group_id = $4
AND feature_id = $5
`
type GetFeatureKVStoreRecordParams struct {
Key string
RuleID int64
Perm bool
GroupID sql.NullInt64
FeatureID sql.NullInt64
}
func (q *Queries) GetFeatureKVStoreRecord(ctx context.Context, arg GetFeatureKVStoreRecordParams) ([]byte, error) {
row := q.db.QueryRowContext(ctx, getFeatureKVStoreRecord,
arg.Key,
arg.RuleID,
arg.Perm,
arg.GroupID,
arg.FeatureID,
)
var value []byte
err := row.Scan(&value)
return value, err
}
const getGlobalKVStoreRecord = `-- name: GetGlobalKVStoreRecord :one
SELECT value
FROM kvstores
WHERE entry_key = $1
AND rule_id = $2
AND perm = $3
AND group_id IS NULL
AND feature_id IS NULL
`
type GetGlobalKVStoreRecordParams struct {
Key string
RuleID int64
Perm bool
}
func (q *Queries) GetGlobalKVStoreRecord(ctx context.Context, arg GetGlobalKVStoreRecordParams) ([]byte, error) {
row := q.db.QueryRowContext(ctx, getGlobalKVStoreRecord, arg.Key, arg.RuleID, arg.Perm)
var value []byte
err := row.Scan(&value)
return value, err
}
const getGroupKVStoreRecord = `-- name: GetGroupKVStoreRecord :one
SELECT value
FROM kvstores
WHERE entry_key = $1
AND rule_id = $2
AND perm = $3
AND group_id = $4
AND feature_id IS NULL
`
type GetGroupKVStoreRecordParams struct {
Key string
RuleID int64
Perm bool
GroupID sql.NullInt64
}
func (q *Queries) GetGroupKVStoreRecord(ctx context.Context, arg GetGroupKVStoreRecordParams) ([]byte, error) {
row := q.db.QueryRowContext(ctx, getGroupKVStoreRecord,
arg.Key,
arg.RuleID,
arg.Perm,
arg.GroupID,
)
var value []byte
err := row.Scan(&value)
return value, err
}
const getOrInsertFeatureID = `-- name: GetOrInsertFeatureID :one
INSERT INTO features (name)
VALUES ($1)
ON CONFLICT(name) DO UPDATE SET name = excluded.name
RETURNING id
`
func (q *Queries) GetOrInsertFeatureID(ctx context.Context, name string) (int64, error) {
row := q.db.QueryRowContext(ctx, getOrInsertFeatureID, name)
var id int64
err := row.Scan(&id)
return id, err
}
const getOrInsertRuleID = `-- name: GetOrInsertRuleID :one
INSERT INTO rules (name)
VALUES ($1)
ON CONFLICT(name) DO UPDATE SET name = excluded.name
RETURNING id
`
func (q *Queries) GetOrInsertRuleID(ctx context.Context, name string) (int64, error) {
row := q.db.QueryRowContext(ctx, getOrInsertRuleID, name)
var id int64
err := row.Scan(&id)
return id, err
}
const getRuleID = `-- name: GetRuleID :one
SELECT id
FROM rules
WHERE name = $1
`
func (q *Queries) GetRuleID(ctx context.Context, name string) (int64, error) {
row := q.db.QueryRowContext(ctx, getRuleID, name)
var id int64
err := row.Scan(&id)
return id, err
}
const insertKVStoreRecord = `-- name: InsertKVStoreRecord :exec
INSERT INTO kvstores (perm, rule_id, group_id, feature_id, entry_key, value)
VALUES ($1, $2, $3, $4, $5, $6)
`
type InsertKVStoreRecordParams struct {
Perm bool
RuleID int64
GroupID sql.NullInt64
FeatureID sql.NullInt64
EntryKey string
Value []byte
}
func (q *Queries) InsertKVStoreRecord(ctx context.Context, arg InsertKVStoreRecordParams) error {
_, err := q.db.ExecContext(ctx, insertKVStoreRecord,
arg.Perm,
arg.RuleID,
arg.GroupID,
arg.FeatureID,
arg.EntryKey,
arg.Value,
)
return err
}
const listAllKVStoresRecords = `-- name: ListAllKVStoresRecords :many
SELECT id, perm, rule_id, group_id, feature_id, entry_key, value
FROM kvstores
`
func (q *Queries) ListAllKVStoresRecords(ctx context.Context) ([]Kvstore, error) {
rows, err := q.db.QueryContext(ctx, listAllKVStoresRecords)
if err != nil {
return nil, err
}
defer rows.Close()
var items []Kvstore
for rows.Next() {
var i Kvstore
if err := rows.Scan(
&i.ID,
&i.Perm,
&i.RuleID,
&i.GroupID,
&i.FeatureID,
&i.EntryKey,
&i.Value,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const updateFeatureKVStoreRecord = `-- name: UpdateFeatureKVStoreRecord :exec
UPDATE kvstores
SET value = $1
WHERE entry_key = $2
AND rule_id = $3
AND perm = $4
AND group_id = $5
AND feature_id = $6
`
type UpdateFeatureKVStoreRecordParams struct {
Value []byte
Key string
RuleID int64
Perm bool
GroupID sql.NullInt64
FeatureID sql.NullInt64
}
func (q *Queries) UpdateFeatureKVStoreRecord(ctx context.Context, arg UpdateFeatureKVStoreRecordParams) error {
_, err := q.db.ExecContext(ctx, updateFeatureKVStoreRecord,
arg.Value,
arg.Key,
arg.RuleID,
arg.Perm,
arg.GroupID,
arg.FeatureID,
)
return err
}
const updateGlobalKVStoreRecord = `-- name: UpdateGlobalKVStoreRecord :exec
UPDATE kvstores
SET value = $1
WHERE entry_key = $2
AND rule_id = $3
AND perm = $4
AND group_id IS NULL
AND feature_id IS NULL
`
type UpdateGlobalKVStoreRecordParams struct {
Value []byte
Key string
RuleID int64
Perm bool
}
func (q *Queries) UpdateGlobalKVStoreRecord(ctx context.Context, arg UpdateGlobalKVStoreRecordParams) error {
_, err := q.db.ExecContext(ctx, updateGlobalKVStoreRecord,
arg.Value,
arg.Key,
arg.RuleID,
arg.Perm,
)
return err
}
const updateGroupKVStoreRecord = `-- name: UpdateGroupKVStoreRecord :exec
UPDATE kvstores
SET value = $1
WHERE entry_key = $2
AND rule_id = $3
AND perm = $4
AND group_id = $5
AND feature_id IS NULL
`
type UpdateGroupKVStoreRecordParams struct {
Value []byte
Key string
RuleID int64
Perm bool
GroupID sql.NullInt64
}
func (q *Queries) UpdateGroupKVStoreRecord(ctx context.Context, arg UpdateGroupKVStoreRecordParams) error {
_, err := q.db.ExecContext(ctx, updateGroupKVStoreRecord,
arg.Value,
arg.Key,
arg.RuleID,
arg.Perm,
arg.GroupID,
)
return err
}

124
db/sqlcmig6/models.go Normal file
View file

@ -0,0 +1,124 @@
package sqlcmig6
import (
"database/sql"
"time"
)
type Account struct {
ID int64
Alias int64
Label sql.NullString
Type int16
InitialBalanceMsat int64
CurrentBalanceMsat int64
LastUpdated time.Time
Expiration time.Time
}
type AccountIndex struct {
Name string
Value int64
}
type AccountInvoice struct {
AccountID int64
Hash []byte
}
type AccountPayment struct {
AccountID int64
Hash []byte
Status int16
FullAmountMsat int64
}
type Action struct {
ID int64
SessionID sql.NullInt64
AccountID sql.NullInt64
MacaroonIdentifier []byte
ActorName sql.NullString
FeatureName sql.NullString
ActionTrigger sql.NullString
Intent sql.NullString
StructuredJsonData []byte
RpcMethod string
RpcParamsJson []byte
CreatedAt time.Time
ActionState int16
ErrorReason sql.NullString
}
type Feature struct {
ID int64
Name string
}
type Kvstore struct {
ID int64
Perm bool
RuleID int64
GroupID sql.NullInt64
FeatureID sql.NullInt64
EntryKey string
Value []byte
}
type PrivacyPair struct {
GroupID int64
RealVal string
PseudoVal string
}
type Rule struct {
ID int64
Name string
}
type Session struct {
ID int64
Alias []byte
Label string
State int16
Type int16
Expiry time.Time
CreatedAt time.Time
RevokedAt sql.NullTime
ServerAddress string
DevServer bool
MacaroonRootKey int64
PairingSecret []byte
LocalPrivateKey []byte
LocalPublicKey []byte
RemotePublicKey []byte
Privacy bool
AccountID sql.NullInt64
GroupID sql.NullInt64
}
type SessionFeatureConfig struct {
SessionID int64
FeatureName string
Config []byte
}
type SessionMacaroonCaveat struct {
ID int64
SessionID int64
CaveatID []byte
VerificationID []byte
Location sql.NullString
}
type SessionMacaroonPermission struct {
ID int64
SessionID int64
Entity string
Action string
}
type SessionPrivacyFlag struct {
SessionID int64
Flag int32
}

View file

@ -0,0 +1,91 @@
package sqlcmig6
import (
"context"
)
const getAllPrivacyPairs = `-- name: GetAllPrivacyPairs :many
SELECT real_val, pseudo_val
FROM privacy_pairs
WHERE group_id = $1
`
type GetAllPrivacyPairsRow struct {
RealVal string
PseudoVal string
}
func (q *Queries) GetAllPrivacyPairs(ctx context.Context, groupID int64) ([]GetAllPrivacyPairsRow, error) {
rows, err := q.db.QueryContext(ctx, getAllPrivacyPairs, groupID)
if err != nil {
return nil, err
}
defer rows.Close()
var items []GetAllPrivacyPairsRow
for rows.Next() {
var i GetAllPrivacyPairsRow
if err := rows.Scan(&i.RealVal, &i.PseudoVal); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const getPseudoForReal = `-- name: GetPseudoForReal :one
SELECT pseudo_val
FROM privacy_pairs
WHERE group_id = $1 AND real_val = $2
`
type GetPseudoForRealParams struct {
GroupID int64
RealVal string
}
func (q *Queries) GetPseudoForReal(ctx context.Context, arg GetPseudoForRealParams) (string, error) {
row := q.db.QueryRowContext(ctx, getPseudoForReal, arg.GroupID, arg.RealVal)
var pseudo_val string
err := row.Scan(&pseudo_val)
return pseudo_val, err
}
const getRealForPseudo = `-- name: GetRealForPseudo :one
SELECT real_val
FROM privacy_pairs
WHERE group_id = $1 AND pseudo_val = $2
`
type GetRealForPseudoParams struct {
GroupID int64
PseudoVal string
}
func (q *Queries) GetRealForPseudo(ctx context.Context, arg GetRealForPseudoParams) (string, error) {
row := q.db.QueryRowContext(ctx, getRealForPseudo, arg.GroupID, arg.PseudoVal)
var real_val string
err := row.Scan(&real_val)
return real_val, err
}
const insertPrivacyPair = `-- name: InsertPrivacyPair :exec
INSERT INTO privacy_pairs (group_id, real_val, pseudo_val)
VALUES ($1, $2, $3)
`
type InsertPrivacyPairParams struct {
GroupID int64
RealVal string
PseudoVal string
}
func (q *Queries) InsertPrivacyPair(ctx context.Context, arg InsertPrivacyPairParams) error {
_, err := q.db.ExecContext(ctx, insertPrivacyPair, arg.GroupID, arg.RealVal, arg.PseudoVal)
return err
}

79
db/sqlcmig6/querier.go Normal file
View file

@ -0,0 +1,79 @@
package sqlcmig6
import (
"context"
"database/sql"
)
type Querier interface {
AddAccountInvoice(ctx context.Context, arg AddAccountInvoiceParams) error
DeleteAccount(ctx context.Context, id int64) error
DeleteAccountPayment(ctx context.Context, arg DeleteAccountPaymentParams) error
DeleteAllTempKVStores(ctx context.Context) error
DeleteFeatureKVStoreRecord(ctx context.Context, arg DeleteFeatureKVStoreRecordParams) error
DeleteGlobalKVStoreRecord(ctx context.Context, arg DeleteGlobalKVStoreRecordParams) error
DeleteGroupKVStoreRecord(ctx context.Context, arg DeleteGroupKVStoreRecordParams) error
DeleteSession(ctx context.Context, id int64) error
DeleteSessionsWithState(ctx context.Context, state int16) error
GetAccount(ctx context.Context, id int64) (Account, error)
GetAccountByLabel(ctx context.Context, label sql.NullString) (Account, error)
GetAccountIDByAlias(ctx context.Context, alias int64) (int64, error)
GetAccountIndex(ctx context.Context, name string) (int64, error)
GetAccountInvoice(ctx context.Context, arg GetAccountInvoiceParams) (AccountInvoice, error)
GetAccountPayment(ctx context.Context, arg GetAccountPaymentParams) (AccountPayment, error)
GetAction(ctx context.Context, id int64) (Action, error)
GetAliasBySessionID(ctx context.Context, id int64) ([]byte, error)
GetAllPrivacyPairs(ctx context.Context, groupID int64) ([]GetAllPrivacyPairsRow, error)
GetFeatureID(ctx context.Context, name string) (int64, error)
GetFeatureKVStoreRecord(ctx context.Context, arg GetFeatureKVStoreRecordParams) ([]byte, error)
GetGlobalKVStoreRecord(ctx context.Context, arg GetGlobalKVStoreRecordParams) ([]byte, error)
GetGroupKVStoreRecord(ctx context.Context, arg GetGroupKVStoreRecordParams) ([]byte, error)
GetOrInsertFeatureID(ctx context.Context, name string) (int64, error)
GetOrInsertRuleID(ctx context.Context, name string) (int64, error)
GetPseudoForReal(ctx context.Context, arg GetPseudoForRealParams) (string, error)
GetRealForPseudo(ctx context.Context, arg GetRealForPseudoParams) (string, error)
GetRuleID(ctx context.Context, name string) (int64, error)
GetSessionAliasesInGroup(ctx context.Context, groupID sql.NullInt64) ([][]byte, error)
GetSessionByAlias(ctx context.Context, alias []byte) (Session, error)
GetSessionByID(ctx context.Context, id int64) (Session, error)
GetSessionByLocalPublicKey(ctx context.Context, localPublicKey []byte) (Session, error)
GetSessionFeatureConfigs(ctx context.Context, sessionID int64) ([]SessionFeatureConfig, error)
GetSessionIDByAlias(ctx context.Context, alias []byte) (int64, error)
GetSessionMacaroonCaveats(ctx context.Context, sessionID int64) ([]SessionMacaroonCaveat, error)
GetSessionMacaroonPermissions(ctx context.Context, sessionID int64) ([]SessionMacaroonPermission, error)
GetSessionPrivacyFlags(ctx context.Context, sessionID int64) ([]SessionPrivacyFlag, error)
GetSessionsInGroup(ctx context.Context, groupID sql.NullInt64) ([]Session, error)
InsertAccount(ctx context.Context, arg InsertAccountParams) (int64, error)
InsertAction(ctx context.Context, arg InsertActionParams) (int64, error)
InsertKVStoreRecord(ctx context.Context, arg InsertKVStoreRecordParams) error
InsertPrivacyPair(ctx context.Context, arg InsertPrivacyPairParams) error
InsertSession(ctx context.Context, arg InsertSessionParams) (int64, error)
InsertSessionFeatureConfig(ctx context.Context, arg InsertSessionFeatureConfigParams) error
InsertSessionMacaroonCaveat(ctx context.Context, arg InsertSessionMacaroonCaveatParams) error
InsertSessionMacaroonPermission(ctx context.Context, arg InsertSessionMacaroonPermissionParams) error
InsertSessionPrivacyFlag(ctx context.Context, arg InsertSessionPrivacyFlagParams) error
ListAccountInvoices(ctx context.Context, accountID int64) ([]AccountInvoice, error)
ListAccountPayments(ctx context.Context, accountID int64) ([]AccountPayment, error)
ListAllAccounts(ctx context.Context) ([]Account, error)
ListAllKVStoresRecords(ctx context.Context) ([]Kvstore, error)
ListSessions(ctx context.Context) ([]Session, error)
ListSessionsByState(ctx context.Context, state int16) ([]Session, error)
ListSessionsByType(ctx context.Context, type_ int16) ([]Session, error)
SetAccountIndex(ctx context.Context, arg SetAccountIndexParams) error
SetActionState(ctx context.Context, arg SetActionStateParams) error
SetSessionGroupID(ctx context.Context, arg SetSessionGroupIDParams) error
SetSessionRemotePublicKey(ctx context.Context, arg SetSessionRemotePublicKeyParams) error
SetSessionRevokedAt(ctx context.Context, arg SetSessionRevokedAtParams) error
// NOTE: This query is only intended for testing purposes.
UpdateAccountAliasForTests(ctx context.Context, arg UpdateAccountAliasForTestsParams) (int64, error)
UpdateAccountBalance(ctx context.Context, arg UpdateAccountBalanceParams) (int64, error)
UpdateAccountExpiry(ctx context.Context, arg UpdateAccountExpiryParams) (int64, error)
UpdateAccountLastUpdate(ctx context.Context, arg UpdateAccountLastUpdateParams) (int64, error)
UpdateFeatureKVStoreRecord(ctx context.Context, arg UpdateFeatureKVStoreRecordParams) error
UpdateGlobalKVStoreRecord(ctx context.Context, arg UpdateGlobalKVStoreRecordParams) error
UpdateGroupKVStoreRecord(ctx context.Context, arg UpdateGroupKVStoreRecordParams) error
UpdateSessionState(ctx context.Context, arg UpdateSessionStateParams) error
UpsertAccountPayment(ctx context.Context, arg UpsertAccountPaymentParams) error
}
var _ Querier = (*Queries)(nil)

685
db/sqlcmig6/sessions.sql.go Normal file
View file

@ -0,0 +1,685 @@
package sqlcmig6
import (
"context"
"database/sql"
"time"
)
const deleteSession = `-- name: DeleteSession :exec
DELETE FROM sessions
WHERE id = $1
`
func (q *Queries) DeleteSession(ctx context.Context, id int64) error {
_, err := q.db.ExecContext(ctx, deleteSession, id)
return err
}
const deleteSessionsWithState = `-- name: DeleteSessionsWithState :exec
DELETE FROM sessions
WHERE state = $1
`
func (q *Queries) DeleteSessionsWithState(ctx context.Context, state int16) error {
_, err := q.db.ExecContext(ctx, deleteSessionsWithState, state)
return err
}
const getAliasBySessionID = `-- name: GetAliasBySessionID :one
SELECT alias FROM sessions
WHERE id = $1
`
func (q *Queries) GetAliasBySessionID(ctx context.Context, id int64) ([]byte, error) {
row := q.db.QueryRowContext(ctx, getAliasBySessionID, id)
var alias []byte
err := row.Scan(&alias)
return alias, err
}
const getSessionAliasesInGroup = `-- name: GetSessionAliasesInGroup :many
SELECT alias FROM sessions
WHERE group_id = $1
`
func (q *Queries) GetSessionAliasesInGroup(ctx context.Context, groupID sql.NullInt64) ([][]byte, error) {
rows, err := q.db.QueryContext(ctx, getSessionAliasesInGroup, groupID)
if err != nil {
return nil, err
}
defer rows.Close()
var items [][]byte
for rows.Next() {
var alias []byte
if err := rows.Scan(&alias); err != nil {
return nil, err
}
items = append(items, alias)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const getSessionByAlias = `-- name: GetSessionByAlias :one
SELECT id, alias, label, state, type, expiry, created_at, revoked_at, server_address, dev_server, macaroon_root_key, pairing_secret, local_private_key, local_public_key, remote_public_key, privacy, account_id, group_id FROM sessions
WHERE alias = $1
`
func (q *Queries) GetSessionByAlias(ctx context.Context, alias []byte) (Session, error) {
row := q.db.QueryRowContext(ctx, getSessionByAlias, alias)
var i Session
err := row.Scan(
&i.ID,
&i.Alias,
&i.Label,
&i.State,
&i.Type,
&i.Expiry,
&i.CreatedAt,
&i.RevokedAt,
&i.ServerAddress,
&i.DevServer,
&i.MacaroonRootKey,
&i.PairingSecret,
&i.LocalPrivateKey,
&i.LocalPublicKey,
&i.RemotePublicKey,
&i.Privacy,
&i.AccountID,
&i.GroupID,
)
return i, err
}
const getSessionByID = `-- name: GetSessionByID :one
SELECT id, alias, label, state, type, expiry, created_at, revoked_at, server_address, dev_server, macaroon_root_key, pairing_secret, local_private_key, local_public_key, remote_public_key, privacy, account_id, group_id FROM sessions
WHERE id = $1
`
func (q *Queries) GetSessionByID(ctx context.Context, id int64) (Session, error) {
row := q.db.QueryRowContext(ctx, getSessionByID, id)
var i Session
err := row.Scan(
&i.ID,
&i.Alias,
&i.Label,
&i.State,
&i.Type,
&i.Expiry,
&i.CreatedAt,
&i.RevokedAt,
&i.ServerAddress,
&i.DevServer,
&i.MacaroonRootKey,
&i.PairingSecret,
&i.LocalPrivateKey,
&i.LocalPublicKey,
&i.RemotePublicKey,
&i.Privacy,
&i.AccountID,
&i.GroupID,
)
return i, err
}
const getSessionByLocalPublicKey = `-- name: GetSessionByLocalPublicKey :one
SELECT id, alias, label, state, type, expiry, created_at, revoked_at, server_address, dev_server, macaroon_root_key, pairing_secret, local_private_key, local_public_key, remote_public_key, privacy, account_id, group_id FROM sessions
WHERE local_public_key = $1
`
func (q *Queries) GetSessionByLocalPublicKey(ctx context.Context, localPublicKey []byte) (Session, error) {
row := q.db.QueryRowContext(ctx, getSessionByLocalPublicKey, localPublicKey)
var i Session
err := row.Scan(
&i.ID,
&i.Alias,
&i.Label,
&i.State,
&i.Type,
&i.Expiry,
&i.CreatedAt,
&i.RevokedAt,
&i.ServerAddress,
&i.DevServer,
&i.MacaroonRootKey,
&i.PairingSecret,
&i.LocalPrivateKey,
&i.LocalPublicKey,
&i.RemotePublicKey,
&i.Privacy,
&i.AccountID,
&i.GroupID,
)
return i, err
}
const getSessionFeatureConfigs = `-- name: GetSessionFeatureConfigs :many
SELECT session_id, feature_name, config FROM session_feature_configs
WHERE session_id = $1
`
func (q *Queries) GetSessionFeatureConfigs(ctx context.Context, sessionID int64) ([]SessionFeatureConfig, error) {
rows, err := q.db.QueryContext(ctx, getSessionFeatureConfigs, sessionID)
if err != nil {
return nil, err
}
defer rows.Close()
var items []SessionFeatureConfig
for rows.Next() {
var i SessionFeatureConfig
if err := rows.Scan(&i.SessionID, &i.FeatureName, &i.Config); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const getSessionIDByAlias = `-- name: GetSessionIDByAlias :one
SELECT id FROM sessions
WHERE alias = $1
`
func (q *Queries) GetSessionIDByAlias(ctx context.Context, alias []byte) (int64, error) {
row := q.db.QueryRowContext(ctx, getSessionIDByAlias, alias)
var id int64
err := row.Scan(&id)
return id, err
}
const getSessionMacaroonCaveats = `-- name: GetSessionMacaroonCaveats :many
SELECT id, session_id, caveat_id, verification_id, location FROM session_macaroon_caveats
WHERE session_id = $1
`
func (q *Queries) GetSessionMacaroonCaveats(ctx context.Context, sessionID int64) ([]SessionMacaroonCaveat, error) {
rows, err := q.db.QueryContext(ctx, getSessionMacaroonCaveats, sessionID)
if err != nil {
return nil, err
}
defer rows.Close()
var items []SessionMacaroonCaveat
for rows.Next() {
var i SessionMacaroonCaveat
if err := rows.Scan(
&i.ID,
&i.SessionID,
&i.CaveatID,
&i.VerificationID,
&i.Location,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const getSessionMacaroonPermissions = `-- name: GetSessionMacaroonPermissions :many
SELECT id, session_id, entity, action FROM session_macaroon_permissions
WHERE session_id = $1
`
func (q *Queries) GetSessionMacaroonPermissions(ctx context.Context, sessionID int64) ([]SessionMacaroonPermission, error) {
rows, err := q.db.QueryContext(ctx, getSessionMacaroonPermissions, sessionID)
if err != nil {
return nil, err
}
defer rows.Close()
var items []SessionMacaroonPermission
for rows.Next() {
var i SessionMacaroonPermission
if err := rows.Scan(
&i.ID,
&i.SessionID,
&i.Entity,
&i.Action,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const getSessionPrivacyFlags = `-- name: GetSessionPrivacyFlags :many
SELECT session_id, flag FROM session_privacy_flags
WHERE session_id = $1
`
func (q *Queries) GetSessionPrivacyFlags(ctx context.Context, sessionID int64) ([]SessionPrivacyFlag, error) {
rows, err := q.db.QueryContext(ctx, getSessionPrivacyFlags, sessionID)
if err != nil {
return nil, err
}
defer rows.Close()
var items []SessionPrivacyFlag
for rows.Next() {
var i SessionPrivacyFlag
if err := rows.Scan(&i.SessionID, &i.Flag); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const getSessionsInGroup = `-- name: GetSessionsInGroup :many
SELECT id, alias, label, state, type, expiry, created_at, revoked_at, server_address, dev_server, macaroon_root_key, pairing_secret, local_private_key, local_public_key, remote_public_key, privacy, account_id, group_id FROM sessions
WHERE group_id = $1
`
func (q *Queries) GetSessionsInGroup(ctx context.Context, groupID sql.NullInt64) ([]Session, error) {
rows, err := q.db.QueryContext(ctx, getSessionsInGroup, groupID)
if err != nil {
return nil, err
}
defer rows.Close()
var items []Session
for rows.Next() {
var i Session
if err := rows.Scan(
&i.ID,
&i.Alias,
&i.Label,
&i.State,
&i.Type,
&i.Expiry,
&i.CreatedAt,
&i.RevokedAt,
&i.ServerAddress,
&i.DevServer,
&i.MacaroonRootKey,
&i.PairingSecret,
&i.LocalPrivateKey,
&i.LocalPublicKey,
&i.RemotePublicKey,
&i.Privacy,
&i.AccountID,
&i.GroupID,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const insertSession = `-- name: InsertSession :one
INSERT INTO sessions (
alias, label, state, type, expiry, created_at,
server_address, dev_server, macaroon_root_key, pairing_secret,
local_private_key, local_public_key, remote_public_key, privacy, group_id, account_id
) VALUES (
$1, $2, $3, $4, $5, $6, $7,
$8, $9, $10, $11, $12,
$13, $14, $15, $16
) RETURNING id
`
type InsertSessionParams struct {
Alias []byte
Label string
State int16
Type int16
Expiry time.Time
CreatedAt time.Time
ServerAddress string
DevServer bool
MacaroonRootKey int64
PairingSecret []byte
LocalPrivateKey []byte
LocalPublicKey []byte
RemotePublicKey []byte
Privacy bool
GroupID sql.NullInt64
AccountID sql.NullInt64
}
func (q *Queries) InsertSession(ctx context.Context, arg InsertSessionParams) (int64, error) {
row := q.db.QueryRowContext(ctx, insertSession,
arg.Alias,
arg.Label,
arg.State,
arg.Type,
arg.Expiry,
arg.CreatedAt,
arg.ServerAddress,
arg.DevServer,
arg.MacaroonRootKey,
arg.PairingSecret,
arg.LocalPrivateKey,
arg.LocalPublicKey,
arg.RemotePublicKey,
arg.Privacy,
arg.GroupID,
arg.AccountID,
)
var id int64
err := row.Scan(&id)
return id, err
}
const insertSessionFeatureConfig = `-- name: InsertSessionFeatureConfig :exec
INSERT INTO session_feature_configs (
session_id, feature_name, config
) VALUES (
$1, $2, $3
)
`
type InsertSessionFeatureConfigParams struct {
SessionID int64
FeatureName string
Config []byte
}
func (q *Queries) InsertSessionFeatureConfig(ctx context.Context, arg InsertSessionFeatureConfigParams) error {
_, err := q.db.ExecContext(ctx, insertSessionFeatureConfig, arg.SessionID, arg.FeatureName, arg.Config)
return err
}
const insertSessionMacaroonCaveat = `-- name: InsertSessionMacaroonCaveat :exec
INSERT INTO session_macaroon_caveats (
session_id, caveat_id, verification_id, location
) VALUES (
$1, $2, $3, $4
)
`
type InsertSessionMacaroonCaveatParams struct {
SessionID int64
CaveatID []byte
VerificationID []byte
Location sql.NullString
}
func (q *Queries) InsertSessionMacaroonCaveat(ctx context.Context, arg InsertSessionMacaroonCaveatParams) error {
_, err := q.db.ExecContext(ctx, insertSessionMacaroonCaveat,
arg.SessionID,
arg.CaveatID,
arg.VerificationID,
arg.Location,
)
return err
}
const insertSessionMacaroonPermission = `-- name: InsertSessionMacaroonPermission :exec
INSERT INTO session_macaroon_permissions (
session_id, entity, action
) VALUES (
$1, $2, $3
)
`
type InsertSessionMacaroonPermissionParams struct {
SessionID int64
Entity string
Action string
}
func (q *Queries) InsertSessionMacaroonPermission(ctx context.Context, arg InsertSessionMacaroonPermissionParams) error {
_, err := q.db.ExecContext(ctx, insertSessionMacaroonPermission, arg.SessionID, arg.Entity, arg.Action)
return err
}
const insertSessionPrivacyFlag = `-- name: InsertSessionPrivacyFlag :exec
INSERT INTO session_privacy_flags (
session_id, flag
) VALUES (
$1, $2
)
`
type InsertSessionPrivacyFlagParams struct {
SessionID int64
Flag int32
}
func (q *Queries) InsertSessionPrivacyFlag(ctx context.Context, arg InsertSessionPrivacyFlagParams) error {
_, err := q.db.ExecContext(ctx, insertSessionPrivacyFlag, arg.SessionID, arg.Flag)
return err
}
const listSessions = `-- name: ListSessions :many
SELECT id, alias, label, state, type, expiry, created_at, revoked_at, server_address, dev_server, macaroon_root_key, pairing_secret, local_private_key, local_public_key, remote_public_key, privacy, account_id, group_id FROM sessions
ORDER BY created_at
`
func (q *Queries) ListSessions(ctx context.Context) ([]Session, error) {
rows, err := q.db.QueryContext(ctx, listSessions)
if err != nil {
return nil, err
}
defer rows.Close()
var items []Session
for rows.Next() {
var i Session
if err := rows.Scan(
&i.ID,
&i.Alias,
&i.Label,
&i.State,
&i.Type,
&i.Expiry,
&i.CreatedAt,
&i.RevokedAt,
&i.ServerAddress,
&i.DevServer,
&i.MacaroonRootKey,
&i.PairingSecret,
&i.LocalPrivateKey,
&i.LocalPublicKey,
&i.RemotePublicKey,
&i.Privacy,
&i.AccountID,
&i.GroupID,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listSessionsByState = `-- name: ListSessionsByState :many
SELECT id, alias, label, state, type, expiry, created_at, revoked_at, server_address, dev_server, macaroon_root_key, pairing_secret, local_private_key, local_public_key, remote_public_key, privacy, account_id, group_id FROM sessions
WHERE state = $1
ORDER BY created_at
`
func (q *Queries) ListSessionsByState(ctx context.Context, state int16) ([]Session, error) {
rows, err := q.db.QueryContext(ctx, listSessionsByState, state)
if err != nil {
return nil, err
}
defer rows.Close()
var items []Session
for rows.Next() {
var i Session
if err := rows.Scan(
&i.ID,
&i.Alias,
&i.Label,
&i.State,
&i.Type,
&i.Expiry,
&i.CreatedAt,
&i.RevokedAt,
&i.ServerAddress,
&i.DevServer,
&i.MacaroonRootKey,
&i.PairingSecret,
&i.LocalPrivateKey,
&i.LocalPublicKey,
&i.RemotePublicKey,
&i.Privacy,
&i.AccountID,
&i.GroupID,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listSessionsByType = `-- name: ListSessionsByType :many
SELECT id, alias, label, state, type, expiry, created_at, revoked_at, server_address, dev_server, macaroon_root_key, pairing_secret, local_private_key, local_public_key, remote_public_key, privacy, account_id, group_id FROM sessions
WHERE type = $1
ORDER BY created_at
`
func (q *Queries) ListSessionsByType(ctx context.Context, type_ int16) ([]Session, error) {
rows, err := q.db.QueryContext(ctx, listSessionsByType, type_)
if err != nil {
return nil, err
}
defer rows.Close()
var items []Session
for rows.Next() {
var i Session
if err := rows.Scan(
&i.ID,
&i.Alias,
&i.Label,
&i.State,
&i.Type,
&i.Expiry,
&i.CreatedAt,
&i.RevokedAt,
&i.ServerAddress,
&i.DevServer,
&i.MacaroonRootKey,
&i.PairingSecret,
&i.LocalPrivateKey,
&i.LocalPublicKey,
&i.RemotePublicKey,
&i.Privacy,
&i.AccountID,
&i.GroupID,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const setSessionGroupID = `-- name: SetSessionGroupID :exec
UPDATE sessions
SET group_id = $1
WHERE id = $2
`
type SetSessionGroupIDParams struct {
GroupID sql.NullInt64
ID int64
}
func (q *Queries) SetSessionGroupID(ctx context.Context, arg SetSessionGroupIDParams) error {
_, err := q.db.ExecContext(ctx, setSessionGroupID, arg.GroupID, arg.ID)
return err
}
const setSessionRemotePublicKey = `-- name: SetSessionRemotePublicKey :exec
UPDATE sessions
SET remote_public_key = $1
WHERE id = $2
`
type SetSessionRemotePublicKeyParams struct {
RemotePublicKey []byte
ID int64
}
func (q *Queries) SetSessionRemotePublicKey(ctx context.Context, arg SetSessionRemotePublicKeyParams) error {
_, err := q.db.ExecContext(ctx, setSessionRemotePublicKey, arg.RemotePublicKey, arg.ID)
return err
}
const setSessionRevokedAt = `-- name: SetSessionRevokedAt :exec
UPDATE sessions
SET revoked_at = $1
WHERE id = $2
`
type SetSessionRevokedAtParams struct {
RevokedAt sql.NullTime
ID int64
}
func (q *Queries) SetSessionRevokedAt(ctx context.Context, arg SetSessionRevokedAtParams) error {
_, err := q.db.ExecContext(ctx, setSessionRevokedAt, arg.RevokedAt, arg.ID)
return err
}
const updateSessionState = `-- name: UpdateSessionState :exec
UPDATE sessions
SET state = $1
WHERE id = $2
`
type UpdateSessionStateParams struct {
State int16
ID int64
}
func (q *Queries) UpdateSessionState(ctx context.Context, arg UpdateSessionStateParams) error {
_, err := q.db.ExecContext(ctx, updateSessionState, arg.State, arg.ID)
return err
}