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

package/dist/core/objects/type/range/changes/range.alter.js

@@ -0,0 +1,30 @@
+import { AlterRangeChange } from "./range.base.js";
+/**
+ * ALTER TYPE ... OWNER TO ...
+ */
+export class AlterRangeChangeOwner extends AlterRangeChange {
+    range;
+    owner;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.range = props.range;
+        this.owner = props.owner;
+    }
+    get requires() {
+        return [this.range.stableId];
+    }
+    serialize() {
+        return [
+            "ALTER TYPE",
+            `${this.range.schema}.${this.range.name}`,
+            "OWNER TO",
+            this.owner,
+        ].join(" ");
+    }
+}
+/**
+ * Replace a range type by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER TYPE change.
+ */
+// NOTE: ReplaceRange removed. Non-alterable changes are emitted as Drop + Create in range.diff.ts.

package/dist/core/objects/type/range/changes/range.base.d.ts

@@ -0,0 +1,17 @@
+import { BaseChange } from "../../../base.change.ts";
+import type { Range } from "../range.model.ts";
+declare abstract class BaseRangeChange extends BaseChange {
+    abstract readonly range: Range;
+    abstract readonly scope: "object" | "comment" | "privilege";
+    readonly objectType: "range";
+}
+export declare abstract class CreateRangeChange extends BaseRangeChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterRangeChange extends BaseRangeChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropRangeChange extends BaseRangeChange {
+    readonly operation: "drop";
+}
+export {};

package/dist/core/objects/type/range/changes/range.base.js

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../../base.change.js";
+class BaseRangeChange extends BaseChange {
+    objectType = "range";
+}
+export class CreateRangeChange extends BaseRangeChange {
+    operation = "create";
+}
+export class AlterRangeChange extends BaseRangeChange {
+    operation = "alter";
+}
+export class DropRangeChange extends BaseRangeChange {
+    operation = "drop";
+}

package/dist/core/objects/type/range/changes/range.comment.d.ts

@@ -0,0 +1,26 @@
+import type { Range } from "../range.model.ts";
+import { CreateRangeChange, DropRangeChange } from "./range.base.ts";
+/**
+ * Create/drop comments on range types.
+ */
+export type CommentRange = CreateCommentOnRange | DropCommentOnRange;
+export declare class CreateCommentOnRange extends CreateRangeChange {
+    readonly range: Range;
+    readonly scope: "comment";
+    constructor(props: {
+        range: Range;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `type:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnRange extends DropRangeChange {
+    readonly range: Range;
+    readonly scope: "comment";
+    constructor(props: {
+        range: Range;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`comment:${string}` | `type:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/type/range/changes/range.comment.js

@@ -0,0 +1,47 @@
+import { quoteLiteral } from "../../../base.change.js";
+import { stableId } from "../../../utils.js";
+import { CreateRangeChange, DropRangeChange } from "./range.base.js";
+export class CreateCommentOnRange extends CreateRangeChange {
+    range;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.range = props.range;
+    }
+    get creates() {
+        return [stableId.comment(this.range.stableId)];
+    }
+    get requires() {
+        return [this.range.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON TYPE",
+            `${this.range.schema}.${this.range.name}`,
+            "IS",
+            // biome-ignore lint/style/noNonNullAssertion: range comment is not nullable in this case
+            quoteLiteral(this.range.comment),
+        ].join(" ");
+    }
+}
+export class DropCommentOnRange extends DropRangeChange {
+    range;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.range = props.range;
+    }
+    get drops() {
+        return [stableId.comment(this.range.stableId)];
+    }
+    get requires() {
+        return [stableId.comment(this.range.stableId), this.range.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON TYPE",
+            `${this.range.schema}.${this.range.name}`,
+            "IS NULL",
+        ].join(" ");
+    }
+}

package/dist/core/objects/type/range/changes/range.create.d.ts

@@ -0,0 +1,31 @@
+import type { Range } from "../range.model.ts";
+import { CreateRangeChange } from "./range.base.ts";
+/**
+ * Create a range type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createtype.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE TYPE name AS RANGE (
+ *   SUBTYPE = subtype
+ *   [ , SUBTYPE_OPCLASS = subtype_operator_class ]
+ *   [ , COLLATION = collation ]
+ *   [ , CANONICAL = canonical_function ]
+ *   [ , SUBTYPE_DIFF = subtype_diff_function ]
+ * )
+ * ```
+ *
+ * Notes
+ * - Only non-default options are emitted in the generated SQL.
+ */
+export declare class CreateRange extends CreateRangeChange {
+    readonly range: Range;
+    readonly scope: "object";
+    constructor(props: {
+        range: Range;
+    });
+    get creates(): `type:${string}`[];
+    get requires(): string[];
+    serialize(): string;
+}

package/dist/core/objects/type/range/changes/range.create.js

@@ -0,0 +1,113 @@
+import { isUserDefinedTypeSchema, parseProcedureReference, stableId, } from "../../../utils.js";
+import { CreateRangeChange } from "./range.base.js";
+/**
+ * Create a range type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createtype.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE TYPE name AS RANGE (
+ *   SUBTYPE = subtype
+ *   [ , SUBTYPE_OPCLASS = subtype_operator_class ]
+ *   [ , COLLATION = collation ]
+ *   [ , CANONICAL = canonical_function ]
+ *   [ , SUBTYPE_DIFF = subtype_diff_function ]
+ * )
+ * ```
+ *
+ * Notes
+ * - Only non-default options are emitted in the generated SQL.
+ */
+export class CreateRange extends CreateRangeChange {
+    range;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.range = props.range;
+    }
+    get creates() {
+        return [this.range.stableId];
+    }
+    get requires() {
+        const dependencies = new Set();
+        // Schema dependency
+        dependencies.add(stableId.schema(this.range.schema));
+        // Owner dependency
+        dependencies.add(stableId.role(this.range.owner));
+        // Subtype dependency (if user-defined)
+        if (this.range.subtype_schema &&
+            isUserDefinedTypeSchema(this.range.subtype_schema)) {
+            // subtype_str is the type name without schema (e.g., "integer", "text")
+            // subtype_schema is the schema name
+            dependencies.add(stableId.type(this.range.subtype_schema, this.range.subtype_str));
+        }
+        // Canonical function dependency
+        if (this.range.canonical_function_schema &&
+            this.range.canonical_function_name) {
+            const procRef = parseProcedureReference(`${this.range.canonical_function_schema}.${this.range.canonical_function_name}()`);
+            if (procRef) {
+                dependencies.add(stableId.procedure(procRef.schema, procRef.name));
+            }
+        }
+        // Subtype diff function dependency
+        if (this.range.subtype_diff_schema && this.range.subtype_diff_name) {
+            const procRef = parseProcedureReference(`${this.range.subtype_diff_schema}.${this.range.subtype_diff_name}()`);
+            if (procRef) {
+                dependencies.add(stableId.procedure(procRef.schema, procRef.name));
+            }
+        }
+        // Collation dependency (if non-default and user-defined)
+        if (this.range.collation) {
+            const unquotedCollation = this.range.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 name = `${this.range.schema}.${this.range.name}`;
+        const prefix = ["CREATE TYPE", name, "AS RANGE"].join(" ");
+        const opts = [];
+        // Required subtype
+        const subtypeQualified = this.range.subtype_schema && this.range.subtype_schema !== "pg_catalog"
+            ? `${this.range.subtype_schema}.${this.range.subtype_str}`
+            : this.range.subtype_str;
+        opts.push(`SUBTYPE = ${subtypeQualified}`);
+        // Optional opclass
+        if (this.range.subtype_opclass_name) {
+            const opclassQualified = this.range.subtype_opclass_schema &&
+                this.range.subtype_opclass_schema !== "pg_catalog"
+                ? `${this.range.subtype_opclass_schema}.${this.range.subtype_opclass_name}`
+                : this.range.subtype_opclass_name;
+            opts.push(`SUBTYPE_OPCLASS = ${opclassQualified}`);
+        }
+        // Optional collation
+        if (this.range.collation) {
+            opts.push(`COLLATION = ${this.range.collation}`);
+        }
+        // Optional canonical function
+        if (this.range.canonical_function_name) {
+            const canonQualified = this.range.canonical_function_schema &&
+                this.range.canonical_function_schema !== "pg_catalog"
+                ? `${this.range.canonical_function_schema}.${this.range.canonical_function_name}`
+                : this.range.canonical_function_name;
+            opts.push(`CANONICAL = ${canonQualified}`);
+        }
+        // Optional subtype diff function
+        if (this.range.subtype_diff_name) {
+            const diffQualified = this.range.subtype_diff_schema &&
+                this.range.subtype_diff_schema !== "pg_catalog"
+                ? `${this.range.subtype_diff_schema}.${this.range.subtype_diff_name}`
+                : this.range.subtype_diff_name;
+            opts.push(`SUBTYPE_DIFF = ${diffQualified}`);
+        }
+        const body = `(${opts.join(", ")})`;
+        return `${prefix} ${body}`;
+    }
+}

package/dist/core/objects/type/range/changes/range.drop.d.ts

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

package/dist/core/objects/type/range/changes/range.drop.js

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

package/dist/core/objects/type/range/changes/range.privilege.d.ts

@@ -0,0 +1,97 @@
+import type { Range } from "../range.model.ts";
+import { AlterRangeChange } from "./range.base.ts";
+export type RangePrivilege = GrantRangePrivileges | RevokeRangePrivileges | RevokeGrantOptionRangePrivileges;
+/**
+ * Grant privileges on a range type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { USAGE | ALL [ PRIVILEGES ] }
+ *    ON TYPE type_name [, ...]
+ *    TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *    [ GRANTED BY role_specification ]
+ * ```
+ */
+export declare class GrantRangePrivileges extends AlterRangeChange {
+    readonly range: Range;
+    readonly grantee: string;
+    readonly privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        range: Range;
+        grantee: string;
+        privileges: {
+            privilege: string;
+            grantable: boolean;
+        }[];
+        version?: number;
+    });
+    get creates(): `acl:${string}::grantee:${string}`[];
+    get requires(): (`role:${string}` | `type:${string}`)[];
+    serialize(): string;
+}
+/**
+ * Revoke privileges on a range type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { USAGE | ALL [ PRIVILEGES ] }
+ *     ON TYPE type_name [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export declare class RevokeRangePrivileges extends AlterRangeChange {
+    readonly range: Range;
+    readonly grantee: string;
+    readonly privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        range: Range;
+        grantee: string;
+        privileges: {
+            privilege: string;
+            grantable: boolean;
+        }[];
+        version?: number;
+    });
+    get drops(): `acl:${string}::grantee:${string}`[];
+    get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `type:${string}`)[];
+    serialize(): string;
+}
+/**
+ * Revoke grant option for privileges on a range type.
+ *
+ * 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 RevokeGrantOptionRangePrivileges extends AlterRangeChange {
+    readonly range: Range;
+    readonly grantee: string;
+    readonly privilegeNames: string[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        range: Range;
+        grantee: string;
+        privilegeNames: string[];
+        version?: number;
+    });
+    get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `type:${string}`)[];
+    serialize(): string;
+}

package/dist/core/objects/type/range/changes/range.privilege.js

@@ -0,0 +1,131 @@
+import { formatObjectPrivilegeList, getObjectKindPrefix, } from "../../../base.privilege.js";
+import { stableId } from "../../../utils.js";
+import { AlterRangeChange } from "./range.base.js";
+/**
+ * Grant privileges on a range type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { USAGE | ALL [ PRIVILEGES ] }
+ *    ON TYPE type_name [, ...]
+ *    TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *    [ GRANTED BY role_specification ]
+ * ```
+ */
+export class GrantRangePrivileges extends AlterRangeChange {
+    range;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.range = props.range;
+        this.grantee = props.grantee;
+        this.privileges = props.privileges;
+        this.version = props.version;
+    }
+    get creates() {
+        return [stableId.acl(this.range.stableId, this.grantee)];
+    }
+    get requires() {
+        return [this.range.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("GrantRangePrivileges expects privileges with uniform grantable flag");
+        }
+        const withGrant = hasGrantable ? " WITH GRANT OPTION" : "";
+        const kindPrefix = getObjectKindPrefix("TYPE");
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList("TYPE", list, this.version);
+        const typeName = `${this.range.schema}.${this.range.name}`;
+        return `GRANT ${privSql} ${kindPrefix} ${typeName} TO ${this.grantee}${withGrant}`;
+    }
+}
+/**
+ * Revoke privileges on a range type.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { USAGE | ALL [ PRIVILEGES ] }
+ *     ON TYPE type_name [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class RevokeRangePrivileges extends AlterRangeChange {
+    range;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.range = props.range;
+        this.grantee = props.grantee;
+        this.privileges = props.privileges;
+        this.version = props.version;
+    }
+    get drops() {
+        // Return ACL ID for dependency tracking, even though this is an ALTER operation
+        // Phase assignment now uses operation type, so this won't affect phase placement
+        return [stableId.acl(this.range.stableId, this.grantee)];
+    }
+    get requires() {
+        return [
+            stableId.acl(this.range.stableId, this.grantee),
+            this.range.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const kindPrefix = getObjectKindPrefix("TYPE");
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList("TYPE", list, this.version);
+        const typeName = `${this.range.schema}.${this.range.name}`;
+        return `REVOKE ${privSql} ${kindPrefix} ${typeName} FROM ${this.grantee}`;
+    }
+}
+/**
+ * Revoke grant option for privileges on a range type.
+ *
+ * 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 RevokeGrantOptionRangePrivileges extends AlterRangeChange {
+    range;
+    grantee;
+    privilegeNames;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.range = props.range;
+        this.grantee = props.grantee;
+        this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+        this.version = props.version;
+    }
+    get requires() {
+        return [
+            stableId.acl(this.range.stableId, this.grantee),
+            this.range.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const kindPrefix = getObjectKindPrefix("TYPE");
+        const privSql = formatObjectPrivilegeList("TYPE", this.privilegeNames, this.version);
+        const typeName = `${this.range.schema}.${this.range.name}`;
+        return `REVOKE GRANT OPTION FOR ${privSql} ${kindPrefix} ${typeName} FROM ${this.grantee}`;
+    }
+}

package/dist/core/objects/type/range/changes/range.types.d.ts

@@ -0,0 +1,6 @@
+import type { AlterRange } from "./range.alter.ts";
+import type { CommentRange } from "./range.comment.ts";
+import type { CreateRange } from "./range.create.ts";
+import type { DropRange } from "./range.drop.ts";
+import type { RangePrivilege } from "./range.privilege.ts";
+export type RangeChange = AlterRange | CommentRange | CreateRange | DropRange | RangePrivilege;

package/dist/core/objects/type/range/changes/range.types.js

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

package/dist/core/objects/type/range/range.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 { RangeChange } from "./changes/range.types.ts";
+import type { Range } from "./range.model.ts";
+/**
+ * Diff two sets of range types from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The ranges in the main catalog.
+ * @param branch - The ranges in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export declare function diffRanges(ctx: {
+    version: number;
+    currentUser: string;
+    defaultPrivilegeState: DefaultPrivilegeState;
+    mainRoles: Record<string, Role>;
+}, main: Record<string, Range>, branch: Record<string, Range>): RangeChange[];