@rebasepro/server-postgres 0.9.1-canary.c0d4c07 → 0.9.1-canary.d906fb7

package/src/security/policy-drift.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "@jest/globals";
 import type { CollectionConfig } from "@rebasepro/types";
 
-import { checkPolicyDrift, parseExpectedPolicies, formatPolicyDrift, hasDrift, dropOrphanedPolicies, isGeneratedPolicyName, type PolicyRef, type Queryable } from "./policy-drift";
+import { checkPolicyDrift, parseExpectedPolicies, formatPolicyDrift, hasDrift, type PolicyRef, type Queryable } from "./policy-drift";
 import { generatePostgresPoliciesDdl } from "../schema/generate-postgres-ddl-logic";
 
 function collection(slug: string): CollectionConfig {
@@ -154,108 +154,3 @@ describe("checkPolicyDrift", () => {
         expect(drift.missing.length).toBeGreaterThan(0);
     });
 });
-
-describe("isGeneratedPolicyName", () => {
-    it("recognises the generator's own shape", () => {
-        expect(isGeneratedPolicyName("documents_insert_a1b2c3d", "documents")).toBe(true);
-        // One rule spanning several operations appends the operation index.
-        expect(isGeneratedPolicyName("documents_update_a1b2c3d_1", "documents")).toBe(true);
-    });
-
-    it("does not claim names a human could have written", () => {
-        expect(isGeneratedPolicyName("owner_access", "documents")).toBe(false);
-        expect(isGeneratedPolicyName("documents_default_admin_read", "documents")).toBe(false);
-        // Right shape, wrong table — belongs to something else.
-        expect(isGeneratedPolicyName("teams_insert_a1b2c3d", "documents")).toBe(false);
-        // A digest is 7 lowercase hex characters, nothing else.
-        expect(isGeneratedPolicyName("documents_insert_notahex", "documents")).toBe(false);
-        expect(isGeneratedPolicyName("documents_grant_a1b2c3d", "documents")).toBe(false);
-    });
-});
-
-describe("dropOrphanedPolicies", () => {
-    /** Records the DDL issued so the test can assert on what was dropped. */
-    function recordingDb(rows: Record<string, unknown>[]) {
-        const executed: string[] = [];
-        const db: Queryable = {
-            query: async (text: string) => {
-                if (!/^SELECT/i.test(text)) executed.push(text);
-                return { rows: rows as never[] };
-            }
-        };
-        return { db, executed };
-    }
-
-    it("drops the policy a rule edit superseded", async () => {
-        // The reported failure: tightening a rule renames its policy, and the
-        // permissive original stays live and keeps ORing itself back in.
-        const cols = [collection("documents")];
-        const expected = parseExpectedPolicies(generatePostgresPoliciesDdl(cols));
-        const stale = {
-            schemaname: "public", tablename: "documents", policyname: "documents_insert_dead1ee",
-            roles: ["public"], cmd: "INSERT", qual: null, with_check: "true"
-        };
-        const live = [...expected.map((p) => liveRow(p)), stale];
-
-        const drift = await checkPolicyDrift(dbWith(live), cols);
-        const { db, executed } = recordingDb(live);
-        const { dropped, kept } = await dropOrphanedPolicies(db, drift, cols);
-
-        expect(dropped).toHaveLength(1);
-        expect(dropped[0].name).toBe("documents_insert_dead1ee");
-        expect(kept).toHaveLength(0);
-        expect(executed).toEqual([
-            'DROP POLICY IF EXISTS "documents_insert_dead1ee" ON "public"."documents"'
-        ]);
-    });
-
-    it("leaves a hand-written policy alone and reports it instead", async () => {
-        const cols = [collection("documents")];
-        const expected = parseExpectedPolicies(generatePostgresPoliciesDdl(cols));
-        const live = [
-            ...expected.map((p) => liveRow(p)),
-            { schemaname: "public", tablename: "documents", policyname: "ops_break_glass", roles: ["public"], cmd: "ALL", qual: "true", with_check: null }
-        ];
-
-        const drift = await checkPolicyDrift(dbWith(live), cols);
-        const { db, executed } = recordingDb(live);
-        const { dropped, kept } = await dropOrphanedPolicies(db, drift, cols);
-
-        expect(dropped).toHaveLength(0);
-        expect(kept.map((p) => p.name)).toEqual(["ops_break_glass"]);
-        expect(executed).toEqual([]);
-    });
-
-    it("never touches a table the collections do not describe", async () => {
-        // Another application sharing the schema owns this table; a
-        // generator-shaped name there is coincidence, not our leftover.
-        const cols = [collection("documents")];
-        const expected = parseExpectedPolicies(generatePostgresPoliciesDdl(cols));
-        const live = [
-            ...expected.map((p) => liveRow(p)),
-            { schemaname: "public", tablename: "legacy", policyname: "legacy_select_a1b2c3d", roles: ["public"], cmd: "SELECT", qual: "true", with_check: null }
-        ];
-
-        const drift = await checkPolicyDrift(dbWith(live), cols);
-        const { db, executed } = recordingDb(live);
-        const { dropped, kept } = await dropOrphanedPolicies(db, drift, cols);
-
-        expect(dropped).toHaveLength(0);
-        expect(kept.map((p) => p.name)).toEqual(["legacy_select_a1b2c3d"]);
-        expect(executed).toEqual([]);
-    });
-
-    it("does nothing when the database already matches", async () => {
-        const cols = [collection("documents")];
-        const expected = parseExpectedPolicies(generatePostgresPoliciesDdl(cols));
-        const live = expected.map((p) => liveRow(p));
-
-        const drift = await checkPolicyDrift(dbWith(live), cols);
-        const { db, executed } = recordingDb(live);
-        const { dropped, kept } = await dropOrphanedPolicies(db, drift, cols);
-
-        expect(dropped).toHaveLength(0);
-        expect(kept).toHaveLength(0);
-        expect(executed).toEqual([]);
-    });
-});

package/src/security/policy-drift.ts

@@ -192,62 +192,6 @@ export async function checkPolicyDrift(
     return drift;
 }
 
-/**
- * Does this name look like one the generator produced for this table?
- *
- * Unnamed rules compile to `<table>_<op>_<sha1[0:7]>` (plus `_<idx>` when one
- * rule spans several operations), and the hash covers the rule's semantics — so
- * *editing* a rule renames its policy. The policy under the old name is left
- * behind by `db push`, which only DROPs the names it is about to CREATE, and
- * Postgres ORs PERMISSIVE policies together: a superseded `USING (true)` keeps
- * granting everything no matter how tight its replacement is.
- *
- * Matching the shape is what makes dropping them safe. A hand-written policy
- * would have to collide with a 7-hex digest to be mistaken for generated one;
- * a policy named anything else is left alone and merely reported, because a
- * custom name is indistinguishable from one someone wrote in SQL on purpose.
- */
-export function isGeneratedPolicyName(name: string, table: string): boolean {
-    return new RegExp(`^${table.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}_(select|insert|update|delete|all)_[0-9a-f]{7}(_\\d+)?$`)
-        .test(name);
-}
-
-export interface OrphanCleanup {
-    /** Superseded generated policies that were dropped. */
-    dropped: PolicyRef[];
-    /** Orphans left in place because their names are not generator-shaped. */
-    kept: PolicyRef[];
-}
-
-/**
- * Drop the policies an earlier push superseded but never removed.
- *
- * Only touches tables the collections describe — a table with no expected
- * policy is not ours to reconcile, and scanning by schema alone would sweep up
- * policies belonging to something else sharing the database.
- */
-export async function dropOrphanedPolicies(
-    client: Queryable,
-    drift: PolicyDrift,
-    collections: CollectionConfig[]
-): Promise<OrphanCleanup> {
-    const expected = parseExpectedPolicies(generatePostgresPoliciesDdl(collections));
-    const managed = new Set(expected.map((p) => `${p.schema}.${p.table}`));
-
-    const cleanup: OrphanCleanup = { dropped: [], kept: [] };
-    for (const p of drift.orphaned) {
-        if (!managed.has(`${p.schema}.${p.table}`) || !isGeneratedPolicyName(p.name, p.table)) {
-            cleanup.kept.push(p);
-            continue;
-        }
-        // Identifiers are quoted, and the name came from pg_policies rather than
-        // from user input, so it is already a valid identifier.
-        await client.query(`DROP POLICY IF EXISTS "${p.name}" ON "${p.schema}"."${p.table}"`);
-        cleanup.dropped.push(p);
-    }
-    return cleanup;
-}
-
 export const hasDrift = (d: PolicyDrift): boolean =>
     d.missing.length > 0 || d.orphaned.length > 0 || d.diverged.length > 0;
 

package/src/services/row-pipeline.ts

@@ -91,30 +91,6 @@ function coerceDeclaredNumbers(
 }
 
 /** Render one target row in the requested style. */
-/**
- * Drop every column the collection marked `excludeFromApi`.
- *
- * Password hashes and verification tokens have to be readable server-side but
- * must never reach a client — and "never" has to mean every exit from this
- * pipeline, including relation targets, or a secret leaks through whichever
- * path was overlooked. Keyed by both the property name and its column name,
- * since a row can arrive keyed either way depending on the caller.
- */
-function stripExcluded(
-    row: Record<string, unknown>,
-    collection: CollectionConfig
-): Record<string, unknown> {
-    const properties = collection.properties as Record<string, Property> | undefined;
-    if (!properties) return row;
-
-    for (const [key, property] of Object.entries(properties)) {
-        if (!property?.excludeFromApi) continue;
-        delete row[key];
-        if (property.columnName) delete row[property.columnName];
-    }
-    return row;
-}
-
 function renderTarget(
     targetRow: Record<string, unknown>,
     targetCollection: CollectionConfig,
@@ -124,7 +100,7 @@ function renderTarget(
     if (style === "inline") {
         // The target's columns, and only those: its address is the consumer's
         // to derive, and merging one in overwrites a real `id` column.
-        return stripExcluded(coerceDeclaredNumbers({ ...targetRow }, targetCollection), targetCollection);
+        return coerceDeclaredNumbers({ ...targetRow }, targetCollection);
     }
 
     const address = relationTargetAddress(targetRow, targetCollection, registry);
@@ -192,7 +168,7 @@ export function toCmsRow(
         }
     }
 
-    return stripExcluded(normalized, collection);
+    return normalized;
 }
 
 /**
@@ -235,5 +211,5 @@ export function toRestRow(
         }
     }
 
-    return stripExcluded(flat, collection);
+    return flat;
 }