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

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

@@ -0,0 +1,228 @@
+import { quoteLiteral } from "../../base.change.js";
+import { parseProcedureReference, parseTypeString, stableId, } from "../../utils.js";
+import { CreateAggregateChange } from "./aggregate.base.js";
+/**
+ * Create an aggregate.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createaggregate.html
+ */
+export class CreateAggregate extends CreateAggregateChange {
+    aggregate;
+    orReplace;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.aggregate = props.aggregate;
+        this.orReplace = props.orReplace ?? false;
+    }
+    get creates() {
+        return [this.aggregate.stableId];
+    }
+    get requires() {
+        const dependencies = new Set();
+        // Schema dependency
+        dependencies.add(stableId.schema(this.aggregate.schema));
+        // Owner dependency
+        dependencies.add(stableId.role(this.aggregate.owner));
+        // Transition function dependency
+        const transProc = parseProcedureReference(this.aggregate.transition_function);
+        if (transProc) {
+            dependencies.add(stableId.procedure(transProc.schema, transProc.name));
+        }
+        // State data type dependency (if user-defined)
+        const stateType = parseTypeString(this.aggregate.state_data_type);
+        if (stateType) {
+            dependencies.add(stableId.type(stateType.schema, stateType.name));
+        }
+        // Final function dependency
+        if (this.aggregate.final_function) {
+            const finalProc = parseProcedureReference(this.aggregate.final_function);
+            if (finalProc) {
+                dependencies.add(stableId.procedure(finalProc.schema, finalProc.name));
+            }
+        }
+        // Combine function dependency
+        if (this.aggregate.combine_function) {
+            const combineProc = parseProcedureReference(this.aggregate.combine_function);
+            if (combineProc) {
+                dependencies.add(stableId.procedure(combineProc.schema, combineProc.name));
+            }
+        }
+        // Serial function dependency
+        if (this.aggregate.serial_function) {
+            const serialProc = parseProcedureReference(this.aggregate.serial_function);
+            if (serialProc) {
+                dependencies.add(stableId.procedure(serialProc.schema, serialProc.name));
+            }
+        }
+        // Deserial function dependency
+        if (this.aggregate.deserial_function) {
+            const deserialProc = parseProcedureReference(this.aggregate.deserial_function);
+            if (deserialProc) {
+                dependencies.add(stableId.procedure(deserialProc.schema, deserialProc.name));
+            }
+        }
+        // Moving transition function dependency
+        if (this.aggregate.moving_transition_function) {
+            const movingTransProc = parseProcedureReference(this.aggregate.moving_transition_function);
+            if (movingTransProc) {
+                dependencies.add(stableId.procedure(movingTransProc.schema, movingTransProc.name));
+            }
+        }
+        // Moving inverse function dependency
+        if (this.aggregate.moving_inverse_function) {
+            const movingInvProc = parseProcedureReference(this.aggregate.moving_inverse_function);
+            if (movingInvProc) {
+                dependencies.add(stableId.procedure(movingInvProc.schema, movingInvProc.name));
+            }
+        }
+        // Moving state data type dependency (if user-defined)
+        if (this.aggregate.moving_state_data_type) {
+            const movingStateType = parseTypeString(this.aggregate.moving_state_data_type);
+            if (movingStateType) {
+                dependencies.add(stableId.type(movingStateType.schema, movingStateType.name));
+            }
+        }
+        // Moving final function dependency
+        if (this.aggregate.moving_final_function) {
+            const movingFinalProc = parseProcedureReference(this.aggregate.moving_final_function);
+            if (movingFinalProc) {
+                dependencies.add(stableId.procedure(movingFinalProc.schema, movingFinalProc.name));
+            }
+        }
+        // Return type dependency (if user-defined)
+        if (this.aggregate.return_type_schema) {
+            const returnType = parseTypeString(this.aggregate.return_type);
+            if (returnType) {
+                dependencies.add(stableId.type(returnType.schema, returnType.name));
+            }
+        }
+        // Argument type dependencies (if user-defined)
+        if (this.aggregate.argument_types) {
+            for (const argType of this.aggregate.argument_types) {
+                const parsedType = parseTypeString(argType);
+                if (parsedType) {
+                    dependencies.add(stableId.type(parsedType.schema, parsedType.name));
+                }
+            }
+        }
+        // Note: Sort operator dependencies are complex (they reference operators which
+        // may reference types/functions). For now, we rely on pg_depend for these.
+        return Array.from(dependencies);
+    }
+    serialize() {
+        const signature = this.aggregate.identityArguments;
+        const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
+        const head = [
+            "CREATE",
+            this.orReplace ? "OR REPLACE" : null,
+            "AGGREGATE",
+            `${qualifiedName}${signature ? `(${signature})` : "()"}`,
+        ]
+            .filter(Boolean)
+            .join(" ");
+        const clauses = [];
+        clauses.push(`SFUNC = ${formatProc(this.aggregate.transition_function)}`);
+        clauses.push(`STYPE = ${this.aggregate.state_data_type}`);
+        if (this.aggregate.state_data_space > 0) {
+            clauses.push(`SSPACE = ${this.aggregate.state_data_space}`);
+        }
+        if (this.aggregate.final_function) {
+            clauses.push(`FINALFUNC = ${formatProc(this.aggregate.final_function)}`);
+        }
+        if (this.aggregate.final_function_extra_args) {
+            clauses.push("FINALFUNC_EXTRA");
+        }
+        // Only include FINALFUNC_MODIFY if it's explicitly set to a non-default value
+        // PostgreSQL defaults to 'r' (READ_ONLY) when not specified
+        if (this.aggregate.final_function_modify &&
+            this.aggregate.final_function_modify !== "r") {
+            clauses.push(`FINALFUNC_MODIFY = ${formatModify(this.aggregate.final_function_modify)}`);
+        }
+        if (this.aggregate.combine_function) {
+            clauses.push(`COMBINEFUNC = ${formatProc(this.aggregate.combine_function)}`);
+        }
+        if (this.aggregate.serial_function) {
+            clauses.push(`SERIALFUNC = ${formatProc(this.aggregate.serial_function)}`);
+        }
+        if (this.aggregate.deserial_function) {
+            clauses.push(`DESERIALFUNC = ${formatProc(this.aggregate.deserial_function)}`);
+        }
+        if (this.aggregate.initial_condition !== null) {
+            clauses.push(`INITCOND = ${quoteLiteral(this.aggregate.initial_condition)}`);
+        }
+        if (this.aggregate.moving_transition_function) {
+            clauses.push(`MSFUNC = ${formatProc(this.aggregate.moving_transition_function)}`);
+        }
+        if (this.aggregate.moving_inverse_function) {
+            clauses.push(`MINVFUNC = ${formatProc(this.aggregate.moving_inverse_function)}`);
+        }
+        if (this.aggregate.moving_state_data_type) {
+            clauses.push(`MSTYPE = ${this.aggregate.moving_state_data_type}`);
+        }
+        if (this.aggregate.moving_state_data_space &&
+            this.aggregate.moving_state_data_space > 0) {
+            clauses.push(`MSSPACE = ${this.aggregate.moving_state_data_space}`);
+        }
+        if (this.aggregate.moving_final_function) {
+            clauses.push(`MFINALFUNC = ${formatProc(this.aggregate.moving_final_function)}`);
+        }
+        if (this.aggregate.moving_final_function_extra_args) {
+            clauses.push("MFINALFUNC_EXTRA");
+        }
+        // Only include MFINALFUNC_MODIFY if it's explicitly set to a non-default value
+        // PostgreSQL defaults to 'r' (READ_ONLY) when not specified
+        if (this.aggregate.moving_final_function_modify &&
+            this.aggregate.moving_final_function_modify !== "r") {
+            clauses.push(`MFINALFUNC_MODIFY = ${formatModify(this.aggregate.moving_final_function_modify)}`);
+        }
+        if (this.aggregate.moving_initial_condition !== null) {
+            clauses.push(`MINITCOND = ${quoteLiteral(this.aggregate.moving_initial_condition)}`);
+        }
+        if (this.aggregate.sort_operator) {
+            clauses.push(`SORTOP = ${formatOperator(this.aggregate.sort_operator)}`);
+        }
+        if (this.aggregate.parallel_safety !== "u") {
+            clauses.push(`PARALLEL ${formatParallel(this.aggregate.parallel_safety)}`);
+        }
+        if (this.aggregate.is_strict) {
+            clauses.push("STRICT");
+        }
+        if (this.aggregate.aggkind === "h") {
+            clauses.push("HYPOTHETICAL");
+        }
+        const body = clauses.length ? `(${clauses.join(", ")})` : "()";
+        return `${head} ${body}`;
+    }
+}
+function formatProc(proc) {
+    const idx = proc.indexOf("(");
+    return idx === -1 ? proc : proc.slice(0, idx);
+}
+function formatOperator(op) {
+    const idx = op.indexOf("(");
+    const qualified = idx === -1 ? op : op.slice(0, idx);
+    return `OPERATOR(${qualified})`;
+}
+function formatModify(code) {
+    switch (code) {
+        case "r":
+            return "READ_ONLY";
+        case "s":
+            return "SHAREABLE";
+        case "w":
+            return "READ_WRITE";
+        default:
+            return code;
+    }
+}
+function formatParallel(code) {
+    switch (code) {
+        case "s":
+            return "SAFE";
+        case "r":
+            return "RESTRICTED";
+        default:
+            return "UNSAFE";
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { Aggregate } from "../aggregate.model.ts";
+import { DropAggregateChange } from "./aggregate.base.ts";
+/**
+ * Drop an aggregate.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropaggregate.html
+ */
+export declare class DropAggregate extends DropAggregateChange {
+    readonly aggregate: Aggregate;
+    readonly scope: "object";
+    constructor(props: {
+        aggregate: Aggregate;
+    });
+    get drops(): `aggregate:${string}`[];
+    get requires(): `aggregate:${string}`[];
+    serialize(): string;
+}

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

@@ -0,0 +1,26 @@
+import { DropAggregateChange } from "./aggregate.base.js";
+/**
+ * Drop an aggregate.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropaggregate.html
+ */
+export class DropAggregate extends DropAggregateChange {
+    aggregate;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.aggregate = props.aggregate;
+    }
+    get drops() {
+        return [this.aggregate.stableId];
+    }
+    get requires() {
+        return [this.aggregate.stableId];
+    }
+    serialize() {
+        const signature = this.aggregate.identityArguments;
+        const qualifiedName = `${this.aggregate.schema}.${this.aggregate.name}`;
+        const withArgs = signature.length > 0 ? `(${signature})` : "()";
+        return `DROP AGGREGATE ${qualifiedName}${withArgs}`;
+    }
+}

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

@@ -0,0 +1,62 @@
+import type { Aggregate } from "../aggregate.model.ts";
+import { AlterAggregateChange } from "./aggregate.base.ts";
+export type AggregatePrivilege = GrantAggregatePrivileges | RevokeAggregatePrivileges | RevokeGrantOptionAggregatePrivileges;
+export declare class GrantAggregatePrivileges extends AlterAggregateChange {
+    readonly aggregate: Aggregate;
+    readonly grantee: string;
+    readonly privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        aggregate: Aggregate;
+        grantee: string;
+        privileges: {
+            privilege: string;
+            grantable: boolean;
+        }[];
+        version?: number;
+    });
+    get creates(): `acl:${string}::grantee:${string}`[];
+    get requires(): (`role:${string}` | `aggregate:${string}`)[];
+    serialize(): string;
+}
+export declare class RevokeAggregatePrivileges extends AlterAggregateChange {
+    readonly aggregate: Aggregate;
+    readonly grantee: string;
+    readonly privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        aggregate: Aggregate;
+        grantee: string;
+        privileges: {
+            privilege: string;
+            grantable: boolean;
+        }[];
+        version?: number;
+    });
+    get drops(): `acl:${string}::grantee:${string}`[];
+    get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `aggregate:${string}`)[];
+    serialize(): string;
+}
+export declare class RevokeGrantOptionAggregatePrivileges extends AlterAggregateChange {
+    readonly aggregate: Aggregate;
+    readonly grantee: string;
+    readonly privilegeNames: string[];
+    readonly version: number | undefined;
+    readonly scope: "privilege";
+    constructor(props: {
+        aggregate: Aggregate;
+        grantee: string;
+        privilegeNames: string[];
+        version?: number;
+    });
+    get requires(): (`acl:${string}::grantee:${string}` | `role:${string}` | `aggregate:${string}`)[];
+    serialize(): string;
+}

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

@@ -0,0 +1,102 @@
+import { formatObjectPrivilegeList, getObjectKindPrefix, } from "../../base.privilege.js";
+import { stableId } from "../../utils.js";
+import { AlterAggregateChange } from "./aggregate.base.js";
+export class GrantAggregatePrivileges extends AlterAggregateChange {
+    aggregate;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.aggregate = props.aggregate;
+        this.grantee = props.grantee;
+        this.privileges = props.privileges;
+        this.version = props.version;
+    }
+    get creates() {
+        return [stableId.acl(this.aggregate.stableId, this.grantee)];
+    }
+    get requires() {
+        return [this.aggregate.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("GrantAggregatePrivileges expects privileges with uniform grantable flag");
+        }
+        const withGrant = hasGrantable ? " WITH GRANT OPTION" : "";
+        const kindPrefix = getObjectKindPrefix("FUNCTION");
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList("FUNCTION", list, this.version);
+        const aggregateName = `${this.aggregate.schema}.${this.aggregate.name}`;
+        const signature = this.aggregate.identityArguments;
+        const qualified = `${aggregateName}(${signature})`;
+        return `GRANT ${privSql} ${kindPrefix} ${qualified} TO ${this.grantee}${withGrant}`;
+    }
+}
+export class RevokeAggregatePrivileges extends AlterAggregateChange {
+    aggregate;
+    grantee;
+    privileges;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.aggregate = props.aggregate;
+        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.aggregate.stableId, this.grantee)];
+    }
+    get requires() {
+        return [
+            stableId.acl(this.aggregate.stableId, this.grantee),
+            this.aggregate.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const kindPrefix = getObjectKindPrefix("FUNCTION");
+        const list = this.privileges.map((p) => p.privilege);
+        const privSql = formatObjectPrivilegeList("FUNCTION", list, this.version);
+        const aggregateName = `${this.aggregate.schema}.${this.aggregate.name}`;
+        const signature = this.aggregate.identityArguments;
+        const qualified = `${aggregateName}(${signature})`;
+        return `REVOKE ${privSql} ${kindPrefix} ${qualified} FROM ${this.grantee}`;
+    }
+}
+export class RevokeGrantOptionAggregatePrivileges extends AlterAggregateChange {
+    aggregate;
+    grantee;
+    privilegeNames;
+    version;
+    scope = "privilege";
+    constructor(props) {
+        super();
+        this.aggregate = props.aggregate;
+        this.grantee = props.grantee;
+        this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+        this.version = props.version;
+    }
+    get requires() {
+        return [
+            stableId.acl(this.aggregate.stableId, this.grantee),
+            this.aggregate.stableId,
+            stableId.role(this.grantee),
+        ];
+    }
+    serialize() {
+        const kindPrefix = getObjectKindPrefix("FUNCTION");
+        const privSql = formatObjectPrivilegeList("FUNCTION", this.privilegeNames, this.version);
+        const aggregateName = `${this.aggregate.schema}.${this.aggregate.name}`;
+        const signature = this.aggregate.identityArguments;
+        const qualified = `${aggregateName}(${signature})`;
+        return `REVOKE GRANT OPTION FOR ${privSql} ${kindPrefix} ${qualified} FROM ${this.grantee}`;
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { AlterAggregate } from "./aggregate.alter.ts";
+import type { CommentAggregate } from "./aggregate.comment.ts";
+import type { CreateAggregate } from "./aggregate.create.ts";
+import type { DropAggregate } from "./aggregate.drop.ts";
+import type { AggregatePrivilege } from "./aggregate.privilege.ts";
+export type AggregateChange = AlterAggregate | CommentAggregate | CreateAggregate | DropAggregate | AggregatePrivilege;

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

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

package/dist/core/objects/base.change.d.ts

@@ -0,0 +1,46 @@
+type ChangeOperation = "create" | "alter" | "drop";
+export declare abstract class BaseChange {
+    /**
+     * The operation of the change.
+     */
+    abstract readonly operation: ChangeOperation;
+    /**
+     * The type of the object targeted by the change.
+     */
+    abstract readonly objectType: string;
+    /**
+     * The scope of the change.
+     */
+    abstract readonly scope: string;
+    /**
+     * A unique identifier for the change.
+     */
+    get changeId(): string;
+    /**
+     * Stable identifiers this change creates.
+     *
+     * Defaults to an empty array. Override in subclasses that create objects.
+     */
+    get creates(): string[];
+    /**
+     * Stable identifiers this change drops.
+     *
+     * Defaults to an empty array. Override in subclasses that remove objects.
+     */
+    get drops(): string[];
+    /**
+     * Stable identifiers this change requires to exist beforehand.
+     *
+     * Defaults to an empty array. Override in subclasses that have prerequisites.
+     */
+    get requires(): string[];
+    /**
+     * Serialize the change into a single SQL statement.
+     */
+    abstract serialize(options?: Record<string, unknown>): string;
+}
+/**
+ * Port of string literal quoting: doubles single quotes inside and wraps with single quotes
+ */
+export declare function quoteLiteral(value: string): string;
+export {};

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

@@ -0,0 +1,38 @@
+export class BaseChange {
+    /**
+     * A unique identifier for the change.
+     */
+    get changeId() {
+        return `${this.operation}:${this.scope}:${this.objectType}:${this.serialize()}`;
+    }
+    /**
+     * Stable identifiers this change creates.
+     *
+     * Defaults to an empty array. Override in subclasses that create objects.
+     */
+    get creates() {
+        return [];
+    }
+    /**
+     * Stable identifiers this change drops.
+     *
+     * Defaults to an empty array. Override in subclasses that remove objects.
+     */
+    get drops() {
+        return [];
+    }
+    /**
+     * Stable identifiers this change requires to exist beforehand.
+     *
+     * Defaults to an empty array. Override in subclasses that have prerequisites.
+     */
+    get requires() {
+        return [];
+    }
+}
+/**
+ * Port of string literal quoting: doubles single quotes inside and wraps with single quotes
+ */
+export function quoteLiteral(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}

package/dist/core/objects/base.default-privileges.d.ts

@@ -0,0 +1,29 @@
+import type { PrivilegeProps } from "./base.privilege-diff.ts";
+import type { Role } from "./role/role.model.ts";
+/**
+ * Tracks the effective state of default privileges as changes are processed.
+ * This allows us to compute what default privileges would be in effect at any point
+ * in the migration script, accounting for ALTER DEFAULT PRIVILEGES statements.
+ */
+export declare class DefaultPrivilegeState {
+    private state;
+    constructor(initialRoles: Record<string, Role>);
+    /**
+     * Apply a GrantRoleDefaultPrivileges change to the state.
+     */
+    applyGrant(roleName: string, objtype: string, inSchema: string | null, grantee: string, privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[]): void;
+    /**
+     * Apply a RevokeRoleDefaultPrivileges change to the state.
+     */
+    applyRevoke(roleName: string, objtype: string, inSchema: string | null, grantee: string, privileges: {
+        privilege: string;
+        grantable: boolean;
+    }[]): void;
+    /**
+     * Get effective default privileges for a given object creation.
+     */
+    getEffectiveDefaults(currentUser: string, objectType: string, objectSchema: string): PrivilegeProps[];
+}