Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

attached sql seed script to make review easier

adilson46bd1b8031af
diff --git a/legacy-access-approvals-seed.sql b/legacy-access-approvals-seed.sql
new file mode 100644
index 0000000000..b6c398267b
--- /dev/null
+++ b/legacy-access-approvals-seed.sql
@@ -0,0 +1,543 @@
+-- Seeds legacy access approval policies and requests (access_approval_* tables) covering bypassers,
+-- self-approval, requesters who are approvers, break-glass, sequences, expiry and deletion. Every row
+-- is written the way the legacy service writes it, including the outcomes of its bugs (see the notes
+-- on p02, p08, p15, p17 and p22).
+--
+-- Usage: edit the three ids in seed_params, then run the whole file (psql -f, or pgAdmin's query tool).
+-- docker exec -i infisical-db-1 psql -U infisical -d infisical -v ON_ERROR_STOP=1 < legacy-access-approvals-seed.sql
+--
+-- Re-running is safe: it first deletes every legacy access approval policy in the project whose name
+-- matches ^p[0-9]{2}- together with its requests and privileges, plus any global copies the
+-- migration made of them (same ids) and global requests filed against those copies.
+--
+-- The migration is already recorded as applied on a dev DB that ran it, so roll it back and re-run it
+-- to migrate a fresh seed.
+
+BEGIN;
+
+CREATE TEMP TABLE seed_params ON COMMIT DROP AS
+SELECT
+ '3187d488-34a7-4ebb-9d5a-5481eba0d538'::text AS project_id,
+ 'ee1008ae-1082-4be2-90e6-b979e82f2476'::uuid AS admin_id, -- project admin: approver and reviewer
+ '1e10c1da-e8c1-4100-ab70-0eaae8b6b639'::uuid AS requester_id; -- project member: files the requests
+
+CREATE TEMP TABLE seed_policies (name text PRIMARY KEY, id uuid NOT NULL, path text NOT NULL) ON COMMIT DROP;
+CREATE TEMP TABLE seed_requests (key text PRIMARY KEY, id uuid NOT NULL, last_at timestamptz NOT NULL) ON COMMIT DROP;
+
+-- ---------------------------------------------------------------------------------------------------
+-- Helpers (session-scoped, gone when the connection closes)
+-- ---------------------------------------------------------------------------------------------------
+
+CREATE OR REPLACE FUNCTION pg_temp.project() RETURNS text LANGUAGE sql STABLE AS
+$$ SELECT project_id FROM seed_params $$;
+CREATE OR REPLACE FUNCTION pg_temp.admin() RETURNS uuid LANGUAGE sql STABLE AS
+$$ SELECT admin_id FROM seed_params $$;
+CREATE OR REPLACE FUNCTION pg_temp.requester() RETURNS uuid LANGUAGE sql STABLE AS
+$$ SELECT requester_id FROM seed_params $$;
+
+-- '30m', '12h', '7d' -> interval, matching the ms() strings the API accepts
+CREATE OR REPLACE FUNCTION pg_temp.dur(p text) RETURNS interval LANGUAGE sql IMMUTABLE AS $$
+ SELECT CASE WHEN p IS NULL THEN NULL ELSE
+ (substring(p FROM '^(\d+)') || ' ' ||
+ CASE substring(p FROM '([smhdw])$')
+ WHEN 's' THEN 'seconds' WHEN 'm' THEN 'minutes' WHEN 'h' THEN 'hours'
+ WHEN 'd' THEN 'days' WHEN 'w' THEN 'weeks' END)::interval
+ END
+$$;
+
+CREATE OR REPLACE FUNCTION pg_temp.env_id(p_slug text) RETURNS uuid LANGUAGE plpgsql STABLE AS $$
+DECLARE v_id uuid;
+BEGIN
+ SELECT id INTO v_id FROM project_environments
+ WHERE "projectId" = pg_temp.project() AND slug = p_slug AND "deleteAfter" IS NULL;
+ IF v_id IS NULL THEN
+ RAISE EXCEPTION 'Environment "%" not found in project %', p_slug, pg_temp.project();
+ END IF;
+ RETURN v_id;
+END $$;
+
+-- Find or create a group in the project's org, make it a project member, and set its members to
+-- exactly p_member (or nobody).
+CREATE OR REPLACE FUNCTION pg_temp.seed_group(p_slug text, p_member uuid) RETURNS uuid LANGUAGE plpgsql AS $$
+DECLARE
+ v_org uuid;
+ v_group uuid;
+ v_membership uuid;
+BEGIN
+ SELECT "orgId" INTO v_org FROM projects WHERE id = pg_temp.project();
+ IF v_org IS NULL THEN
+ RAISE EXCEPTION 'Project % not found', pg_temp.project();
+ END IF;
+
+ SELECT id INTO v_group FROM groups WHERE "orgId" = v_org AND (slug = p_slug OR name = p_slug);
+ IF v_group IS NULL THEN
+ INSERT INTO groups ("orgId", name, slug) VALUES (v_org, p_slug, p_slug) RETURNING id INTO v_group;
+ END IF;
+
+ IF NOT EXISTS (SELECT 1 FROM memberships WHERE scope = 'organization' AND "scopeOrgId" = v_org AND "actorGroupId" = v_group) THEN
+ INSERT INTO memberships (scope, "actorGroupId", "scopeOrgId") VALUES ('organization', v_group, v_org)
+ RETURNING id INTO v_membership;
+ INSERT INTO membership_roles ("membershipId", role) VALUES (v_membership, 'no-access');
+ END IF;
+
+ IF NOT EXISTS (SELECT 1 FROM memberships WHERE scope = 'project' AND "scopeProjectId" = pg_temp.project() AND "actorGroupId" = v_group) THEN
+ INSERT INTO memberships (scope, "actorGroupId", "scopeOrgId", "scopeProjectId")
+ VALUES ('project', v_group, v_org, pg_temp.project())
+ RETURNING id INTO v_membership;
+ INSERT INTO membership_roles ("membershipId", role) VALUES (v_membership, 'member');
+ END IF;
+
+ DELETE FROM user_group_membership WHERE "groupId" = v_group AND "userId" IS DISTINCT FROM p_member;
+ IF p_member IS NOT NULL AND NOT EXISTS (SELECT 1 FROM user_group_membership WHERE "groupId" = v_group AND "userId" = p_member) THEN
+ INSERT INTO user_group_membership ("userId", "groupId") VALUES (p_member, v_group);
+ END IF;
+
+ RETURN v_group;
+END $$;
+
+CREATE OR REPLACE FUNCTION pg_temp.seed_policy(
+ p_name text,
+ p_envs text[],
+ p_path text,
+ p_approvals int DEFAULT 1,
+ p_enforcement text DEFAULT 'hard',
+ p_allow_self boolean DEFAULT true,
+ p_max_time text DEFAULT NULL,
+ p_request_expiration text DEFAULT NULL
+) RETURNS uuid LANGUAGE plpgsql AS $$
+DECLARE
+ v_id uuid;
+ v_at timestamptz := now() - interval '1 hour';
+BEGIN
+ INSERT INTO access_approval_policies
+ (name, approvals, "secretPath", "envId", "enforcementLevel", "allowedSelfApprovals", "maxTimePeriod", "requestExpirationTime", "createdAt", "updatedAt")
+ VALUES
+ (p_name, p_approvals, p_path, pg_temp.env_id(p_envs[1]), p_enforcement, p_allow_self, p_max_time, p_request_expiration, v_at, v_at)
+ RETURNING id INTO v_id;
+
+ INSERT INTO access_approval_policies_environments ("policyId", "envId", "createdAt", "updatedAt")
+ SELECT v_id, pg_temp.env_id(e), v_at, v_at FROM unnest(p_envs) AS e;
+
+ INSERT INTO seed_policies (name, id, path) VALUES (p_name, v_id, p_path);
+ RETURN v_id;
+END $$;
+
+-- The API stores approvalsRequired only when the request sends a step map, so it stays NULL otherwise.
+CREATE OR REPLACE FUNCTION pg_temp.seed_approver(
+ p_policy text, p_user uuid, p_group uuid, p_sequence int DEFAULT 1, p_required int DEFAULT NULL
+) RETURNS void LANGUAGE sql AS $$
+ INSERT INTO access_approval_policies_approvers ("policyId", "approverUserId", "approverGroupId", sequence, "approvalsRequired")
+ SELECT id, p_user, p_group, p_sequence, p_required FROM seed_policies WHERE name = p_policy
+$$;
+
+CREATE OR REPLACE FUNCTION pg_temp.seed_bypasser(p_policy text, p_user uuid, p_group uuid) RETURNS void LANGUAGE sql AS $$
+ INSERT INTO access_approval_policies_bypassers ("policyId", "bypasserUserId", "bypasserGroupId")
+ SELECT id, p_user, p_group FROM seed_policies WHERE name = p_policy
+$$;
+
+-- p_rules is [[actions, subject], ...] with comma-joined actions, packed like the frontend's packRules.
+-- Requests are spaced 10 seconds apart starting 20 minutes ago unless p_created_at is given.
+CREATE OR REPLACE FUNCTION pg_temp.seed_request(
+ p_key text,
+ p_policy text,
+ p_requester uuid,
+ p_env text,
+ p_rules jsonb,
+ p_is_temporary boolean DEFAULT false,
+ p_range text DEFAULT NULL,
+ p_note text DEFAULT NULL,
+ p_created_at timestamptz DEFAULT NULL
+) RETURNS uuid LANGUAGE plpgsql AS $$
+DECLARE
+ v_policy record;
+ v_permissions jsonb;
+ v_at timestamptz;
+ v_id uuid;
+BEGIN
+ SELECT sp.id, sp.path, p."requestExpirationTime" INTO v_policy
+ FROM seed_policies sp JOIN access_approval_policies p ON p.id = sp.id
+ WHERE sp.name = p_policy;
+
+ v_at := coalesce(p_created_at, now() - interval '20 minutes' + (SELECT count(*) FROM seed_requests) * interval '10 seconds');
+
+ SELECT jsonb_agg(
+ jsonb_build_array(r ->> 0, r ->> 1, jsonb_build_object('environment', p_env, 'secretPath', jsonb_build_object('$glob', v_policy.path)))
+ ORDER BY ord)
+ INTO v_permissions
+ FROM jsonb_array_elements(p_rules) WITH ORDINALITY AS t(r, ord);
+
+ INSERT INTO access_approval_requests
+ ("policyId", "requestedByUserId", permissions, "isTemporary", "temporaryRange", note, "expiresAt", status, "createdAt", "updatedAt")
+ VALUES
+ (v_policy.id, p_requester, v_permissions, p_is_temporary, p_range, p_note,
+ v_at + pg_temp.dur(v_policy."requestExpirationTime"), 'pending', v_at, v_at)
+ RETURNING id INTO v_id;
+
+ INSERT INTO seed_requests (key, id, last_at) VALUES (p_key, v_id, v_at);
+ RETURN v_id;
+END $$;
+
+-- Records one review 15 seconds after the request's last activity. A rejection closes the request.
+-- An approval closes it only when p_closes says so, because whether the legacy threshold logic
+-- would close it is exactly what the scenarios pin down. Closing creates the additional privilege.
+CREATE OR REPLACE FUNCTION pg_temp.seed_review(
+ p_key text, p_reviewer uuid, p_status text, p_closes boolean DEFAULT false, p_bypass_reason text DEFAULT NULL
+) RETURNS void LANGUAGE plpgsql AS $$
+DECLARE
+ v_req record;
+ v_at timestamptz;
+ v_privilege uuid;
+BEGIN
+ SELECT r.*, sr.last_at INTO v_req
+ FROM seed_requests sr JOIN access_approval_requests r ON r.id = sr.id
+ WHERE sr.key = p_key;
+ v_at := v_req.last_at + interval '15 seconds';
+
+ INSERT INTO access_approval_requests_reviewers ("requestId", "reviewerUserId", status, "createdAt", "updatedAt")
+ VALUES (v_req.id, p_reviewer, p_status, v_at, v_at);
+
+ IF p_status = 'rejected' THEN
+ UPDATE access_approval_requests SET status = 'rejected', "updatedAt" = v_at WHERE id = v_req.id;
+ ELSIF p_closes THEN
+ INSERT INTO additional_privileges
+ (name, "actorUserId", "projectId", permissions, "isTemporary", "temporaryMode", "temporaryRange",
+ "temporaryAccessStartTime", "temporaryAccessEndTime", "createdAt", "updatedAt")
+ SELECT
+ 'requested-privilege-' || substr(md5(random()::text), 1, 12),
+ v_req."requestedByUserId",
+ pg_temp.project(),
+ v_req.permissions,
+ tmp,
+ CASE WHEN tmp THEN 'relative' END,
+ CASE WHEN tmp THEN v_req."temporaryRange" END,
+ CASE WHEN tmp THEN v_at END,
+ CASE WHEN tmp THEN v_at + pg_temp.dur(v_req."temporaryRange") END,
+ v_at,
+ v_at
+ FROM (SELECT v_req."isTemporary" OR v_req."temporaryRange" IS NOT NULL AS tmp) AS x
+ RETURNING id INTO v_privilege;
+
+ UPDATE access_approval_requests
+ SET status = 'approved', "privilegeId" = v_privilege, "approvedAt" = v_at, "approvedByUserId" = p_reviewer,
+ "bypassReason" = p_bypass_reason, "updatedAt" = v_at
+ WHERE id = v_req.id;
+ END IF;
+
+ UPDATE seed_requests SET last_at = v_at WHERE key = p_key;
+END $$;
+
+-- Same order as the legacy revoke: detach the privilege, then delete it (the FK would cascade the request).
+CREATE OR REPLACE FUNCTION pg_temp.seed_revoke(p_key text, p_revoker uuid) RETURNS void LANGUAGE plpgsql AS $$
+DECLARE
+ v_req record;
+ v_at timestamptz;
+BEGIN
+ SELECT r.*, sr.last_at INTO v_req FROM seed_requests sr JOIN access_approval_requests r ON r.id = sr.id WHERE sr.key = p_key;
+ v_at := v_req.last_at + interval '15 seconds';
+
+ UPDATE access_approval_requests
+ SET status = 'revoked', "revokedAt" = v_at, "revokedByUserId" = p_revoker, "privilegeId" = NULL, "updatedAt" = v_at
+ WHERE id = v_req.id;
+ DELETE FROM additional_privileges WHERE id = v_req."privilegeId";
+
+ UPDATE seed_requests SET last_at = v_at WHERE key = p_key;
+END $$;
+
+CREATE OR REPLACE FUNCTION pg_temp.seed_edit(p_key text, p_editor uuid, p_range text, p_note text) RETURNS void LANGUAGE plpgsql AS $$
+DECLARE v_at timestamptz;
+BEGIN
+ SELECT last_at + interval '15 seconds' INTO v_at FROM seed_requests WHERE key = p_key;
+ UPDATE access_approval_requests
+ SET "temporaryRange" = p_range, "editedByUserId" = p_editor, "editNote" = p_note, "updatedAt" = v_at
+ WHERE id = (SELECT id FROM seed_requests WHERE key = p_key);
+ UPDATE seed_requests SET last_at = v_at WHERE key = p_key;
+END $$;
+
+-- Mirrors the legacy delete: soft-delete the policy and hard-delete its requests' privileges. The
+-- privilegeId FK is ON DELETE CASCADE, so every approved request still holding a privilege goes too.
+CREATE OR REPLACE FUNCTION pg_temp.seed_delete_policy(p_policy text) RETURNS void LANGUAGE plpgsql AS $$
+DECLARE v_id uuid;
+BEGIN
+ SELECT id INTO v_id FROM seed_policies WHERE name = p_policy;
+ UPDATE access_approval_policies SET "deletedAt" = now() - interval '1 minute' WHERE id = v_id;
+ DELETE FROM additional_privileges
+ WHERE id IN (SELECT "privilegeId" FROM access_approval_requests WHERE "policyId" = v_id AND "privilegeId" IS NOT NULL);
+END $$;
+
+-- ---------------------------------------------------------------------------------------------------
+-- Remove the previous seed (legacy rows, privileges, and global copies sharing their ids)
+-- ---------------------------------------------------------------------------------------------------
+
+CREATE TEMP TABLE seed_old_policies ON COMMIT DROP AS
+SELECT p.id
+FROM access_approval_policies p
+JOIN access_approval_policies_environments pe ON pe."policyId" = p.id
+JOIN project_environments e ON e.id = pe."envId"
+WHERE e."projectId" = pg_temp.project() AND p.name ~ '^p[0-9]{2}-'
+GROUP BY p.id;
+
+CREATE TEMP TABLE seed_old_global_requests ON COMMIT DROP AS
+SELECT id FROM approval_requests WHERE "policyId" IN (SELECT id FROM seed_old_policies)
+UNION
+SELECT g.id FROM approval_requests g
+JOIN access_approval_requests r ON r.id = g.id
+WHERE r."policyId" IN (SELECT id FROM seed_old_policies);
+
+DELETE FROM additional_privileges
+WHERE "grantId" IN (SELECT id FROM approval_request_grants WHERE "requestId" IN (SELECT id FROM seed_old_global_requests))
+ OR id IN (SELECT "privilegeId" FROM access_approval_requests WHERE "policyId" IN (SELECT id FROM seed_old_policies));
+DELETE FROM approval_request_grants WHERE "requestId" IN (SELECT id FROM seed_old_global_requests);
+DELETE FROM approval_requests WHERE id IN (SELECT id FROM seed_old_global_requests);
+DELETE FROM approval_policies WHERE id IN (SELECT id FROM seed_old_policies);
+DELETE FROM access_approval_policies WHERE id IN (SELECT id FROM seed_old_policies);
+
+-- ---------------------------------------------------------------------------------------------------
+-- Seed
+-- ---------------------------------------------------------------------------------------------------
+
+DO $$
+DECLARE
+ a uuid := pg_temp.admin();
+ b uuid := pg_temp.requester();
+ -- The admin is the approver group's only member, which is what lets group approvers and group
+ -- bypassers be exercised by a user who can log in.
+ g uuid := pg_temp.seed_group('seed-approvers', pg_temp.admin());
+ empty_group uuid := pg_temp.seed_group('seed-empty-approvers', NULL);
+ -- The requester is this group's only member, so p20's requester is an approver only through it.
+ requester_group uuid := pg_temp.seed_group('seed-requester-approvers', pg_temp.requester());
+BEGIN
+ -- p01: plain hard policy, every terminal state
+ PERFORM pg_temp.seed_policy('p01-hard-single-approver', ARRAY['dev'], '/');
+ PERFORM pg_temp.seed_approver('p01-hard-single-approver', a, NULL);
+
+ PERFORM pg_temp.seed_request('r01a-approved-permanent', 'p01-hard-single-approver', b, 'dev', '[["read","secrets"]]', p_note => 'need read on dev root');
+ PERFORM pg_temp.seed_review('r01a-approved-permanent', a, 'approved', true);
+ PERFORM pg_temp.seed_request('r01b-approved-temp-30d', 'p01-hard-single-approver', b, 'dev', '[["describeSecret,readValue","secrets"]]', true, '30d');
+ PERFORM pg_temp.seed_review('r01b-approved-temp-30d', a, 'approved', true);
+ PERFORM pg_temp.seed_request('r01c-approved-temp-1m-expired', 'p01-hard-single-approver', b, 'dev', '[["edit","secrets"]]', true, '1m');
+ PERFORM pg_temp.seed_review('r01c-approved-temp-1m-expired', a, 'approved', true);
+ PERFORM pg_temp.seed_request('r01d-rejected', 'p01-hard-single-approver', b, 'dev', '[["create","secrets"]]');
+ PERFORM pg_temp.seed_review('r01d-rejected', a, 'rejected');
+ PERFORM pg_temp.seed_request('r01e-revoked', 'p01-hard-single-approver', b, 'dev', '[["delete","secrets"]]');
+ PERFORM pg_temp.seed_review('r01e-revoked', a, 'approved', true);
+ PERFORM pg_temp.seed_revoke('r01e-revoked', a);
+ PERFORM pg_temp.seed_request('r01f-pending', 'p01-hard-single-approver', b, 'dev', '[["read","secret-folders"]]', p_note => 'pending folder read');
+ PERFORM pg_temp.seed_request('r01g-cancelled-by-requester', 'p01-hard-single-approver', b, 'dev', '[["read","secret-imports"]]');
+ PERFORM pg_temp.seed_review('r01g-cancelled-by-requester', b, 'rejected');
+ PERFORM pg_temp.seed_request('r01h-pending-edited', 'p01-hard-single-approver', b, 'dev', '[["read,edit","secrets"]]', true, '2h');
+ PERFORM pg_temp.seed_edit('r01h-pending-edited', a, '1h', 'shortened to one hour');
+ PERFORM pg_temp.seed_request('r01i-multi-subject-approved', 'p01-hard-single-approver', b, 'dev', '[["describeSecret","secrets"],["create,edit","secret-folders"]]');
+ PERFORM pg_temp.seed_review('r01i-multi-subject-approved', a, 'approved', true);
+ -- same criteria as r01c, allowed again because that grant has expired
+ PERFORM pg_temp.seed_request('r01j-re-request-after-grant-expired', 'p01-hard-single-approver', b, 'dev', '[["edit","secrets"]]', true, '1m', p_created_at => now());
+
+ -- p02: two steps with the group in step 2, bypassers on a hard policy (bypassers do nothing under
+ -- hard enforcement). The admin is a direct step-1 approver and a step-2 group member; the legacy
+ -- findById dedupes him into step 2 only, so his single review approves the whole request.
+ PERFORM pg_temp.seed_policy('p02-two-step-group-and-bypassers', ARRAY['staging'], '/app');
+ PERFORM pg_temp.seed_approver('p02-two-step-group-and-bypassers', a, NULL, 1, 1);
+ PERFORM pg_temp.seed_approver('p02-two-step-group-and-bypassers', NULL, g, 2, 1);
+ PERFORM pg_temp.seed_bypasser('p02-two-step-group-and-bypassers', b, NULL);
+ PERFORM pg_temp.seed_bypasser('p02-two-step-group-and-bypassers', NULL, g);
+ PERFORM pg_temp.seed_request('r02a-approved-after-step-1-only', 'p02-two-step-group-and-bypassers', b, 'staging', '[["read","secrets"]]');
+ PERFORM pg_temp.seed_review('r02a-approved-after-step-1-only', a, 'approved', true);
+ PERFORM pg_temp.seed_request('r02b-rejected-at-step1', 'p02-two-step-group-and-bypassers', b, 'staging', '[["edit","secrets"]]');
+ PERFORM pg_temp.seed_review('r02b-rejected-at-step1', a, 'rejected');
+ PERFORM pg_temp.seed_request('r02c-pending-untouched', 'p02-two-step-group-and-bypassers', b, 'staging', '[["create","secrets"]]', true, '4h');
+
+ -- p03: self-approval allowed
+ PERFORM pg_temp.seed_policy('p03-self-approval-allowed', ARRAY['dev'], '/self');
+ PERFORM pg_temp.seed_approver('p03-self-approval-allowed', b, NULL);
+ PERFORM pg_temp.seed_approver('p03-self-approval-allowed', a, NULL);
+ PERFORM pg_temp.seed_request('r03a-self-approved', 'p03-self-approval-allowed', b, 'dev', '[["read","secrets"]]');
+ PERFORM pg_temp.seed_review('r03a-self-approved', b, 'approved', true);
+ PERFORM pg_temp.seed_request('r03b-approved-by-other', 'p03-self-approval-allowed', b, 'dev', '[["edit","secrets"]]', true, '7d');
+ PERFORM pg_temp.seed_review('r03b-approved-by-other', a, 'approved', true);
+ -- the requester's own approval alone would close it
+ PERFORM pg_temp.seed_request('r03c-pending-untouched', 'p03-self-approval-allowed', b, 'dev', '[["create","secrets"]]');
+
+ -- p04: self-approval disallowed (the requester's own approval is refused, so only the admin's lands)
+ PERFORM pg_temp.seed_policy('p04-self-approval-blocked', ARRAY['dev'], '/no-self', p_allow_self => false);
+ PERFORM pg_temp.seed_approver('p04-self-approval-blocked', a, NULL);
+ PERFORM pg_temp.seed_approver('p04-self-approval-blocked', b, NULL);
+ PERFORM pg_temp.seed_request('r04a-approved-by-other', 'p04-self-approval-blocked', b, 'dev', '[["read","secrets"]]');
+ PERFORM pg_temp.seed_review('r04a-approved-by-other', a, 'approved', true);
+ PERFORM pg_temp.seed_request('r04b-pending', 'p04-self-approval-blocked', b, 'dev', '[["edit","secrets"]]');
+
+ -- p05: soft with no bypassers listed, so any requester can break glass
+ PERFORM pg_temp.seed_policy('p05-soft-breakglass-no-bypassers', ARRAY['prod'], '/', p_enforcement => 'soft');
+ PERFORM pg_temp.seed_approver('p05-soft-breakglass-no-bypassers', a, NULL);
+ PERFORM pg_temp.seed_request('r05a-break-glass', 'p05-soft-breakglass-no-bypassers', b, 'prod', '[["read","secrets"]]', true, '1h');
+ PERFORM pg_temp.seed_review('r05a-break-glass', b, 'approved', true, 'Production incident INC-4821, paging on-call');
+ PERFORM pg_temp.seed_request('r05b-normal-approval-on-soft', 'p05-soft-breakglass-no-bypassers', b, 'prod', '[["edit","secrets"]]');
+ PERFORM pg_temp.seed_review('r05b-normal-approval-on-soft', a, 'approved', true);
+ -- break-glass without a reason is indistinguishable from a normal approval in the stored row
+ PERFORM pg_temp.seed_request('r05c-break-glass-no-reason', 'p05-soft-breakglass-no-bypassers', b, 'prod', '[["create","secrets"]]');
+ PERFORM pg_temp.seed_review('r05c-break-glass-no-reason', b, 'approved', true);
+
+ -- p06: soft, requester is a user bypasser, self-approval disabled (being a bypasser overrides it)
+ PERFORM pg_temp.seed_policy('p06-soft-requester-is-bypasser-self-blocked', ARRAY['prod'], '/payments', p_enforcement => 'soft', p_allow_self => false);
+ PERFORM pg_temp.seed_approver('p06-soft-requester-is-bypasser-self-blocked', a, NULL);
+ PERFORM pg_temp.seed_bypasser('p06-soft-requester-is-bypasser-self-blocked', b, NULL);
+ PERFORM pg_temp.seed_request('r06a-bypasser-break-glass', 'p06-soft-requester-is-bypasser-self-blocked', b, 'prod', '[["read","secrets"]]');
+ PERFORM pg_temp.seed_review('r06a-bypasser-break-glass', b, 'approved', true, 'Payment outage, need to rotate keys now');
+ PERFORM pg_temp.seed_request('r06b-pending', 'p06-soft-requester-is-bypasser-self-blocked', b, 'prod', '[["edit","secrets"]]');
+
+ -- p07: soft, only someone else is a bypasser, so the requester's break-glass is refused
+ PERFORM pg_temp.seed_policy('p07-soft-bypasser-is-someone-else', ARRAY['prod'], '/billing', p_enforcement => 'soft');
+ PERFORM pg_temp.seed_approver('p07-soft-bypasser-is-someone-else', a, NULL);
+ PERFORM pg_temp.seed_bypasser('p07-soft-bypasser-is-someone-else', a, NULL);
+ PERFORM pg_temp.seed_request('r07a-break-glass-refused', 'p07-soft-bypasser-is-someone-else', b, 'prod', '[["read","secrets"]]');
+
+ -- p08: soft, group bypasser, self-approval disabled. The admin's break-glass on his own request is
+ -- refused too, because the legacy findById resolves group bypassers from the wrong column.
+ PERFORM pg_temp.seed_policy('p08-soft-group-bypasser-self-blocked', ARRAY['prod'], '/ops', p_enforcement => 'soft', p_allow_self => false);
+ PERFORM pg_temp.seed_approver('p08-soft-group-bypasser-self-blocked', b, NULL);
+ PERFORM pg_temp.seed_bypasser('p08-soft-group-bypasser-self-blocked', NULL, g);
+ PERFORM pg_temp.seed_request('r08a-requester-not-in-bypass-group', 'p08-soft-group-bypasser-self-blocked', b, 'prod', '[["read","secrets"]]');
+ PERFORM pg_temp.seed_request('r08b-admin-in-bypass-group', 'p08-soft-group-bypasser-self-blocked', a, 'prod', '[["read","secrets"]]');
+
+ -- p09: one policy over two environments
+ PERFORM pg_temp.seed_policy('p09-multi-environment', ARRAY['dev', 'staging'], '/shared');
+ PERFORM pg_temp.seed_approver('p09-multi-environment', a, NULL);
+ PERFORM pg_temp.seed_request('r09a-dev-approved', 'p09-multi-environment', b, 'dev', '[["read","secrets"]]');
+ PERFORM pg_temp.seed_review('r09a-dev-approved', a, 'approved', true);
+ PERFORM pg_temp.seed_request('r09b-staging-pending', 'p09-multi-environment', b, 'staging', '[["read","secrets"]]');
+
+ -- p10: maxTimePeriod 1h (the API refuses permanent and 2h requests here)
+ PERFORM pg_temp.seed_policy('p10-max-time-period-1h', ARRAY['staging'], '/temp-only', p_max_time => '1h');
+ PERFORM pg_temp.seed_approver('p10-max-time-period-1h', a, NULL);
+ PERFORM pg_temp.seed_request('r10a-temp-30m-approved', 'p10-max-time-period-1h', b, 'staging', '[["read","secrets"]]', true, '30m');
+ PERFORM pg_temp.seed_review('r10a-temp-30m-approved', a, 'approved', true);
+ PERFORM pg_temp.seed_request('r10b-temp-1h-pending', 'p10-max-time-period-1h', b, 'staging', '[["edit","secrets"]]', true, '1h');
+
+ -- p11: requests expire 1 minute after they are filed
+ PERFORM pg_temp.seed_policy('p11-request-expiration-1m', ARRAY['staging'], '/expiring', p_request_expiration => '1m');
+ PERFORM pg_temp.seed_approver('p11-request-expiration-1m', a, NULL);
+ PERFORM pg_temp.seed_request('r11a-approved-before-expiry', 'p11-request-expiration-1m', b, 'staging', '[["read","secrets"]]');
+ PERFORM pg_temp.seed_review('r11a-approved-before-expiry', a, 'approved', true);
+ PERFORM pg_temp.seed_request('r11b-pending-expired', 'p11-request-expiration-1m', b, 'staging', '[["edit","secrets"]]');
+ PERFORM pg_temp.seed_request('r11c-rejected-before-expiry', 'p11-request-expiration-1m', b, 'staging', '[["create","secrets"]]');
+ PERFORM pg_temp.seed_review('r11c-rejected-before-expiry', a, 'rejected');
+ -- live for one minute after the seed runs, then expired too
+ PERFORM pg_temp.seed_request('r11d-re-request-after-expiry', 'p11-request-expiration-1m', b, 'staging', '[["edit","secrets"]]', p_created_at => now());
+
+ -- p12: two approvals in one step, the requester is one of the approvers
+ PERFORM pg_temp.seed_policy('p12-two-approvals-one-step', ARRAY['prod'], '/db', p_approvals => 2);
+ PERFORM pg_temp.seed_approver('p12-two-approvals-one-step', a, NULL, 1, 2);
+ PERFORM pg_temp.seed_approver('p12-two-approvals-one-step', b, NULL, 1, 2);
+ PERFORM pg_temp.seed_approver('p12-two-approvals-one-step', NULL, g, 1, 2);
+ PERFORM pg_temp.seed_request('r12a-approved-2-of-2', 'p12-two-approvals-one-step', b, 'prod', '[["read","secrets"]]');
+ PERFORM pg_temp.seed_review('r12a-approved-2-of-2', a, 'approved');
+ PERFORM pg_temp.seed_review('r12a-approved-2-of-2', b, 'approved', true);
+ PERFORM pg_temp.seed_request('r12b-pending-1-of-2', 'p12-two-approvals-one-step', b, 'prod', '[["edit","secrets"]]');
+ PERFORM pg_temp.seed_review('r12b-pending-1-of-2', a, 'approved');
+ PERFORM pg_temp.seed_request('r12c-self-approved-then-rejected', 'p12-two-approvals-one-step', b, 'prod', '[["create","secrets"]]');
+ PERFORM pg_temp.seed_review('r12c-self-approved-then-rejected', b, 'approved');
+ PERFORM pg_temp.seed_review('r12c-self-approved-then-rejected', a, 'rejected');
+ -- the requester's own approval would count as 1 of 2
+ PERFORM pg_temp.seed_request('r12d-pending-untouched', 'p12-two-approvals-one-step', b, 'prod', '[["delete","secrets"]]');
+
+ -- p13: approvals = 2 but no approvalsRequired, so legacy treats the step as needing one
+ PERFORM pg_temp.seed_policy('p13-approvals-2-without-approvalsRequired', ARRAY['dev'], '/legacy-count', p_approvals => 2);
+ PERFORM pg_temp.seed_approver('p13-approvals-2-without-approvalsRequired', a, NULL);
+ PERFORM pg_temp.seed_approver('p13-approvals-2-without-approvalsRequired', b, NULL);
+ PERFORM pg_temp.seed_request('r13a-approved-by-one', 'p13-approvals-2-without-approvalsRequired', b, 'dev', '[["read","secrets"]]');
+ PERFORM pg_temp.seed_review('r13a-approved-by-one', a, 'approved', true);
+ PERFORM pg_temp.seed_request('r13b-pending', 'p13-approvals-2-without-approvalsRequired', b, 'dev', '[["edit","secrets"]]');
+
+ -- p14: the step needs 2 approvals but has 1 approver, so the request can never close
+ PERFORM pg_temp.seed_policy('p14-step-needs-more-than-its-approvers', ARRAY['dev'], '/overdemanding', p_approvals => 2);
+ PERFORM pg_temp.seed_approver('p14-step-needs-more-than-its-approvers', a, NULL, 1, 2);
+ PERFORM pg_temp.seed_request('r14a-stuck-1-of-2', 'p14-step-needs-more-than-its-approvers', b, 'dev', '[["read","secrets"]]');
+ PERFORM pg_temp.seed_review('r14a-stuck-1-of-2', a, 'approved');
+
+ -- p15: the only approver is an empty group. The API 500s when filing a request while the group is
+ -- empty (sendMail with no recipients), so this state means the group was emptied afterwards.
+ PERFORM pg_temp.seed_policy('p15-empty-group-only-approver', ARRAY['staging'], '/empty-group');
+ PERFORM pg_temp.seed_approver('p15-empty-group-only-approver', NULL, empty_group);
+ PERFORM pg_temp.seed_request('r15a-unapprovable', 'p15-empty-group-only-approver', b, 'staging', '[["read","secrets"]]');
+
+ -- p16: the admin named directly and through the group
+ PERFORM pg_temp.seed_policy('p16-user-direct-and-through-group', ARRAY['prod'], '/dup-approver');
+ PERFORM pg_temp.seed_approver('p16-user-direct-and-through-group', a, NULL);
+ PERFORM pg_temp.seed_approver('p16-user-direct-and-through-group', NULL, g);
+ PERFORM pg_temp.seed_request('r16a-pending', 'p16-user-direct-and-through-group', b, 'prod', '[["read","secrets"]]');
+ PERFORM pg_temp.seed_request('r16b-approved', 'p16-user-direct-and-through-group', b, 'prod', '[["edit","secrets"]]');
+ PERFORM pg_temp.seed_review('r16b-approved', a, 'approved', true);
+
+ -- p17: requests in several states, then the policy is deleted. The delete removes r17a entirely
+ -- (its privilege is deleted and the FK cascades), leaving pending, rejected and revoked requests.
+ PERFORM pg_temp.seed_policy('p17-deleted-policy', ARRAY['dev'], '/deleted');
+ PERFORM pg_temp.seed_approver('p17-deleted-policy', a, NULL);
+ PERFORM pg_temp.seed_request('r17a-approved-then-cascaded', 'p17-deleted-policy', b, 'dev', '[["read","secrets"]]');
+ PERFORM pg_temp.seed_review('r17a-approved-then-cascaded', a, 'approved', true);
+ PERFORM pg_temp.seed_request('r17b-pending', 'p17-deleted-policy', b, 'dev', '[["edit","secrets"]]');
+ PERFORM pg_temp.seed_request('r17c-rejected', 'p17-deleted-policy', b, 'dev', '[["create","secrets"]]');
+ PERFORM pg_temp.seed_review('r17c-rejected', a, 'rejected');
+ PERFORM pg_temp.seed_request('r17d-revoked', 'p17-deleted-policy', b, 'dev', '[["delete","secrets"]]', true, '1d');
+ PERFORM pg_temp.seed_review('r17d-revoked', a, 'approved', true);
+ PERFORM pg_temp.seed_revoke('r17d-revoked', a);
+ PERFORM pg_temp.seed_delete_policy('p17-deleted-policy');
+
+ -- p18: the requester approves step 1, the admin step 2
+ PERFORM pg_temp.seed_policy('p18-two-step-self-approval-first', ARRAY['prod'], '/two-step');
+ PERFORM pg_temp.seed_approver('p18-two-step-self-approval-first', b, NULL, 1, 1);
+ PERFORM pg_temp.seed_approver('p18-two-step-self-approval-first', a, NULL, 2, 1);
+ PERFORM pg_temp.seed_request('r18a-approved-both-steps', 'p18-two-step-self-approval-first', b, 'prod', '[["read","secrets"]]');
+ PERFORM pg_temp.seed_review('r18a-approved-both-steps', b, 'approved');
+ PERFORM pg_temp.seed_review('r18a-approved-both-steps', a, 'approved', true);
+ PERFORM pg_temp.seed_request('r18b-step1-done-step2-pending', 'p18-two-step-self-approval-first', b, 'prod', '[["edit","secrets"]]', true, '12h');
+ PERFORM pg_temp.seed_review('r18b-step1-done-step2-pending', b, 'approved');
+ PERFORM pg_temp.seed_request('r18c-rejected-at-step2', 'p18-two-step-self-approval-first', b, 'prod', '[["create","secrets"]]');
+ PERFORM pg_temp.seed_review('r18c-rejected-at-step2', b, 'approved');
+ PERFORM pg_temp.seed_review('r18c-rejected-at-step2', a, 'rejected');
+ -- the requester's own approval would clear step 1 and leave step 2 to the admin
+ PERFORM pg_temp.seed_request('r18d-pending-untouched', 'p18-two-step-self-approval-first', b, 'prod', '[["delete","secrets"]]');
+
+ -- p19-p22: the requester is an approver and nobody else is. Each policy keeps a request nobody has
+ -- reviewed, which is what an auto-approval of the requester's own steps would act on.
+
+ -- p19: direct approver, self-approval allowed
+ PERFORM pg_temp.seed_policy('p19-requester-only-approver', ARRAY['dev'], '/requester-approver');
+ PERFORM pg_temp.seed_approver('p19-requester-only-approver', b, NULL);
+ PERFORM pg_temp.seed_request('r19a-pending-untouched', 'p19-requester-only-approver', b, 'dev', '[["read","secrets"]]');
+ PERFORM pg_temp.seed_request('r19b-self-approved', 'p19-requester-only-approver', b, 'dev', '[["edit","secrets"]]', true, '8h');
+ PERFORM pg_temp.seed_review('r19b-self-approved', b, 'approved', true);
+
+ -- p20: approver only through a group, self-approval allowed
+ PERFORM pg_temp.seed_policy('p20-requester-only-approver-via-group', ARRAY['dev'], '/requester-group-approver');
+ PERFORM pg_temp.seed_approver('p20-requester-only-approver-via-group', NULL, requester_group);
+ PERFORM pg_temp.seed_request('r20a-pending-untouched', 'p20-requester-only-approver-via-group', b, 'dev', '[["read","secrets"]]');
+ PERFORM pg_temp.seed_request('r20b-self-approved-via-group', 'p20-requester-only-approver-via-group', b, 'dev', '[["edit","secrets"]]');
+ PERFORM pg_temp.seed_review('r20b-self-approved-via-group', b, 'approved', true);
+
+ -- p21: direct approver, self-approval disallowed, so nobody can ever approve (and nothing should
+ -- auto-approve it either)
+ PERFORM pg_temp.seed_policy('p21-requester-only-approver-self-blocked', ARRAY['dev'], '/requester-approver-self-blocked', p_allow_self => false);
+ PERFORM pg_temp.seed_approver('p21-requester-only-approver-self-blocked', b, NULL);
+ PERFORM pg_temp.seed_request('r21a-unapprovable', 'p21-requester-only-approver-self-blocked', b, 'dev', '[["read","secrets"]]');
+
+ -- p22: the only approver in both steps. The legacy findById dedupes approvers by user id, leaving
+ -- the requester in a single step, so their one review approves the whole request.
+ PERFORM pg_temp.seed_policy('p22-requester-approver-in-both-steps', ARRAY['staging'], '/requester-every-step');
+ PERFORM pg_temp.seed_approver('p22-requester-approver-in-both-steps', b, NULL, 1, 1);
+ PERFORM pg_temp.seed_approver('p22-requester-approver-in-both-steps', b, NULL, 2, 1);
+ PERFORM pg_temp.seed_request('r22a-pending-untouched', 'p22-requester-approver-in-both-steps', b, 'staging', '[["read","secrets"]]', true, '1d');
+ PERFORM pg_temp.seed_request('r22b-self-approved-both-steps', 'p22-requester-approver-in-both-steps', b, 'staging', '[["edit","secrets"]]');
+ PERFORM pg_temp.seed_review('r22b-self-approved-both-steps', b, 'approved', true);
+END $$;
+
+SELECT p.name AS policy,
+ count(r.id) AS requests,
+ count(r.id) FILTER (WHERE r.status = 'pending') AS pending,
+ count(r.id) FILTER (WHERE r.status = 'approved') AS approved,
+ count(r.id) FILTER (WHERE r.status = 'rejected') AS rejected,
+ count(r.id) FILTER (WHERE r.status = 'revoked') AS revoked
+FROM seed_policies sp
+JOIN access_approval_policies p ON p.id = sp.id
+LEFT JOIN access_approval_requests r ON r."policyId" = p.id
+GROUP BY p.name
+ORDER BY p.name;
+
+COMMIT;