Files
archie/internal/infrastructure/postgres/postgresdb/access.sql.go
T
sam 003771ca48 feat(access): denial retention knob, State Store sweep and dashboard denials page (#1842)
Add [access].denial_retention (default 90 days, matching the audit-retention
seed) wired through config defaults and validation; the State Store sweeps
denial records older than the configured age hourly via the new
access.DenialPruner / PruneDenials store query. The dashboard gains
GET /api/access/denials (read_audit-gated, so org admins/owners see their
org's records; the store scopes by the credential's org) and an
/org/denials page backed by a Pinia store.
2026-10-31 14:23:31 +11:00

482 lines
13 KiB
Go

// Code generated by sqlc. DO NOT EDIT.
// versions:
// sqlc v1.31.1
// source: access.sql
package postgresdb
import (
"context"
"time"
"github.com/jackc/pgx/v5/pgtype"
)
const accessPolicyRevision = `-- name: AccessPolicyRevision :one
SELECT version FROM access_policy_revision
`
func (q *Queries) AccessPolicyRevision(ctx context.Context) (int64, error) {
row := q.db.QueryRow(ctx, accessPolicyRevision)
var version int64
err := row.Scan(&version)
return version, err
}
const accessPolicyText = `-- name: AccessPolicyText :one
SELECT text FROM access_policies
WHERE level = $1 AND org_id = $2 AND workspace_id = $3 AND object_kind = $4
AND object_id = $5 AND policy_id = $6
FOR UPDATE
`
type AccessPolicyTextParams struct {
Level string
OrgID string
WorkspaceID string
ObjectKind string
ObjectID string
PolicyID string
}
func (q *Queries) AccessPolicyText(ctx context.Context, arg AccessPolicyTextParams) (string, error) {
row := q.db.QueryRow(ctx, accessPolicyText,
arg.Level,
arg.OrgID,
arg.WorkspaceID,
arg.ObjectKind,
arg.ObjectID,
arg.PolicyID,
)
var text string
err := row.Scan(&text)
return text, err
}
const bumpAccessPolicyRevision = `-- name: BumpAccessPolicyRevision :one
INSERT INTO access_policy_revision (only_row, version) VALUES (true, 1)
ON CONFLICT (only_row)
DO UPDATE SET version = access_policy_revision.version + 1, updated_at = now()
RETURNING version
`
// The instance-wide version. It moves inside the transaction of every policy
// write, so it changes exactly when the policy snapshot changes.
func (q *Queries) BumpAccessPolicyRevision(ctx context.Context) (int64, error) {
row := q.db.QueryRow(ctx, bumpAccessPolicyRevision)
var version int64
err := row.Scan(&version)
return version, err
}
const countShippedOrgPolicies = `-- name: CountShippedOrgPolicies :one
SELECT count(*) FROM access_policies
WHERE level = 'org' AND org_id = $1 AND policy_id = ANY($2::text[])
`
type CountShippedOrgPoliciesParams struct {
OrgID string
Column2 []string
}
func (q *Queries) CountShippedOrgPolicies(ctx context.Context, arg CountShippedOrgPoliciesParams) (int64, error) {
row := q.db.QueryRow(ctx, countShippedOrgPolicies, arg.OrgID, arg.Column2)
var count int64
err := row.Scan(&count)
return count, err
}
const deleteAccessPolicy = `-- name: DeleteAccessPolicy :one
DELETE FROM access_policies
WHERE level = $1 AND org_id = $2 AND workspace_id = $3 AND object_kind = $4
AND object_id = $5 AND policy_id = $6
RETURNING text
`
type DeleteAccessPolicyParams struct {
Level string
OrgID string
WorkspaceID string
ObjectKind string
ObjectID string
PolicyID string
}
func (q *Queries) DeleteAccessPolicy(ctx context.Context, arg DeleteAccessPolicyParams) (string, error) {
row := q.db.QueryRow(ctx, deleteAccessPolicy,
arg.Level,
arg.OrgID,
arg.WorkspaceID,
arg.ObjectKind,
arg.ObjectID,
arg.PolicyID,
)
var text string
err := row.Scan(&text)
return text, err
}
const deleteAccessPolicyVersion = `-- name: DeleteAccessPolicyVersion :exec
DELETE FROM access_policy_versions v
WHERE v.level = $1 AND v.org_id = $2 AND v.workspace_id = $3
AND NOT EXISTS (SELECT 1 FROM access_policies p
WHERE p.level = v.level AND p.org_id = v.org_id AND p.workspace_id = v.workspace_id)
`
type DeleteAccessPolicyVersionParams struct {
Level string
OrgID string
WorkspaceID string
}
func (q *Queries) DeleteAccessPolicyVersion(ctx context.Context, arg DeleteAccessPolicyVersionParams) error {
_, err := q.db.Exec(ctx, deleteAccessPolicyVersion, arg.Level, arg.OrgID, arg.WorkspaceID)
return err
}
const deleteOrgPoliciesNotShipped = `-- name: DeleteOrgPoliciesNotShipped :many
DELETE FROM access_policies
WHERE level = 'org' AND org_id = $1 AND NOT (policy_id = ANY($2::text[]))
RETURNING level, org_id, workspace_id, object_kind, object_id, policy_id, text
`
type DeleteOrgPoliciesNotShippedParams struct {
OrgID string
Column2 []string
}
type DeleteOrgPoliciesNotShippedRow struct {
Level string
OrgID string
WorkspaceID string
ObjectKind string
ObjectID string
PolicyID string
Text string
}
func (q *Queries) DeleteOrgPoliciesNotShipped(ctx context.Context, arg DeleteOrgPoliciesNotShippedParams) ([]DeleteOrgPoliciesNotShippedRow, error) {
rows, err := q.db.Query(ctx, deleteOrgPoliciesNotShipped, arg.OrgID, arg.Column2)
if err != nil {
return nil, err
}
defer rows.Close()
var items []DeleteOrgPoliciesNotShippedRow
for rows.Next() {
var i DeleteOrgPoliciesNotShippedRow
if err := rows.Scan(
&i.Level,
&i.OrgID,
&i.WorkspaceID,
&i.ObjectKind,
&i.ObjectID,
&i.PolicyID,
&i.Text,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const insertAccessPolicyAudit = `-- name: InsertAccessPolicyAudit :exec
INSERT INTO sys_audit (at, table_name, record_key, field, old_value, new_value, record_version, actor, source, request_id, org_id)
VALUES (now(), 'access_policies', $1, 'text', $2, $3, $4, $5, $6, $7, $8)
`
type InsertAccessPolicyAuditParams struct {
RecordKey string
OldValue []byte
NewValue []byte
RecordVersion int64
Actor string
Source string
RequestID string
OrgID string
}
func (q *Queries) InsertAccessPolicyAudit(ctx context.Context, arg InsertAccessPolicyAuditParams) error {
_, err := q.db.Exec(ctx, insertAccessPolicyAudit,
arg.RecordKey,
arg.OldValue,
arg.NewValue,
arg.RecordVersion,
arg.Actor,
arg.Source,
arg.RequestID,
arg.OrgID,
)
return err
}
const insertAccessResetAudit = `-- name: InsertAccessResetAudit :exec
INSERT INTO sys_audit (at, table_name, record_key, field, record_version, actor, source, request_id, org_id)
VALUES (now(), 'access_policies', $1, 'reset', 1, 'archie-state-store access reset', 'archie-state-store', '', $2)
`
type InsertAccessResetAuditParams struct {
RecordKey string
OrgID string
}
func (q *Queries) InsertAccessResetAudit(ctx context.Context, arg InsertAccessResetAuditParams) error {
_, err := q.db.Exec(ctx, insertAccessResetAudit, arg.RecordKey, arg.OrgID)
return err
}
const listAccessPolicies = `-- name: ListAccessPolicies :many
SELECT level, org_id, workspace_id, object_kind, object_id, policy_id, text, updated_at
FROM access_policies
WHERE $1::text IS NULL
OR (level = 'instance' AND $2::bool)
OR (level <> 'instance' AND org_id = $1)
ORDER BY level, org_id, workspace_id, object_kind, object_id, policy_id
`
type ListAccessPoliciesParams struct {
ScopeOrg pgtype.Text
InstanceScope bool
}
// Access policies and denial records (internal/domain/access)
// A scoped read sees its own org's policies, and the instance policies only
// when it may read the instance.
func (q *Queries) ListAccessPolicies(ctx context.Context, arg ListAccessPoliciesParams) ([]AccessPolicy, error) {
rows, err := q.db.Query(ctx, listAccessPolicies, arg.ScopeOrg, arg.InstanceScope)
if err != nil {
return nil, err
}
defer rows.Close()
var items []AccessPolicy
for rows.Next() {
var i AccessPolicy
if err := rows.Scan(
&i.Level,
&i.OrgID,
&i.WorkspaceID,
&i.ObjectKind,
&i.ObjectID,
&i.PolicyID,
&i.Text,
&i.UpdatedAt,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listDenials = `-- name: ListDenials :many
SELECT id, org_id, principal, action, resource_kind, resource_id, level, policies, minute_at, count, created_at, updated_at
FROM access_denials WHERE org_id = $1 ORDER BY id DESC LIMIT $2
`
type ListDenialsParams struct {
OrgID string
Limit int32
}
func (q *Queries) ListDenials(ctx context.Context, arg ListDenialsParams) ([]AccessDenial, error) {
rows, err := q.db.Query(ctx, listDenials, arg.OrgID, arg.Limit)
if err != nil {
return nil, err
}
defer rows.Close()
var items []AccessDenial
for rows.Next() {
var i AccessDenial
if err := rows.Scan(
&i.ID,
&i.OrgID,
&i.Principal,
&i.Action,
&i.ResourceKind,
&i.ResourceID,
&i.Level,
&i.Policies,
&i.MinuteAt,
&i.Count,
&i.CreatedAt,
&i.UpdatedAt,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const lockPolicyWrite = `-- name: LockPolicyWrite :exec
SELECT pg_advisory_xact_lock(hashtextextended($1::text, 0))
`
// Serialises concurrent writes to one policy key. SELECT FOR UPDATE cannot
// lock a row that does not exist yet, so without this two concurrent creates
// both read no previous row and the second is audited as a create.
func (q *Queries) LockPolicyWrite(ctx context.Context, key string) error {
_, err := q.db.Exec(ctx, lockPolicyWrite, key)
return err
}
const pruneDenials = `-- name: PruneDenials :execrows
DELETE FROM access_denials
WHERE id IN (
SELECT id FROM access_denials
WHERE created_at < $1::timestamptz
ORDER BY created_at
LIMIT $2::bigint
)
`
type PruneDenialsParams struct {
Cutoff time.Time
Batch int64
}
// The retention sweep's delete: every denial record created before the
// cutoff, oldest first in bounded batches so one sweep does not own the
// table for an unbounded time.
func (q *Queries) PruneDenials(ctx context.Context, arg PruneDenialsParams) (int64, error) {
result, err := q.db.Exec(ctx, pruneDenials, arg.Cutoff, arg.Batch)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const recordDenial = `-- name: RecordDenial :exec
INSERT INTO access_denials (org_id, principal, action, resource_kind, resource_id, level, policies)
VALUES ($1, $2, $3, $4, $5, $6, $7)
ON CONFLICT (org_id, principal, action, resource_kind, resource_id, level, policies, minute_at)
DO UPDATE SET count = access_denials.count + 1, updated_at = now()
`
type RecordDenialParams struct {
OrgID string
Principal string
Action string
ResourceKind string
ResourceID string
Level string
Policies []string
}
// One row per (principal, action, resource, level, policies, minute);
func (q *Queries) RecordDenial(ctx context.Context, arg RecordDenialParams) error {
_, err := q.db.Exec(ctx, recordDenial,
arg.OrgID,
arg.Principal,
arg.Action,
arg.ResourceKind,
arg.ResourceID,
arg.Level,
arg.Policies,
)
return err
}
const resetInstancePolicies = `-- name: ResetInstancePolicies :many
DELETE FROM access_policies WHERE level = 'instance'
RETURNING level, org_id, workspace_id, object_kind, object_id, policy_id, text
`
type ResetInstancePoliciesRow struct {
Level string
OrgID string
WorkspaceID string
ObjectKind string
ObjectID string
PolicyID string
Text string
}
func (q *Queries) ResetInstancePolicies(ctx context.Context) ([]ResetInstancePoliciesRow, error) {
rows, err := q.db.Query(ctx, resetInstancePolicies)
if err != nil {
return nil, err
}
defer rows.Close()
var items []ResetInstancePoliciesRow
for rows.Next() {
var i ResetInstancePoliciesRow
if err := rows.Scan(
&i.Level,
&i.OrgID,
&i.WorkspaceID,
&i.ObjectKind,
&i.ObjectID,
&i.PolicyID,
&i.Text,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const upsertAccessPolicy = `-- name: UpsertAccessPolicy :exec
INSERT INTO access_policies (level, org_id, workspace_id, object_kind, object_id, policy_id, text)
VALUES ($1, $2, $3, $4, $5, $6, $7)
ON CONFLICT (level, org_id, workspace_id, object_kind, object_id, policy_id)
DO UPDATE SET text = excluded.text, updated_at = now()
`
type UpsertAccessPolicyParams struct {
Level string
OrgID string
WorkspaceID string
ObjectKind string
ObjectID string
PolicyID string
Text string
}
func (q *Queries) UpsertAccessPolicy(ctx context.Context, arg UpsertAccessPolicyParams) error {
_, err := q.db.Exec(ctx, upsertAccessPolicy,
arg.Level,
arg.OrgID,
arg.WorkspaceID,
arg.ObjectKind,
arg.ObjectID,
arg.PolicyID,
arg.Text,
)
return err
}
const upsertAccessPolicyVersion = `-- name: UpsertAccessPolicyVersion :one
INSERT INTO access_policy_versions (level, org_id, workspace_id, version) VALUES ($1, $2, $3, 2)
ON CONFLICT (level, org_id, workspace_id)
DO UPDATE SET version = access_policy_versions.version + 1, updated_at = now()
RETURNING version
`
type UpsertAccessPolicyVersionParams struct {
Level string
OrgID string
WorkspaceID string
}
func (q *Queries) UpsertAccessPolicyVersion(ctx context.Context, arg UpsertAccessPolicyVersionParams) (int64, error) {
row := q.db.QueryRow(ctx, upsertAccessPolicyVersion, arg.Level, arg.OrgID, arg.WorkspaceID)
var version int64
err := row.Scan(&version)
return version, err
}