@supabase/pg-delta 1.0.0-alpha.2 → 1.0.0-alpha.4

package/src/core/objects/rule/changes/rule.create.ts

@@ -0,0 +1,42 @@
+import { stableId } from "../../utils.ts";
+import type { Rule } from "../rule.model.ts";
+import { CreateRuleChange } from "./rule.base.ts";
+
+export class CreateRule extends CreateRuleChange {
+  public readonly rule: Rule;
+  public readonly scope = "object" as const;
+  public readonly orReplace?: boolean;
+
+  constructor(props: { rule: Rule; orReplace?: boolean }) {
+    super();
+    this.rule = props.rule;
+    this.orReplace = props.orReplace;
+  }
+
+  get creates() {
+    return [this.rule.stableId];
+  }
+
+  get requires() {
+    return [
+      this.rule.relationStableId,
+      ...this.rule.columns.map((column) =>
+        stableId.column(this.rule.schema, this.rule.table_name, column),
+      ),
+    ];
+  }
+
+  serialize(): string {
+    let definition = this.rule.definition.trim();
+
+    definition = definition.replace(
+      /^CREATE\s+(?:OR\s+REPLACE\s+)?/i,
+      `CREATE ${this.orReplace ? "OR REPLACE " : ""}`,
+    );
+
+    // Remove trailing semicolons (pg_get_ruledef includes them, but we add our own)
+    definition = definition.replace(/;+\s*$/, "");
+
+    return definition;
+  }
+}

package/src/core/objects/rule/changes/rule.drop.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "bun:test";
+import { Rule } from "../rule.model.ts";
+import { DropRule } from "./rule.drop.ts";
+
+type RuleProps = ConstructorParameters<typeof Rule>[0];
+
+const base: RuleProps = {
+  schema: "public",
+  name: '"my_rule"',
+  table_name: '"my_table"',
+  relation_kind: "r",
+  event: "INSERT",
+  enabled: "O",
+  is_instead: true,
+  owner: "owner1",
+  definition:
+    'CREATE RULE "my_rule" AS ON INSERT TO public."my_table" DO INSTEAD NOTHING',
+  comment: null,
+  columns: ["id"],
+};
+
+const makeRule = (override: Partial<RuleProps> = {}) =>
+  new Rule({
+    ...base,
+    ...override,
+    columns: override.columns ? [...override.columns] : [...base.columns],
+  });
+
+describe("rule.drop", () => {
+  test("serialize rule drop and track dependencies", () => {
+    const rule = makeRule();
+    const change = new DropRule({ rule });
+
+    expect(change.drops).toEqual([rule.stableId]);
+    expect(change.requires).toEqual([rule.stableId, rule.relationStableId]);
+    expect(change.serialize()).toBe('DROP RULE "my_rule" ON public."my_table"');
+  });
+});

package/src/core/objects/rule/changes/rule.drop.ts

@@ -0,0 +1,29 @@
+import type { Rule } from "../rule.model.ts";
+import { DropRuleChange } from "./rule.base.ts";
+
+export class DropRule extends DropRuleChange {
+  public readonly rule: Rule;
+  public readonly scope = "object" as const;
+
+  constructor(props: { rule: Rule }) {
+    super();
+    this.rule = props.rule;
+  }
+
+  get drops() {
+    return [this.rule.stableId];
+  }
+
+  get requires() {
+    return [this.rule.stableId, this.rule.relationStableId];
+  }
+
+  serialize(): string {
+    return [
+      "DROP RULE",
+      this.rule.name,
+      "ON",
+      `${this.rule.schema}.${this.rule.table_name}`,
+    ].join(" ");
+  }
+}

package/src/core/objects/rule/changes/rule.types.ts

@@ -0,0 +1,12 @@
+import type { ReplaceRule, SetRuleEnabledState } from "./rule.alter.ts";
+import type { CreateCommentOnRule, DropCommentOnRule } from "./rule.comment.ts";
+import type { CreateRule } from "./rule.create.ts";
+import type { DropRule } from "./rule.drop.ts";
+
+export type RuleChange =
+  | CreateRule
+  | DropRule
+  | ReplaceRule
+  | SetRuleEnabledState
+  | CreateCommentOnRule
+  | DropCommentOnRule;

package/src/core/objects/rule/rule.diff.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, test } from "bun:test";
+import { ReplaceRule, SetRuleEnabledState } from "./changes/rule.alter.ts";
+import {
+  CreateCommentOnRule,
+  DropCommentOnRule,
+} from "./changes/rule.comment.ts";
+import { CreateRule } from "./changes/rule.create.ts";
+import { DropRule } from "./changes/rule.drop.ts";
+import { diffRules } from "./rule.diff.ts";
+import { Rule, type RuleProps } from "./rule.model.ts";
+
+const baseRule: RuleProps = {
+  schema: "public",
+  name: '"my_rule"',
+  table_name: '"my_table"',
+  relation_kind: "r",
+  event: "INSERT",
+  enabled: "O",
+  is_instead: true,
+  definition:
+    'CREATE RULE "my_rule" AS ON INSERT TO public."my_table" DO INSTEAD NOTHING',
+  comment: null,
+  columns: ["id"],
+  owner: "o1",
+};
+
+describe.concurrent("rule.diff", () => {
+  test("create rule", () => {
+    const rule = new Rule(baseRule);
+    const changes = diffRules({}, { [rule.stableId]: rule });
+    expect(changes[0]).toBeInstanceOf(CreateRule);
+  });
+
+  test("drop rule", () => {
+    const rule = new Rule(baseRule);
+    const changes = diffRules({ [rule.stableId]: rule }, {});
+    expect(changes[0]).toBeInstanceOf(DropRule);
+  });
+
+  test("replace when definition changes", () => {
+    const main = new Rule(baseRule);
+    const branch = new Rule({
+      ...baseRule,
+      definition:
+        'CREATE RULE "my_rule" AS ON INSERT TO public."my_table" DO ALSO NOTHING',
+      is_instead: false,
+      columns: ["id", "amount"],
+    });
+    const changes = diffRules(
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes.some((change) => change instanceof ReplaceRule)).toBe(true);
+  });
+
+  test("handle comment changes", () => {
+    const main = new Rule({ ...baseRule, comment: "old comment" });
+    const branch = new Rule({ ...baseRule, comment: "new comment" });
+    const changes = diffRules(
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(
+      changes.some((change) => change instanceof CreateCommentOnRule),
+    ).toBe(true);
+    expect(changes.some((change) => change instanceof DropCommentOnRule)).toBe(
+      false,
+    );
+  });
+
+  test("handle comment removal", () => {
+    const main = new Rule({ ...baseRule, comment: "old comment" });
+    const branch = new Rule(baseRule);
+    const changes = diffRules(
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(DropCommentOnRule);
+  });
+
+  test("handle enabled state changes", () => {
+    const main = new Rule(baseRule);
+    const branch = new Rule({ ...baseRule, enabled: "D" });
+    const changes = diffRules(
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(
+      changes.some((change) => change instanceof SetRuleEnabledState),
+    ).toBe(true);
+  });
+
+  test("reapply comment when replacing rule", () => {
+    const main = new Rule({ ...baseRule, comment: "my comment" });
+    const branch = new Rule({
+      ...baseRule,
+      definition:
+        'CREATE RULE "my_rule" AS ON INSERT TO public."my_table" DO ALSO NOTHING',
+      is_instead: false,
+      comment: "my comment",
+      columns: ["id", "balance"],
+    });
+    const changes = diffRules(
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes.some((change) => change instanceof ReplaceRule)).toBe(true);
+    expect(
+      changes.some((change) => change instanceof CreateCommentOnRule),
+    ).toBe(true);
+  });
+
+  test("reapply enabled state when replacing rule", () => {
+    const main = new Rule({ ...baseRule, enabled: "D" });
+    const branch = new Rule({
+      ...baseRule,
+      definition:
+        'CREATE RULE "my_rule" AS ON INSERT TO public."my_table" DO ALSO NOTHING',
+      is_instead: false,
+      enabled: "D",
+      columns: ["id", "balance"],
+    });
+    const changes = diffRules(
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes.some((change) => change instanceof ReplaceRule)).toBe(true);
+    expect(
+      changes.some((change) => change instanceof SetRuleEnabledState),
+    ).toBe(true);
+  });
+});

package/src/core/objects/rule/rule.diff.ts

@@ -0,0 +1,79 @@
+import { diffObjects } from "../base.diff.ts";
+import { deepEqual, hasNonAlterableChanges } from "../utils.ts";
+import { ReplaceRule, SetRuleEnabledState } from "./changes/rule.alter.ts";
+import {
+  CreateCommentOnRule,
+  DropCommentOnRule,
+} from "./changes/rule.comment.ts";
+import { CreateRule } from "./changes/rule.create.ts";
+import { DropRule } from "./changes/rule.drop.ts";
+import type { RuleChange } from "./changes/rule.types.ts";
+import type { Rule } from "./rule.model.ts";
+
+export function diffRules(
+  main: Record<string, Rule>,
+  branch: Record<string, Rule>,
+): RuleChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+  const changes: RuleChange[] = [];
+
+  for (const id of created) {
+    const rule = branch[id];
+    changes.push(new CreateRule({ rule }));
+
+    if (rule.comment !== null) {
+      changes.push(new CreateCommentOnRule({ rule }));
+    }
+
+    if (rule.enabled !== "O") {
+      changes.push(new SetRuleEnabledState({ rule }));
+    }
+  }
+
+  for (const id of dropped) {
+    changes.push(new DropRule({ rule: main[id] }));
+  }
+
+  for (const id of altered) {
+    const mainRule = main[id];
+    const branchRule = branch[id];
+
+    const NON_ALTERABLE_FIELDS: Array<keyof Rule> = [
+      "definition",
+      "event",
+      "is_instead",
+    ];
+
+    const shouldReplace = hasNonAlterableChanges(
+      mainRule,
+      branchRule,
+      NON_ALTERABLE_FIELDS,
+      { columns: deepEqual },
+    );
+
+    const replaced = shouldReplace;
+
+    if (shouldReplace) {
+      changes.push(new ReplaceRule({ rule: branchRule }));
+    }
+
+    if (mainRule.comment !== branchRule.comment) {
+      if (branchRule.comment === null) {
+        changes.push(new DropCommentOnRule({ rule: mainRule }));
+      } else {
+        changes.push(new CreateCommentOnRule({ rule: branchRule }));
+      }
+    } else if (replaced && branchRule.comment !== null) {
+      changes.push(new CreateCommentOnRule({ rule: branchRule }));
+    }
+
+    if (
+      mainRule.enabled !== branchRule.enabled ||
+      (replaced && branchRule.enabled !== "O")
+    ) {
+      changes.push(new SetRuleEnabledState({ rule: branchRule }));
+    }
+  }
+
+  return changes;
+}

package/src/core/objects/rule/rule.model.ts

@@ -0,0 +1,173 @@
+import { sql } from "@ts-safeql/sql-tag";
+import type { Pool } from "pg";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+import { stableId } from "../utils.ts";
+
+const RuleEventSchema = z.enum(["SELECT", "INSERT", "UPDATE", "DELETE"]);
+const RuleEnabledStateSchema = z.enum(["O", "D", "R", "A"]);
+
+const RuleRelationKindSchema = z.enum([
+  "r", // ordinary table
+  "p", // partitioned table
+  "f", // foreign table
+  "v", // view
+  "m", // materialized view
+]);
+
+const rulePropsSchema = z.object({
+  schema: z.string(),
+  name: z.string(),
+  table_name: z.string(),
+  relation_kind: RuleRelationKindSchema,
+  event: RuleEventSchema,
+  enabled: RuleEnabledStateSchema,
+  is_instead: z.boolean(),
+  owner: z.string(),
+  definition: z.string(),
+  comment: z.string().nullable(),
+  columns: z.array(z.string()),
+});
+
+export type RuleEnabledState = z.infer<typeof RuleEnabledStateSchema>;
+export type RuleProps = z.infer<typeof rulePropsSchema>;
+
+export class Rule extends BasePgModel {
+  public readonly schema: RuleProps["schema"];
+  public readonly name: RuleProps["name"];
+  public readonly table_name: RuleProps["table_name"];
+  public readonly relation_kind: RuleProps["relation_kind"];
+  public readonly event: RuleProps["event"];
+  public readonly enabled: RuleProps["enabled"];
+  public readonly is_instead: RuleProps["is_instead"];
+  public readonly owner: RuleProps["owner"];
+  public readonly definition: RuleProps["definition"];
+  public readonly comment: RuleProps["comment"];
+  public readonly columns: RuleProps["columns"];
+
+  constructor(props: RuleProps) {
+    super();
+
+    this.schema = props.schema;
+    this.name = props.name;
+    this.table_name = props.table_name;
+    this.relation_kind = props.relation_kind;
+    this.event = props.event;
+    this.enabled = props.enabled;
+    this.is_instead = props.is_instead;
+    this.owner = props.owner;
+    this.definition = props.definition;
+    this.comment = props.comment;
+    this.columns = props.columns;
+  }
+
+  get stableId(): `rule:${string}` {
+    return `rule:${this.schema}.${this.table_name}.${this.name}`;
+  }
+
+  get identityFields() {
+    return {
+      schema: this.schema,
+      name: this.name,
+      table_name: this.table_name,
+    };
+  }
+
+  get dataFields() {
+    return {
+      event: this.event,
+      enabled: this.enabled,
+      is_instead: this.is_instead,
+      owner: this.owner,
+      definition: this.definition,
+      comment: this.comment,
+      columns: this.columns,
+    };
+  }
+
+  get relationStableId(): string {
+    switch (this.relation_kind) {
+      case "v":
+        return stableId.view(this.schema, this.table_name);
+      case "m":
+        return stableId.materializedView(this.schema, this.table_name);
+      default:
+        return stableId.table(this.schema, this.table_name);
+    }
+  }
+}
+
+export async function extractRules(pool: Pool): Promise<Rule[]> {
+  const { rows: ruleRows } = await pool.query<RuleProps>(sql`
+      WITH extension_rule_oids AS (
+        SELECT
+          objid
+        FROM
+          pg_depend d
+        WHERE
+          d.refclassid = 'pg_extension'::regclass
+          AND d.classid = 'pg_rewrite'::regclass
+      ),
+      extension_relation_oids AS (
+        SELECT
+          objid
+        FROM
+          pg_depend d
+        WHERE
+          d.refclassid = 'pg_extension'::regclass
+          AND d.classid = 'pg_class'::regclass
+          AND d.deptype = 'e'
+      )
+      SELECT
+        c.relnamespace::regnamespace::text AS schema,
+        quote_ident(r.rulename) AS name,
+        quote_ident(c.relname) AS table_name,
+        c.relkind AS relation_kind,
+        CASE r.ev_type
+          WHEN '1' THEN 'SELECT'
+          WHEN '2' THEN 'UPDATE'
+          WHEN '3' THEN 'INSERT'
+          WHEN '4' THEN 'DELETE'
+          ELSE NULL
+        END AS event,
+        r.ev_enabled AS enabled,
+        r.is_instead,
+        c.relowner::regrole::text AS owner,
+        pg_get_ruledef(r.oid, true) AS definition,
+        obj_description(r.oid, 'pg_rewrite') AS comment,
+        COALESCE(
+          (
+            SELECT json_agg(quote_ident(att.attname) ORDER BY dep.refobjsubid)
+            FROM pg_depend dep
+            JOIN pg_attribute att
+              ON att.attrelid = dep.refobjid
+             AND att.attnum = dep.refobjsubid
+             AND att.attnum > 0
+             AND NOT att.attisdropped
+            WHERE dep.classid = 'pg_rewrite'::regclass
+              AND dep.objid = r.oid
+              AND dep.refclassid = 'pg_class'::regclass
+              AND dep.refobjid = c.oid
+              AND dep.refobjsubid > 0
+          ), '[]'
+        ) AS columns
+      FROM
+        pg_catalog.pg_rewrite r
+        JOIN pg_catalog.pg_class c ON c.oid = r.ev_class
+        LEFT JOIN extension_rule_oids e_rule ON r.oid = e_rule.objid
+        LEFT JOIN extension_relation_oids e_rel ON c.oid = e_rel.objid
+      WHERE
+        NOT c.relnamespace::regnamespace::text LIKE ANY (ARRAY['pg\\_%', 'information\\_schema'])
+        AND e_rule.objid IS NULL
+        AND e_rel.objid IS NULL
+        AND r.rulename <> '_RETURN'
+      ORDER BY
+        1, 3, 2
+  `);
+
+  const validatedRows = ruleRows.map((row: unknown) =>
+    rulePropsSchema.parse(row),
+  );
+
+  return validatedRows.map((row) => new Rule(row));
+}

package/src/core/objects/schema/changes/schema.alter.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import { Schema, type SchemaProps } from "../schema.model.ts";
+import { AlterSchemaChangeOwner } from "./schema.alter.ts";
+
+describe.concurrent("schema", () => {
+  describe("alter", () => {
+    test("change owner", () => {
+      const props: Omit<SchemaProps, "owner"> = {
+        name: "test_schema",
+        comment: null,
+        privileges: [],
+      };
+      const schemaObj = new Schema({
+        ...props,
+        owner: "old_owner",
+      });
+
+      const change = new AlterSchemaChangeOwner({
+        schema: schemaObj,
+        owner: "new_owner",
+      });
+
+      expect(change.serialize()).toBe(
+        "ALTER SCHEMA test_schema OWNER TO new_owner",
+      );
+    });
+  });
+});

package/src/core/objects/schema/changes/schema.alter.ts

@@ -0,0 +1,45 @@
+import type { Schema } from "../schema.model.ts";
+import { AlterSchemaChange } from "./schema.base.ts";
+
+/**
+ * Alter a schema.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterschema.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER SCHEMA name RENAME TO new_name
+ * ALTER SCHEMA name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ * ```
+ */
+
+export type AlterSchema = AlterSchemaChangeOwner;
+
+/**
+ * ALTER SCHEMA ... OWNER TO ...
+ */
+export class AlterSchemaChangeOwner extends AlterSchemaChange {
+  public readonly schema: Schema;
+  public readonly owner: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { schema: Schema; owner: string }) {
+    super();
+    this.schema = props.schema;
+    this.owner = props.owner;
+  }
+
+  get requires() {
+    return [this.schema.stableId];
+  }
+
+  serialize(): string {
+    return ["ALTER SCHEMA", this.schema.name, "OWNER TO", this.owner].join(" ");
+  }
+}
+
+/**
+ * Replace a schema by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER SCHEMA change.
+ */
+// NOTE: ReplaceSchema removed. Non-alterable changes would be emitted via Drop + Create in schema.diff.ts if needed.

package/src/core/objects/schema/changes/schema.base.ts

@@ -0,0 +1,20 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Schema } from "../schema.model.ts";
+
+abstract class BaseSchemaChange extends BaseChange {
+  abstract readonly schema: Schema;
+  abstract readonly scope: "object" | "comment" | "privilege";
+  readonly objectType: "schema" = "schema";
+}
+
+export abstract class CreateSchemaChange extends BaseSchemaChange {
+  readonly operation = "create" as const;
+}
+
+export abstract class AlterSchemaChange extends BaseSchemaChange {
+  readonly operation = "alter" as const;
+}
+
+export abstract class DropSchemaChange extends BaseSchemaChange {
+  readonly operation = "drop" as const;
+}

package/src/core/objects/schema/changes/schema.comment.ts

@@ -0,0 +1,56 @@
+import { quoteLiteral } from "../../base.change.ts";
+import { stableId } from "../../utils.ts";
+import type { Schema } from "../schema.model.ts";
+import { CreateSchemaChange, DropSchemaChange } from "./schema.base.ts";
+
+export type CommentSchema = CreateCommentOnSchema | DropCommentOnSchema;
+
+export class CreateCommentOnSchema extends CreateSchemaChange {
+  public readonly schema: Schema;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { schema: Schema }) {
+    super();
+    this.schema = props.schema;
+  }
+
+  get creates() {
+    return [stableId.comment(this.schema.stableId)];
+  }
+
+  get requires() {
+    return [this.schema.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "COMMENT ON SCHEMA",
+      this.schema.name,
+      "IS",
+      // biome-ignore lint/style/noNonNullAssertion: schema comment is not nullable in this case
+      quoteLiteral(this.schema.comment!),
+    ].join(" ");
+  }
+}
+
+export class DropCommentOnSchema extends DropSchemaChange {
+  public readonly schema: Schema;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { schema: Schema }) {
+    super();
+    this.schema = props.schema;
+  }
+
+  get drops() {
+    return [stableId.comment(this.schema.stableId)];
+  }
+
+  get requires() {
+    return [stableId.comment(this.schema.stableId), this.schema.stableId];
+  }
+
+  serialize(): string {
+    return ["COMMENT ON SCHEMA", this.schema.name, "IS NULL"].join(" ");
+  }
+}

package/src/core/objects/schema/changes/schema.create.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, test } from "bun:test";
+import { Schema } from "../schema.model.ts";
+import { CreateSchema } from "./schema.create.ts";
+
+describe("schema", () => {
+  test("create", () => {
+    const schema = new Schema({
+      name: "test_schema",
+      owner: "test",
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new CreateSchema({
+      schema,
+    });
+
+    expect(change.serialize()).toBe(
+      "CREATE SCHEMA test_schema AUTHORIZATION test",
+    );
+  });
+});