Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming. Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
191 lines
8.7 KiB
Go
191 lines
8.7 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"database/sql"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
var ErrApprovalTransition = errors.New("invalid approval request transition")
|
|
|
|
type ApprovalRequest struct {
|
|
UUID string `json:"uuid"`
|
|
DomainUUID string `json:"domain_uuid"`
|
|
ScopeKind string `json:"scope_kind"`
|
|
ScopeUUID string `json:"scope_uuid"`
|
|
SubjectHash string `json:"subject_hash"`
|
|
SubjectJSON string `json:"subject_json,omitempty"`
|
|
PolicyVersion int64 `json:"policy_version"`
|
|
RequesterUUID string `json:"requester_uuid"`
|
|
State string `json:"state"`
|
|
Generation int64 `json:"generation"`
|
|
IdempotencyKey string `json:"idempotency_key"`
|
|
ExpiresAtMS int64 `json:"expires_at_ms"`
|
|
CreatedAtMS int64 `json:"created_at_ms"`
|
|
UpdatedAtMS int64 `json:"updated_at_ms"`
|
|
}
|
|
|
|
type ApprovalDecision struct {
|
|
UUID string `json:"uuid"`
|
|
RequestUUID string `json:"request_uuid"`
|
|
ReviewerUUID string `json:"reviewer_uuid"`
|
|
Generation int64 `json:"generation"`
|
|
Decision string `json:"decision"`
|
|
Justification string `json:"justification,omitempty"`
|
|
CreatedAtMS int64 `json:"created_at_ms"`
|
|
}
|
|
|
|
func (s *Store) EnsurePublicationApprovalSchema() error {
|
|
for _, statement := range []string{
|
|
`CREATE TABLE IF NOT EXISTS publication_requests (uuid TEXT PRIMARY KEY, domain_uuid TEXT NOT NULL, scope_kind TEXT NOT NULL, scope_uuid TEXT NOT NULL, subject_hash TEXT NOT NULL, subject_json TEXT NOT NULL, policy_version INTEGER NOT NULL, requester_uuid TEXT NOT NULL, state TEXT NOT NULL CHECK(state IN ('pending','approved','rejected','withdrawn','expired','superseded')), generation INTEGER NOT NULL, idempotency_key TEXT NOT NULL, expires_at_ms INTEGER NOT NULL DEFAULT 0, created_at_ms INTEGER NOT NULL, updated_at_ms INTEGER NOT NULL, UNIQUE(domain_uuid,idempotency_key))`,
|
|
`CREATE INDEX IF NOT EXISTS idx_publication_requests_state ON publication_requests(domain_uuid,state,updated_at_ms DESC,uuid DESC)`,
|
|
`CREATE TABLE IF NOT EXISTS publication_decisions (uuid TEXT PRIMARY KEY, request_uuid TEXT NOT NULL REFERENCES publication_requests(uuid), reviewer_uuid TEXT NOT NULL, generation INTEGER NOT NULL, decision TEXT NOT NULL CHECK(decision IN ('approved','rejected','changes_requested')), justification TEXT NOT NULL DEFAULT '', created_at_ms INTEGER NOT NULL, UNIQUE(request_uuid,reviewer_uuid,generation))`,
|
|
} {
|
|
if _, err := s.DB.Exec(statement); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func ApprovalSubjectHash(subject any) (string, string, error) {
|
|
b, err := json.Marshal(subject)
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
h := sha256.Sum256(b)
|
|
return hex.EncodeToString(h[:]), string(b), nil
|
|
}
|
|
|
|
func ApprovalSubjectHashJSON(b []byte) (string, string, error) {
|
|
var raw json.RawMessage
|
|
if err := json.Unmarshal(b, &raw); err != nil {
|
|
return "", "", err
|
|
}
|
|
h := sha256.Sum256(raw)
|
|
return hex.EncodeToString(h[:]), string(raw), nil
|
|
}
|
|
|
|
const approvalRequestColumns = `uuid,domain_uuid,scope_kind,scope_uuid,subject_hash,subject_json,policy_version,requester_uuid,state,generation,idempotency_key,expires_at_ms,created_at_ms,updated_at_ms`
|
|
|
|
func scanApprovalRequest(scanner interface{ Scan(...any) error }, item *ApprovalRequest) error {
|
|
return scanner.Scan(&item.UUID, &item.DomainUUID, &item.ScopeKind, &item.ScopeUUID, &item.SubjectHash, &item.SubjectJSON, &item.PolicyVersion, &item.RequesterUUID, &item.State, &item.Generation, &item.IdempotencyKey, &item.ExpiresAtMS, &item.CreatedAtMS, &item.UpdatedAtMS)
|
|
}
|
|
|
|
func (s *Store) CreateApprovalRequestTx(tx *sql.Tx, request ApprovalRequest) (ApprovalRequest, bool, error) {
|
|
request.DomainUUID = strings.TrimSpace(request.DomainUUID)
|
|
request.ScopeKind = strings.TrimSpace(request.ScopeKind)
|
|
request.ScopeUUID = strings.TrimSpace(request.ScopeUUID)
|
|
request.RequesterUUID = strings.TrimSpace(request.RequesterUUID)
|
|
request.IdempotencyKey = strings.TrimSpace(request.IdempotencyKey)
|
|
if request.DomainUUID == "" || request.ScopeKind == "" || request.ScopeUUID == "" || request.RequesterUUID == "" || request.IdempotencyKey == "" || request.SubjectHash == "" {
|
|
return ApprovalRequest{}, false, ErrNotificationInput
|
|
}
|
|
if request.UUID == "" {
|
|
request.UUID = uuid.NewString()
|
|
}
|
|
if request.State == "" {
|
|
request.State = "pending"
|
|
}
|
|
if request.Generation == 0 {
|
|
request.Generation = 1
|
|
}
|
|
if request.CreatedAtMS == 0 {
|
|
request.CreatedAtMS = time.Now().UnixMilli()
|
|
}
|
|
if request.UpdatedAtMS == 0 {
|
|
request.UpdatedAtMS = request.CreatedAtMS
|
|
}
|
|
var existing ApprovalRequest
|
|
err := scanApprovalRequest(tx.QueryRow(`SELECT `+approvalRequestColumns+` FROM publication_requests WHERE domain_uuid=? AND idempotency_key=?`, request.DomainUUID, request.IdempotencyKey), &existing)
|
|
if err == nil {
|
|
return existing, false, nil
|
|
}
|
|
if !errors.Is(err, sql.ErrNoRows) {
|
|
return ApprovalRequest{}, false, err
|
|
}
|
|
_, err = tx.Exec(`INSERT INTO publication_requests(`+approvalRequestColumns+`) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?)`, request.UUID, request.DomainUUID, request.ScopeKind, request.ScopeUUID, request.SubjectHash, request.SubjectJSON, request.PolicyVersion, request.RequesterUUID, request.State, request.Generation, request.IdempotencyKey, request.ExpiresAtMS, request.CreatedAtMS, request.UpdatedAtMS)
|
|
if err != nil {
|
|
return ApprovalRequest{}, false, err
|
|
}
|
|
return request, true, nil
|
|
}
|
|
|
|
func (s *Store) DecideApprovalRequest(ctx context.Context, requestUUID, reviewerUUID, decision, justification string, generation int64) error {
|
|
return s.decideApprovalRequest(ctx, "", requestUUID, reviewerUUID, decision, justification, generation)
|
|
}
|
|
|
|
func (s *Store) DecideApprovalRequestScoped(ctx context.Context, domainUUID, requestUUID, reviewerUUID, decision, justification string, generation int64) error {
|
|
return s.decideApprovalRequest(ctx, domainUUID, requestUUID, reviewerUUID, decision, justification, generation)
|
|
}
|
|
|
|
func (s *Store) decideApprovalRequest(ctx context.Context, domainUUID, requestUUID, reviewerUUID, decision, justification string, generation int64) error {
|
|
if requestUUID == "" || reviewerUUID == "" || generation < 1 || (decision != "approved" && decision != "rejected" && decision != "changes_requested") {
|
|
return ErrApprovalTransition
|
|
}
|
|
tx, err := s.DB.BeginTx(ctx, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.Rollback()
|
|
var state string
|
|
var currentGeneration int64
|
|
query := `SELECT state,generation FROM publication_requests WHERE uuid=?`
|
|
args := []any{requestUUID}
|
|
if strings.TrimSpace(domainUUID) != "" {
|
|
query = `SELECT state,generation FROM publication_requests WHERE uuid=? AND domain_uuid=?`
|
|
args = append(args, domainUUID)
|
|
}
|
|
if err := tx.QueryRowContext(ctx, query, args...).Scan(&state, ¤tGeneration); err != nil {
|
|
return err
|
|
}
|
|
if state != "pending" || currentGeneration != generation {
|
|
return ErrApprovalTransition
|
|
}
|
|
now := time.Now().UnixMilli()
|
|
if _, err := tx.ExecContext(ctx, `INSERT INTO publication_decisions(uuid,request_uuid,reviewer_uuid,generation,decision,justification,created_at_ms) VALUES(?,?,?,?,?,?,?)`, uuid.NewString(), requestUUID, reviewerUUID, generation, decision, justification, now); err != nil {
|
|
return err
|
|
}
|
|
newState := decision
|
|
if decision == "changes_requested" {
|
|
newState = "rejected"
|
|
}
|
|
if _, err := tx.ExecContext(ctx, `UPDATE publication_requests SET state=?,updated_at_ms=? WHERE uuid=? AND state='pending' AND generation=?`, newState, now, requestUUID, generation); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit()
|
|
}
|
|
|
|
func (s *Store) GetApprovalRequest(ctx context.Context, domainUUID, requestUUID string) (ApprovalRequest, error) {
|
|
var request ApprovalRequest
|
|
if strings.TrimSpace(domainUUID) == "" || strings.TrimSpace(requestUUID) == "" {
|
|
return request, ErrApprovalTransition
|
|
}
|
|
err := scanApprovalRequest(s.DB.QueryRowContext(ctx, `SELECT `+approvalRequestColumns+` FROM publication_requests WHERE domain_uuid=? AND uuid=?`, domainUUID, requestUUID), &request)
|
|
return request, err
|
|
}
|
|
|
|
// ExpireApprovalRequests moves only pending requests whose explicit deadline
|
|
// has passed. A zero deadline means no automatic expiry. The bounded update
|
|
// keeps scheduler cleanup from monopolizing the SQLite writer.
|
|
func (s *Store) ExpireApprovalRequests(ctx context.Context, nowMS int64, limit int) (int64, error) {
|
|
if nowMS <= 0 {
|
|
nowMS = time.Now().UnixMilli()
|
|
}
|
|
if limit < 1 || limit > 1000 {
|
|
limit = 100
|
|
}
|
|
result, err := s.DB.ExecContext(ctx, `UPDATE publication_requests SET state='expired',updated_at_ms=? WHERE state='pending' AND expires_at_ms>0 AND expires_at_ms<=? AND uuid IN (SELECT uuid FROM publication_requests WHERE state='pending' AND expires_at_ms>0 AND expires_at_ms<=? ORDER BY expires_at_ms,uuid LIMIT ?)`, nowMS, nowMS, nowMS, limit)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|