@supabase/pg-delta 1.0.0-alpha.2 → 1.0.0-alpha.21

package/src/core/objects/foreign-data-wrapper/foreign-table/foreign-table.diff.ts

@@ -0,0 +1,343 @@
+import { diffObjects } from "../../base.diff.ts";
+import {
+  diffPrivileges,
+  emitObjectPrivilegeChanges,
+  filterPublicBuiltInDefaults,
+} from "../../base.privilege-diff.ts";
+import type { ObjectDiffContext } from "../../diff-context.ts";
+import {
+  AlterForeignTableAddColumn,
+  AlterForeignTableAlterColumnDropDefault,
+  AlterForeignTableAlterColumnDropNotNull,
+  AlterForeignTableAlterColumnSetDefault,
+  AlterForeignTableAlterColumnSetNotNull,
+  AlterForeignTableAlterColumnType,
+  AlterForeignTableChangeOwner,
+  AlterForeignTableDropColumn,
+  AlterForeignTableSetOptions,
+} from "./changes/foreign-table.alter.ts";
+import {
+  CreateCommentOnForeignTable,
+  DropCommentOnForeignTable,
+} from "./changes/foreign-table.comment.ts";
+import { CreateForeignTable } from "./changes/foreign-table.create.ts";
+import { DropForeignTable } from "./changes/foreign-table.drop.ts";
+import {
+  GrantForeignTablePrivileges,
+  RevokeForeignTablePrivileges,
+  RevokeGrantOptionForeignTablePrivileges,
+} from "./changes/foreign-table.privilege.ts";
+import type { ForeignTableChange } from "./changes/foreign-table.types.ts";
+import type { ForeignTable } from "./foreign-table.model.ts";
+
+/**
+ * Diff two sets of foreign tables from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The foreign tables in the main catalog.
+ * @param branch - The foreign tables in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffForeignTables(
+  ctx: Pick<
+    ObjectDiffContext,
+    "version" | "currentUser" | "defaultPrivilegeState"
+  >,
+  main: Record<string, ForeignTable>,
+  branch: Record<string, ForeignTable>,
+): ForeignTableChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+
+  const changes: ForeignTableChange[] = [];
+
+  for (const tableId of created) {
+    const createdTable = branch[tableId];
+    changes.push(new CreateForeignTable({ foreignTable: createdTable }));
+
+    // OWNER: If the table should be owned by someone other than the current user,
+    // emit ALTER FOREIGN TABLE ... OWNER TO after creation
+    if (createdTable.owner !== ctx.currentUser) {
+      changes.push(
+        new AlterForeignTableChangeOwner({
+          foreignTable: createdTable,
+          owner: createdTable.owner,
+        }),
+      );
+    }
+
+    if (createdTable.comment !== null) {
+      changes.push(
+        new CreateCommentOnForeignTable({ foreignTable: createdTable }),
+      );
+    }
+
+    // PRIVILEGES: For created objects, compare against default privileges state
+    const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(
+      ctx.currentUser,
+      "foreign_table",
+      createdTable.schema ?? "",
+    );
+    const creatorFilteredDefaults =
+      createdTable.owner !== ctx.currentUser
+        ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+        : effectiveDefaults;
+    const desiredPrivileges = filterPublicBuiltInDefaults(
+      "foreign_table",
+      createdTable.privileges,
+    );
+    const privilegeResults = diffPrivileges(
+      filterPublicBuiltInDefaults("foreign_table", creatorFilteredDefaults),
+      desiredPrivileges,
+      createdTable.owner,
+    );
+
+    changes.push(
+      ...(emitObjectPrivilegeChanges(
+        privilegeResults,
+        createdTable,
+        createdTable,
+        "foreignTable",
+        {
+          Grant: GrantForeignTablePrivileges,
+          Revoke: RevokeForeignTablePrivileges,
+          RevokeGrantOption: RevokeGrantOptionForeignTablePrivileges,
+        },
+        ctx.version,
+      ) as ForeignTableChange[]),
+    );
+  }
+
+  for (const tableId of dropped) {
+    changes.push(new DropForeignTable({ foreignTable: main[tableId] }));
+  }
+
+  for (const tableId of altered) {
+    const mainTable = main[tableId];
+    const branchTable = branch[tableId];
+
+    // OWNER
+    if (mainTable.owner !== branchTable.owner) {
+      changes.push(
+        new AlterForeignTableChangeOwner({
+          foreignTable: mainTable,
+          owner: branchTable.owner,
+        }),
+      );
+    }
+
+    // SERVER - if changed, need to recreate (not directly alterable)
+    if (mainTable.server !== branchTable.server) {
+      changes.push(new DropForeignTable({ foreignTable: mainTable }));
+      changes.push(new CreateForeignTable({ foreignTable: branchTable }));
+      if (branchTable.comment !== null) {
+        changes.push(
+          new CreateCommentOnForeignTable({ foreignTable: branchTable }),
+        );
+      }
+      continue;
+    }
+
+    // COLUMNS
+    const mainColumnsByName = new Map(
+      mainTable.columns.map((c) => [c.name, c]),
+    );
+    const branchColumnsByName = new Map(
+      branchTable.columns.map((c) => [c.name, c]),
+    );
+
+    // Added columns
+    for (const [name, col] of branchColumnsByName) {
+      if (!mainColumnsByName.has(name)) {
+        changes.push(
+          new AlterForeignTableAddColumn({
+            foreignTable: mainTable,
+            column: col,
+          }),
+        );
+      }
+    }
+
+    // Dropped columns
+    for (const [name] of mainColumnsByName) {
+      if (!branchColumnsByName.has(name)) {
+        changes.push(
+          new AlterForeignTableDropColumn({
+            foreignTable: mainTable,
+            columnName: name,
+          }),
+        );
+      }
+    }
+
+    // Altered columns
+    for (const [name, mainCol] of mainColumnsByName) {
+      const branchCol = branchColumnsByName.get(name);
+      if (!branchCol) continue;
+
+      // Type change
+      if (mainCol.data_type_str !== branchCol.data_type_str) {
+        changes.push(
+          new AlterForeignTableAlterColumnType({
+            foreignTable: mainTable,
+            columnName: name,
+            dataType: branchCol.data_type_str,
+          }),
+        );
+      }
+
+      // Default change
+      if (mainCol.default !== branchCol.default) {
+        if (branchCol.default === null) {
+          changes.push(
+            new AlterForeignTableAlterColumnDropDefault({
+              foreignTable: mainTable,
+              columnName: name,
+            }),
+          );
+        } else {
+          changes.push(
+            new AlterForeignTableAlterColumnSetDefault({
+              foreignTable: mainTable,
+              columnName: name,
+              defaultValue: branchCol.default,
+            }),
+          );
+        }
+      }
+
+      // NOT NULL change
+      if (mainCol.not_null !== branchCol.not_null) {
+        if (branchCol.not_null) {
+          changes.push(
+            new AlterForeignTableAlterColumnSetNotNull({
+              foreignTable: mainTable,
+              columnName: name,
+            }),
+          );
+        } else {
+          changes.push(
+            new AlterForeignTableAlterColumnDropNotNull({
+              foreignTable: mainTable,
+              columnName: name,
+            }),
+          );
+        }
+      }
+    }
+
+    // OPTIONS
+    const optionsChanged = diffOptions(mainTable.options, branchTable.options);
+    if (optionsChanged.length > 0) {
+      changes.push(
+        new AlterForeignTableSetOptions({
+          foreignTable: mainTable,
+          options: optionsChanged,
+        }),
+      );
+    }
+
+    // COMMENT
+    if (mainTable.comment !== branchTable.comment) {
+      if (branchTable.comment === null) {
+        changes.push(
+          new DropCommentOnForeignTable({ foreignTable: mainTable }),
+        );
+      } else {
+        changes.push(
+          new CreateCommentOnForeignTable({ foreignTable: branchTable }),
+        );
+      }
+    }
+
+    // PRIVILEGES
+    const mainPrivilegesFiltered = filterPublicBuiltInDefaults(
+      "foreign_table",
+      mainTable.privileges,
+    );
+    const branchPrivilegesFiltered = filterPublicBuiltInDefaults(
+      "foreign_table",
+      branchTable.privileges,
+    );
+    const privilegeResults = diffPrivileges(
+      mainPrivilegesFiltered,
+      branchPrivilegesFiltered,
+      branchTable.owner,
+    );
+
+    changes.push(
+      ...(emitObjectPrivilegeChanges(
+        privilegeResults,
+        branchTable,
+        mainTable,
+        "foreignTable",
+        {
+          Grant: GrantForeignTablePrivileges,
+          Revoke: RevokeForeignTablePrivileges,
+          RevokeGrantOption: RevokeGrantOptionForeignTablePrivileges,
+        },
+        ctx.version,
+      ) as ForeignTableChange[]),
+    );
+
+    // Note: Foreign table renaming would also use ALTER FOREIGN TABLE ... RENAME TO ...
+    // But since our ForeignTable model uses 'name' as the identity field,
+    // a name change would be handled as drop + create by diffObjects()
+  }
+
+  return changes;
+}
+
+/**
+ * Diff options arrays to determine ADD/SET/DROP operations.
+ * Options are stored as [key1, value1, key2, value2, ...]
+ */
+function diffOptions(
+  mainOptions: string[] | null,
+  branchOptions: string[] | null,
+): Array<{ action: "ADD" | "SET" | "DROP"; option: string; value?: string }> {
+  const mainMap = new Map<string, string>();
+  const branchMap = new Map<string, string>();
+
+  // 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: Array<{
+    action: "ADD" | "SET" | "DROP";
+    option: string;
+    value?: string;
+  }> = [];
+
+  // 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/src/core/objects/foreign-data-wrapper/foreign-table/foreign-table.model.ts

@@ -0,0 +1,242 @@
+import { sql } from "@ts-safeql/sql-tag";
+import type { Pool } from "pg";
+import z from "zod";
+import {
+  BasePgModel,
+  columnPropsSchema,
+  type TableLikeObject,
+} from "../../base.model.ts";
+import {
+  type PrivilegeProps,
+  privilegePropsSchema,
+} from "../../base.privilege-diff.ts";
+
+/**
+ * All properties exposed by CREATE FOREIGN TABLE statement are included in diff output.
+ * https://www.postgresql.org/docs/17/sql-createforeigntable.html
+ *
+ * ALTER FOREIGN TABLE statement can be generated for changes to the following properties:
+ *  - owner, columns, options
+ * https://www.postgresql.org/docs/17/sql-alterforeigntable.html
+ *
+ * Foreign tables are schema-qualified and similar to regular tables but reference a server.
+ */
+const foreignTablePropsSchema = z.object({
+  schema: z.string(),
+  name: z.string(),
+  owner: z.string(),
+  server: z.string(),
+  options: z.array(z.string()).nullable(),
+  comment: z.string().nullable(),
+  columns: z.array(columnPropsSchema),
+  privileges: z.array(privilegePropsSchema),
+});
+
+type ForeignTablePrivilegeProps = PrivilegeProps;
+export type ForeignTableProps = z.infer<typeof foreignTablePropsSchema>;
+
+export class ForeignTable extends BasePgModel implements TableLikeObject {
+  public readonly schema: ForeignTableProps["schema"];
+  public readonly name: ForeignTableProps["name"];
+  public readonly owner: ForeignTableProps["owner"];
+  public readonly server: ForeignTableProps["server"];
+  public readonly options: ForeignTableProps["options"];
+  public readonly comment: ForeignTableProps["comment"];
+  public readonly columns: ForeignTableProps["columns"];
+  public readonly privileges: ForeignTablePrivilegeProps[];
+
+  constructor(props: ForeignTableProps) {
+    super();
+
+    // Identity fields
+    this.schema = props.schema;
+    this.name = props.name;
+
+    // Data fields
+    this.owner = props.owner;
+    this.server = props.server;
+    this.options = props.options;
+    this.comment = props.comment;
+    this.columns = props.columns;
+    this.privileges = props.privileges;
+  }
+
+  get stableId(): `foreignTable:${string}` {
+    return `foreignTable:${this.schema}.${this.name}`;
+  }
+
+  get identityFields() {
+    return {
+      schema: this.schema,
+      name: this.name,
+    };
+  }
+
+  get dataFields() {
+    return {
+      owner: this.owner,
+      server: this.server,
+      options: this.options,
+      comment: this.comment,
+      columns: this.columns,
+      privileges: this.privileges,
+    };
+  }
+
+  override stableSnapshot() {
+    const normalizeColumns = () =>
+      [...this.columns]
+        .map((col) => {
+          const { position: _pos, ...rest } = col as unknown as Record<
+            string,
+            unknown
+          >;
+          return rest;
+        })
+        .sort((a, b) => {
+          const nameA = (a.name as string | undefined) ?? "";
+          const nameB = (b.name as string | undefined) ?? "";
+          return nameA.localeCompare(nameB);
+        });
+
+    return {
+      identity: this.identityFields,
+      data: {
+        ...this.dataFields,
+        columns: normalizeColumns(),
+      },
+    };
+  }
+}
+
+export async function extractForeignTables(
+  pool: Pool,
+): Promise<ForeignTable[]> {
+  const { rows: tableRows } = await pool.query<ForeignTableProps>(sql`
+      with extension_oids as (
+        select objid
+        from pg_depend d
+        where d.refclassid = 'pg_extension'::regclass
+          and d.classid = 'pg_class'::regclass
+      ), foreign_tables as (
+        select
+          c.relnamespace::regnamespace::text as schema,
+          quote_ident(c.relname) as name,
+          c.relowner::regrole::text as owner,
+          quote_ident(srv.srvname) as server,
+          coalesce(ft.ftoptions, array[]::text[]) as options,
+          c.oid as oid
+        from
+          pg_class c
+          inner join pg_foreign_table ft on ft.ftrelid = c.oid
+          inner join pg_foreign_server srv on srv.oid = ft.ftserver
+          inner join pg_foreign_data_wrapper fdw on fdw.oid = srv.srvfdw
+          left outer join extension_oids e1 on c.oid = e1.objid
+        where
+          c.relkind = 'f'
+          and not c.relnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+          and e1.objid is null
+          and not fdw.fdwname like any(array['pg\\_%'])
+      )
+      select
+        ft.schema,
+        ft.name,
+        ft.owner,
+        ft.server,
+        ft.options,
+        obj_description(ft.oid, 'pg_class') as comment,
+        coalesce(json_agg(
+          case when a.attname is not null then
+            json_build_object(
+              'name', quote_ident(a.attname),
+              'position', a.attnum,
+              'data_type', a.atttypid::regtype::text,
+              'data_type_str', format_type(a.atttypid, a.atttypmod),
+              'is_custom_type', ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema'),
+              'custom_type_type', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then ty.typtype else null end,
+              'custom_type_category', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then ty.typcategory else null end,
+              'custom_type_schema', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then ty.typnamespace::regnamespace else null end,
+              'custom_type_name', case when ty.typnamespace::regnamespace::text not in ('pg_catalog', 'information_schema') then quote_ident(ty.typname) else null end,
+              'not_null', a.attnotnull,
+              'is_identity', a.attidentity != '',
+              'is_identity_always', a.attidentity = 'a',
+              'is_generated', a.attgenerated != '',
+              'collation', (
+                select quote_ident(c2.collname)
+                from pg_collation c2, pg_type t2
+                where c2.oid = a.attcollation
+                  and t2.oid = a.atttypid
+                  and a.attcollation <> t2.typcollation
+              ),
+              'default', pg_get_expr(ad.adbin, ad.adrelid),
+              'comment', col_description(a.attrelid, a.attnum)
+            )
+          end
+          order by a.attnum
+        ) filter (where a.attname is not null), '[]') as columns,
+        coalesce((
+          select json_agg(
+                  json_build_object(
+                    'grantee', case when grp.grantee = 0 then 'PUBLIC' else grp.grantee::regrole::text end,
+                    'privilege', grp.privilege_type,
+                    'grantable', grp.is_grantable,
+                    'columns', case when grp.cols is not null and array_length(grp.cols,1) > 0
+                                    then grp.cols
+                                    else null end
+                  )
+                  order by grp.grantee, grp.privilege_type
+                )
+          from (
+            select
+              x.grantee,
+              x.privilege_type,
+              bool_or(x.is_grantable) as is_grantable,
+              array_agg(quote_ident(src.attname) order by src.attname)
+                filter (where src.attname is not null) as cols
+            from (
+              -- one row for object ACL + one row per column ACL
+              select null::name as attname, ft.oid as relacl_oid, (
+                select COALESCE(c_rel.relacl, acldefault('r', c_rel.relowner)) from pg_class c_rel where c_rel.oid = ft.oid
+              ) as acl
+              union all
+              select a2.attname, ft.oid as relacl_oid, a2.attacl
+              from pg_attribute a2
+              where a2.attrelid = ft.oid
+                and a2.attnum > 0
+                and not a2.attisdropped
+                and a2.attacl is not null
+            ) as src
+            join lateral aclexplode(src.acl) as x(grantor, grantee, privilege_type, is_grantable) on true
+            group by x.grantee, x.privilege_type
+          ) as grp
+        ), '[]') as privileges
+      from
+        foreign_tables ft
+        left join pg_attribute a on a.attrelid = ft.oid and a.attnum > 0 and not a.attisdropped
+        left join pg_attrdef ad on a.attrelid = ad.adrelid and a.attnum = ad.adnum
+        left join pg_type ty on ty.oid = a.atttypid
+      group by
+        ft.oid, ft.schema, ft.name, ft.owner, ft.server, ft.options
+      order by
+        ft.schema, ft.name
+  `);
+
+  // Validate and parse each row using the Zod schema
+  const validatedRows = tableRows.map((row: unknown) => {
+    const parsed = foreignTablePropsSchema.parse(row);
+    // Parse options from PostgreSQL format ['key=value'] to ['key', 'value']
+    if (parsed.options && parsed.options.length > 0) {
+      const parsedOptions: string[] = [];
+      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: ForeignTableProps) => new ForeignTable(row));
+}