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

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

@@ -0,0 +1,42 @@
+import type { Procedure } from "../procedure.model.ts";
+import { CreateProcedureChange } from "./procedure.base.ts";
+/**
+ * Create a procedure.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createfunction.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE [ OR REPLACE ] FUNCTION
+ *     name ( [ [ argmode ] [ argname ] argtype [ { DEFAULT | = } default_expr ] [, ...] ] )
+ *     [ RETURNS rettype
+ *       | RETURNS TABLE ( column_name column_type [, ...] ) ]
+ *     { LANGUAGE lang_name
+ *       | TRANSFORM { FOR TYPE type_name } [, ... ]
+ *       | WINDOW
+ *       | IMMUTABLE | STABLE | VOLATILE | [ NOT ] LEAKPROOF
+ *       | CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT
+ *       | [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
+ *       | PARALLEL { UNSAFE | RESTRICTED | SAFE }
+ *       | COST execution_cost
+ *       | ROWS result_rows
+ *       | SUPPORT support_function
+ *       | SET configuration_parameter { TO value | = value | FROM CURRENT }
+ *       | AS 'definition'
+ *       | AS 'obj_file', 'link_symbol'
+ *       | sql_body
+ *     } ...
+ * ```
+ */
+export declare class CreateProcedure extends CreateProcedureChange {
+    readonly procedure: Procedure;
+    readonly orReplace: boolean;
+    readonly scope: "object";
+    constructor(props: {
+        procedure: Procedure;
+        orReplace?: boolean;
+    });
+    get creates(): `procedure:${string}`[];
+    get requires(): string[];
+    serialize(): string;
+}

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

@@ -0,0 +1,77 @@
+import { parseTypeString, stableId } from "../../utils.js";
+import { CreateProcedureChange } from "./procedure.base.js";
+/**
+ * Create a procedure.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createfunction.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE [ OR REPLACE ] FUNCTION
+ *     name ( [ [ argmode ] [ argname ] argtype [ { DEFAULT | = } default_expr ] [, ...] ] )
+ *     [ RETURNS rettype
+ *       | RETURNS TABLE ( column_name column_type [, ...] ) ]
+ *     { LANGUAGE lang_name
+ *       | TRANSFORM { FOR TYPE type_name } [, ... ]
+ *       | WINDOW
+ *       | IMMUTABLE | STABLE | VOLATILE | [ NOT ] LEAKPROOF
+ *       | CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT
+ *       | [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
+ *       | PARALLEL { UNSAFE | RESTRICTED | SAFE }
+ *       | COST execution_cost
+ *       | ROWS result_rows
+ *       | SUPPORT support_function
+ *       | SET configuration_parameter { TO value | = value | FROM CURRENT }
+ *       | AS 'definition'
+ *       | AS 'obj_file', 'link_symbol'
+ *       | sql_body
+ *     } ...
+ * ```
+ */
+export class CreateProcedure extends CreateProcedureChange {
+    procedure;
+    orReplace;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.procedure = props.procedure;
+        this.orReplace = props.orReplace ?? false;
+    }
+    get creates() {
+        return [this.procedure.stableId];
+    }
+    get requires() {
+        const dependencies = new Set();
+        // Schema dependency
+        dependencies.add(stableId.schema(this.procedure.schema));
+        // Owner dependency
+        dependencies.add(stableId.role(this.procedure.owner));
+        // Language dependency (if user-defined)
+        // Note: Most languages are built-in (plpgsql, sql, etc.), but custom languages
+        // can be created. We can't reliably determine if a language is user-defined
+        // from just the name, so we rely on pg_depend for language dependencies.
+        // Return type dependency (if user-defined)
+        const returnType = parseTypeString(this.procedure.return_type);
+        if (returnType) {
+            dependencies.add(stableId.type(returnType.schema, returnType.name));
+        }
+        // Argument type dependencies (if user-defined)
+        if (this.procedure.argument_types) {
+            for (const argType of this.procedure.argument_types) {
+                const parsedType = parseTypeString(argType);
+                if (parsedType) {
+                    dependencies.add(stableId.type(parsedType.schema, parsedType.name));
+                }
+            }
+        }
+        return Array.from(dependencies);
+    }
+    serialize() {
+        // Use the server-generated CREATE statement for functions/procedures
+        // Normalize trailing semicolon and OR REPLACE clause according to flag
+        let definition = this.procedure.definition.trim();
+        definition = definition.replace(/;\s*$/, "");
+        definition = definition.replace(/^CREATE\s+(?:OR\s+REPLACE\s+)?/i, `CREATE ${this.orReplace ? "OR REPLACE " : ""}`);
+        return definition;
+    }
+}

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

@@ -0,0 +1,23 @@
+import type { Procedure } from "../procedure.model.ts";
+import { DropProcedureChange } from "./procedure.base.ts";
+/**
+ * Drop a procedure.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropfunction.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP FUNCTION [ IF EXISTS ] name ( [ [ argmode ] [ argname ] argtype [, ...] ] ) [, ...] [ CASCADE | RESTRICT ]
+ * DROP PROCEDURE [ IF EXISTS ] name ( [ [ argmode ] [ argname ] argtype [, ...] ] ) [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export declare class DropProcedure extends DropProcedureChange {
+    readonly procedure: Procedure;
+    readonly scope: "object";
+    constructor(props: {
+        procedure: Procedure;
+    });
+    get drops(): `procedure:${string}`[];
+    get requires(): `procedure:${string}`[];
+    serialize(): string;
+}

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

@@ -0,0 +1,37 @@
+import { formatFunctionArguments } from "../utils.js";
+import { DropProcedureChange } from "./procedure.base.js";
+/**
+ * Drop a procedure.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropfunction.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP FUNCTION [ IF EXISTS ] name ( [ [ argmode ] [ argname ] argtype [, ...] ] ) [, ...] [ CASCADE | RESTRICT ]
+ * DROP PROCEDURE [ IF EXISTS ] name ( [ [ argmode ] [ argname ] argtype [, ...] ] ) [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropProcedure extends DropProcedureChange {
+    procedure;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.procedure = props.procedure;
+    }
+    get drops() {
+        return [this.procedure.stableId];
+    }
+    get requires() {
+        return [this.procedure.stableId];
+    }
+    serialize() {
+        const objectType = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+        // Build argument list
+        const args = formatFunctionArguments(this.procedure.argument_names, this.procedure.argument_types, this.procedure.argument_modes);
+        return [
+            "DROP",
+            objectType,
+            `${this.procedure.schema}.${this.procedure.name}(${args})`,
+        ].join(" ");
+    }
+}

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

@@ -0,0 +1,98 @@
+import type { Procedure } from "../procedure.model.ts";
+import { AlterProcedureChange } from "./procedure.base.ts";
+export type ProcedurePrivilege = GrantProcedurePrivileges | RevokeProcedurePrivileges | RevokeGrantOptionProcedurePrivileges;
+/**
+ * Grant privileges on a procedure.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { EXECUTE | ALL [ PRIVILEGES ] }
+ *    ON { { FUNCTION | PROCEDURE | ROUTINE } routine_name [ ( [ [ argmode ] [ arg_name ] arg_type [, ...] ] ) ] [, ...]
+ *         | ALL { FUNCTIONS | PROCEDURES | ROUTINES } IN SCHEMA schema_name [, ...] }
+ *    TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *    [ GRANTED BY role_specification ]
+ * ```
+ */
+export declare class GrantProcedurePrivileges extends AlterProcedureChange {
+    readonly procedure: Procedure;
+    readonly grantee: string;
+    readonly privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        procedure: Procedure;
+        grantee: string;
+        privileges: {
+            privilege: string;
+            grantable: boolean;
+        }[];
+        version?: number;
+    });
+    get creates(): `acl:${string}::grantee:${string}`[];
+    get requires(): (`role:${string}` | `procedure:${string}`)[];
+    serialize(): string;
+}
+/**
+ * Revoke privileges on a procedure.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { { EXECUTE | ALL [ PRIVILEGES ] } }
+ *     ON { FUNCTION | PROCEDURE | ROUTINE } routine_name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export declare class RevokeProcedurePrivileges extends AlterProcedureChange {
+    readonly procedure: Procedure;
+    readonly grantee: string;
+    readonly privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        procedure: Procedure;
+        grantee: string;
+        privileges: {
+            privilege: string;
+            grantable: boolean;
+        }[];
+        version?: number;
+    });
+    get drops(): `acl:${string}::grantee:${string}`[];
+    get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `procedure:${string}`)[];
+    serialize(): string;
+}
+/**
+ * Revoke grant option for privileges on a procedure.
+ *
+ * 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 RevokeGrantOptionProcedurePrivileges extends AlterProcedureChange {
+    readonly procedure: Procedure;
+    readonly grantee: string;
+    readonly privilegeNames: string[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        procedure: Procedure;
+        grantee: string;
+        privilegeNames: string[];
+        version?: number;
+    });
+    get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `procedure:${string}`)[];
+    serialize(): string;
+}

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

@@ -0,0 +1,144 @@
+import { formatObjectPrivilegeList, getObjectKindPrefix, } from "../../base.privilege.js";
+import { stableId } from "../../utils.js";
+import { AlterProcedureChange } from "./procedure.base.js";
+/**
+ * Grant privileges on a procedure.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { EXECUTE | ALL [ PRIVILEGES ] }
+ *    ON { { FUNCTION | PROCEDURE | ROUTINE } routine_name [ ( [ [ argmode ] [ arg_name ] arg_type [, ...] ] ) ] [, ...]
+ *         | ALL { FUNCTIONS | PROCEDURES | ROUTINES } IN SCHEMA schema_name [, ...] }
+ *    TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *    [ GRANTED BY role_specification ]
+ * ```
+ */
+export class GrantProcedurePrivileges extends AlterProcedureChange {
+    procedure;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.procedure = props.procedure;
+        this.grantee = props.grantee;
+        this.privileges = props.privileges;
+        this.version = props.version;
+    }
+    get creates() {
+        return [stableId.acl(this.procedure.stableId, this.grantee)];
+    }
+    get requires() {
+        return [this.procedure.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("GrantProcedurePrivileges expects privileges with uniform grantable flag");
+        }
+        const withGrant = hasGrantable ? " WITH GRANT OPTION" : "";
+        const objectKind = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+        const kindPrefix = getObjectKindPrefix(objectKind);
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList(objectKind, list, this.version);
+        const procedureName = `${this.procedure.schema}.${this.procedure.name}`;
+        const args = this.procedure.argument_types?.join(", ") ?? "";
+        // Always include parentheses for privilege statements, even for zero-argument procedures/functions
+        const signature = `${procedureName}(${args})`;
+        return `GRANT ${privSql} ${kindPrefix} ${signature} TO ${this.grantee}${withGrant}`;
+    }
+}
+/**
+ * Revoke privileges on a procedure.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { { EXECUTE | ALL [ PRIVILEGES ] } }
+ *     ON { FUNCTION | PROCEDURE | ROUTINE } routine_name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class RevokeProcedurePrivileges extends AlterProcedureChange {
+    procedure;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.procedure = props.procedure;
+        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.procedure.stableId, this.grantee)];
+    }
+    get requires() {
+        return [
+            stableId.acl(this.procedure.stableId, this.grantee),
+            this.procedure.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const objectKind = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+        const kindPrefix = getObjectKindPrefix(objectKind);
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList(objectKind, list, this.version);
+        const procedureName = `${this.procedure.schema}.${this.procedure.name}`;
+        const args = this.procedure.argument_types?.join(", ") ?? "";
+        // Always include parentheses for privilege statements, even for zero-argument procedures/functions
+        const signature = `${procedureName}(${args})`;
+        return `REVOKE ${privSql} ${kindPrefix} ${signature} FROM ${this.grantee}`;
+    }
+}
+/**
+ * Revoke grant option for privileges on a procedure.
+ *
+ * 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 RevokeGrantOptionProcedurePrivileges extends AlterProcedureChange {
+    procedure;
+    grantee;
+    privilegeNames;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.procedure = props.procedure;
+        this.grantee = props.grantee;
+        this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+        this.version = props.version;
+    }
+    get requires() {
+        return [
+            stableId.acl(this.procedure.stableId, this.grantee),
+            this.procedure.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const objectKind = this.procedure.kind === "p" ? "PROCEDURE" : "FUNCTION";
+        const kindPrefix = getObjectKindPrefix(objectKind);
+        const privSql = formatObjectPrivilegeList(objectKind, this.privilegeNames, this.version);
+        const procedureName = `${this.procedure.schema}.${this.procedure.name}`;
+        const args = this.procedure.argument_types?.join(", ") ?? "";
+        // Always include parentheses for privilege statements, even for zero-argument procedures/functions
+        const signature = `${procedureName}(${args})`;
+        return `REVOKE GRANT OPTION FOR ${privSql} ${kindPrefix} ${signature} FROM ${this.grantee}`;
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { AlterProcedure } from "./procedure.alter.ts";
+import type { CommentProcedure } from "./procedure.comment.ts";
+import type { CreateProcedure } from "./procedure.create.ts";
+import type { DropProcedure } from "./procedure.drop.ts";
+import type { ProcedurePrivilege } from "./procedure.privilege.ts";
+export type ProcedureChange = AlterProcedure | CommentProcedure | CreateProcedure | DropProcedure | ProcedurePrivilege;

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

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

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