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

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

@@ -0,0 +1,20 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Table } from "../table.model.ts";
+
+abstract class BaseTableChange extends BaseChange {
+  abstract readonly table: Table;
+  abstract readonly scope: "object" | "comment" | "privilege";
+  readonly objectType: "table" = "table";
+}
+
+export abstract class CreateTableChange extends BaseTableChange {
+  readonly operation = "create" as const;
+}
+
+export abstract class AlterTableChange extends BaseTableChange {
+  readonly operation = "alter" as const;
+}
+
+export abstract class DropTableChange extends BaseTableChange {
+  readonly operation = "drop" as const;
+}

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

@@ -0,0 +1,267 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import { quoteLiteral } from "../../base.change.ts";
+import type { ColumnProps } from "../../base.model.ts";
+import { stableId } from "../../utils.ts";
+import type { Table, TableConstraintProps } from "../table.model.ts";
+import { CreateTableChange, DropTableChange } from "./table.base.ts";
+
+/**
+ * Create a table/column/constraint comment.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-comment.html
+ *
+ * Synopsis
+ * ```sql
+ * COMMENT ON
+ * {
+ *   COLUMN relation_name.column_name |
+ *   CONSTRAINT constraint_name ON table_name |
+ *   TABLE object_name
+ * } IS { string_literal | NULL }
+ *
+ * ```
+ */
+
+export type CommentTable =
+  | CreateCommentOnColumn
+  | CreateCommentOnConstraint
+  | CreateCommentOnTable
+  | DropCommentOnColumn
+  | DropCommentOnConstraint
+  | DropCommentOnTable;
+
+/**
+ * COMMENT ON TABLE ... IS ...
+ */
+export class CreateCommentOnTable extends CreateTableChange {
+  public readonly table: Table;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { table: Table }) {
+    super();
+    this.table = props.table;
+  }
+
+  get creates() {
+    return [stableId.comment(this.table.stableId)];
+  }
+
+  get requires() {
+    return [this.table.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON TABLE",
+      `${this.table.schema}.${this.table.name}`,
+      "IS",
+      // biome-ignore lint/style/noNonNullAssertion: table comment is not nullable in this case
+      quoteLiteral(this.table.comment!),
+    ].join(" ");
+  }
+}
+
+/**
+ * COMMENT ON TABLE ... IS ...
+ */
+export class DropCommentOnTable extends DropTableChange {
+  public readonly table: Table;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { table: Table }) {
+    super();
+    this.table = props.table;
+  }
+
+  get drops() {
+    return [stableId.comment(this.table.stableId)];
+  }
+
+  get requires() {
+    return [stableId.comment(this.table.stableId), this.table.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON TABLE",
+      `${this.table.schema}.${this.table.name}`,
+      "IS NULL",
+    ].join(" ");
+  }
+}
+
+/**
+ * COMMENT ON COLUMN ... IS ...
+ */
+export class CreateCommentOnColumn extends CreateTableChange {
+  public readonly table: Table;
+  public readonly column: ColumnProps;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { table: Table; column: ColumnProps }) {
+    super();
+    this.table = props.table;
+    this.column = props.column;
+  }
+
+  get creates() {
+    const columnStableId = stableId.column(
+      this.table.schema,
+      this.table.name,
+      this.column.name,
+    );
+    return [stableId.comment(columnStableId)];
+  }
+
+  get requires() {
+    return [
+      stableId.column(this.table.schema, this.table.name, this.column.name),
+    ];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON COLUMN",
+      `${this.table.schema}.${this.table.name}.${this.column.name}`,
+      "IS",
+      // biome-ignore lint/style/noNonNullAssertion: column comment is not nullable in this case
+      quoteLiteral(this.column.comment!),
+    ].join(" ");
+  }
+}
+
+/**
+ * COMMENT ON COLUMN ... IS ...
+ */
+export class DropCommentOnColumn extends DropTableChange {
+  public readonly table: Table;
+  public readonly column: ColumnProps;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { table: Table; column: ColumnProps }) {
+    super();
+    this.table = props.table;
+    this.column = props.column;
+  }
+
+  get drops() {
+    const columnStableId = stableId.column(
+      this.table.schema,
+      this.table.name,
+      this.column.name,
+    );
+    return [stableId.comment(columnStableId)];
+  }
+
+  get requires() {
+    const columnStableId = stableId.column(
+      this.table.schema,
+      this.table.name,
+      this.column.name,
+    );
+    return [stableId.comment(columnStableId), columnStableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON COLUMN",
+      `${this.table.schema}.${this.table.name}.${this.column.name}`,
+      "IS NULL",
+    ].join(" ");
+  }
+}
+
+/**
+ * COMMENT ON CONSTRAINT ... IS ...
+ */
+export class CreateCommentOnConstraint extends CreateTableChange {
+  public readonly table: Table;
+  public readonly constraint: TableConstraintProps;
+  public readonly scope = "comment" as const;
+
+  constructor(props: {
+    table: Table;
+    constraint: TableConstraintProps;
+  }) {
+    super();
+    this.table = props.table;
+    this.constraint = props.constraint;
+  }
+
+  get creates() {
+    const constraintStableId = stableId.constraint(
+      this.table.schema,
+      this.table.name,
+      this.constraint.name,
+    );
+    return [stableId.comment(constraintStableId)];
+  }
+
+  get requires() {
+    return [
+      stableId.constraint(
+        this.table.schema,
+        this.table.name,
+        this.constraint.name,
+      ),
+    ];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON CONSTRAINT",
+      this.constraint.name,
+      "ON",
+      `${this.table.schema}.${this.table.name}`,
+      "IS",
+      // biome-ignore lint/style/noNonNullAssertion: constraint comment is not nullable in this case
+      quoteLiteral(this.constraint.comment!),
+    ].join(" ");
+  }
+}
+
+/**
+ * COMMENT ON CONSTRAINT ... IS ...
+ */
+export class DropCommentOnConstraint extends DropTableChange {
+  public readonly table: Table;
+  public readonly constraint: TableConstraintProps;
+  public readonly scope = "comment" as const;
+
+  constructor(props: {
+    table: Table;
+    constraint: TableConstraintProps;
+  }) {
+    super();
+    this.table = props.table;
+    this.constraint = props.constraint;
+  }
+
+  get drops() {
+    const constraintStableId = stableId.constraint(
+      this.table.schema,
+      this.table.name,
+      this.constraint.name,
+    );
+    return [stableId.comment(constraintStableId)];
+  }
+
+  get requires() {
+    const constraintStableId = stableId.constraint(
+      this.table.schema,
+      this.table.name,
+      this.constraint.name,
+    );
+    return [stableId.comment(constraintStableId), constraintStableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON CONSTRAINT",
+      this.constraint.name,
+      "ON",
+      `${this.table.schema}.${this.table.name}`,
+      "IS NULL",
+    ].join(" ");
+  }
+}

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

@@ -0,0 +1,188 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Table, type TableProps } from "../table.model.ts";
+import { CreateTable } from "./table.create.ts";
+
+const base: TableProps = {
+  schema: "public",
+  name: "t",
+  persistence: "p",
+  row_security: false,
+  force_row_security: false,
+  has_indexes: false,
+  has_rules: false,
+  has_triggers: false,
+  has_subclasses: false,
+  is_populated: true,
+  replica_identity: "d",
+  is_partition: false,
+  options: null,
+  partition_bound: null,
+  partition_by: null,
+  owner: "o1",
+  parent_schema: null,
+  parent_name: null,
+  columns: [],
+  privileges: [],
+};
+
+describe.concurrent("table.create", () => {
+  test("minimal create with no columns", async () => {
+    const t = new Table(base);
+    const change = new CreateTable({ table: t });
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe("CREATE TABLE public.t ()");
+  });
+
+  test("TEMPORARY with columns, inherits and options", async () => {
+    const t = new Table({
+      ...base,
+      persistence: "t",
+      parent_schema: "public",
+      parent_name: "parent",
+      options: ["fillfactor=90", "autovacuum_enabled=true"],
+      columns: [
+        {
+          name: "c1",
+          position: 1,
+          data_type: "integer",
+          data_type_str: "integer",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: true,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: "0",
+          comment: null,
+        },
+        {
+          name: "c2",
+          position: 2,
+          data_type: "text",
+          data_type_str: "text",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: '"en_US"',
+          default: null,
+          comment: null,
+        },
+        {
+          name: "c3",
+          position: 3,
+          data_type: "integer",
+          data_type_str: "integer",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: true,
+          is_identity_always: true,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+        {
+          name: "c4",
+          position: 4,
+          data_type: "text",
+          data_type_str: "text",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: true,
+          collation: null,
+          default: "lower((name))",
+          comment: null,
+        },
+        {
+          name: "c5",
+          position: 5,
+          data_type: "integer",
+          data_type_str: "integer",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: true,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: null,
+          comment: null,
+        },
+      ],
+    });
+
+    const change = new CreateTable({ table: t });
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      'CREATE TEMPORARY TABLE public.t (c1 integer DEFAULT 0 NOT NULL, c2 text COLLATE "en_US", c3 integer GENERATED ALWAYS AS IDENTITY, c4 text GENERATED ALWAYS AS (lower((name))) STORED, c5 integer GENERATED BY DEFAULT AS IDENTITY) INHERITS (public.parent) WITH (fillfactor=90, autovacuum_enabled=true)',
+    );
+  });
+
+  test("UNLOGGED minimal create (no columns)", async () => {
+    const t = new Table({
+      ...base,
+      persistence: "u",
+    });
+    const change = new CreateTable({ table: t });
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe("CREATE UNLOGGED TABLE public.t ()");
+  });
+
+  test("requires does NOT include procedure stableIds from DEFAULT expressions (handled by pg_depend catalog constraints)", async () => {
+    // Function dependencies in DEFAULT expressions are resolved through pg_depend
+    // in the sort pipeline, which provides exact argument types and covers all
+    // expression contexts. The CreateTable change itself does not need to list them.
+    const t = new Table({
+      ...base,
+      columns: [
+        {
+          name: "auth_role",
+          position: 1,
+          data_type: "text",
+          data_type_str: "text",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: "auth.role()",
+          comment: null,
+        },
+      ],
+    });
+    const change = new CreateTable({ table: t });
+    const procedureRequires = change.requires.filter((r) =>
+      r.startsWith("procedure:"),
+    );
+    expect(procedureRequires).toEqual([]);
+  });
+});

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

@@ -0,0 +1,193 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import { isUserDefinedTypeSchema, stableId } from "../../utils.ts";
+import type { Table } from "../table.model.ts";
+import { CreateTableChange } from "./table.base.ts";
+
+/**
+ * Create a table.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createtable.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] table_name ( [
+ *   { column_name data_type [ COLLATE collation ] [ column_constraint [ ... ] ]
+ *     | table_constraint
+ *     | LIKE source_table [ like_option ... ] }
+ *     [, ... ]
+ * ] )
+ * [ INHERITS ( parent_table [, ... ] ) ]
+ * [ PARTITION BY { RANGE | LIST | HASH } ( { column_name | ( expression ) } [, ... ] ) ]
+ * [ USING method ]
+ * [ WITH ( storage_parameter [= value] [, ... ] ) | WITHOUT OIDS ]
+ * [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
+ * [ TABLESPACE tablespace_name ]
+ * ```
+ */
+export class CreateTable extends CreateTableChange {
+  public readonly table: Table;
+  public readonly scope = "object" as const;
+
+  constructor(props: { table: Table }) {
+    super();
+    this.table = props.table;
+  }
+
+  get creates() {
+    return [
+      this.table.stableId,
+      ...this.table.columns.map((col) =>
+        stableId.column(this.table.schema, this.table.name, col.name),
+      ),
+    ];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // Schema dependency
+    dependencies.add(stableId.schema(this.table.schema));
+
+    // Owner dependency
+    dependencies.add(stableId.role(this.table.owner));
+
+    // Parent table dependency (for inheritance or partitioning)
+    if (this.table.parent_schema && this.table.parent_name) {
+      dependencies.add(
+        stableId.table(this.table.parent_schema, this.table.parent_name),
+      );
+    }
+
+    // Column type dependencies (user-defined types only)
+    for (const col of this.table.columns) {
+      if (
+        col.is_custom_type &&
+        col.custom_type_schema &&
+        col.custom_type_name
+      ) {
+        dependencies.add(
+          stableId.type(col.custom_type_schema, col.custom_type_name),
+        );
+      }
+
+      // Collation dependency (if non-default)
+      if (col.collation) {
+        // Collations are stored as schema-qualified strings like "public.collation_name"
+        // Note: The collation string may be quoted, so we need to handle that
+        const unquotedCollation = col.collation.replace(/^"|"$/g, "");
+        const collationParts = unquotedCollation.split(".");
+        if (collationParts.length === 2) {
+          const [collationSchema, collationName] = collationParts;
+          if (isUserDefinedTypeSchema(collationSchema)) {
+            dependencies.add(
+              stableId.collation(collationSchema, collationName),
+            );
+          }
+        }
+      }
+
+      // Function dependencies from DEFAULT expressions are handled by pg_depend
+      // catalog constraints in the sort pipeline, which provides exact argument
+      // types and covers all expression contexts (not just column defaults).
+    }
+
+    return Array.from(dependencies);
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const parts: string[] = ["CREATE"];
+
+    // Add TEMPORARY/UNLOGGED based on persistence
+    if (this.table.persistence === "t") {
+      parts.push("TEMPORARY");
+    } else if (this.table.persistence === "u") {
+      parts.push("UNLOGGED");
+    }
+
+    parts.push("TABLE");
+
+    // Add schema and name
+    parts.push(`${this.table.schema}.${this.table.name}`);
+
+    // If this is a partition (child) table, emit PARTITION OF ... FOR VALUES ...
+    if (
+      this.table.parent_schema &&
+      this.table.parent_name &&
+      this.table.partition_bound
+    ) {
+      return [
+        ...parts,
+        "PARTITION OF",
+        `${this.table.parent_schema}.${this.table.parent_name}`,
+        this.table.partition_bound,
+      ].join(" ");
+    }
+
+    // Add columns definition
+    if (this.table.columns.length === 0) {
+      parts.push("()");
+    } else {
+      const columnDefinitions = this.table.columns.map((col) => {
+        const tokens: string[] = [];
+
+        // Column name
+        tokens.push(col.name);
+
+        // Data type (use formatted type string from the catalog)
+        tokens.push(col.data_type_str);
+
+        // Collation
+        if (col.collation) {
+          tokens.push("COLLATE", col.collation);
+        }
+
+        // Identity / generated / default
+        if (col.is_identity) {
+          tokens.push(
+            col.is_identity_always
+              ? "GENERATED ALWAYS AS IDENTITY"
+              : "GENERATED BY DEFAULT AS IDENTITY",
+          );
+        } else if (col.is_generated && col.default) {
+          // Generated stored columns expose their expression via pg_attrdef
+          tokens.push(`GENERATED ALWAYS AS (${col.default}) STORED`);
+        } else if (col.default) {
+          tokens.push("DEFAULT", col.default);
+        }
+
+        // Nullability
+        if (col.not_null) {
+          tokens.push("NOT NULL");
+        }
+
+        return tokens.join(" ");
+      });
+
+      parts.push(`(${columnDefinitions.join(", ")})`);
+    }
+
+    // Add INHERITS if parent table exists (non-partition inheritance only)
+    if (
+      this.table.parent_schema &&
+      this.table.parent_name &&
+      !this.table.partition_bound
+    ) {
+      parts.push(
+        "INHERITS",
+        `(${this.table.parent_schema}.${this.table.parent_name})`,
+      );
+    }
+
+    // Add PARTITION BY if this is a partitioned table (parent)
+    if (this.table.partition_by) {
+      parts.push("PARTITION BY", this.table.partition_by);
+    }
+
+    // Add storage parameters if specified
+    if (this.table.options && this.table.options.length > 0) {
+      parts.push("WITH", `(${this.table.options.join(", ")})`);
+    }
+
+    return parts.join(" ");
+  }
+}

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

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Table, type TableProps } from "../table.model.ts";
+import { DropTable } from "./table.drop.ts";
+
+const base: TableProps = {
+  schema: "public",
+  name: "t",
+  persistence: "p",
+  row_security: false,
+  force_row_security: false,
+  has_indexes: false,
+  has_rules: false,
+  has_triggers: false,
+  has_subclasses: false,
+  is_populated: true,
+  replica_identity: "d",
+  is_partition: false,
+  options: null,
+  partition_bound: null,
+  partition_by: null,
+  owner: "o1",
+  parent_schema: null,
+  parent_name: null,
+  columns: [],
+  privileges: [],
+};
+
+describe.concurrent("table.drop", () => {
+  test("drop table basic", async () => {
+    const t = new Table(base);
+    const change = new DropTable({ table: t });
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe("DROP TABLE public.t");
+  });
+});