Files

167 lines
6.4 KiB
Go

package store
import (
"context"
"database/sql"
"errors"
"fmt"
"time"
"github.com/google/uuid"
)
// ErrNoClass means no class has that id.
var ErrNoClass = errors.New("no such action class")
// Class is one action class and the level it stands at.
type Class struct {
ID uuid.UUID `db:"id"`
OrgID string `db:"org_id"`
Connector string `db:"connector"`
Action string `db:"action"`
TargetKind string `db:"target_kind"`
Environment string `db:"environment"`
ReadOnly bool `db:"read_only"`
Level string `db:"level"`
CreatedAt time.Time `db:"created_at"`
ResetAt sql.NullTime `db:"reset_at"`
// TightenedAt and TightenedBecause say when and why the class last lost
// autonomy; the count of approvals restarts there.
TightenedAt sql.NullTime `db:"tightened_at"`
TightenedBecause sql.NullString `db:"tightened_because"`
}
// ClassSummary is a class with how many decisions it holds.
type ClassSummary struct {
Class
Decisions int `db:"decisions"`
LastAt sql.NullTime `db:"last_at"`
Streak int `db:"streak"`
}
// Reset is one return of a class to its default.
type Reset struct {
ID uuid.UUID `db:"id"`
FromLevel string `db:"from_level"`
ToLevel string `db:"to_level"`
By string `db:"by"`
At time.Time `db:"at"`
}
const classColumns = `id, org_id, connector, action, target_kind, environment, read_only, level, created_at, reset_at, tightened_at, tightened_because`
// EnsureClass returns the class c names, creating it at c.Level when it is
// new. An existing class keeps its level.
func (s *Store) EnsureClass(ctx context.Context, c Class) (Class, error) {
var out Class
err := s.db.GetContext(ctx, &out, `
INSERT INTO judgement.classes (id, org_id, connector, action, target_kind, environment, read_only, level)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
ON CONFLICT (org_id, connector, action, target_kind, environment)
DO UPDATE SET read_only = judgement.classes.read_only
RETURNING `+classColumns,
c.ID, c.OrgID, c.Connector, c.Action, c.TargetKind, c.Environment, c.ReadOnly, c.Level)
if err != nil {
return Class{}, fmt.Errorf("ensure class: %w", err)
}
return out, nil
}
// Classes returns every class, most recently decided first.
func (s *Store) Classes(ctx context.Context, orgID string) ([]ClassSummary, error) {
var out []ClassSummary
err := s.db.SelectContext(ctx, &out, `
SELECT c.id, c.org_id, c.connector, c.action, c.target_kind, c.environment, c.read_only, c.level,
c.created_at, c.reset_at, c.tightened_at, c.tightened_because,
count(d.id) AS decisions, max(d.created_at) AS last_at,
(SELECT count(*) FROM judgement.class_approvals a WHERE a.class_id = c.id AND a.counted) AS streak
FROM judgement.classes c
LEFT JOIN judgement.decisions d ON d.org_id = c.org_id AND d.connector = c.connector
AND d.action = c.action AND d.target_kind = c.target_kind AND d.environment = c.environment AND NOT d.dry
WHERE c.org_id = $1
GROUP BY c.id
ORDER BY coalesce(max(d.created_at), c.created_at) DESC, c.id`, orgID)
if err != nil {
return nil, fmt.Errorf("list classes: %w", err)
}
return out, nil
}
// ClassByID returns one class.
func (s *Store) ClassByID(ctx context.Context, orgID string, id uuid.UUID) (Class, error) {
var out Class
err := s.db.GetContext(ctx, &out, `SELECT `+classColumns+` FROM judgement.classes WHERE org_id = $1 AND id = $2`, orgID, id)
if errors.Is(err, sql.ErrNoRows) {
return Class{}, ErrNoClass
}
if err != nil {
return Class{}, fmt.Errorf("read class: %w", err)
}
return out, nil
}
// ClassDecisions returns a class's newest decisions, newest first.
func (s *Store) ClassDecisions(ctx context.Context, c Class, limit int) ([]Decision, error) {
var out []Decision
err := s.db.SelectContext(ctx, &out, `
SELECT id, org_id, run_id, key, connector, action, target_kind, environment, level, body, created_at
FROM judgement.decisions
WHERE org_id = $1 AND connector = $2 AND action = $3 AND target_kind = $4 AND environment = $5 AND NOT dry
ORDER BY created_at DESC, id LIMIT $6`,
c.OrgID, c.Connector, c.Action, c.TargetKind, c.Environment, limit)
if err != nil {
return nil, fmt.Errorf("list class decisions: %w", err)
}
return out, nil
}
// ClassResets returns a class's resets, newest first.
func (s *Store) ClassResets(ctx context.Context, id uuid.UUID) ([]Reset, error) {
var out []Reset
err := s.db.SelectContext(ctx, &out, `
SELECT id, from_level, to_level, by, at FROM judgement.class_resets
WHERE class_id = $1 ORDER BY at DESC, id`, id)
if err != nil {
return nil, fmt.Errorf("list class resets: %w", err)
}
return out, nil
}
// ResetClass sets a class to level and records the reset, in one transaction.
func (s *Store) ResetClass(ctx context.Context, orgID string, id uuid.UUID, level, by string, at time.Time) (Class, error) {
tx, err := s.db.BeginTxx(ctx, nil)
if err != nil {
return Class{}, fmt.Errorf("reset class: %w", err)
}
defer func() { _ = tx.Rollback() }()
var before Class
err = tx.GetContext(ctx, &before, `SELECT `+classColumns+` FROM judgement.classes WHERE org_id = $1 AND id = $2 FOR UPDATE`, orgID, id)
if errors.Is(err, sql.ErrNoRows) {
return Class{}, ErrNoClass
}
if err != nil {
return Class{}, fmt.Errorf("reset class: %w", err)
}
var out Class
if err := tx.GetContext(ctx, &out, `
UPDATE judgement.classes SET level = $2, reset_at = $3 WHERE id = $1 RETURNING `+classColumns, id, level, at); err != nil {
return Class{}, fmt.Errorf("reset class: %w", err)
}
// A reset starts the count again and withdraws a raise that was waiting.
if _, err := tx.ExecContext(ctx, `UPDATE judgement.class_approvals SET counted = false WHERE class_id = $1 AND counted`, id); err != nil {
return Class{}, fmt.Errorf("reset class: %w", err)
}
if _, err := tx.ExecContext(ctx, `UPDATE judgement.class_raises SET state = 'superseded' WHERE class_id = $1 AND state = 'pending'`, id); err != nil {
return Class{}, fmt.Errorf("reset class: %w", err)
}
if _, err := tx.ExecContext(ctx, `
INSERT INTO judgement.class_resets (id, org_id, class_id, from_level, to_level, by, at)
VALUES ($1, $2, $3, $4, $5, $6, $7)`, uuid.New(), orgID, id, before.Level, level, by, at); err != nil {
return Class{}, fmt.Errorf("record reset: %w", err)
}
if err := tx.Commit(); err != nil {
return Class{}, fmt.Errorf("reset class: %w", err)
}
return out, nil
}