@supabase/pg-delta 0.0.0 → 1.0.0-alpha.0

package/dist/core/objects/table/changes/table.comment.d.ts

@@ -0,0 +1,106 @@
+import type { ColumnProps } from "../../base.model.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 declare class CreateCommentOnTable extends CreateTableChange {
+    readonly table: Table;
+    readonly scope: "comment";
+    constructor(props: {
+        table: Table;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `table:${string}`[];
+    serialize(): string;
+}
+/**
+ * COMMENT ON TABLE ... IS ...
+ */
+export declare class DropCommentOnTable extends DropTableChange {
+    readonly table: Table;
+    readonly scope: "comment";
+    constructor(props: {
+        table: Table;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`comment:${string}` | `table:${string}`)[];
+    serialize(): string;
+}
+/**
+ * COMMENT ON COLUMN ... IS ...
+ */
+export declare class CreateCommentOnColumn extends CreateTableChange {
+    readonly table: Table;
+    readonly column: ColumnProps;
+    readonly scope: "comment";
+    constructor(props: {
+        table: Table;
+        column: ColumnProps;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `column:${string}.${string}.${string}`[];
+    serialize(): string;
+}
+/**
+ * COMMENT ON COLUMN ... IS ...
+ */
+export declare class DropCommentOnColumn extends DropTableChange {
+    readonly table: Table;
+    readonly column: ColumnProps;
+    readonly scope: "comment";
+    constructor(props: {
+        table: Table;
+        column: ColumnProps;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`column:${string}.${string}.${string}` | `comment:${string}`)[];
+    serialize(): string;
+}
+/**
+ * COMMENT ON CONSTRAINT ... IS ...
+ */
+export declare class CreateCommentOnConstraint extends CreateTableChange {
+    readonly table: Table;
+    readonly constraint: TableConstraintProps;
+    readonly scope: "comment";
+    constructor(props: {
+        table: Table;
+        constraint: TableConstraintProps;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `constraint:${string}.${string}.${string}`[];
+    serialize(): string;
+}
+/**
+ * COMMENT ON CONSTRAINT ... IS ...
+ */
+export declare class DropCommentOnConstraint extends DropTableChange {
+    readonly table: Table;
+    readonly constraint: TableConstraintProps;
+    readonly scope: "comment";
+    constructor(props: {
+        table: Table;
+        constraint: TableConstraintProps;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`constraint:${string}.${string}.${string}` | `comment:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/table/changes/table.comment.js

@@ -0,0 +1,175 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateTableChange, DropTableChange } from "./table.base.js";
+/**
+ * COMMENT ON TABLE ... IS ...
+ */
+export class CreateCommentOnTable extends CreateTableChange {
+    table;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.table = props.table;
+    }
+    get creates() {
+        return [stableId.comment(this.table.stableId)];
+    }
+    get requires() {
+        return [this.table.stableId];
+    }
+    serialize() {
+        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 {
+    table;
+    scope = "comment";
+    constructor(props) {
+        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() {
+        return [
+            "COMMENT ON TABLE",
+            `${this.table.schema}.${this.table.name}`,
+            "IS NULL",
+        ].join(" ");
+    }
+}
+/**
+ * COMMENT ON COLUMN ... IS ...
+ */
+export class CreateCommentOnColumn extends CreateTableChange {
+    table;
+    column;
+    scope = "comment";
+    constructor(props) {
+        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() {
+        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 {
+    table;
+    column;
+    scope = "comment";
+    constructor(props) {
+        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() {
+        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 {
+    table;
+    constraint;
+    scope = "comment";
+    constructor(props) {
+        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() {
+        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 {
+    table;
+    constraint;
+    scope = "comment";
+    constructor(props) {
+        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() {
+        return [
+            "COMMENT ON CONSTRAINT",
+            this.constraint.name,
+            "ON",
+            `${this.table.schema}.${this.table.name}`,
+            "IS NULL",
+        ].join(" ");
+    }
+}

package/dist/core/objects/table/changes/table.create.d.ts

@@ -0,0 +1,33 @@
+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 declare class CreateTable extends CreateTableChange {
+    readonly table: Table;
+    readonly scope: "object";
+    constructor(props: {
+        table: Table;
+    });
+    get creates(): (`column:${string}.${string}.${string}` | `table:${string}`)[];
+    get requires(): string[];
+    serialize(): string;
+}

package/dist/core/objects/table/changes/table.create.js

@@ -0,0 +1,145 @@
+import { isUserDefinedTypeSchema, stableId } from "../../utils.js";
+import { CreateTableChange } from "./table.base.js";
+/**
+ * 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 {
+    table;
+    scope = "object";
+    constructor(props) {
+        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();
+        // 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));
+                    }
+                }
+            }
+        }
+        return Array.from(dependencies);
+    }
+    serialize() {
+        const parts = ["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 = [];
+                // 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/dist/core/objects/table/changes/table.drop.d.ts

@@ -0,0 +1,22 @@
+import type { Table } from "../table.model.ts";
+import { DropTableChange } from "./table.base.ts";
+/**
+ * Drop a table.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-droptable.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP TABLE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export declare class DropTable extends DropTableChange {
+    readonly table: Table;
+    readonly scope: "object";
+    constructor(props: {
+        table: Table;
+    });
+    get drops(): (`column:${string}.${string}.${string}` | `table:${string}`)[];
+    get requires(): (`column:${string}.${string}.${string}` | `table:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/table/changes/table.drop.js

@@ -0,0 +1,35 @@
+import { stableId } from "../../utils.js";
+import { DropTableChange } from "./table.base.js";
+/**
+ * Drop a table.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-droptable.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP TABLE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropTable extends DropTableChange {
+    table;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.table = props.table;
+    }
+    get drops() {
+        return [
+            this.table.stableId,
+            ...this.table.columns.map((column) => stableId.column(this.table.schema, this.table.name, column.name)),
+        ];
+    }
+    get requires() {
+        return [
+            this.table.stableId,
+            ...this.table.columns.map((col) => stableId.column(this.table.schema, this.table.name, col.name)),
+        ];
+    }
+    serialize() {
+        return ["DROP TABLE", `${this.table.schema}.${this.table.name}`].join(" ");
+    }
+}

package/dist/core/objects/table/changes/table.privilege.d.ts

@@ -0,0 +1,107 @@
+import type { Table } from "../table.model.ts";
+import { AlterTableChange } from "./table.base.ts";
+export type TablePrivilege = GrantTablePrivileges | RevokeTablePrivileges | RevokeGrantOptionTablePrivileges;
+/**
+ * Grant privileges on a table.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER | MAINTAIN }
+ *     [, ...] | ALL [ PRIVILEGES ] }
+ *     ON { [ TABLE ] table_name [, ...]
+ *          | ALL TABLES IN SCHEMA schema_name [, ...] }
+ *     TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *     [ GRANTED BY role_specification ]
+ * ```
+ */
+export declare class GrantTablePrivileges extends AlterTableChange {
+    readonly table: Table;
+    readonly grantee: string;
+    readonly privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[];
+    readonly columns?: string[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        table: Table;
+        grantee: string;
+        privileges: {
+            privilege: string;
+            grantable: boolean;
+        }[];
+        columns?: string[];
+        version?: number;
+    });
+    get creates(): `acl:${string}::grantee:${string}`[];
+    get requires(): (`role:${string}` | `table:${string}`)[];
+    serialize(): string;
+}
+/**
+ * Revoke privileges on a table.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER | MAINTAIN }
+ *     [, ...] | ALL [ PRIVILEGES ] }
+ *     ON { [ TABLE ] table_name [, ...]
+ *          | ALL TABLES IN SCHEMA schema_name [, ...] }
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export declare class RevokeTablePrivileges extends AlterTableChange {
+    readonly table: Table;
+    readonly grantee: string;
+    readonly privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[];
+    readonly columns?: string[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        table: Table;
+        grantee: string;
+        privileges: {
+            privilege: string;
+            grantable: boolean;
+        }[];
+        columns?: string[];
+        version?: number;
+    });
+    get drops(): `acl:${string}::grantee:${string}`[];
+    get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `table:${string}`)[];
+    serialize(): string;
+}
+/**
+ * Revoke grant option for privileges on a table.
+ *
+ * This removes the ability to grant the privilege to others, but keeps the privilege itself.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ */
+export declare class RevokeGrantOptionTablePrivileges extends AlterTableChange {
+    readonly table: Table;
+    readonly grantee: string;
+    readonly privilegeNames: string[];
+    readonly columns?: string[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        table: Table;
+        grantee: string;
+        privilegeNames: string[];
+        columns?: string[];
+        version?: number;
+    });
+    get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `table:${string}`)[];
+    serialize(): string;
+}