@supabase/pg-delta 1.0.0-alpha.3 → 1.0.0-alpha.30

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,24 @@
+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"
+    | "security_label";
+  readonly objectType = "sequence" as const;
+}
+
+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");
+  });
+});

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

@@ -0,0 +1,50 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import type { Sequence } from "../sequence.model.ts";
+import { DropSequenceChange } from "./sequence.base.ts";
+
+/**
+ * Drop a sequence.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropsequence.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP SEQUENCE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropSequence extends DropSequenceChange {
+  public readonly sequence: Sequence;
+  public readonly scope = "object" as const;
+
+  constructor(props: { sequence: Sequence }) {
+    super();
+    this.sequence = props.sequence;
+  }
+
+  get drops() {
+    return [this.sequence.stableId];
+  }
+
+  get requires() {
+    return [this.sequence.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const parts = [
+      "DROP SEQUENCE",
+      `${this.sequence.schema}.${this.sequence.name}`,
+    ];
+
+    // Owned sequences still need CASCADE here because DROP runs in the earlier
+    // phase and later ALTER TABLE statements will re-establish the desired default.
+    if (
+      this.sequence.owned_by_schema &&
+      this.sequence.owned_by_table &&
+      this.sequence.owned_by_column
+    ) {
+      parts.push("CASCADE");
+    }
+
+    return parts.join(" ");
+  }
+}