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

package/dist/core/objects/base.privilege.js

@@ -0,0 +1,169 @@
+/**
+ * Base utilities and helpers for object privilege changes.
+ * These functions support GRANT/REVOKE operations across different database objects.
+ */
+/**
+ * Returns the complete set of available privileges for a given object kind.
+ * This is used to determine whether a privilege list represents "ALL PRIVILEGES".
+ *
+ * @param kind - The PostgreSQL object kind (TABLE, VIEW, SEQUENCE, etc.)
+ * @param version - The PostgreSQL version number (e.g., 170000 for 17.0.0)
+ * @returns An array of privilege names available for this object kind
+ */
+function objectPrivilegeUniverse(kind, version) {
+    switch (kind) {
+        case "TABLE": {
+            const includesMaintain = (version ?? 170000) >= 170000;
+            return [
+                "DELETE",
+                "INSERT",
+                ...(includesMaintain ? ["MAINTAIN"] : []),
+                "REFERENCES",
+                "SELECT",
+                "TRIGGER",
+                "TRUNCATE",
+                "UPDATE",
+            ];
+        }
+        case "VIEW": {
+            // Per PostgreSQL docs, views are table-like and share the table privilege set
+            // for GRANT/REVOKE purposes. MAINTAIN exists on PostgreSQL >= 17
+            const includesMaintain = (version ?? 170000) >= 170000;
+            return [
+                "DELETE",
+                "INSERT",
+                ...(includesMaintain ? ["MAINTAIN"] : []),
+                "REFERENCES",
+                "SELECT",
+                "TRIGGER",
+                "TRUNCATE",
+                "UPDATE",
+            ];
+        }
+        case "MATERIALIZED VIEW": {
+            // Materialized views support the same table-like privileges as tables/views
+            // Per PostgreSQL docs, materialized views are table-like for GRANT/REVOKE purposes
+            const includesMaintain = (version ?? 170000) >= 170000;
+            return [
+                "DELETE",
+                "INSERT",
+                ...(includesMaintain ? ["MAINTAIN"] : []),
+                "REFERENCES",
+                "SELECT",
+                "TRIGGER",
+                "TRUNCATE",
+                "UPDATE",
+            ];
+        }
+        case "SEQUENCE":
+            return ["SELECT", "UPDATE", "USAGE"].sort();
+        case "SCHEMA":
+            return ["CREATE", "USAGE"].sort();
+        case "LANGUAGE":
+            return ["USAGE"];
+        case "FUNCTION":
+        case "PROCEDURE":
+        case "ROUTINE":
+            return ["EXECUTE"];
+        case "TYPE":
+        case "DOMAIN":
+            return ["USAGE"];
+        case "FOREIGN DATA WRAPPER":
+            return ["USAGE"];
+        case "SERVER":
+            return ["USAGE"];
+        case "FOREIGN TABLE": {
+            const includesMaintain = (version ?? 170000) >= 170000;
+            return [
+                "DELETE",
+                "INSERT",
+                ...(includesMaintain ? ["MAINTAIN"] : []),
+                "REFERENCES",
+                "SELECT",
+                "TRIGGER",
+                "TRUNCATE",
+                "UPDATE",
+            ];
+        }
+        default:
+            return [];
+    }
+}
+/**
+ * Checks if a privilege list represents the full set of privileges for an object kind.
+ * This determines whether we can use "ALL PRIVILEGES" shorthand in SQL.
+ *
+ * @param kind - The PostgreSQL object kind
+ * @param list - Array of privilege names to check
+ * @param version - The PostgreSQL version number
+ * @returns true if the list contains all available privileges for this object kind
+ */
+function isFullObjectPrivilegeSet(kind, list, version) {
+    const uniqSorted = [...new Set(list)].sort();
+    const fullSorted = [...objectPrivilegeUniverse(kind, version)].sort();
+    if (uniqSorted.length !== fullSorted.length)
+        return false;
+    for (let i = 0; i < uniqSorted.length; i++) {
+        if (uniqSorted[i] !== fullSorted[i])
+            return false;
+    }
+    return true;
+}
+/**
+ * Formats a list of privileges for use in GRANT/REVOKE statements.
+ * If the list represents all privileges, returns "ALL", otherwise returns a comma-separated list.
+ *
+ * @param kind - The PostgreSQL object kind
+ * @param list - Array of privilege names to format
+ * @param version - The PostgreSQL version number
+ * @returns A SQL-formatted privilege list (either "ALL" or "PRIV1, PRIV2, ...")
+ */
+export function formatObjectPrivilegeList(kind, list, version) {
+    const uniqSorted = [...new Set(list)].sort();
+    return isFullObjectPrivilegeSet(kind, uniqSorted, version)
+        ? "ALL"
+        : uniqSorted.join(", ");
+}
+/**
+ * Gets the SQL keyword prefix for a given object kind in GRANT/REVOKE statements.
+ *
+ * @param objectKind - The PostgreSQL object kind
+ * @returns The SQL prefix (e.g., "ON SCHEMA", "ON DOMAIN", "ON")
+ */
+export function getObjectKindPrefix(objectKind) {
+    switch (objectKind) {
+        case "FUNCTION":
+            return "ON FUNCTION";
+        case "PROCEDURE":
+            return "ON PROCEDURE";
+        case "ROUTINE":
+            return "ON ROUTINE";
+        case "LANGUAGE":
+            return "ON LANGUAGE";
+        case "SCHEMA":
+            return "ON SCHEMA";
+        case "SEQUENCE":
+            return "ON SEQUENCE";
+        case "DOMAIN":
+            return "ON DOMAIN";
+        case "TYPE":
+            return "ON TYPE";
+        case "FOREIGN TABLE":
+            return "ON FOREIGN TABLE";
+        default:
+            return "ON";
+    }
+}
+export function normalizePrivileges(privileges) {
+    return privileges
+        .map((privilege) => ({
+        grantee: privilege.grantee,
+        privilege: privilege.privilege,
+        grantable: privilege.grantable,
+    }))
+        .sort((a, b) => {
+        if (a.grantee !== b.grantee)
+            return a.grantee.localeCompare(b.grantee);
+        return a.privilege.localeCompare(b.privilege);
+    });
+}

package/dist/core/objects/collation/changes/collation.alter.d.ts

@@ -0,0 +1,45 @@
+import type { Collation } from "../collation.model.ts";
+import { AlterCollationChange } from "./collation.base.ts";
+/**
+ * Alter a collation.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-altercollation.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER COLLATION name REFRESH VERSION
+ * ALTER COLLATION name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ * ALTER COLLATION name RENAME TO new_name
+ * ```
+ */
+export type AlterCollation = AlterCollationChangeOwner | AlterCollationRefreshVersion;
+/**
+ * ALTER COLLATION ... OWNER TO ...
+ */
+export declare class AlterCollationChangeOwner extends AlterCollationChange {
+    readonly collation: Collation;
+    readonly owner: string;
+    readonly scope: "object";
+    constructor(props: {
+        collation: Collation;
+        owner: string;
+    });
+    get requires(): `collation:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER COLLATION ... REFRESH VERSION
+ */
+export declare class AlterCollationRefreshVersion extends AlterCollationChange {
+    readonly collation: Collation;
+    readonly scope: "object";
+    constructor(props: {
+        collation: Collation;
+    });
+    get requires(): `collation:${string}`[];
+    serialize(): string;
+}
+/**
+ * Replace a collation by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER COLLATION change.
+ */

package/dist/core/objects/collation/changes/collation.alter.js

@@ -0,0 +1,52 @@
+import { AlterCollationChange } from "./collation.base.js";
+/**
+ * ALTER COLLATION ... OWNER TO ...
+ */
+export class AlterCollationChangeOwner extends AlterCollationChange {
+    collation;
+    owner;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.collation = props.collation;
+        this.owner = props.owner;
+    }
+    get requires() {
+        return [this.collation.stableId];
+    }
+    serialize() {
+        return [
+            "ALTER COLLATION",
+            `${this.collation.schema}.${this.collation.name}`,
+            "OWNER TO",
+            this.owner,
+        ].join(" ");
+    }
+}
+/**
+ * ALTER COLLATION ... REFRESH VERSION
+ */
+export class AlterCollationRefreshVersion extends AlterCollationChange {
+    collation;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.collation = props.collation;
+    }
+    get requires() {
+        return [this.collation.stableId];
+    }
+    serialize() {
+        return [
+            "ALTER COLLATION",
+            `${this.collation.schema}.${this.collation.name}`,
+            "REFRESH VERSION",
+        ].join(" ");
+    }
+}
+/**
+ * Replace a collation by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER COLLATION change.
+ */
+// NOTE: ReplaceCollation has been removed. Non-alterable property changes
+// are modeled as separate DropCollation + CreateCollation changes in collation.diff.ts.

package/dist/core/objects/collation/changes/collation.base.d.ts

@@ -0,0 +1,17 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Collation } from "../collation.model.ts";
+declare abstract class BaseCollationChange extends BaseChange {
+    abstract readonly collation: Collation;
+    abstract readonly scope: "object" | "comment";
+    readonly objectType: "collation";
+}
+export declare abstract class CreateCollationChange extends BaseCollationChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterCollationChange extends BaseCollationChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropCollationChange extends BaseCollationChange {
+    readonly operation: "drop";
+}
+export {};

package/dist/core/objects/collation/changes/collation.base.js

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../base.change.js";
+class BaseCollationChange extends BaseChange {
+    objectType = "collation";
+}
+export class CreateCollationChange extends BaseCollationChange {
+    operation = "create";
+}
+export class AlterCollationChange extends BaseCollationChange {
+    operation = "alter";
+}
+export class DropCollationChange extends BaseCollationChange {
+    operation = "drop";
+}

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

@@ -0,0 +1,26 @@
+import type { Collation } from "../collation.model.ts";
+import { CreateCollationChange, DropCollationChange } from "./collation.base.ts";
+export type CommentCollation = CreateCommentOnCollation | DropCommentOnCollation;
+/**
+ * Create/drop comments on collations.
+ */
+export declare class CreateCommentOnCollation extends CreateCollationChange {
+    readonly collation: Collation;
+    readonly scope: "comment";
+    constructor(props: {
+        collation: Collation;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `collation:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnCollation extends DropCollationChange {
+    readonly collation: Collation;
+    readonly scope: "comment";
+    constructor(props: {
+        collation: Collation;
+    });
+    get requires(): (`comment:${string}` | `collation:${string}`)[];
+    get drops(): `comment:${string}`[];
+    serialize(): string;
+}

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

@@ -0,0 +1,50 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateCollationChange, DropCollationChange, } from "./collation.base.js";
+/**
+ * Create/drop comments on collations.
+ */
+export class CreateCommentOnCollation extends CreateCollationChange {
+    collation;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.collation = props.collation;
+    }
+    get creates() {
+        return [stableId.comment(this.collation.stableId)];
+    }
+    get requires() {
+        return [this.collation.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON COLLATION",
+            `${this.collation.schema}.${this.collation.name}`,
+            "IS",
+            // biome-ignore lint/style/noNonNullAssertion: collation comment is not nullable in this case
+            quoteLiteral(this.collation.comment),
+        ].join(" ");
+    }
+}
+export class DropCommentOnCollation extends DropCollationChange {
+    collation;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.collation = props.collation;
+    }
+    get requires() {
+        return [this.collation.stableId, stableId.comment(this.collation.stableId)];
+    }
+    get drops() {
+        return [stableId.comment(this.collation.stableId)];
+    }
+    serialize() {
+        return [
+            "COMMENT ON COLLATION",
+            `${this.collation.schema}.${this.collation.name}`,
+            "IS NULL",
+        ].join(" ");
+    }
+}

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

@@ -0,0 +1,32 @@
+import type { Collation } from "../collation.model.ts";
+import { CreateCollationChange } from "./collation.base.ts";
+/**
+ * Create a collation.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createcollation.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE COLLATION [ IF NOT EXISTS ] name (
+ *     [ LOCALE = locale, ]
+ *     [ LC_COLLATE = lc_collate, ]
+ *     [ LC_CTYPE = lc_ctype, ]
+ *     [ PROVIDER = provider, ]
+ *     [ DETERMINISTIC = boolean, ]
+ *     [ RULES = rules, ]
+ *     [ VERSION = version ]
+ * )
+ *
+ * CREATE COLLATION [ IF NOT EXISTS ] name FROM existing_collation
+ * ```
+ */
+export declare class CreateCollation extends CreateCollationChange {
+    readonly collation: Collation;
+    readonly scope: "object";
+    constructor(props: {
+        collation: Collation;
+    });
+    get creates(): `collation:${string}`[];
+    get requires(): string[];
+    serialize(): string;
+}

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

@@ -0,0 +1,86 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateCollationChange } from "./collation.base.js";
+/**
+ * Create a collation.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createcollation.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE COLLATION [ IF NOT EXISTS ] name (
+ *     [ LOCALE = locale, ]
+ *     [ LC_COLLATE = lc_collate, ]
+ *     [ LC_CTYPE = lc_ctype, ]
+ *     [ PROVIDER = provider, ]
+ *     [ DETERMINISTIC = boolean, ]
+ *     [ RULES = rules, ]
+ *     [ VERSION = version ]
+ * )
+ *
+ * CREATE COLLATION [ IF NOT EXISTS ] name FROM existing_collation
+ * ```
+ */
+export class CreateCollation extends CreateCollationChange {
+    collation;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.collation = props.collation;
+    }
+    get creates() {
+        return [this.collation.stableId];
+    }
+    get requires() {
+        const dependencies = new Set();
+        // Schema dependency
+        dependencies.add(stableId.schema(this.collation.schema));
+        // Owner dependency
+        dependencies.add(stableId.role(this.collation.owner));
+        return Array.from(dependencies);
+    }
+    serialize() {
+        const parts = ["CREATE COLLATION"];
+        // Add schema and name (already quoted in model extraction)
+        parts.push(`${this.collation.schema}.${this.collation.name}`);
+        // Add properties
+        const properties = [];
+        // LOCALE
+        if (this.collation.locale) {
+            properties.push(`LOCALE = ${quoteLiteral(this.collation.locale)}`);
+        }
+        // LC_COLLATE
+        if (this.collation.collate) {
+            properties.push(`LC_COLLATE = ${quoteLiteral(this.collation.collate)}`);
+        }
+        // LC_CTYPE
+        if (this.collation.ctype) {
+            properties.push(`LC_CTYPE = ${quoteLiteral(this.collation.ctype)}`);
+        }
+        // PROVIDER
+        const providerMap = {
+            c: "libc",
+            i: "icu",
+            b: "builtin",
+        };
+        // provider 'd' means default provider in catalog; omit PROVIDER clause
+        if (this.collation.provider !== "d") {
+            properties.push(`PROVIDER = ${providerMap[this.collation.provider]}`);
+        }
+        // DETERMINISTIC
+        // DETERMINISTIC (only emit when false; true is default in PG)
+        if (this.collation.is_deterministic === false) {
+            properties.push(`DETERMINISTIC = false`);
+        }
+        // RULES (ICU rules)
+        if (this.collation.icu_rules) {
+            properties.push(`RULES = ${quoteLiteral(this.collation.icu_rules)}`);
+        }
+        // VERSION
+        if (this.collation.version) {
+            properties.push(`VERSION = ${quoteLiteral(this.collation.version)}`);
+        }
+        parts.push(["(", properties.join(", "), ")"].join(""));
+        return parts.join(" ");
+    }
+}

package/dist/core/objects/collation/changes/collation.drop.d.ts

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

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

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

package/dist/core/objects/collation/changes/collation.types.d.ts

@@ -0,0 +1,5 @@
+import type { AlterCollation } from "./collation.alter.ts";
+import type { CommentCollation } from "./collation.comment.ts";
+import type { CreateCollation } from "./collation.create.ts";
+import type { DropCollation } from "./collation.drop.ts";
+export type CollationChange = AlterCollation | CommentCollation | CreateCollation | DropCollation;

package/dist/core/objects/collation/changes/collation.types.js

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

package/dist/core/objects/collation/collation.diff.d.ts

@@ -0,0 +1,13 @@
+import type { CollationChange } from "./changes/collation.types.ts";
+import type { Collation } from "./collation.model.ts";
+/**
+ * Diff two sets of collations from main and branch catalogs.
+ *
+ * @param ctx - Context containing currentUser
+ * @param main - The collations in the main catalog.
+ * @param branch - The collations in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export declare function diffCollations(ctx: {
+    currentUser: string;
+}, main: Record<string, Collation>, branch: Record<string, Collation>): CollationChange[];

package/dist/core/objects/collation/collation.diff.js

@@ -0,0 +1,85 @@
+import { diffObjects } from "../base.diff.js";
+import { hasNonAlterableChanges } from "../utils.js";
+import { AlterCollationChangeOwner, AlterCollationRefreshVersion, } from "./changes/collation.alter.js";
+import { CreateCommentOnCollation, DropCommentOnCollation, } from "./changes/collation.comment.js";
+import { CreateCollation } from "./changes/collation.create.js";
+import { DropCollation } from "./changes/collation.drop.js";
+/**
+ * Diff two sets of collations from main and branch catalogs.
+ *
+ * @param ctx - Context containing currentUser
+ * @param main - The collations in the main catalog.
+ * @param branch - The collations in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffCollations(ctx, main, branch) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    for (const collationId of created) {
+        const coll = branch[collationId];
+        changes.push(new CreateCollation({ collation: coll }));
+        // OWNER: If the collation should be owned by someone other than the current user,
+        // emit ALTER COLLATION ... OWNER TO after creation
+        if (coll.owner !== ctx.currentUser) {
+            changes.push(new AlterCollationChangeOwner({
+                collation: coll,
+                owner: coll.owner,
+            }));
+        }
+        if (coll.comment !== null) {
+            changes.push(new CreateCommentOnCollation({ collation: coll }));
+        }
+    }
+    for (const collationId of dropped) {
+        changes.push(new DropCollation({ collation: main[collationId] }));
+    }
+    for (const collationId of altered) {
+        const mainCollation = main[collationId];
+        const branchCollation = branch[collationId];
+        // Check if non-alterable properties have changed
+        // These require dropping and recreating the collation
+        const NON_ALTERABLE_FIELDS = [
+            "provider",
+            "is_deterministic",
+            "encoding",
+            "collate",
+            "ctype",
+            "locale",
+            "icu_rules",
+        ];
+        const nonAlterablePropsChanged = hasNonAlterableChanges(mainCollation, branchCollation, NON_ALTERABLE_FIELDS);
+        if (nonAlterablePropsChanged) {
+            // Replace the entire collation (drop + create)
+            changes.push(new DropCollation({ collation: mainCollation }), new CreateCollation({ collation: branchCollation }));
+        }
+        else {
+            // Only alterable properties changed - check each one
+            // VERSION
+            if (mainCollation.version !== branchCollation.version) {
+                changes.push(new AlterCollationRefreshVersion({
+                    collation: mainCollation,
+                }));
+            }
+            // OWNER
+            if (mainCollation.owner !== branchCollation.owner) {
+                changes.push(new AlterCollationChangeOwner({
+                    collation: mainCollation,
+                    owner: branchCollation.owner,
+                }));
+            }
+            // COMMENT
+            if (mainCollation.comment !== branchCollation.comment) {
+                if (branchCollation.comment === null) {
+                    changes.push(new DropCommentOnCollation({ collation: mainCollation }));
+                }
+                else {
+                    changes.push(new CreateCommentOnCollation({ collation: branchCollation }));
+                }
+            }
+            // Note: Collation renaming would also use ALTER COLLATION ... RENAME TO ...
+            // But since our Collation model uses 'name' as the identity field,
+            // a name change would be handled as drop + create by diffObjects()
+        }
+    }
+    return changes;
+}