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

package/dist/core/objects/foreign-data-wrapper/user-mapping/user-mapping.diff.js

@@ -0,0 +1,77 @@
+import { diffObjects } from "../../base.diff.js";
+import { AlterUserMappingSetOptions } from "./changes/user-mapping.alter.js";
+import { CreateUserMapping } from "./changes/user-mapping.create.js";
+import { DropUserMapping } from "./changes/user-mapping.drop.js";
+/**
+ * Diff two sets of user mappings from main and branch catalogs.
+ *
+ * @param main - The user mappings in the main catalog.
+ * @param branch - The user mappings in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffUserMappings(main, branch) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    for (const mappingId of created) {
+        const createdMapping = branch[mappingId];
+        changes.push(new CreateUserMapping({ userMapping: createdMapping }));
+    }
+    for (const mappingId of dropped) {
+        changes.push(new DropUserMapping({ userMapping: main[mappingId] }));
+    }
+    for (const mappingId of altered) {
+        const mainMapping = main[mappingId];
+        const branchMapping = branch[mappingId];
+        // OPTIONS
+        const optionsChanged = diffOptions(mainMapping.options, branchMapping.options);
+        if (optionsChanged.length > 0) {
+            changes.push(new AlterUserMappingSetOptions({
+                userMapping: mainMapping,
+                options: optionsChanged,
+            }));
+        }
+    }
+    return changes;
+}
+/**
+ * Diff options arrays to determine ADD/SET/DROP operations.
+ * Options are stored as [key1, value1, key2, value2, ...]
+ */
+function diffOptions(mainOptions, branchOptions) {
+    const mainMap = new Map();
+    const branchMap = new Map();
+    // Parse main options
+    if (mainOptions) {
+        for (let i = 0; i < mainOptions.length; i += 2) {
+            if (i + 1 < mainOptions.length) {
+                mainMap.set(mainOptions[i], mainOptions[i + 1]);
+            }
+        }
+    }
+    // Parse branch options
+    if (branchOptions) {
+        for (let i = 0; i < branchOptions.length; i += 2) {
+            if (i + 1 < branchOptions.length) {
+                branchMap.set(branchOptions[i], branchOptions[i + 1]);
+            }
+        }
+    }
+    const changes = [];
+    // Find options to ADD or SET
+    for (const [key, value] of branchMap) {
+        const mainValue = mainMap.get(key);
+        if (mainValue === undefined) {
+            changes.push({ action: "ADD", option: key, value });
+        }
+        else if (mainValue !== value) {
+            changes.push({ action: "SET", option: key, value });
+        }
+    }
+    // Find options to DROP
+    for (const [key] of mainMap) {
+        if (!branchMap.has(key)) {
+            changes.push({ action: "DROP", option: key });
+        }
+    }
+    return changes;
+}

package/dist/core/objects/foreign-data-wrapper/user-mapping/user-mapping.model.d.ts

@@ -0,0 +1,36 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel } from "../../base.model.ts";
+/**
+ * All properties exposed by CREATE USER MAPPING statement are included in diff output.
+ * https://www.postgresql.org/docs/17/sql-createusermapping.html
+ *
+ * ALTER USER MAPPING statement can be generated for changes to the following properties:
+ *  - options
+ * https://www.postgresql.org/docs/17/sql-alterusermapping.html
+ *
+ * User mappings are not schema-qualified (no schema property).
+ * User can be a role name, CURRENT_USER, PUBLIC, etc.
+ */
+declare const userMappingPropsSchema: z.ZodObject<{
+    user: z.ZodString;
+    server: z.ZodString;
+    options: z.ZodNullable<z.ZodArray<z.ZodString>>;
+}, z.z.core.$strip>;
+export type UserMappingProps = z.infer<typeof userMappingPropsSchema>;
+export declare class UserMapping extends BasePgModel {
+    readonly user: UserMappingProps["user"];
+    readonly server: UserMappingProps["server"];
+    readonly options: UserMappingProps["options"];
+    constructor(props: UserMappingProps);
+    get stableId(): `userMapping:${string}:${string}`;
+    get identityFields(): {
+        user: string;
+        server: string;
+    };
+    get dataFields(): {
+        options: string[] | null;
+    };
+}
+export declare function extractUserMappings(sql: Sql): Promise<UserMapping[]>;
+export {};

package/dist/core/objects/foreign-data-wrapper/user-mapping/user-mapping.model.js

@@ -0,0 +1,85 @@
+import z from "zod";
+import { BasePgModel } from "../../base.model.js";
+/**
+ * All properties exposed by CREATE USER MAPPING statement are included in diff output.
+ * https://www.postgresql.org/docs/17/sql-createusermapping.html
+ *
+ * ALTER USER MAPPING statement can be generated for changes to the following properties:
+ *  - options
+ * https://www.postgresql.org/docs/17/sql-alterusermapping.html
+ *
+ * User mappings are not schema-qualified (no schema property).
+ * User can be a role name, CURRENT_USER, PUBLIC, etc.
+ */
+const userMappingPropsSchema = z.object({
+    user: z.string(),
+    server: z.string(),
+    options: z.array(z.string()).nullable(),
+});
+export class UserMapping extends BasePgModel {
+    user;
+    server;
+    options;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.user = props.user;
+        this.server = props.server;
+        // Data fields
+        this.options = props.options;
+    }
+    get stableId() {
+        return `userMapping:${this.server}:${this.user}`;
+    }
+    get identityFields() {
+        return {
+            user: this.user,
+            server: this.server,
+        };
+    }
+    get dataFields() {
+        return {
+            options: this.options,
+        };
+    }
+}
+export async function extractUserMappings(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const mappingRows = await sql `
+      select
+        case
+          when um.umuser = 0 then 'PUBLIC'
+          else um.umuser::regrole::text
+        end as user,
+        quote_ident(srv.srvname) as server,
+        coalesce(um.umoptions, array[]::text[]) as options
+      from
+        pg_catalog.pg_user_mapping um
+        inner join pg_catalog.pg_foreign_server srv on srv.oid = um.umserver
+        inner join pg_catalog.pg_foreign_data_wrapper fdw on fdw.oid = srv.srvfdw
+      where
+        not fdw.fdwname like any(array['pg\\_%'])
+      order by
+        srv.srvname, um.umuser;
+    `;
+        // Validate and parse each row using the Zod schema
+        const validatedRows = mappingRows.map((row) => {
+            const parsed = userMappingPropsSchema.parse(row);
+            // Parse options from PostgreSQL format ['key=value'] to ['key', 'value']
+            if (parsed.options && parsed.options.length > 0) {
+                const parsedOptions = [];
+                for (const opt of parsed.options) {
+                    const eqIndex = opt.indexOf("=");
+                    if (eqIndex > 0) {
+                        parsedOptions.push(opt.substring(0, eqIndex));
+                        parsedOptions.push(opt.substring(eqIndex + 1));
+                    }
+                }
+                parsed.options = parsedOptions.length > 0 ? parsedOptions : null;
+            }
+            return parsed;
+        });
+        return validatedRows.map((row) => new UserMapping(row));
+    });
+}

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

@@ -0,0 +1,76 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Index } from "../index.model.ts";
+import { AlterIndexChange } from "./index.base.ts";
+/**
+ * Alter an index.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterindex.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER INDEX [ CONCURRENTLY ] [ IF EXISTS ] name SET TABLESPACE tablespace_name
+ * ALTER INDEX [ CONCURRENTLY ] [ IF EXISTS ] name SET ( storage_parameter = value [, ... ] )
+ * ALTER INDEX [ CONCURRENTLY ] [ IF EXISTS ] name RESET ( storage_parameter [, ... ] )
+ * ALTER INDEX [ CONCURRENTLY ] [ IF EXISTS ] name SET STATISTICS integer
+ * ALTER INDEX [ CONCURRENTLY ] [ IF EXISTS ] name ALTER [ COLUMN ] column_number SET STATISTICS integer
+ * ```
+ */
+export type AlterIndex = AlterIndexSetStatistics | AlterIndexSetStorageParams | AlterIndexSetTablespace;
+/**
+ * ALTER INDEX ... SET ( storage_parameter = value [, ... ] )
+ */
+export declare class AlterIndexSetStorageParams extends AlterIndexChange {
+    readonly index: Index;
+    readonly paramsToSet: string[];
+    readonly keysToReset: string[];
+    readonly scope: "object";
+    constructor(props: {
+        index: Index;
+        paramsToSet: string[];
+        keysToReset: string[];
+    });
+    get requires(): `index:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER INDEX ... SET STATISTICS ...
+ */
+export declare class AlterIndexSetStatistics extends BaseChange {
+    readonly index: Index;
+    readonly columnTargets: Array<{
+        columnNumber: number;
+        statistics: number;
+    }>;
+    readonly operation: "alter";
+    readonly scope: "object";
+    readonly objectType: "index";
+    constructor(props: {
+        index: Index;
+        columnTargets: Array<{
+            columnNumber: number;
+            statistics: number;
+        }>;
+    });
+    get requires(): `index:${string}`[];
+    serialize(): string;
+}
+/**
+ * ALTER INDEX ... SET TABLESPACE ...
+ */
+export declare class AlterIndexSetTablespace extends BaseChange {
+    readonly index: Index;
+    readonly tablespace: string;
+    readonly operation: "alter";
+    readonly scope: "object";
+    readonly objectType: "index";
+    constructor(props: {
+        index: Index;
+        tablespace: string;
+    });
+    get requires(): `index:${string}`[];
+    serialize(): string;
+}
+/**
+ * Replace an index by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER INDEX change.
+ */

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

@@ -0,0 +1,94 @@
+import { BaseChange } from "../../base.change.js";
+import { AlterIndexChange } from "./index.base.js";
+/**
+ * ALTER INDEX ... SET ( storage_parameter = value [, ... ] )
+ */
+export class AlterIndexSetStorageParams extends AlterIndexChange {
+    index;
+    paramsToSet;
+    keysToReset;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.index = props.index;
+        this.paramsToSet = props.paramsToSet;
+        this.keysToReset = props.keysToReset;
+    }
+    get requires() {
+        return [this.index.stableId];
+    }
+    serialize() {
+        const head = [
+            "ALTER INDEX",
+            `${this.index.schema}.${this.index.name}`,
+        ].join(" ");
+        const statements = [];
+        if (this.keysToReset.length > 0) {
+            statements.push(`${head} RESET (${this.keysToReset.join(", ")})`);
+        }
+        if (this.paramsToSet.length > 0) {
+            statements.push(`${head} SET (${this.paramsToSet.join(", ")})`);
+        }
+        return statements.join(";\n");
+    }
+}
+/**
+ * ALTER INDEX ... SET STATISTICS ...
+ */
+export class AlterIndexSetStatistics extends BaseChange {
+    index;
+    columnTargets;
+    operation = "alter";
+    scope = "object";
+    objectType = "index";
+    constructor(props) {
+        super();
+        this.index = props.index;
+        this.columnTargets = props.columnTargets;
+    }
+    get requires() {
+        return [this.index.stableId];
+    }
+    serialize() {
+        const statements = [];
+        const head = [
+            "ALTER INDEX",
+            `${this.index.schema}.${this.index.name}`,
+        ].join(" ");
+        for (const { columnNumber, statistics } of this.columnTargets) {
+            statements.push(`${head} ALTER COLUMN ${columnNumber} SET STATISTICS ${statistics.toString()}`);
+        }
+        return statements.join(";\n");
+    }
+}
+/**
+ * ALTER INDEX ... SET TABLESPACE ...
+ */
+export class AlterIndexSetTablespace extends BaseChange {
+    index;
+    tablespace;
+    operation = "alter";
+    scope = "object";
+    objectType = "index";
+    constructor(props) {
+        super();
+        this.index = props.index;
+        this.tablespace = props.tablespace;
+    }
+    get requires() {
+        return [this.index.stableId];
+    }
+    serialize() {
+        return [
+            "ALTER INDEX",
+            `${this.index.schema}.${this.index.name}`,
+            "SET TABLESPACE",
+            this.tablespace,
+        ].join(" ");
+    }
+}
+/**
+ * Replace an index by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER INDEX change.
+ */
+// NOTE: ReplaceIndex removed. Non-alterable changes are emitted as DropIndex + CreateIndex in index.diff.ts.

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

@@ -0,0 +1,17 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Index } from "../index.model.ts";
+declare abstract class BaseIndexChange extends BaseChange {
+    abstract readonly index: Index;
+    abstract readonly scope: "object" | "comment";
+    readonly objectType: "index";
+}
+export declare abstract class CreateIndexChange extends BaseIndexChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterIndexChange extends BaseIndexChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropIndexChange extends BaseIndexChange {
+    readonly operation: "drop";
+}
+export {};

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

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../base.change.js";
+class BaseIndexChange extends BaseChange {
+    objectType = "index";
+}
+export class CreateIndexChange extends BaseIndexChange {
+    operation = "create";
+}
+export class AlterIndexChange extends BaseIndexChange {
+    operation = "alter";
+}
+export class DropIndexChange extends BaseIndexChange {
+    operation = "drop";
+}

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

@@ -0,0 +1,26 @@
+import type { Index } from "../index.model.ts";
+import { CreateIndexChange, DropIndexChange } from "./index.base.ts";
+export type CommentIndex = CreateCommentOnIndex | DropCommentOnIndex;
+/**
+ * Create/drop comments on indexes.
+ */
+export declare class CreateCommentOnIndex extends CreateIndexChange {
+    readonly index: Index;
+    readonly scope: "comment";
+    constructor(props: {
+        index: Index;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `index:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnIndex extends DropIndexChange {
+    readonly index: Index;
+    readonly scope: "comment";
+    constructor(props: {
+        index: Index;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`comment:${string}` | `index:${string}`)[];
+    serialize(): string;
+}

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

@@ -0,0 +1,50 @@
+import { quoteLiteral } from "../../base.change.js";
+import { stableId } from "../../utils.js";
+import { CreateIndexChange, DropIndexChange } from "./index.base.js";
+/**
+ * Create/drop comments on indexes.
+ */
+export class CreateCommentOnIndex extends CreateIndexChange {
+    index;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.index = props.index;
+    }
+    get creates() {
+        return [stableId.comment(this.index.stableId)];
+    }
+    get requires() {
+        return [this.index.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON INDEX",
+            `${this.index.schema}.${this.index.name}`,
+            "IS",
+            // biome-ignore lint/style/noNonNullAssertion: index comment is not nullable here
+            quoteLiteral(this.index.comment),
+        ].join(" ");
+    }
+}
+export class DropCommentOnIndex extends DropIndexChange {
+    index;
+    scope = "comment";
+    constructor(props) {
+        super();
+        this.index = props.index;
+    }
+    get drops() {
+        return [stableId.comment(this.index.stableId)];
+    }
+    get requires() {
+        return [stableId.comment(this.index.stableId), this.index.stableId];
+    }
+    serialize() {
+        return [
+            "COMMENT ON INDEX",
+            `${this.index.schema}.${this.index.name}`,
+            "IS NULL",
+        ].join(" ");
+    }
+}

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

@@ -0,0 +1,30 @@
+import type { TableLikeObject } from "../../base.model.ts";
+import type { Index } from "../index.model.ts";
+import { CreateIndexChange } from "./index.base.ts";
+/**
+ * Create an index.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createindex.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE [ UNIQUE ] INDEX [ CONCURRENTLY ] [ [ IF NOT EXISTS ] name ] ON [ ONLY ] table_name [ USING method ]
+ *     ( { column_name | ( expression ) } [ COLLATE collation ] [ opclass [ ( opclass_parameter = value [, ... ] ) ] ] [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [, ...] )
+ *     [ INCLUDE ( column_name [, ...] ) ]
+ *     [ WITH ( storage_parameter [= value] [, ... ] ) ]
+ *     [ TABLESPACE tablespace_name ]
+ *     [ WHERE predicate ]
+ * ```
+ */
+export declare class CreateIndex extends CreateIndexChange {
+    readonly index: Index;
+    readonly indexableObject?: TableLikeObject;
+    readonly scope: "object";
+    constructor(props: {
+        index: Index;
+        indexableObject?: TableLikeObject;
+    });
+    get creates(): `index:${string}`[];
+    get requires(): string[];
+    serialize(): string;
+}

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

@@ -0,0 +1,53 @@
+import { stableId } from "../../utils.js";
+import { CreateIndexChange } from "./index.base.js";
+import { checkIsSerializable } from "./utils.js";
+/**
+ * Create an index.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createindex.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE [ UNIQUE ] INDEX [ CONCURRENTLY ] [ [ IF NOT EXISTS ] name ] ON [ ONLY ] table_name [ USING method ]
+ *     ( { column_name | ( expression ) } [ COLLATE collation ] [ opclass [ ( opclass_parameter = value [, ... ] ) ] ] [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [, ...] )
+ *     [ INCLUDE ( column_name [, ...] ) ]
+ *     [ WITH ( storage_parameter [= value] [, ... ] ) ]
+ *     [ TABLESPACE tablespace_name ]
+ *     [ WHERE predicate ]
+ * ```
+ */
+export class CreateIndex extends CreateIndexChange {
+    index;
+    indexableObject;
+    scope = "object";
+    constructor(props) {
+        super();
+        checkIsSerializable(props.index, props.indexableObject);
+        this.index = props.index;
+        this.indexableObject = props.indexableObject;
+    }
+    get creates() {
+        return [this.index.stableId];
+    }
+    get requires() {
+        const dependencies = new Set();
+        // Schema dependency
+        dependencies.add(stableId.schema(this.index.schema));
+        // Table dependency
+        dependencies.add(stableId.table(this.index.schema, this.index.table_name));
+        // Owner dependency
+        dependencies.add(stableId.role(this.index.owner));
+        return Array.from(dependencies);
+    }
+    serialize() {
+        let definition = this.index.definition;
+        // btree being the default, we can omit it
+        definition = definition.replace(" USING btree", "");
+        // Remove "ON ONLY" for partitioned indexes to allow automatic propagation to partitions.
+        // Preserve "ON ONLY" for non-partitioned indexes on partitioned tables (explicit user intent).
+        if (this.index.is_partitioned_index) {
+            definition = definition.replace(/\s+ON\s+ONLY\s+/i, " ON ");
+        }
+        return definition;
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { Index } from "../index.model.ts";
+import { DropIndexChange } from "./index.base.ts";
+/**
+ * Drop an index.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropindex.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP INDEX [ CONCURRENTLY ] [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export declare class DropIndex extends DropIndexChange {
+    readonly index: Index;
+    readonly scope: "object";
+    constructor(props: {
+        index: Index;
+    });
+    get drops(): `index:${string}`[];
+    get requires(): `index:${string}`[];
+    serialize(): string;
+}

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

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

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

@@ -0,0 +1,5 @@
+import type { AlterIndex } from "./index.alter.ts";
+import type { CommentIndex } from "./index.comment.ts";
+import type { CreateIndex } from "./index.create.ts";
+import type { DropIndex } from "./index.drop.ts";
+export type IndexChange = AlterIndex | CommentIndex | CreateIndex | DropIndex;

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

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

package/dist/core/objects/index/changes/utils.d.ts

@@ -0,0 +1,3 @@
+import type { TableLikeObject } from "../../base.model.ts";
+import type { Index } from "../index.model.ts";
+export declare function checkIsSerializable(index: Index, indexableObject?: TableLikeObject): void;

package/dist/core/objects/index/changes/utils.js

@@ -0,0 +1,6 @@
+export function checkIsSerializable(index, indexableObject) {
+    if (index.index_expressions === null &&
+        (indexableObject === undefined || indexableObject.columns.length === 0)) {
+        throw new Error("Index requires an indexableObject with columns when key_columns are used");
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { TableLikeObject } from "../base.model.ts";
+import type { IndexChange } from "./changes/index.types.ts";
+import type { Index } from "./index.model.ts";
+/**
+ * Diff two sets of indexes from main and branch catalogs.
+ *
+ * @param main - The indexes in the main catalog.
+ * @param branch - The indexes in the branch catalog.
+ * @param branchIndexableObjects - Table-like objects (tables, materialized views) in branch.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export declare function diffIndexes(main: Record<string, Index>, branch: Record<string, Index>, branchIndexableObjects: Record<string, TableLikeObject>): IndexChange[];