Files
pages/internal/store/publication_approval.go
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
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.
2026-09-27 14:44:43 +09:00

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, &currentGeneration); 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()
}