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

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

@@ -0,0 +1,107 @@
+import { sql } from "@ts-safeql/sql-tag";
+import type { Pool } from "pg";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+import {
+  type PrivilegeProps,
+  privilegePropsSchema,
+} from "../base.privilege-diff.ts";
+
+/**
+ * All properties exposed by CREATE SCHEMA statement are included in diff output.
+ * https://www.postgresql.org/docs/current/sql-createschema.html
+ *
+ * ALTER SCHEMA statement can be generated for all properties.
+ * https://www.postgresql.org/docs/current/sql-alterschema.html
+ */
+const schemaPropsSchema = z.object({
+  name: z.string(),
+  owner: z.string(),
+  comment: z.string().nullable(),
+  privileges: z.array(privilegePropsSchema),
+});
+
+type SchemaPrivilegeProps = PrivilegeProps;
+export type SchemaProps = z.infer<typeof schemaPropsSchema>;
+
+export class Schema extends BasePgModel {
+  public readonly name: SchemaProps["name"];
+  public readonly owner: SchemaProps["owner"];
+  public readonly comment: SchemaProps["comment"];
+  public readonly privileges: SchemaPrivilegeProps[];
+
+  constructor(props: SchemaProps) {
+    super();
+
+    // Identity fields
+    this.name = props.name;
+
+    // Data fields
+    this.owner = props.owner;
+    this.comment = props.comment;
+    this.privileges = props.privileges;
+  }
+
+  get stableId(): `schema:${string}` {
+    return `schema:${this.name}`;
+  }
+
+  get identityFields() {
+    return {
+      name: this.name,
+    };
+  }
+
+  get dataFields() {
+    return {
+      owner: this.owner,
+      comment: this.comment,
+      privileges: this.privileges,
+    };
+  }
+}
+
+export async function extractSchemas(pool: Pool): Promise<Schema[]> {
+  const { rows: schemaRows } = await pool.query<SchemaProps>(sql`
+    with extension_oids as (
+      select
+        objid
+      from
+        pg_depend d
+      where
+        d.refclassid = 'pg_extension'::regclass
+        and d.classid = 'pg_namespace'::regclass
+    )
+    select
+      quote_ident(nspname) as name,
+      nspowner::regrole::text as owner,
+      obj_description(oid, 'pg_namespace') as comment,
+      coalesce(
+        (
+          select json_agg(
+            json_build_object(
+              'grantee', case when x.grantee = 0 then 'PUBLIC' else x.grantee::regrole::text end,
+              'privilege', x.privilege_type,
+              'grantable', x.is_grantable
+            )
+            order by x.grantee, x.privilege_type
+          )
+          from lateral aclexplode(COALESCE(nspacl, acldefault('n', nspowner))) as x(grantor, grantee, privilege_type, is_grantable)
+        ), '[]'
+      ) as privileges
+    from
+      pg_catalog.pg_namespace
+      left outer join extension_oids e on e.objid = oid
+      -- <EXCLUDE_INTERNAL>
+      where not nspname like any(array['pg\\_%', 'information\\_schema'])
+      and e.objid is null
+      -- </EXCLUDE_INTERNAL>
+    order by
+      1
+  `);
+  // Validate and parse each row using the Zod schema
+  const validatedRows = schemaRows.map((row: unknown) =>
+    schemaPropsSchema.parse(row),
+  );
+  return validatedRows.map((row: SchemaProps) => new Schema(row));
+}

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

@@ -0,0 +1,157 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Sequence, type SequenceProps } from "../sequence.model.ts";
+import {
+  AlterSequenceSetOptions,
+  AlterSequenceSetOwnedBy,
+} from "./sequence.alter.ts";
+
+describe.concurrent("sequence", () => {
+  describe("alter", () => {
+    test("set owned by table column", async () => {
+      const props: Omit<
+        SequenceProps,
+        "owned_by_schema" | "owned_by_table" | "owned_by_column"
+      > = {
+        schema: "public",
+        name: "test_sequence",
+        data_type: "integer",
+        start_value: 1,
+        minimum_value: 1n,
+        maximum_value: 2147483647n,
+        increment: 1,
+        cycle_option: false,
+        cache_size: 1,
+        persistence: "p",
+        comment: null,
+        privileges: [],
+        owner: "test",
+      };
+      const sequence = new Sequence({
+        ...props,
+        owned_by_schema: null,
+        owned_by_table: null,
+        owned_by_column: null,
+      });
+
+      const change = new AlterSequenceSetOwnedBy({
+        sequence,
+        ownedBy: { schema: "public", table: "t", column: "id" },
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER SEQUENCE public.test_sequence OWNED BY public.t.id",
+      );
+    });
+
+    test("owned by none", async () => {
+      const sequence = new Sequence({
+        schema: "public",
+        name: "s",
+        data_type: "bigint",
+        start_value: 1,
+        minimum_value: 1n,
+        maximum_value: 9223372036854775807n,
+        increment: 1,
+        cycle_option: false,
+        cache_size: 1,
+        persistence: "p",
+        owned_by_schema: "public",
+        owned_by_table: "t",
+        owned_by_column: "id",
+        comment: null,
+        privileges: [],
+        owner: "test",
+      });
+      const change = new AlterSequenceSetOwnedBy({ sequence, ownedBy: null });
+      await assertValidSql(change.serialize());
+      expect(change.serialize()).toBe("ALTER SEQUENCE public.s OWNED BY NONE");
+    });
+
+    test("drop + create sequence (handled in diff)", async () => {
+      expect(1).toBe(1);
+    });
+
+    test("alter options: increment, min/max, start, cache, cycle", async () => {
+      const sequence = new Sequence({
+        schema: "public",
+        name: "s",
+        data_type: "bigint",
+        start_value: 1,
+        minimum_value: 1n,
+        maximum_value: 9223372036854775807n,
+        increment: 1,
+        cycle_option: false,
+        cache_size: 1,
+        persistence: "p",
+        owned_by_schema: null,
+        owned_by_table: null,
+        owned_by_column: null,
+        comment: null,
+        privileges: [],
+        owner: "test",
+      });
+      const change = new AlterSequenceSetOptions({
+        sequence,
+        options: [
+          "INCREMENT BY",
+          "2",
+          "MINVALUE",
+          "5",
+          "MAXVALUE",
+          "100",
+          "START WITH",
+          "10",
+          "CACHE",
+          "3",
+          "CYCLE",
+        ],
+      });
+      await assertValidSql(change.serialize());
+      expect(change.serialize()).toBe(
+        "ALTER SEQUENCE public.s INCREMENT BY 2 MINVALUE 5 MAXVALUE 100 START WITH 10 CACHE 3 CYCLE",
+      );
+    });
+
+    test("alter options: reset to defaults uses NO MINVALUE/NO MAXVALUE", async () => {
+      const sequence = new Sequence({
+        schema: "public",
+        name: "s",
+        data_type: "integer",
+        start_value: 5,
+        minimum_value: 3n,
+        maximum_value: 100n,
+        increment: 2,
+        cycle_option: true,
+        cache_size: 2,
+        persistence: "p",
+        owned_by_schema: null,
+        owned_by_table: null,
+        owned_by_column: null,
+        comment: null,
+        privileges: [],
+        owner: "test",
+      });
+      const change = new AlterSequenceSetOptions({
+        sequence,
+        options: [
+          "INCREMENT BY",
+          "1",
+          "NO MINVALUE",
+          "NO MAXVALUE",
+          "START WITH",
+          "1",
+          "CACHE",
+          "1",
+          "NO CYCLE",
+        ],
+      });
+      await assertValidSql(change.serialize());
+      expect(change.serialize()).toBe(
+        "ALTER SEQUENCE public.s INCREMENT BY 1 NO MINVALUE NO MAXVALUE START WITH 1 CACHE 1 NO CYCLE",
+      );
+    });
+  });
+});

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

@@ -0,0 +1,116 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import { stableId } from "../../utils.ts";
+import type { Sequence } from "../sequence.model.ts";
+import { AlterSequenceChange } from "./sequence.base.ts";
+
+/**
+ * Alter a sequence.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-altersequence.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER SEQUENCE [ IF EXISTS ] name [ INCREMENT [ BY ] increment ]
+ *     [ MINVALUE minvalue | NO MINVALUE ] [ MAXVALUE maxvalue | NO MAXVALUE ]
+ *     [ START [ WITH ] start ] [ RESTART [ [ WITH ] restart ] ]
+ *     [ CACHE cache ] [ [ NO ] CYCLE ] [ OWNED BY { table_name.column_name | NONE } ]
+ * ```
+ */
+
+export type AlterSequence = AlterSequenceSetOptions | AlterSequenceSetOwnedBy;
+
+/**
+ * ALTER SEQUENCE ... OWNED BY ... | OWNED BY NONE
+ */
+export class AlterSequenceSetOwnedBy extends AlterSequenceChange {
+  public readonly sequence: Sequence;
+  public readonly ownedBy: {
+    schema: string;
+    table: string;
+    column: string;
+  } | null;
+  public readonly scope = "object" as const;
+
+  constructor(props: {
+    sequence: Sequence;
+    ownedBy: { schema: string; table: string; column: string } | null;
+  }) {
+    super();
+    this.sequence = props.sequence;
+    this.ownedBy = props.ownedBy;
+  }
+
+  get creates() {
+    return [];
+  }
+
+  get requires() {
+    return [
+      this.sequence.stableId,
+      ...(this.ownedBy
+        ? [
+            stableId.column(
+              this.ownedBy.schema,
+              this.ownedBy.table,
+              this.ownedBy.column,
+            ),
+          ]
+        : []),
+    ];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const head = [
+      "ALTER SEQUENCE",
+      `${this.sequence.schema}.${this.sequence.name}`,
+    ];
+    if (this.ownedBy) {
+      return [
+        ...head,
+        "OWNED BY",
+        `${this.ownedBy.schema}.${this.ownedBy.table}.${this.ownedBy.column}`,
+      ].join(" ");
+    }
+    return [...head, "OWNED BY NONE"].join(" ");
+  }
+}
+
+/**
+ * ALTER SEQUENCE ... set options ...
+ * Emits only changed options, in a stable order.
+ */
+export class AlterSequenceSetOptions extends AlterSequenceChange {
+  public readonly sequence: Sequence;
+  public readonly options: string[];
+  public readonly scope = "object" as const;
+
+  constructor(props: { sequence: Sequence; options: string[] }) {
+    super();
+    this.sequence = props.sequence;
+    this.options = props.options;
+  }
+
+  get creates() {
+    return [];
+  }
+
+  get requires() {
+    return [this.sequence.stableId];
+  }
+
+  // Note: default max computation moved to diff when building options
+
+  serialize(_options?: SerializeOptions): string {
+    const parts: string[] = [
+      "ALTER SEQUENCE",
+      `${this.sequence.schema}.${this.sequence.name}`,
+    ];
+    return [...parts, ...this.options].join(" ");
+  }
+}
+
+/**
+ * Replace a sequence by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER SEQUENCE change.
+ */
+// NOTE: ReplaceSequence removed. Non-alterable changes are emitted as Drop + Create in sequence.diff.ts.

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

@@ -0,0 +1,20 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Sequence } from "../sequence.model.ts";
+
+abstract class BaseSequenceChange extends BaseChange {
+  abstract readonly sequence: Sequence;
+  abstract readonly scope: "object" | "comment" | "privilege";
+  readonly objectType: "sequence" = "sequence";
+}
+
+export abstract class CreateSequenceChange extends BaseSequenceChange {
+  readonly operation = "create" as const;
+}
+
+export abstract class AlterSequenceChange extends BaseSequenceChange {
+  readonly operation = "alter" as const;
+}
+
+export abstract class DropSequenceChange extends BaseSequenceChange {
+  readonly operation = "drop" as const;
+}

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

@@ -0,0 +1,61 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import { quoteLiteral } from "../../base.change.ts";
+import { stableId } from "../../utils.ts";
+import type { Sequence } from "../sequence.model.ts";
+import { CreateSequenceChange, DropSequenceChange } from "./sequence.base.ts";
+
+export type CommentSequence = CreateCommentOnSequence | DropCommentOnSequence;
+
+export class CreateCommentOnSequence extends CreateSequenceChange {
+  public readonly sequence: Sequence;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { sequence: Sequence }) {
+    super();
+    this.sequence = props.sequence;
+  }
+
+  get creates() {
+    return [stableId.comment(this.sequence.stableId)];
+  }
+
+  get requires() {
+    return [this.sequence.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON SEQUENCE",
+      `${this.sequence.schema}.${this.sequence.name}`,
+      "IS",
+      // biome-ignore lint/style/noNonNullAssertion: sequence comment is not nullable in this case
+      quoteLiteral(this.sequence.comment!),
+    ].join(" ");
+  }
+}
+
+export class DropCommentOnSequence extends DropSequenceChange {
+  public readonly sequence: Sequence;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { sequence: Sequence }) {
+    super();
+    this.sequence = props.sequence;
+  }
+
+  get drops() {
+    return [stableId.comment(this.sequence.stableId)];
+  }
+
+  get requires() {
+    return [stableId.comment(this.sequence.stableId), this.sequence.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON SEQUENCE",
+      `${this.sequence.schema}.${this.sequence.name}`,
+      "IS NULL",
+    ].join(" ");
+  }
+}

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

@@ -0,0 +1,89 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Sequence } from "../sequence.model.ts";
+import { CreateSequence } from "./sequence.create.ts";
+
+describe("sequence", () => {
+  test("create minimal (all defaults elided)", async () => {
+    const sequence = new Sequence({
+      schema: "public",
+      name: "s_min",
+      data_type: "bigint",
+      start_value: 1,
+      minimum_value: 1n,
+      maximum_value: 9223372036854775807n,
+      increment: 1,
+      cycle_option: false,
+      cache_size: 1,
+      persistence: "p",
+      owned_by_schema: null,
+      owned_by_table: null,
+      owned_by_column: null,
+      comment: null,
+      privileges: [],
+      owner: "test",
+    });
+
+    const change = new CreateSequence({ sequence });
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe("CREATE SEQUENCE public.s_min");
+  });
+
+  test("create", async () => {
+    const sequence = new Sequence({
+      schema: "public",
+      name: "test_sequence",
+      data_type: "integer",
+      start_value: 1,
+      minimum_value: 1n,
+      maximum_value: 2147483647n,
+      increment: 1,
+      cycle_option: false,
+      cache_size: 1,
+      persistence: "p",
+      owned_by_schema: null,
+      owned_by_table: null,
+      owned_by_column: null,
+      comment: null,
+      privileges: [],
+      owner: "test",
+    });
+
+    const change = new CreateSequence({
+      sequence,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE SEQUENCE public.test_sequence AS integer",
+    );
+  });
+
+  test("create with all options", async () => {
+    const sequence = new Sequence({
+      schema: "public",
+      name: "s_all",
+      data_type: "integer",
+      start_value: 10,
+      minimum_value: 5n,
+      maximum_value: 100n,
+      increment: 2,
+      cycle_option: true,
+      cache_size: 3,
+      persistence: "p",
+      owned_by_schema: null,
+      owned_by_table: null,
+      owned_by_column: null,
+      comment: null,
+      privileges: [],
+      owner: "test",
+    });
+
+    const change = new CreateSequence({ sequence });
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "CREATE SEQUENCE public.s_all AS integer INCREMENT BY 2 MINVALUE 5 MAXVALUE 100 START WITH 10 CACHE 3 CYCLE",
+    );
+  });
+});

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

@@ -0,0 +1,112 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import { stableId } from "../../utils.ts";
+import type { Sequence } from "../sequence.model.ts";
+import { CreateSequenceChange } from "./sequence.base.ts";
+
+/**
+ * Create a sequence.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createsequence.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE [ TEMPORARY | TEMP ] SEQUENCE [ IF NOT EXISTS ] name [ INCREMENT [ BY ] increment ]
+ *     [ MINVALUE minvalue | NO MINVALUE ] [ MAXVALUE maxvalue | NO MAXVALUE ]
+ *     [ START [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]
+ *     [ OWNED BY { table_name.column_name | NONE } ]
+ * ```
+ */
+export class CreateSequence extends CreateSequenceChange {
+  public readonly sequence: Sequence;
+  public readonly scope = "object" as const;
+
+  constructor(props: { sequence: Sequence }) {
+    super();
+    this.sequence = props.sequence;
+  }
+
+  get creates() {
+    return [this.sequence.stableId];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // Schema dependency
+    dependencies.add(stableId.schema(this.sequence.schema));
+
+    // Owner dependency
+    dependencies.add(stableId.role(this.sequence.owner));
+
+    // Owned by table/column dependency (if set)
+    if (
+      this.sequence.owned_by_schema &&
+      this.sequence.owned_by_table &&
+      this.sequence.owned_by_column
+    ) {
+      dependencies.add(
+        stableId.table(
+          this.sequence.owned_by_schema,
+          this.sequence.owned_by_table,
+        ),
+      );
+      dependencies.add(
+        stableId.column(
+          this.sequence.owned_by_schema,
+          this.sequence.owned_by_table,
+          this.sequence.owned_by_column,
+        ),
+      );
+    }
+
+    return Array.from(dependencies);
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const parts: string[] = ["CREATE SEQUENCE"];
+
+    // Add schema and name
+    parts.push(`${this.sequence.schema}.${this.sequence.name}`);
+
+    // Add data type if not default
+    if (this.sequence.data_type && this.sequence.data_type !== "bigint") {
+      parts.push("AS", this.sequence.data_type);
+    }
+
+    // Add INCREMENT
+    if (this.sequence.increment !== 1) {
+      parts.push("INCREMENT BY", this.sequence.increment.toString());
+    }
+
+    // Add MINVALUE if not default (1)
+    if (this.sequence.minimum_value !== BigInt(1)) {
+      parts.push("MINVALUE", this.sequence.minimum_value.toString());
+    }
+
+    // Add MAXVALUE if not default (depends on data type)
+    const defaultMaxValue =
+      this.sequence.data_type === "integer"
+        ? BigInt("2147483647")
+        : BigInt("9223372036854775807");
+    if (this.sequence.maximum_value !== defaultMaxValue) {
+      parts.push("MAXVALUE", this.sequence.maximum_value.toString());
+    }
+
+    // Add START
+    if (this.sequence.start_value !== 1) {
+      parts.push("START WITH", this.sequence.start_value.toString());
+    }
+
+    // Add CACHE
+    if (this.sequence.cache_size !== 1) {
+      parts.push("CACHE", this.sequence.cache_size.toString());
+    }
+
+    // Add CYCLE only if true (default is NO CYCLE)
+    if (this.sequence.cycle_option) {
+      parts.push("CYCLE");
+    }
+
+    return parts.join(" ");
+  }
+}

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

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Sequence } from "../sequence.model.ts";
+import { DropSequence } from "./sequence.drop.ts";
+
+describe("sequence", () => {
+  test("drop", async () => {
+    const sequence = new Sequence({
+      schema: "public",
+      name: "test_sequence",
+      data_type: "integer",
+      start_value: 1,
+      minimum_value: 1n,
+      maximum_value: 2147483647n,
+      increment: 1,
+      cycle_option: false,
+      cache_size: 1,
+      persistence: "p",
+      owned_by_schema: null,
+      owned_by_table: null,
+      owned_by_column: null,
+      comment: null,
+      privileges: [],
+      owner: "test",
+    });
+
+    const change = new DropSequence({
+      sequence,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe("DROP SEQUENCE public.test_sequence");
+  });
+});