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

package/dist/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.comment.js

@@ -0,0 +1,50 @@
+import { quoteLiteral } from "../../../base.change.js";
+import { stableId } from "../../../utils.js";
+import { CreateForeignTableChange, DropForeignTableChange, } from "./foreign-table.base.js";
+export class CreateCommentOnForeignTable extends CreateForeignTableChange {
+    foreignTable;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.foreignTable = props.foreignTable;
+    }
+    get creates() {
+        return [stableId.comment(this.foreignTable.stableId)];
+    }
+    get requires() {
+        return [this.foreignTable.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON FOREIGN TABLE",
+            `${this.foreignTable.schema}.${this.foreignTable.name}`,
+            "IS",
+            // biome-ignore lint/style/noNonNullAssertion: comment is not nullable in this case
+            quoteLiteral(this.foreignTable.comment),
+        ].join(" ");
+    }
+}
+export class DropCommentOnForeignTable extends DropForeignTableChange {
+    foreignTable;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.foreignTable = props.foreignTable;
+    }
+    get drops() {
+        return [stableId.comment(this.foreignTable.stableId)];
+    }
+    get requires() {
+        return [
+            stableId.comment(this.foreignTable.stableId),
+            this.foreignTable.stableId,
+        ];
+    }
+    serialize() {
+        return [
+            "COMMENT ON FOREIGN TABLE",
+            `${this.foreignTable.schema}.${this.foreignTable.name}`,
+            "IS NULL",
+        ].join(" ");
+    }
+}

package/dist/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.create.d.ts

@@ -0,0 +1,25 @@
+import type { ForeignTable } from "../foreign-table.model.ts";
+import { CreateForeignTableChange } from "./foreign-table.base.ts";
+/**
+ * Create a foreign table.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createforeigntable.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE FOREIGN TABLE [ IF NOT EXISTS ] table_name
+ *     ( [ { column_name data_type [ OPTIONS ( option 'value' [, ... ] ) ] [ COLLATE collation ] [ column_constraint [ ... ] ] | table_constraint } [, ... ] ] )
+ *     SERVER server_name
+ *     [ OPTIONS ( option 'value' [, ... ] ) ]
+ * ```
+ */
+export declare class CreateForeignTable extends CreateForeignTableChange {
+    readonly foreignTable: ForeignTable;
+    readonly scope: "object";
+    constructor(props: {
+        foreignTable: ForeignTable;
+    });
+    get creates(): `foreignTable:${string}`[];
+    get requires(): string[];
+    serialize(): string;
+}

package/dist/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.create.js

@@ -0,0 +1,64 @@
+import { quoteLiteral } from "../../../base.change.js";
+import { stableId } from "../../../utils.js";
+import { CreateForeignTableChange } from "./foreign-table.base.js";
+/**
+ * Create a foreign table.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createforeigntable.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE FOREIGN TABLE [ IF NOT EXISTS ] table_name
+ *     ( [ { column_name data_type [ OPTIONS ( option 'value' [, ... ] ) ] [ COLLATE collation ] [ column_constraint [ ... ] ] | table_constraint } [, ... ] ] )
+ *     SERVER server_name
+ *     [ OPTIONS ( option 'value' [, ... ] ) ]
+ * ```
+ */
+export class CreateForeignTable extends CreateForeignTableChange {
+    foreignTable;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.foreignTable = props.foreignTable;
+    }
+    get creates() {
+        return [this.foreignTable.stableId];
+    }
+    get requires() {
+        const dependencies = new Set();
+        // Schema dependency
+        dependencies.add(stableId.schema(this.foreignTable.schema));
+        // Server dependency
+        dependencies.add(stableId.server(this.foreignTable.server));
+        // Owner dependency
+        dependencies.add(stableId.role(this.foreignTable.owner));
+        return Array.from(dependencies);
+    }
+    serialize() {
+        const parts = ["CREATE FOREIGN TABLE"];
+        // Add schema and name
+        parts.push(`${this.foreignTable.schema}.${this.foreignTable.name}`);
+        // Add columns
+        const columnDefs = [];
+        for (const col of this.foreignTable.columns) {
+            const colParts = [col.name, col.data_type_str];
+            columnDefs.push(colParts.join(" "));
+        }
+        parts.push(`(${columnDefs.join(", ")})`);
+        // Add SERVER clause
+        parts.push("SERVER", this.foreignTable.server);
+        // Add OPTIONS clause (table-level)
+        if (this.foreignTable.options && this.foreignTable.options.length > 0) {
+            const optionPairs = [];
+            for (let i = 0; i < this.foreignTable.options.length; i += 2) {
+                if (i + 1 < this.foreignTable.options.length) {
+                    optionPairs.push(`${this.foreignTable.options[i]} ${quoteLiteral(this.foreignTable.options[i + 1])}`);
+                }
+            }
+            if (optionPairs.length > 0) {
+                parts.push(`OPTIONS (${optionPairs.join(", ")})`);
+            }
+        }
+        return parts.join(" ");
+    }
+}

package/dist/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.drop.d.ts

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

package/dist/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.drop.js

@@ -0,0 +1,31 @@
+import { DropForeignTableChange } from "./foreign-table.base.js";
+/**
+ * Drop a foreign table.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropforeigntable.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP FOREIGN TABLE [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropForeignTable extends DropForeignTableChange {
+    foreignTable;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.foreignTable = props.foreignTable;
+    }
+    get drops() {
+        return [this.foreignTable.stableId];
+    }
+    get requires() {
+        return [this.foreignTable.stableId];
+    }
+    serialize() {
+        return [
+            "DROP FOREIGN TABLE",
+            `${this.foreignTable.schema}.${this.foreignTable.name}`,
+        ].join(" ");
+    }
+}

package/dist/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.privilege.d.ts

@@ -0,0 +1,97 @@
+import type { ForeignTable } from "../foreign-table.model.ts";
+import { AlterForeignTableChange } from "./foreign-table.base.ts";
+export type ForeignTablePrivilege = GrantForeignTablePrivileges | RevokeForeignTablePrivileges | RevokeGrantOptionForeignTablePrivileges;
+/**
+ * Grant privileges on a foreign table.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER } [, ...] | ALL [ PRIVILEGES ] }
+ *     ON FOREIGN TABLE table_name [, ...]
+ *     TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *     [ GRANTED BY role_specification ]
+ * ```
+ */
+export declare class GrantForeignTablePrivileges extends AlterForeignTableChange {
+    readonly foreignTable: ForeignTable;
+    readonly grantee: string;
+    readonly privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        foreignTable: ForeignTable;
+        grantee: string;
+        privileges: {
+            privilege: string;
+            grantable: boolean;
+        }[];
+        version?: number;
+    });
+    get creates(): `acl:${string}::grantee:${string}`[];
+    get requires(): (`role:${string}` | `foreignTable:${string}`)[];
+    serialize(): string;
+}
+/**
+ * Revoke privileges on a foreign table.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER } [, ...] | ALL [ PRIVILEGES ] }
+ *     ON FOREIGN TABLE table_name [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export declare class RevokeForeignTablePrivileges extends AlterForeignTableChange {
+    readonly foreignTable: ForeignTable;
+    readonly grantee: string;
+    readonly privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        foreignTable: ForeignTable;
+        grantee: string;
+        privileges: {
+            privilege: string;
+            grantable: boolean;
+        }[];
+        version?: number;
+    });
+    get drops(): `acl:${string}::grantee:${string}`[];
+    get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `foreignTable:${string}`)[];
+    serialize(): string;
+}
+/**
+ * Revoke grant option for privileges on a foreign 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 RevokeGrantOptionForeignTablePrivileges extends AlterForeignTableChange {
+    readonly foreignTable: ForeignTable;
+    readonly grantee: string;
+    readonly privilegeNames: string[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        foreignTable: ForeignTable;
+        grantee: string;
+        privilegeNames: string[];
+        version?: number;
+    });
+    get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `foreignTable:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.privilege.js

@@ -0,0 +1,129 @@
+import { formatObjectPrivilegeList, getObjectKindPrefix, } from "../../../base.privilege.js";
+import { stableId } from "../../../utils.js";
+import { AlterForeignTableChange } from "./foreign-table.base.js";
+/**
+ * Grant privileges on a foreign table.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER } [, ...] | ALL [ PRIVILEGES ] }
+ *     ON FOREIGN TABLE table_name [, ...]
+ *     TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *     [ GRANTED BY role_specification ]
+ * ```
+ */
+export class GrantForeignTablePrivileges extends AlterForeignTableChange {
+    foreignTable;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.foreignTable = props.foreignTable;
+        this.grantee = props.grantee;
+        this.privileges = props.privileges;
+        this.version = props.version;
+    }
+    get creates() {
+        return [stableId.acl(this.foreignTable.stableId, this.grantee)];
+    }
+    get requires() {
+        return [this.foreignTable.stableId, stableId.role(this.grantee)];
+    }
+    serialize() {
+        const hasGrantable = this.privileges.some((p) => p.grantable);
+        const hasBase = this.privileges.some((p) => !p.grantable);
+        if (hasGrantable && hasBase) {
+            throw new Error("GrantForeignTablePrivileges expects privileges with uniform grantable flag");
+        }
+        const withGrant = hasGrantable ? " WITH GRANT OPTION" : "";
+        const kindPrefix = getObjectKindPrefix("FOREIGN TABLE");
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList("FOREIGN TABLE", list, this.version);
+        const tableName = `${this.foreignTable.schema}.${this.foreignTable.name}`;
+        return `GRANT ${privSql} ${kindPrefix} ${tableName} TO ${this.grantee}${withGrant}`;
+    }
+}
+/**
+ * Revoke privileges on a foreign table.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { { SELECT | INSERT | UPDATE | DELETE | TRUNCATE | REFERENCES | TRIGGER } [, ...] | ALL [ PRIVILEGES ] }
+ *     ON FOREIGN TABLE table_name [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class RevokeForeignTablePrivileges extends AlterForeignTableChange {
+    foreignTable;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.foreignTable = props.foreignTable;
+        this.grantee = props.grantee;
+        this.privileges = props.privileges;
+        this.version = props.version;
+    }
+    get drops() {
+        return [stableId.acl(this.foreignTable.stableId, this.grantee)];
+    }
+    get requires() {
+        return [
+            stableId.acl(this.foreignTable.stableId, this.grantee),
+            this.foreignTable.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const kindPrefix = getObjectKindPrefix("FOREIGN TABLE");
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList("FOREIGN TABLE", list, this.version);
+        const tableName = `${this.foreignTable.schema}.${this.foreignTable.name}`;
+        return `REVOKE ${privSql} ${kindPrefix} ${tableName} FROM ${this.grantee}`;
+    }
+}
+/**
+ * Revoke grant option for privileges on a foreign 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 class RevokeGrantOptionForeignTablePrivileges extends AlterForeignTableChange {
+    foreignTable;
+    grantee;
+    privilegeNames;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.foreignTable = props.foreignTable;
+        this.grantee = props.grantee;
+        this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+        this.version = props.version;
+    }
+    get requires() {
+        return [
+            stableId.acl(this.foreignTable.stableId, this.grantee),
+            this.foreignTable.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const kindPrefix = getObjectKindPrefix("FOREIGN TABLE");
+        const privSql = formatObjectPrivilegeList("FOREIGN TABLE", this.privilegeNames, this.version);
+        const tableName = `${this.foreignTable.schema}.${this.foreignTable.name}`;
+        return `REVOKE GRANT OPTION FOR ${privSql} ${kindPrefix} ${tableName} FROM ${this.grantee}`;
+    }
+}

package/dist/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.types.d.ts

@@ -0,0 +1,6 @@
+import type { AlterForeignTable } from "./foreign-table.alter.ts";
+import type { CommentForeignTable } from "./foreign-table.comment.ts";
+import type { CreateForeignTable } from "./foreign-table.create.ts";
+import type { DropForeignTable } from "./foreign-table.drop.ts";
+import type { ForeignTablePrivilege } from "./foreign-table.privilege.ts";
+export type ForeignTableChange = AlterForeignTable | CommentForeignTable | CreateForeignTable | DropForeignTable | ForeignTablePrivilege;

package/dist/core/objects/foreign-data-wrapper/foreign-table/changes/foreign-table.types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/objects/foreign-data-wrapper/foreign-table/foreign-table.diff.d.ts

@@ -0,0 +1,18 @@
+import type { DefaultPrivilegeState } from "../../base.default-privileges.ts";
+import type { Role } from "../../role/role.model.ts";
+import type { ForeignTableChange } from "./changes/foreign-table.types.ts";
+import type { ForeignTable } from "./foreign-table.model.ts";
+/**
+ * Diff two sets of foreign tables from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The foreign tables in the main catalog.
+ * @param branch - The foreign tables in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export declare function diffForeignTables(ctx: {
+    version: number;
+    currentUser: string;
+    defaultPrivilegeState: DefaultPrivilegeState;
+    mainRoles: Record<string, Role>;
+}, main: Record<string, ForeignTable>, branch: Record<string, ForeignTable>): ForeignTableChange[];