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

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

@@ -0,0 +1,49 @@
+import { stableId } from "../../utils.js";
+import { CreateExtensionChange } from "./extension.base.js";
+/**
+ * Create an extension.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createextension.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE EXTENSION [ IF NOT EXISTS ] extension_name
+ *     [ WITH ] [ SCHEMA schema_name ]
+ *              [ VERSION version ]
+ *              [ CASCADE ]
+ * ```
+ */
+export class CreateExtension extends CreateExtensionChange {
+    extension;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.extension = props.extension;
+    }
+    get creates() {
+        return [this.extension.stableId, ...this.extension.members];
+    }
+    get requires() {
+        const dependencies = new Set();
+        // Schema dependency
+        dependencies.add(stableId.schema(this.extension.schema));
+        // Owner dependency
+        dependencies.add(stableId.role(this.extension.owner));
+        return Array.from(dependencies);
+    }
+    serialize() {
+        const parts = ["CREATE EXTENSION"];
+        // Add extension name
+        parts.push(this.extension.name);
+        // Add schema
+        parts.push("WITH SCHEMA", this.extension.schema);
+        // Add version
+        // TODO: Omit version for now as versions can differ between main and branch
+        // if (this.extension.version) {
+        //   parts.push("VERSION", quoteLiteral(this.extension.version));
+        // }
+        // TODO: Add CASCADE if the extension has dependencies
+        // parts.push("CASCADE");
+        return parts.join(" ");
+    }
+}

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

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

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

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

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

@@ -0,0 +1,5 @@
+import type { AlterExtension } from "./extension.alter.ts";
+import type { CommentExtension } from "./extension.comment.ts";
+import type { CreateExtension } from "./extension.create.ts";
+import type { DropExtension } from "./extension.drop.ts";
+export type ExtensionChange = AlterExtension | CommentExtension | CreateExtension | DropExtension;

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

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

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

@@ -0,0 +1,10 @@
+import type { ExtensionChange } from "./changes/extension.types.ts";
+import type { Extension } from "./extension.model.ts";
+/**
+ * Diff two sets of extensions from main and branch catalogs.
+ *
+ * @param main - The extensions in the main catalog.
+ * @param branch - The extensions in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export declare function diffExtensions(main: Record<string, Extension>, branch: Record<string, Extension>): ExtensionChange[];

package/dist/core/objects/extension/extension.diff.js

@@ -0,0 +1,65 @@
+import { diffObjects } from "../base.diff.js";
+import { AlterExtensionSetSchema } from "./changes/extension.alter.js";
+import { CreateCommentOnExtension, DropCommentOnExtension, } from "./changes/extension.comment.js";
+import { CreateExtension } from "./changes/extension.create.js";
+import { DropExtension } from "./changes/extension.drop.js";
+/**
+ * Diff two sets of extensions from main and branch catalogs.
+ *
+ * @param main - The extensions in the main catalog.
+ * @param branch - The extensions in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffExtensions(main, branch) {
+    const { created, dropped, altered } = diffObjects(main, branch);
+    const changes = [];
+    for (const extensionId of created) {
+        const ext = branch[extensionId];
+        changes.push(new CreateExtension({ extension: ext }));
+        if (ext.comment !== null) {
+            changes.push(new CreateCommentOnExtension({ extension: ext }));
+        }
+    }
+    for (const extensionId of dropped) {
+        changes.push(new DropExtension({ extension: main[extensionId] }));
+    }
+    for (const extensionId of altered) {
+        const mainExtension = main[extensionId];
+        const branchExtension = branch[extensionId];
+        const schemaChanged = mainExtension.schema !== branchExtension.schema;
+        if (schemaChanged && !mainExtension.relocatable) {
+            // Cannot ALTER schema if not relocatable: must replace
+            changes.push(new DropExtension({ extension: mainExtension }), new CreateExtension({ extension: branchExtension }));
+            continue;
+        }
+        // VERSION
+        // TODO: Omit version for now as versions can differ between main and branch
+        // if (mainExtension.version !== branchExtension.version) {
+        //   changes.push(
+        //     new AlterExtensionUpdateVersion({
+        //       extension: mainExtension,
+        //       version: branchExtension.version,
+        //     }),
+        //   );
+        // }
+        // SCHEMA (only if relocatable)
+        if (schemaChanged && mainExtension.relocatable) {
+            changes.push(new AlterExtensionSetSchema({
+                extension: mainExtension,
+                schema: branchExtension.schema,
+            }));
+        }
+        // COMMENT
+        if (mainExtension.comment !== branchExtension.comment) {
+            if (branchExtension.comment === null) {
+                changes.push(new DropCommentOnExtension({ extension: mainExtension }));
+            }
+            else {
+                changes.push(new CreateCommentOnExtension({ extension: branchExtension }));
+            }
+        }
+        // Note: Extension renaming would also use ALTER EXTENSION ... RENAME TO ...
+        // Name is identity; renames are handled as drop + create by diffObjects()
+    }
+    return changes;
+}

package/dist/core/objects/extension/extension.model.d.ts

@@ -0,0 +1,52 @@
+import type { Sql } from "postgres";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+/**
+ * All properties exposed by CREATE EXTENSION statement are included in diff output.
+ * https://www.postgresql.org/docs/current/sql-createextension.html
+ *
+ * ALTER EXTENSION statement can be generated for changes to the following properties:
+ *  - version (limited to available ones), schema (only if relocatable)
+ * https://www.postgresql.org/docs/current/sql-alterextension.html
+ *
+ * Adding or dropping member objects are not supported. For eg. pgmq allows detaching
+ * user defined queues by removing its entry from pg_depend. If the detached table
+ * lives in an excluded schema like pg_catalog, it will not be diffed.
+ *
+ * The extension's configuration tables are not diffed.
+ *  - extconfig, extcondition
+ * https://www.postgresql.org/docs/current/catalog-pg-extension.html
+ */
+declare const extensionPropsSchema: z.ZodObject<{
+    name: z.ZodString;
+    schema: z.ZodString;
+    relocatable: z.ZodBoolean;
+    version: z.ZodString;
+    owner: z.ZodString;
+    comment: z.ZodNullable<z.ZodString>;
+    members: z.ZodArray<z.ZodString>;
+}, z.z.core.$strip>;
+export type ExtensionProps = z.infer<typeof extensionPropsSchema>;
+export declare class Extension extends BasePgModel {
+    readonly name: ExtensionProps["name"];
+    readonly schema: ExtensionProps["schema"];
+    readonly relocatable: ExtensionProps["relocatable"];
+    readonly version: ExtensionProps["version"];
+    readonly owner: ExtensionProps["owner"];
+    readonly comment: ExtensionProps["comment"];
+    readonly members: ExtensionProps["members"];
+    constructor(props: ExtensionProps);
+    get stableId(): `extension:${string}`;
+    get identityFields(): {
+        name: string;
+    };
+    get dataFields(): {
+        schema: string;
+        relocatable: boolean;
+        version: string;
+        owner: string;
+        comment: string | null;
+    };
+}
+export declare function extractExtensions(sql: Sql): Promise<Extension[]>;
+export {};

package/dist/core/objects/extension/extension.model.js

@@ -0,0 +1,268 @@
+import z from "zod";
+import { BasePgModel } from "../base.model.js";
+/**
+ * All properties exposed by CREATE EXTENSION statement are included in diff output.
+ * https://www.postgresql.org/docs/current/sql-createextension.html
+ *
+ * ALTER EXTENSION statement can be generated for changes to the following properties:
+ *  - version (limited to available ones), schema (only if relocatable)
+ * https://www.postgresql.org/docs/current/sql-alterextension.html
+ *
+ * Adding or dropping member objects are not supported. For eg. pgmq allows detaching
+ * user defined queues by removing its entry from pg_depend. If the detached table
+ * lives in an excluded schema like pg_catalog, it will not be diffed.
+ *
+ * The extension's configuration tables are not diffed.
+ *  - extconfig, extcondition
+ * https://www.postgresql.org/docs/current/catalog-pg-extension.html
+ */
+const extensionPropsSchema = z.object({
+    name: z.string(),
+    schema: z.string(),
+    relocatable: z.boolean(),
+    version: z.string(),
+    owner: z.string(),
+    comment: z.string().nullable(),
+    members: z.array(z.string()),
+});
+export class Extension extends BasePgModel {
+    name;
+    schema;
+    relocatable;
+    version;
+    owner;
+    comment;
+    members;
+    constructor(props) {
+        super();
+        // Identity fields
+        this.name = props.name;
+        // Data fields
+        this.schema = props.schema;
+        this.relocatable = props.relocatable;
+        this.version = props.version;
+        this.owner = props.owner;
+        this.comment = props.comment;
+        this.members = props.members;
+    }
+    get stableId() {
+        // Extension names are unique per database; schema is relocatable
+        return `extension:${this.name}`;
+    }
+    get identityFields() {
+        return {
+            name: this.name,
+        };
+    }
+    get dataFields() {
+        return {
+            schema: this.schema,
+            relocatable: this.relocatable,
+            version: this.version,
+            owner: this.owner,
+            comment: this.comment,
+        };
+    }
+}
+// TODO: fetch extension dependencies so we can determine when to use CASCADE on creation
+export async function extractExtensions(sql) {
+    return sql.begin(async (sql) => {
+        await sql `set search_path = ''`;
+        const extensionRows = await sql `
+  with extension_rows as (
+    select
+      e.oid,
+      quote_ident(e.extname) as name,
+      e.extnamespace::regnamespace::text as schema,
+      e.extrelocatable as relocatable,
+      e.extversion as version,
+      e.extowner::regrole::text as owner,
+      obj_description(e.oid, 'pg_extension') as comment
+    from
+      pg_catalog.pg_extension e
+  ), extension_members_raw as (
+    select
+      er.oid as extension_oid,
+      d.classid,
+      d.objid,
+      d.objsubid
+    from
+      extension_rows er
+      join pg_depend d on d.refclassid = 'pg_extension'::regclass
+        and d.refobjid = er.oid
+    where
+      d.deptype = 'e'
+  ), ids as (
+    select distinct
+      classid,
+      objid,
+      coalesce(nullif(objsubid, 0), 0)::int2 as objsubid
+    from extension_members_raw
+  ), objects as (
+    select 'pg_namespace'::regclass as classid, n.oid as objid, 0::int2 as objsubid,
+          format('schema:%I', n.nspname) as stable_id
+    from pg_namespace n
+    join ids i on i.classid = 'pg_namespace'::regclass and i.objid = n.oid and i.objsubid = 0
+
+    union all
+
+    select 'pg_class'::regclass, c.oid, 0::int2,
+          case c.relkind
+            when 'r' then format('table:%I.%I', ns.nspname, c.relname)
+            when 'p' then format('table:%I.%I', ns.nspname, c.relname)
+            when 'v' then format('view:%I.%I', ns.nspname, c.relname)
+            when 'm' then format('materializedView:%I.%I', ns.nspname, c.relname)
+            when 'S' then format('sequence:%I.%I', ns.nspname, c.relname)
+            when 'i' then format('index:%I.%I.%I', ns.nspname, tbl.relname, c.relname)
+            when 'c' then format('type:%I.%I', ns.nspname, c.relname)
+            else format('unknown:%s.%s', 'pg_class', c.oid::text)
+          end as stable_id
+    from pg_class c
+    join pg_namespace ns on ns.oid = c.relnamespace
+    left join pg_index idx on idx.indexrelid = c.oid
+    left join pg_class tbl on tbl.oid = idx.indrelid
+    join ids i on i.classid = 'pg_class'::regclass and i.objid = c.oid and i.objsubid = 0
+
+    union all
+
+    select 'pg_class'::regclass, a.attrelid, a.attnum,
+          format('column:%I.%I.%I', ns.nspname, c.relname, a.attname) as stable_id
+    from pg_attribute a
+    join pg_class c on c.oid = a.attrelid
+    join pg_namespace ns on ns.oid = c.relnamespace
+    join ids i on i.classid = 'pg_class'::regclass and i.objid = a.attrelid and i.objsubid = a.attnum
+    where a.attnum > 0 and not a.attisdropped
+
+    union all
+
+    select 'pg_type'::regclass, t.oid, 0::int2,
+          case t.typtype
+            when 'd' then format('domain:%I.%I', ns.nspname, t.typname)
+            when 'e' then format('type:%I.%I', ns.nspname, t.typname)
+            when 'r' then format('type:%I.%I', ns.nspname, t.typname)
+            when 'm' then format('multirange:%I.%I', ns.nspname, t.typname)
+            when 'c' then
+              case
+                when r.oid is not null and r.relkind in ('r','p','f') then format('table:%I.%I', rns.nspname, r.relname)
+                when r.oid is not null and r.relkind = 'v' then format('view:%I.%I', rns.nspname, r.relname)
+                when r.oid is not null and r.relkind = 'm' then format('materializedView:%I.%I', rns.nspname, r.relname)
+                else format('type:%I.%I', ns.nspname, t.typname)
+              end
+            when 'p' then format('pseudoType:%I.%I', ns.nspname, t.typname)
+            else format('type:%I.%I', ns.nspname, t.typname)
+          end as stable_id
+    from pg_type t
+    join pg_namespace ns on ns.oid = t.typnamespace
+    left join pg_class r on r.oid = t.typrelid
+    left join pg_namespace rns on rns.oid = r.relnamespace
+    join ids i on i.classid = 'pg_type'::regclass and i.objid = t.oid and i.objsubid = 0
+
+    union all
+
+    select 'pg_constraint'::regclass, c.oid, 0::int2,
+          case
+            when c.contypid <> 0 then format('constraint:%I.%I.%I', ns.nspname, ty.typname, c.conname)
+            when c.conrelid <> 0 then format('constraint:%I.%I.%I', tbl_ns.nspname, tbl.relname, c.conname)
+            else format('constraint:%s', c.oid::text)
+          end as stable_id
+    from pg_constraint c
+    left join pg_type ty on ty.oid = c.contypid
+    left join pg_namespace ns on ns.oid = ty.typnamespace
+    left join pg_class tbl on tbl.oid = c.conrelid
+    left join pg_namespace tbl_ns on tbl_ns.oid = tbl.relnamespace
+    join ids i on i.classid = 'pg_constraint'::regclass and i.objid = c.oid and i.objsubid = 0
+
+    union all
+
+    select 'pg_proc'::regclass, p.oid, 0::int2,
+          format(
+            'procedure:%I.%I(%s)',
+            ns.nspname,
+            p.proname,
+            coalesce((select string_agg(format_type(oid, null), ',' order by ord)
+              from unnest(p.proargtypes) with ordinality as t(oid, ord)), '')
+          ) as stable_id
+    from pg_proc p
+    join pg_namespace ns on ns.oid = p.pronamespace
+    join ids i on i.classid = 'pg_proc'::regclass and i.objid = p.oid and i.objsubid = 0
+
+    union all
+
+    select 'pg_trigger'::regclass, tg.oid, 0::int2,
+          format('trigger:%I.%I.%I', ns.nspname, tbl.relname, tg.tgname) as stable_id
+    from pg_trigger tg
+    join pg_class tbl on tbl.oid = tg.tgrelid
+    join pg_namespace ns on ns.oid = tbl.relnamespace
+    join ids i on i.classid = 'pg_trigger'::regclass and i.objid = tg.oid and i.objsubid = 0
+
+    union all
+
+    select 'pg_collation'::regclass, c.oid, 0::int2,
+          format('collation:%I.%I', ns.nspname, c.collname) as stable_id
+    from pg_collation c
+    join pg_namespace ns on ns.oid = c.collnamespace
+    join ids i on i.classid = 'pg_collation'::regclass and i.objid = c.oid and i.objsubid = 0
+
+    union all
+
+    select 'pg_event_trigger'::regclass, et.oid, 0::int2,
+          format('eventTrigger:%I', et.evtname) as stable_id
+    from pg_event_trigger et
+    join ids i on i.classid = 'pg_event_trigger'::regclass and i.objid = et.oid and i.objsubid = 0
+
+    union all
+
+    select 'pg_ts_config'::regclass, cfg.oid, 0::int2,
+          format('tsConfig:%I.%I', ns.nspname, cfg.cfgname) as stable_id
+    from pg_ts_config cfg
+    join pg_namespace ns on ns.oid = cfg.cfgnamespace
+    join ids i on i.classid = 'pg_ts_config'::regclass and i.objid = cfg.oid and i.objsubid = 0
+
+    union all
+
+    select 'pg_ts_dict'::regclass, dict.oid, 0::int2,
+          format('tsDict:%I.%I', ns.nspname, dict.dictname) as stable_id
+    from pg_ts_dict dict
+    join pg_namespace ns on ns.oid = dict.dictnamespace
+    join ids i on i.classid = 'pg_ts_dict'::regclass and i.objid = dict.oid and i.objsubid = 0
+
+    union all
+
+    select 'pg_ts_template'::regclass, tmpl.oid, 0::int2,
+          format('tsTemplate:%I.%I', ns.nspname, tmpl.tmplname) as stable_id
+    from pg_ts_template tmpl
+    join pg_namespace ns on ns.oid = tmpl.tmplnamespace
+    join ids i on i.classid = 'pg_ts_template'::regclass and i.objid = tmpl.oid and i.objsubid = 0
+  ), extension_members as (
+    select
+      em.extension_oid,
+      obj.stable_id
+    from extension_members_raw em
+    join objects obj
+      on obj.classid = em.classid
+      and obj.objid = em.objid
+      and obj.objsubid = coalesce(nullif(em.objsubid, 0), 0)
+  )
+  select
+    er.name,
+    er.schema,
+    er.relocatable,
+    er.version,
+    er.owner,
+    er.comment,
+    coalesce(
+      (
+        select json_agg(em.stable_id order by em.stable_id)
+        from extension_members em
+        where em.extension_oid = er.oid
+      ), '[]'::json
+    ) as members
+  from extension_rows er
+  order by
+    er.name;
+  `;
+        // Validate and parse each row using the Zod schema
+        const validatedRows = extensionRows.map((row) => extensionPropsSchema.parse(row));
+        return validatedRows.map((row) => new Extension(row));
+    });
+}

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper/changes/foreign-data-wrapper.alter.d.ts

@@ -0,0 +1,51 @@
+import type { ForeignDataWrapper } from "../foreign-data-wrapper.model.ts";
+import { AlterForeignDataWrapperChange } from "./foreign-data-wrapper.base.ts";
+/**
+ * Alter a foreign data wrapper.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterforeigndatawrapper.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER FOREIGN DATA WRAPPER name
+ *     [ OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] ) ]
+ * ALTER FOREIGN DATA WRAPPER name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ * ```
+ */
+export type AlterForeignDataWrapper = AlterForeignDataWrapperChangeOwner | AlterForeignDataWrapperSetOptions;
+/**
+ * ALTER FOREIGN DATA WRAPPER ... OWNER TO ...
+ */
+export declare class AlterForeignDataWrapperChangeOwner extends AlterForeignDataWrapperChange {
+    readonly foreignDataWrapper: ForeignDataWrapper;
+    readonly owner: string;
+    readonly scope: "object";
+    constructor(props: {
+        foreignDataWrapper: ForeignDataWrapper;
+        owner: string;
+    });
+    get requires(): (`role:${string}` | `foreignDataWrapper:${string}`)[];
+    serialize(): string;
+}
+/**
+ * ALTER FOREIGN DATA WRAPPER ... OPTIONS ( ADD | SET | DROP ... )
+ */
+export declare class AlterForeignDataWrapperSetOptions extends AlterForeignDataWrapperChange {
+    readonly foreignDataWrapper: ForeignDataWrapper;
+    readonly options: Array<{
+        action: "ADD" | "SET" | "DROP";
+        option: string;
+        value?: string;
+    }>;
+    readonly scope: "object";
+    constructor(props: {
+        foreignDataWrapper: ForeignDataWrapper;
+        options: Array<{
+            action: "ADD" | "SET" | "DROP";
+            option: string;
+            value?: string;
+        }>;
+    });
+    get requires(): `foreignDataWrapper:${string}`[];
+    serialize(): string;
+}

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper/changes/foreign-data-wrapper.alter.js

@@ -0,0 +1,61 @@
+import { quoteLiteral } from "../../../base.change.js";
+import { stableId } from "../../../utils.js";
+import { AlterForeignDataWrapperChange } from "./foreign-data-wrapper.base.js";
+/**
+ * ALTER FOREIGN DATA WRAPPER ... OWNER TO ...
+ */
+export class AlterForeignDataWrapperChangeOwner extends AlterForeignDataWrapperChange {
+    foreignDataWrapper;
+    owner;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.foreignDataWrapper = props.foreignDataWrapper;
+        this.owner = props.owner;
+    }
+    get requires() {
+        return [this.foreignDataWrapper.stableId, stableId.role(this.owner)];
+    }
+    serialize() {
+        return [
+            "ALTER FOREIGN DATA WRAPPER",
+            this.foreignDataWrapper.name,
+            "OWNER TO",
+            this.owner,
+        ].join(" ");
+    }
+}
+/**
+ * ALTER FOREIGN DATA WRAPPER ... OPTIONS ( ADD | SET | DROP ... )
+ */
+export class AlterForeignDataWrapperSetOptions extends AlterForeignDataWrapperChange {
+    foreignDataWrapper;
+    options;
+    scope = "object";
+    constructor(props) {
+        super();
+        this.foreignDataWrapper = props.foreignDataWrapper;
+        this.options = props.options;
+    }
+    get requires() {
+        return [this.foreignDataWrapper.stableId];
+    }
+    serialize() {
+        const optionParts = [];
+        for (const opt of this.options) {
+            if (opt.action === "DROP") {
+                optionParts.push(`DROP ${opt.option}`);
+            }
+            else {
+                const value = opt.value !== undefined ? quoteLiteral(opt.value) : "''";
+                optionParts.push(`${opt.action} ${opt.option} ${value}`);
+            }
+        }
+        return [
+            "ALTER FOREIGN DATA WRAPPER",
+            this.foreignDataWrapper.name,
+            "OPTIONS",
+            `(${optionParts.join(", ")})`,
+        ].join(" ");
+    }
+}

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper/changes/foreign-data-wrapper.base.d.ts

@@ -0,0 +1,17 @@
+import { BaseChange } from "../../../base.change.ts";
+import type { ForeignDataWrapper } from "../foreign-data-wrapper.model.ts";
+declare abstract class BaseForeignDataWrapperChange extends BaseChange {
+    abstract readonly foreignDataWrapper: ForeignDataWrapper;
+    abstract readonly scope: "object" | "comment" | "privilege";
+    readonly objectType: "foreign_data_wrapper";
+}
+export declare abstract class CreateForeignDataWrapperChange extends BaseForeignDataWrapperChange {
+    readonly operation: "create";
+}
+export declare abstract class AlterForeignDataWrapperChange extends BaseForeignDataWrapperChange {
+    readonly operation: "alter";
+}
+export declare abstract class DropForeignDataWrapperChange extends BaseForeignDataWrapperChange {
+    readonly operation: "drop";
+}
+export {};

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper/changes/foreign-data-wrapper.base.js

@@ -0,0 +1,13 @@
+import { BaseChange } from "../../../base.change.js";
+class BaseForeignDataWrapperChange extends BaseChange {
+    objectType = "foreign_data_wrapper";
+}
+export class CreateForeignDataWrapperChange extends BaseForeignDataWrapperChange {
+    operation = "create";
+}
+export class AlterForeignDataWrapperChange extends BaseForeignDataWrapperChange {
+    operation = "alter";
+}
+export class DropForeignDataWrapperChange extends BaseForeignDataWrapperChange {
+    operation = "drop";
+}

package/dist/core/objects/foreign-data-wrapper/foreign-data-wrapper/changes/foreign-data-wrapper.comment.d.ts

@@ -0,0 +1,26 @@
+import type { ForeignDataWrapper } from "../foreign-data-wrapper.model.ts";
+import { CreateForeignDataWrapperChange, DropForeignDataWrapperChange } from "./foreign-data-wrapper.base.ts";
+/**
+ * Create/drop comments on foreign data wrappers.
+ */
+export type CommentForeignDataWrapper = CreateCommentOnForeignDataWrapper | DropCommentOnForeignDataWrapper;
+export declare class CreateCommentOnForeignDataWrapper extends CreateForeignDataWrapperChange {
+    readonly foreignDataWrapper: ForeignDataWrapper;
+    readonly scope: "comment";
+    constructor(props: {
+        foreignDataWrapper: ForeignDataWrapper;
+    });
+    get creates(): `comment:${string}`[];
+    get requires(): `foreignDataWrapper:${string}`[];
+    serialize(): string;
+}
+export declare class DropCommentOnForeignDataWrapper extends DropForeignDataWrapperChange {
+    readonly foreignDataWrapper: ForeignDataWrapper;
+    readonly scope: "comment";
+    constructor(props: {
+        foreignDataWrapper: ForeignDataWrapper;
+    });
+    get drops(): `comment:${string}`[];
+    get requires(): (`comment:${string}` | `foreignDataWrapper:${string}`)[];
+    serialize(): string;
+}