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

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

@@ -0,0 +1,47 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateDomainChange, DropDomainChange } from "./domain.base.js";
+/**
+ * Create/drop comments on domains.
+ */
+export class CreateCommentOnDomain extends CreateDomainChange {
+    domain;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.domain = props.domain;
+    }
+    get creates() {
+        return [stableId.comment(this.domain.stableId)];
+    }
+    get requires() {
+        return [this.domain.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON DOMAIN",
+            `${this.domain.schema}.${this.domain.name}`,
+            "IS",
+            // biome-ignore lint/style/noNonNullAssertion: domain comment is not nullable in this case
+            quoteLiteral(this.domain.comment),
+        ].join(" ");
+    }
+}
+export class DropCommentOnDomain extends DropDomainChange {
+    domain;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.domain = props.domain;
+    }
+    get requires() {
+        return [stableId.comment(this.domain.stableId), this.domain.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON DOMAIN",
+            `${this.domain.schema}.${this.domain.name}`,
+            "IS NULL",
+        ].join(" ");
+    }
+}

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

@@ -0,0 +1,30 @@
+import type { Domain } from "../domain.model.ts";
+import { CreateDomainChange } from "./domain.base.ts";
+/**
+ * Create a domain.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createdomain.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE DOMAIN name [ AS ] data_type
+ * [ COLLATE collation ]
+ * [ DEFAULT expression ]
+ * [ domain_constraint [ ... ] ]
+ *
+ * where domain_constraint is:
+ *
+ * [ CONSTRAINT constraint_name ]
+ * { NOT NULL | NULL | CHECK (expression) }
+ * ```
+ */
+export declare class CreateDomain extends CreateDomainChange {
+    readonly domain: Domain;
+    readonly scope: "object";
+    constructor(props: {
+        domain: Domain;
+    });
+    get creates(): `domain:${string}`[];
+    get requires(): string[];
+    serialize(): string;
+}

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

@@ -0,0 +1,92 @@
+import { isUserDefinedTypeSchema, stableId } from "../../utils.js";
+import { CreateDomainChange } from "./domain.base.js";
+/**
+ * Create a domain.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createdomain.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE DOMAIN name [ AS ] data_type
+ * [ COLLATE collation ]
+ * [ DEFAULT expression ]
+ * [ domain_constraint [ ... ] ]
+ *
+ * where domain_constraint is:
+ *
+ * [ CONSTRAINT constraint_name ]
+ * { NOT NULL | NULL | CHECK (expression) }
+ * ```
+ */
+export class CreateDomain extends CreateDomainChange {
+    domain;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.domain = props.domain;
+    }
+    get creates() {
+        return [this.domain.stableId];
+    }
+    get requires() {
+        const dependencies = new Set();
+        // Schema dependency
+        dependencies.add(stableId.schema(this.domain.schema));
+        // Owner dependency
+        dependencies.add(stableId.role(this.domain.owner));
+        // Base type dependency (if user-defined)
+        if (this.domain.base_type_schema &&
+            isUserDefinedTypeSchema(this.domain.base_type_schema)) {
+            dependencies.add(stableId.type(this.domain.base_type_schema, this.domain.base_type));
+        }
+        // Collation dependency (if non-default and user-defined)
+        if (this.domain.collation) {
+            const unquotedCollation = this.domain.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 = [];
+        // Schema-qualified name
+        const domainName = `${this.domain.schema}.${this.domain.name}`;
+        // Base type (use formatted string for type+typmod and add schema if needed)
+        let baseType = this.domain.base_type_str;
+        if (this.domain.base_type_schema &&
+            this.domain.base_type_schema !== "pg_catalog") {
+            baseType = `${this.domain.base_type_schema}.${baseType}`;
+        }
+        // Array dimensions
+        if (this.domain.array_dimensions && this.domain.array_dimensions > 0) {
+            baseType += "[]".repeat(this.domain.array_dimensions);
+        }
+        parts.push(`CREATE DOMAIN ${domainName} AS ${baseType}`);
+        // Collation
+        if (this.domain.collation) {
+            parts.push(`COLLATE ${this.domain.collation}`);
+        }
+        // Default value
+        if (this.domain.default_value) {
+            parts.push(`DEFAULT ${this.domain.default_value}`);
+        }
+        // NOT NULL constraint
+        if (this.domain.not_null) {
+            parts.push("NOT NULL");
+        }
+        // Inline CHECK constraints that are already validated
+        if (this.domain.constraints && this.domain.constraints.length > 0) {
+            for (const c of this.domain.constraints) {
+                if (c.check_expression && c.validated !== false) {
+                    parts.push(`CHECK (${c.check_expression})`);
+                }
+            }
+        }
+        return parts.join(" ");
+    }
+}

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

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

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

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

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

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

package/dist/core/objects/domain/changes/domain.privilege.js

@@ -0,0 +1,127 @@
+import { formatObjectPrivilegeList, getObjectKindPrefix, } from "../../base.privilege.js";
+import { stableId } from "../../utils.js";
+import { AlterDomainChange } from "./domain.base.js";
+/**
+ * Grant privileges on a domain.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { USAGE | ALL [ PRIVILEGES ] }
+ *    ON DOMAIN domain_name [, ...]
+ *    TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *    [ GRANTED BY role_specification ]
+ * ```
+ */
+export class GrantDomainPrivileges extends AlterDomainChange {
+    domain;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.domain = props.domain;
+        this.grantee = props.grantee;
+        this.privileges = props.privileges;
+        this.version = props.version;
+    }
+    get creates() {
+        return [stableId.acl(this.domain.stableId, this.grantee)];
+    }
+    get requires() {
+        return [this.domain.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("GrantDomainPrivileges expects privileges with uniform grantable flag");
+        }
+        const withGrant = hasGrantable ? " WITH GRANT OPTION" : "";
+        const kindPrefix = getObjectKindPrefix("DOMAIN");
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList("DOMAIN", list, this.version);
+        const domainName = `${this.domain.schema}.${this.domain.name}`;
+        return `GRANT ${privSql} ${kindPrefix} ${domainName} TO ${this.grantee}${withGrant}`;
+    }
+}
+/**
+ * Revoke privileges on a domain.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { USAGE | ALL [ PRIVILEGES ] }
+ *     ON DOMAIN domain_name [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class RevokeDomainPrivileges extends AlterDomainChange {
+    domain;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.domain = props.domain;
+        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.domain.stableId, this.grantee)];
+    }
+    get requires() {
+        return [this.domain.stableId, stableId.role(this.grantee)];
+    }
+    serialize() {
+        const kindPrefix = getObjectKindPrefix("DOMAIN");
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList("DOMAIN", list, this.version);
+        const domainName = `${this.domain.schema}.${this.domain.name}`;
+        return `REVOKE ${privSql} ${kindPrefix} ${domainName} FROM ${this.grantee}`;
+    }
+}
+/**
+ * Revoke grant option for privileges on a domain.
+ *
+ * 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 RevokeGrantOptionDomainPrivileges extends AlterDomainChange {
+    domain;
+    grantee;
+    privilegeNames;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.domain = props.domain;
+        this.grantee = props.grantee;
+        this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+        this.version = props.version;
+    }
+    get requires() {
+        return [
+            this.domain.stableId,
+            stableId.role(this.grantee),
+            stableId.acl(this.domain.stableId, this.grantee),
+        ];
+    }
+    serialize() {
+        const kindPrefix = getObjectKindPrefix("DOMAIN");
+        const privSql = formatObjectPrivilegeList("DOMAIN", this.privilegeNames, this.version);
+        const domainName = `${this.domain.schema}.${this.domain.name}`;
+        return `REVOKE GRANT OPTION FOR ${privSql} ${kindPrefix} ${domainName} FROM ${this.grantee}`;
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { AlterDomain } from "./domain.alter.ts";
+import type { CommentDomain } from "./domain.comment.ts";
+import type { CreateDomain } from "./domain.create.ts";
+import type { DropDomain } from "./domain.drop.ts";
+import type { DomainPrivilege } from "./domain.privilege.ts";
+export type DomainChange = AlterDomain | CommentDomain | CreateDomain | DropDomain | DomainPrivilege;

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

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

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