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

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

@@ -0,0 +1,32 @@
+import type { Language } from "../language.model.ts";
+import { AlterLanguageChange } from "./language.base.ts";
+/**
+ * Alter a language.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterlanguage.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER [ PROCEDURAL ] LANGUAGE name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ * ALTER [ PROCEDURAL ] LANGUAGE name RENAME TO new_name
+ * ```
+ */
+export type AlterLanguage = AlterLanguageChangeOwner;
+/**
+ * ALTER LANGUAGE ... OWNER TO ...
+ */
+export declare class AlterLanguageChangeOwner extends AlterLanguageChange {
+    readonly language: Language;
+    readonly owner: string;
+    readonly scope: "object";
+    constructor(props: {
+        language: Language;
+        owner: string;
+    });
+    get requires(): `language:${string}`[];
+    serialize(): string;
+}
+/**
+ * Replace a language.
+ * This is used when properties that cannot be altered via ALTER LANGUAGE change.
+ */

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

@@ -0,0 +1,30 @@
+import { AlterLanguageChange } from "./language.base.js";
+/**
+ * ALTER LANGUAGE ... OWNER TO ...
+ */
+export class AlterLanguageChangeOwner extends AlterLanguageChange {
+    language;
+    owner;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.language = props.language;
+        this.owner = props.owner;
+    }
+    get requires() {
+        return [this.language.stableId];
+    }
+    serialize() {
+        const parts = ["ALTER"];
+        // Do not print the optional PROCEDURAL keyword.
+        // It is syntactic noise and the default for procedural languages,
+        // so we purposely omit it to avoid emitting defaults.
+        parts.push("LANGUAGE", this.language.name, "OWNER TO", this.owner);
+        return parts.join(" ");
+    }
+}
+/**
+ * Replace a language.
+ * This is used when properties that cannot be altered via ALTER LANGUAGE change.
+ */
+// NOTE: ReplaceLanguage removed. Non-alterable changes are emitted as Drop + Create in language.diff.ts.

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

@@ -0,0 +1,17 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Language } from "../language.model.ts";
+declare abstract class BaseLanguageChange extends BaseChange {
+    abstract readonly language: Language;
+    abstract readonly scope: "object" | "comment" | "privilege";
+    readonly objectType: "language";
+}
+export declare abstract class CreateLanguageChange extends BaseLanguageChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterLanguageChange extends BaseLanguageChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropLanguageChange extends BaseLanguageChange {
+    readonly operation: "drop";
+}
+export {};

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

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../base.change.js";
+class BaseLanguageChange extends BaseChange {
+    objectType = "language";
+}
+export class CreateLanguageChange extends BaseLanguageChange {
+    operation = "create";
+}
+export class AlterLanguageChange extends BaseLanguageChange {
+    operation = "alter";
+}
+export class DropLanguageChange extends BaseLanguageChange {
+    operation = "drop";
+}

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

@@ -0,0 +1,26 @@
+import type { Language } from "../language.model.ts";
+import { CreateLanguageChange, DropLanguageChange } from "./language.base.ts";
+export type CommentLanguage = CreateCommentOnLanguage | DropCommentOnLanguage;
+/**
+ * Create/drop comments on languages.
+ */
+export declare class CreateCommentOnLanguage extends CreateLanguageChange {
+    readonly language: Language;
+    readonly scope: "comment";
+    constructor(props: {
+        language: Language;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `language:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnLanguage extends DropLanguageChange {
+    readonly language: Language;
+    readonly scope: "comment";
+    constructor(props: {
+        language: Language;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`comment:${string}` | `language:${string}`)[];
+    serialize(): string;
+}

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

@@ -0,0 +1,45 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateLanguageChange, DropLanguageChange } from "./language.base.js";
+/**
+ * Create/drop comments on languages.
+ */
+export class CreateCommentOnLanguage extends CreateLanguageChange {
+    language;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.language = props.language;
+    }
+    get creates() {
+        return [stableId.comment(this.language.stableId)];
+    }
+    get requires() {
+        return [this.language.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON LANGUAGE",
+            this.language.name,
+            "IS",
+            quoteLiteral(this.language.comment),
+        ].join(" ");
+    }
+}
+export class DropCommentOnLanguage extends DropLanguageChange {
+    language;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.language = props.language;
+    }
+    get drops() {
+        return [stableId.comment(this.language.stableId)];
+    }
+    get requires() {
+        return [stableId.comment(this.language.stableId), this.language.stableId];
+    }
+    serialize() {
+        return ["COMMENT ON LANGUAGE", this.language.name, "IS NULL"].join(" ");
+    }
+}

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

@@ -0,0 +1,25 @@
+import type { Language } from "../language.model.ts";
+import { CreateLanguageChange } from "./language.base.ts";
+/**
+ * Create a language.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createlanguage.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE [ OR REPLACE ] [ TRUSTED ] [ PROCEDURAL ] LANGUAGE name
+ * [ HANDLER call_handler [ INLINE inline_handler ] [ VALIDATOR valfunction ] ]
+ * ```
+ */
+export declare class CreateLanguage extends CreateLanguageChange {
+    readonly language: Language;
+    readonly orReplace?: boolean;
+    readonly scope: "object";
+    constructor(props: {
+        language: Language;
+        orReplace?: boolean;
+    });
+    get creates(): `language:${string}`[];
+    get requires(): string[];
+    serialize(): string;
+}

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

@@ -0,0 +1,76 @@
+import { parseProcedureReference, stableId } from "../../utils.js";
+import { CreateLanguageChange } from "./language.base.js";
+/**
+ * Create a language.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createlanguage.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE [ OR REPLACE ] [ TRUSTED ] [ PROCEDURAL ] LANGUAGE name
+ * [ HANDLER call_handler [ INLINE inline_handler ] [ VALIDATOR valfunction ] ]
+ * ```
+ */
+export class CreateLanguage extends CreateLanguageChange {
+    language;
+    orReplace;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.language = props.language;
+        this.orReplace = props.orReplace;
+    }
+    get creates() {
+        return [this.language.stableId];
+    }
+    get requires() {
+        const dependencies = new Set();
+        // Owner dependency
+        dependencies.add(stableId.role(this.language.owner));
+        // Call handler function dependency
+        if (this.language.call_handler) {
+            const callHandlerProc = parseProcedureReference(this.language.call_handler);
+            if (callHandlerProc) {
+                dependencies.add(stableId.procedure(callHandlerProc.schema, callHandlerProc.name));
+            }
+        }
+        // Inline handler function dependency
+        if (this.language.inline_handler) {
+            const inlineHandlerProc = parseProcedureReference(this.language.inline_handler);
+            if (inlineHandlerProc) {
+                dependencies.add(stableId.procedure(inlineHandlerProc.schema, inlineHandlerProc.name));
+            }
+        }
+        // Validator function dependency
+        if (this.language.validator) {
+            const validatorProc = parseProcedureReference(this.language.validator);
+            if (validatorProc) {
+                dependencies.add(stableId.procedure(validatorProc.schema, validatorProc.name));
+            }
+        }
+        return Array.from(dependencies);
+    }
+    serialize() {
+        const parts = [`CREATE${this.orReplace ? " OR REPLACE" : ""}`];
+        // Only include non-default flags. We never print the optional
+        // PROCEDURAL keyword or any defaults.
+        // TRUSTED keyword (default is untrusted -> omitted unless true)
+        if (this.language.is_trusted) {
+            parts.push("TRUSTED");
+        }
+        parts.push("LANGUAGE", this.language.name);
+        // HANDLER (omit when null)
+        if (this.language.call_handler) {
+            parts.push("HANDLER", this.language.call_handler);
+        }
+        // INLINE (omit when null)
+        if (this.language.inline_handler) {
+            parts.push("INLINE", this.language.inline_handler);
+        }
+        // VALIDATOR (omit when null)
+        if (this.language.validator) {
+            parts.push("VALIDATOR", this.language.validator);
+        }
+        return parts.join(" ");
+    }
+}

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

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

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

@@ -0,0 +1,31 @@
+import { DropLanguageChange } from "./language.base.js";
+/**
+ * Drop a language.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-droplanguage.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP [ PROCEDURAL ] LANGUAGE [ IF EXISTS ] name [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropLanguage extends DropLanguageChange {
+    language;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.language = props.language;
+    }
+    get drops() {
+        return [this.language.stableId];
+    }
+    get requires() {
+        return [this.language.stableId];
+    }
+    serialize() {
+        const parts = ["DROP"];
+        // Do not print optional keywords (e.g., PROCEDURAL). Keep the statement minimal.
+        parts.push("LANGUAGE", this.language.name);
+        return parts.join(" ");
+    }
+}

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

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

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

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

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

@@ -0,0 +1,6 @@
+import type { AlterLanguage } from "./language.alter.ts";
+import type { CommentLanguage } from "./language.comment.ts";
+import type { CreateLanguage } from "./language.create.ts";
+import type { DropLanguage } from "./language.drop.ts";
+import type { LanguagePrivilege } from "./language.privilege.ts";
+export type LanguageChange = AlterLanguage | CommentLanguage | CreateLanguage | DropLanguage | LanguagePrivilege;

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

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

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

@@ -0,0 +1,15 @@
+import type { Change } from "../../change.types.ts";
+import type { Role } from "../role/role.model.ts";
+import type { Language } from "./language.model.ts";
+/**
+ * Diff two sets of languages from main and branch catalogs.
+ *
+ * @param ctx - Context containing version information.
+ * @param main - The languages in the main catalog.
+ * @param branch - The languages in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export declare function diffLanguages(ctx: {
+    version: number;
+    mainRoles?: Record<string, Role>;
+}, main: Record<string, Language>, branch: Record<string, Language>): Change[];