@supabase/pg-delta 1.0.0-alpha.3 → 1.0.0-alpha.30

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

@@ -0,0 +1,107 @@
+import { diffObjects } from "../../base.diff.ts";
+import { AlterUserMappingSetOptions } from "./changes/user-mapping.alter.ts";
+import { CreateUserMapping } from "./changes/user-mapping.create.ts";
+import { DropUserMapping } from "./changes/user-mapping.drop.ts";
+import type { UserMappingChange } from "./changes/user-mapping.types.ts";
+import type { UserMapping } from "./user-mapping.model.ts";
+
+/**
+ * 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: Record<string, UserMapping>,
+  branch: Record<string, UserMapping>,
+): UserMappingChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+
+  const changes: UserMappingChange[] = [];
+
+  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: 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/user-mapping/user-mapping.model.ts

@@ -0,0 +1,123 @@
+import { sql } from "@ts-safeql/sql-tag";
+import type { Pool } from "pg";
+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.
+ */
+const userMappingPropsSchema = z.object({
+  user: z.string(),
+  server: z.string(),
+  options: z.array(z.string()).nullable(),
+  // Parent FDW handler/validator — filter metadata only, not in dataFields.
+  wrapper_handler: z.string().nullable().optional(),
+  wrapper_validator: z.string().nullable().optional(),
+});
+
+export type UserMappingProps = z.infer<typeof userMappingPropsSchema>;
+
+export class UserMapping extends BasePgModel {
+  public readonly user: UserMappingProps["user"];
+  public readonly server: UserMappingProps["server"];
+  public readonly options: UserMappingProps["options"];
+  public readonly wrapper_handler: UserMappingProps["wrapper_handler"];
+  public readonly wrapper_validator: UserMappingProps["wrapper_validator"];
+
+  constructor(props: UserMappingProps) {
+    super();
+
+    // Identity fields
+    this.user = props.user;
+    this.server = props.server;
+
+    // Data fields
+    this.options = props.options;
+    this.wrapper_handler = props.wrapper_handler ?? null;
+    this.wrapper_validator = props.wrapper_validator ?? null;
+  }
+
+  get stableId(): `userMapping:${string}:${string}` {
+    return `userMapping:${this.server}:${this.user}`;
+  }
+
+  get identityFields() {
+    return {
+      user: this.user,
+      server: this.server,
+    };
+  }
+
+  get dataFields() {
+    return {
+      options: this.options,
+    };
+  }
+}
+
+/**
+ * Extract `pg_user_mapping` rows into `UserMapping` models.
+ *
+ * The returned models carry option values **verbatim** from
+ * `pg_user_mapping.umoptions`, which means cleartext secrets like
+ * `password` are present in memory. Always route through
+ * `extractCatalog` (which calls `normalizeCatalog`) before emitting
+ * options to any output channel — see CLI-1467 and
+ * `packages/pg-delta/src/core/objects/foreign-data-wrapper/sensitive-options.ts`.
+ */
+export async function extractUserMappings(pool: Pool): Promise<UserMapping[]> {
+  const { rows: mappingRows } = await pool.query<UserMappingProps>(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,
+        case
+          when fdw.fdwhandler = 0 then null
+          else p_handler.pronamespace::regnamespace::text || '.' || quote_ident(p_handler.proname)
+        end as wrapper_handler,
+        case
+          when fdw.fdwvalidator = 0 then null
+          else p_validator.pronamespace::regnamespace::text || '.' || quote_ident(p_validator.proname)
+        end as wrapper_validator
+      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
+        left join pg_catalog.pg_proc p_handler on p_handler.oid = fdw.fdwhandler
+        left join pg_catalog.pg_proc p_validator on p_validator.oid = fdw.fdwvalidator
+      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: unknown) => {
+    const parsed = userMappingPropsSchema.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: UserMappingProps) => new UserMapping(row));
+}

package/src/core/objects/index/changes/index.alter.test.ts

@@ -0,0 +1,209 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Index, type IndexProps } from "../index.model.ts";
+import {
+  AlterIndexSetStatistics,
+  AlterIndexSetStorageParams,
+  AlterIndexSetTablespace,
+} from "./index.alter.ts";
+
+describe.concurrent("index", () => {
+  describe("alter", () => {
+    test("set storage params", async () => {
+      const props: Omit<IndexProps, "storage_params"> = {
+        schema: "public",
+        table_name: "test_table",
+        name: "test_index",
+        statistics_target: [0],
+        index_type: "btree",
+        tablespace: null,
+        is_owned_by_constraint: false,
+        is_unique: false,
+        is_primary: false,
+        is_exclusion: false,
+        nulls_not_distinct: false,
+        immediate: true,
+        is_clustered: false,
+        is_replica_identity: false,
+        key_columns: [1],
+        column_collations: [],
+        operator_classes: [],
+        column_options: [],
+        index_expressions: null,
+        partial_predicate: null,
+        table_relkind: "r",
+        is_partitioned_index: false,
+        is_index_partition: false,
+        parent_index_name: null,
+        definition:
+          "CREATE INDEX test_index ON public.test_table USING btree (id)",
+        comment: null,
+        owner: "test",
+      };
+      const index = new Index({
+        ...props,
+        storage_params: [],
+      });
+
+      const change = new AlterIndexSetStorageParams({
+        index,
+        paramsToSet: ["fillfactor=90"],
+        keysToReset: [],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER INDEX public.test_index SET (fillfactor=90)",
+      );
+    });
+
+    test("reset and set storage params", async () => {
+      const props: Omit<IndexProps, "storage_params"> = {
+        schema: "public",
+        table_name: "test_table",
+        name: "test_index",
+        statistics_target: [0],
+        index_type: "btree",
+        tablespace: null,
+        is_unique: false,
+        is_primary: false,
+        is_owned_by_constraint: false,
+        is_exclusion: false,
+        nulls_not_distinct: false,
+        immediate: true,
+        is_clustered: false,
+        is_replica_identity: false,
+        key_columns: [1],
+        column_collations: [],
+        operator_classes: [],
+        column_options: [],
+        index_expressions: null,
+        partial_predicate: null,
+        table_relkind: "r",
+        is_partitioned_index: false,
+        is_index_partition: false,
+        parent_index_name: null,
+        definition:
+          "CREATE INDEX test_index ON public.test_table USING btree (id)",
+        comment: null,
+        owner: "test",
+      };
+      const index = new Index({
+        ...props,
+        storage_params: ["fillfactor=70", "fastupdate=on"],
+      });
+
+      const change = new AlterIndexSetStorageParams({
+        index,
+        paramsToSet: ["fillfactor=90"],
+        keysToReset: ["fastupdate"],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        [
+          "ALTER INDEX public.test_index RESET (fastupdate)",
+          "ALTER INDEX public.test_index SET (fillfactor=90)",
+        ].join(";\n"),
+      );
+    });
+
+    test("set statistics", async () => {
+      const props: Omit<IndexProps, "statistics_target"> = {
+        schema: "public",
+        table_name: "test_table",
+        name: "test_index",
+        storage_params: [],
+        index_type: "btree",
+        tablespace: null,
+        is_unique: false,
+        is_primary: false,
+        is_exclusion: false,
+        is_owned_by_constraint: false,
+        nulls_not_distinct: false,
+        immediate: true,
+        is_clustered: false,
+        is_replica_identity: false,
+        key_columns: [1],
+        column_collations: [],
+        operator_classes: [],
+        column_options: [],
+        index_expressions: null,
+        partial_predicate: null,
+        table_relkind: "r",
+        is_partitioned_index: false,
+        is_index_partition: false,
+        parent_index_name: null,
+        definition:
+          "CREATE INDEX test_index ON public.test_table USING btree (id)",
+        comment: null,
+        owner: "test",
+      };
+      const index = new Index({
+        ...props,
+        statistics_target: [0],
+      });
+
+      const change = new AlterIndexSetStatistics({
+        index,
+        columnTargets: [{ columnNumber: 1, statistics: 100 }],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER INDEX public.test_index ALTER COLUMN 1 SET STATISTICS 100",
+      );
+    });
+
+    test("set tablespace", async () => {
+      const props: Omit<IndexProps, "tablespace"> = {
+        schema: "public",
+        table_name: "test_table",
+        name: "test_index",
+        storage_params: [],
+        statistics_target: [0],
+        index_type: "btree",
+        is_unique: false,
+        is_primary: false,
+        is_owned_by_constraint: false,
+        is_exclusion: false,
+        nulls_not_distinct: false,
+        immediate: true,
+        is_clustered: false,
+        is_replica_identity: false,
+        key_columns: [1],
+        column_collations: [],
+        operator_classes: [],
+        column_options: [],
+        index_expressions: null,
+        partial_predicate: null,
+        table_relkind: "r",
+        is_partitioned_index: false,
+        is_index_partition: false,
+        parent_index_name: null,
+        definition:
+          "CREATE INDEX test_index ON public.test_table USING btree (id)",
+        comment: null,
+        owner: "test",
+      };
+      const index = new Index({
+        ...props,
+        tablespace: null,
+      });
+
+      const change = new AlterIndexSetTablespace({
+        index,
+        tablespace: "fast_space",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER INDEX public.test_index SET TABLESPACE fast_space",
+      );
+    });
+  });
+});

package/src/core/objects/index/changes/index.alter.ts

@@ -0,0 +1,145 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+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 class AlterIndexSetStorageParams extends AlterIndexChange {
+  public readonly index: Index;
+  public readonly paramsToSet: string[];
+  public readonly keysToReset: string[];
+  public readonly scope = "object" as const;
+
+  constructor(props: {
+    index: Index;
+    paramsToSet: string[];
+    keysToReset: string[];
+  }) {
+    super();
+    this.index = props.index;
+    this.paramsToSet = props.paramsToSet;
+    this.keysToReset = props.keysToReset;
+  }
+
+  get requires() {
+    return [this.index.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const head = [
+      "ALTER INDEX",
+      `${this.index.schema}.${this.index.name}`,
+    ].join(" ");
+
+    const statements: string[] = [];
+    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 {
+  public readonly index: Index;
+  public readonly columnTargets: Array<{
+    columnNumber: number;
+    statistics: number;
+  }>;
+  public readonly operation = "alter" as const;
+  public readonly scope = "object" as const;
+  public readonly objectType = "index" as const;
+
+  constructor(props: {
+    index: Index;
+    columnTargets: Array<{ columnNumber: number; statistics: number }>;
+  }) {
+    super();
+    this.index = props.index;
+    this.columnTargets = props.columnTargets;
+  }
+
+  get requires() {
+    return [this.index.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const statements: string[] = [];
+    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 {
+  public readonly index: Index;
+  public readonly tablespace: string;
+  public readonly operation = "alter" as const;
+  public readonly scope = "object" as const;
+  public readonly objectType = "index" as const;
+
+  constructor(props: { index: Index; tablespace: string }) {
+    super();
+    this.index = props.index;
+    this.tablespace = props.tablespace;
+  }
+
+  get requires() {
+    return [this.index.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    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/src/core/objects/index/changes/index.base.ts

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

package/src/core/objects/index/changes/index.comment.ts

@@ -0,0 +1,64 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import { quoteLiteral } from "../../base.change.ts";
+import { stableId } from "../../utils.ts";
+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 class CreateCommentOnIndex extends CreateIndexChange {
+  public readonly index: Index;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { index: Index }) {
+    super();
+    this.index = props.index;
+  }
+
+  get creates() {
+    return [stableId.comment(this.index.stableId)];
+  }
+
+  get requires() {
+    return [this.index.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    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 {
+  public readonly index: Index;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { index: Index }) {
+    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(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON INDEX",
+      `${this.index.schema}.${this.index.name}`,
+      "IS NULL",
+    ].join(" ");
+  }
+}