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

package/src/core/objects/procedure/procedure.model.ts

@@ -0,0 +1,308 @@
+import { sql } from "@ts-safeql/sql-tag";
+import type { Pool } from "pg";
+import z from "zod";
+import { BasePgModel } from "../base.model.ts";
+import {
+  type PrivilegeProps,
+  privilegePropsSchema,
+} from "../base.privilege-diff.ts";
+import {
+  type ExtractRetryOptions,
+  extractWithDefinitionRetry,
+} from "../extract-with-retry.ts";
+import {
+  type SecurityLabelProps,
+  securityLabelPropsSchema,
+} from "../security-label.types.ts";
+
+const FunctionKindSchema = z.enum([
+  "f", // function
+  "p", // procedure
+  "a", // aggregate function
+  "w", // window function
+]);
+
+const FunctionVolatilitySchema = z.enum([
+  "i", // IMMUTABLE
+  "s", // STABLE
+  "v", // VOLATILE
+]);
+
+const FunctionParallelSafetySchema = z.enum([
+  "u", // UNSAFE (cannot run in parallel)
+  "s", // SAFE (can run in parallel)
+  "r", // RESTRICTED (can run in parallel with restrictions)
+]);
+
+const FunctionArgumentModeSchema = z.enum([
+  "i", // IN parameter
+  "o", // OUT parameter
+  "b", // INOUT parameter
+  "v", // VARIADIC parameter
+  "t", // TABLE parameter
+]);
+
+const procedurePropsSchema = z.object({
+  schema: z.string(),
+  name: z.string(),
+  kind: FunctionKindSchema,
+  return_type: z.string(),
+  return_type_schema: z.string(),
+  language: z.string(),
+  security_definer: z.boolean(),
+  volatility: FunctionVolatilitySchema,
+  parallel_safety: FunctionParallelSafetySchema,
+  execution_cost: z.number(),
+  result_rows: z.number(),
+  is_strict: z.boolean(),
+  leakproof: z.boolean(),
+  returns_set: z.boolean(),
+  argument_count: z.number(),
+  argument_default_count: z.number(),
+  argument_names: z.array(z.string()).nullable(),
+  argument_types: z.array(z.string()).nullable(),
+  all_argument_types: z.array(z.string()).nullable(),
+  argument_modes: z.array(FunctionArgumentModeSchema).nullable(),
+  argument_defaults: z.string().nullable(),
+  source_code: z.string().nullable(),
+  binary_path: z.string().nullable(),
+  sql_body: z.string().nullable(),
+  definition: z.string(),
+  config: z.array(z.string()).nullable(),
+  owner: z.string(),
+  comment: z.string().nullable(),
+  privileges: z.array(privilegePropsSchema),
+  security_labels: z.array(securityLabelPropsSchema).default([]).optional(),
+});
+
+// pg_get_functiondef(oid) can return NULL when the function (its pg_proc
+// row) is dropped between catalog scan and resolution, or under transient
+// catalog state. An unreadable function cannot be diffed, so we accept NULL
+// here and filter the row out at extraction time rather than crashing the
+// whole catalog parse with a ZodError.
+const procedureRowSchema = procedurePropsSchema.extend({
+  definition: z.string().nullable(),
+});
+
+type ProcedurePrivilegeProps = PrivilegeProps;
+export type ProcedureProps = z.infer<typeof procedurePropsSchema>;
+
+export class Procedure extends BasePgModel {
+  public readonly schema: ProcedureProps["schema"];
+  public readonly name: ProcedureProps["name"];
+  public readonly kind: ProcedureProps["kind"];
+  public readonly return_type: ProcedureProps["return_type"];
+  public readonly return_type_schema: ProcedureProps["return_type_schema"];
+  public readonly language: ProcedureProps["language"];
+  public readonly security_definer: ProcedureProps["security_definer"];
+  public readonly volatility: ProcedureProps["volatility"];
+  public readonly parallel_safety: ProcedureProps["parallel_safety"];
+  public readonly execution_cost: ProcedureProps["execution_cost"];
+  public readonly result_rows: ProcedureProps["result_rows"];
+  public readonly is_strict: ProcedureProps["is_strict"];
+  public readonly leakproof: ProcedureProps["leakproof"];
+  public readonly returns_set: ProcedureProps["returns_set"];
+  public readonly argument_count: ProcedureProps["argument_count"];
+  public readonly argument_default_count: ProcedureProps["argument_default_count"];
+  public readonly argument_names: ProcedureProps["argument_names"];
+  public readonly argument_types: ProcedureProps["argument_types"];
+  public readonly all_argument_types: ProcedureProps["all_argument_types"];
+  public readonly argument_modes: ProcedureProps["argument_modes"];
+  public readonly argument_defaults: ProcedureProps["argument_defaults"];
+  public readonly source_code: ProcedureProps["source_code"];
+  public readonly binary_path: ProcedureProps["binary_path"];
+  public readonly sql_body: ProcedureProps["sql_body"];
+  public readonly definition: ProcedureProps["definition"];
+  public readonly config: ProcedureProps["config"];
+  public readonly owner: ProcedureProps["owner"];
+  public readonly comment: ProcedureProps["comment"];
+  public readonly privileges: ProcedurePrivilegeProps[];
+  public readonly security_labels: SecurityLabelProps[];
+
+  constructor(props: ProcedureProps) {
+    super();
+
+    // Identity fields
+    this.schema = props.schema;
+    this.name = props.name;
+
+    // Data fields
+    this.kind = props.kind;
+    this.return_type = props.return_type;
+    this.return_type_schema = props.return_type_schema;
+    this.language = props.language;
+    this.security_definer = props.security_definer;
+    this.volatility = props.volatility;
+    this.parallel_safety = props.parallel_safety;
+    this.execution_cost = props.execution_cost;
+    this.result_rows = props.result_rows;
+    this.is_strict = props.is_strict;
+    this.leakproof = props.leakproof;
+    this.returns_set = props.returns_set;
+    this.argument_count = props.argument_count;
+    this.argument_default_count = props.argument_default_count;
+    this.argument_names = props.argument_names;
+    this.argument_types = props.argument_types;
+    this.all_argument_types = props.all_argument_types;
+    this.argument_modes = props.argument_modes;
+    this.argument_defaults = props.argument_defaults;
+    this.source_code = props.source_code;
+    this.binary_path = props.binary_path;
+    this.sql_body = props.sql_body;
+    this.definition = props.definition;
+    this.config = props.config;
+    this.owner = props.owner;
+    this.comment = props.comment;
+    this.privileges = props.privileges;
+    this.security_labels = props.security_labels ?? [];
+  }
+
+  get stableId(): `procedure:${string}` {
+    const args = this.argument_types?.join(",") ?? "";
+    return `procedure:${this.schema}.${this.name}(${args})`;
+  }
+
+  get identityFields() {
+    return {
+      schema: this.schema,
+      name: this.name,
+    };
+  }
+
+  get dataFields() {
+    return {
+      kind: this.kind,
+      return_type: this.return_type,
+      return_type_schema: this.return_type_schema,
+      language: this.language,
+      security_definer: this.security_definer,
+      volatility: this.volatility,
+      parallel_safety: this.parallel_safety,
+      // execution_cost and result_rows are planner hints. We intentionally
+      // exclude them from dataFields to avoid generating diffs solely due to
+      // changes in estimates. They are still used for CREATE serialization.
+      is_strict: this.is_strict,
+      leakproof: this.leakproof,
+      returns_set: this.returns_set,
+      argument_count: this.argument_count,
+      argument_default_count: this.argument_default_count,
+      argument_names: this.argument_names,
+      argument_types: this.argument_types,
+      all_argument_types: this.all_argument_types,
+      argument_modes: this.argument_modes,
+      argument_defaults: this.argument_defaults,
+      source_code: this.source_code,
+      binary_path: this.binary_path,
+      sql_body: this.sql_body,
+      definition: this.definition,
+      config: this.config,
+      owner: this.owner,
+      comment: this.comment,
+      privileges: this.privileges,
+      security_labels: this.security_labels,
+    };
+  }
+}
+
+export async function extractProcedures(
+  pool: Pool,
+  options?: ExtractRetryOptions,
+): Promise<Procedure[]> {
+  const procedureRows = await extractWithDefinitionRetry({
+    label: "procedures",
+    options,
+    hasNullDefinition: (row) => row.definition === null,
+    query: async () => {
+      const result = await pool.query<ProcedureProps>(sql`
+with extension_oids as (
+  select
+    objid
+  from
+    pg_depend d
+  where
+    d.refclassid = 'pg_extension'::regclass
+    and d.classid = 'pg_proc'::regclass
+)
+select
+  p.pronamespace::regnamespace::text as schema,
+  quote_ident(p.proname) as name,
+  p.prokind as kind,
+  format_type(p.prorettype, null) as return_type,
+  rt.typnamespace::regnamespace::text as return_type_schema,
+  l.lanname as language,
+  p.prosecdef as security_definer,
+  p.provolatile as volatility,
+  p.proparallel as parallel_safety,
+  p.procost as execution_cost,
+  p.prorows as result_rows,
+  p.proisstrict as is_strict,
+  p.proleakproof as leakproof,
+  p.proretset as returns_set,
+  p.pronargs as argument_count,
+  p.pronargdefaults as argument_default_count,
+  -- quote argument names server-side for safe serialization
+  case when p.proargnames is null then null
+       else array(select quote_ident(n) from unnest(p.proargnames) as n)
+  end as argument_names,
+  array(
+    select format_type(oid, null)
+    from unnest(p.proargtypes) as oid
+  ) as argument_types,
+  array(
+    select format_type(oid, null)
+    from unnest(p.proallargtypes) as oid
+  ) as all_argument_types,
+  p.proargmodes as argument_modes,
+  pg_get_expr(p.proargdefaults, 0) as argument_defaults,
+  p.prosrc as source_code,
+  p.probin as binary_path,
+  pg_get_function_sqlbody(p.oid) as sql_body,
+  pg_get_functiondef(p.oid) as definition,
+  p.proconfig as config,
+  p.proowner::regrole::text as owner,
+  obj_description(p.oid, 'pg_proc') as comment,
+  coalesce(
+    (
+      select json_agg(
+        json_build_object(
+          'grantee', case when x.grantee = 0 then 'PUBLIC' else x.grantee::regrole::text end,
+          'privilege', x.privilege_type,
+          'grantable', x.is_grantable
+        )
+        order by x.grantee, x.privilege_type
+      )
+      from lateral aclexplode(COALESCE(p.proacl, acldefault('f', p.proowner))) as x(grantor, grantee, privilege_type, is_grantable)
+    ), '[]'
+  ) as privileges,
+  coalesce(
+    (
+      select json_agg(
+        json_build_object('provider', sl.provider, 'label', sl.label)
+        order by sl.provider
+      )
+      from pg_catalog.pg_seclabel sl
+      where sl.objoid = p.oid
+        and sl.classoid = 'pg_proc'::regclass
+        and sl.objsubid = 0
+    ),
+    '[]'::json
+  ) as security_labels
+from
+  pg_catalog.pg_proc p
+  inner join pg_catalog.pg_language l on l.oid = p.prolang
+  left join pg_catalog.pg_type rt on rt.oid = p.prorettype
+  left outer join extension_oids e on p.oid = e.objid
+  where not p.pronamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+  and e.objid is null
+  and l.lanname not in ('c', 'internal')
+order by
+  1, 2
+  `);
+      return result.rows.map((row: unknown) => procedureRowSchema.parse(row));
+    },
+  });
+  const validatedRows = procedureRows.filter(
+    (row): row is ProcedureProps => row.definition !== null,
+  );
+  return validatedRows.map((row) => new Procedure(row));
+}

package/src/core/objects/procedure/utils.ts

@@ -0,0 +1,58 @@
+/**
+ * Format function arguments for CREATE/DROP FUNCTION statements.
+ *
+ * @param argNames - Array of argument names (can be null)
+ * @param argTypes - Array of argument types (required)
+ * @param argModes - Array of argument modes (can be null)
+ * @returns Formatted argument string
+ */
+export function formatFunctionArguments(
+  argNames: string[] | null,
+  argTypes: string[] | null,
+  argModes: string[] | null,
+): string {
+  const names = argNames ?? [];
+  const types = argTypes ?? [];
+  const modes = argModes ?? [];
+
+  if (types.length === 0) {
+    return "";
+  }
+
+  const modeMap: Record<string, string> = {
+    i: "IN",
+    o: "OUT",
+    b: "INOUT",
+    v: "VARIADIC",
+    t: "TABLE",
+  };
+
+  return types
+    .map((type, i) => {
+      const name = names[i] ?? ""; // already quoted in model, if present
+      const mode = modes[i] ? modeMap[modes[i]] : "";
+
+      const parts: string[] = [];
+      if (mode) parts.push(mode);
+      if (name) parts.push(name);
+      parts.push(type);
+
+      return parts.join(" ");
+    })
+    .join(", ");
+}
+
+/**
+ * Format a GUC value for SET ... TO ... in function/procedure definitions.
+ * Applies quoting rules consistent with PostgreSQL docs and psql style.
+ */
+export function formatConfigValue(key: string, rawValue: string): string {
+  const value = rawValue.trim();
+  if (value.length === 0) return value;
+  const lowerKey = key.toLowerCase();
+  if (value.startsWith("'") && value.endsWith("'")) return value;
+  if (/^(true|false|on|off)$/i.test(value)) return value.toLowerCase();
+  if (/^-?\d+(?:\.\d+)?$/.test(value)) return value;
+  if (lowerKey === "search_path" || value.includes(",")) return value;
+  return `'${value.replace(/'/g, "''")}'`;
+}

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

@@ -0,0 +1,221 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { stableId } from "../../utils.ts";
+import type { PublicationTableProps } from "../publication.model.ts";
+import { Publication } from "../publication.model.ts";
+import {
+  AlterPublicationAddSchemas,
+  AlterPublicationAddTables,
+  AlterPublicationDropSchemas,
+  AlterPublicationDropTables,
+  AlterPublicationSetList,
+  AlterPublicationSetOptions,
+  AlterPublicationSetOwner,
+} from "./publication.alter.ts";
+
+type PublicationProps = ConstructorParameters<typeof Publication>[0];
+
+const base: PublicationProps = {
+  name: "pub_base",
+  owner: "owner1",
+  comment: null,
+  all_tables: true,
+  publish_insert: true,
+  publish_update: true,
+  publish_delete: true,
+  publish_truncate: true,
+  publish_via_partition_root: false,
+  tables: [],
+  schemas: [],
+};
+
+const cloneTables = (tables: PublicationProps["tables"]) =>
+  tables.map((table) => ({
+    ...table,
+    columns: table.columns ? [...table.columns] : null,
+  }));
+
+const makePublication = (override: Partial<PublicationProps> = {}) =>
+  new Publication({
+    ...base,
+    ...override,
+    tables: override.tables
+      ? cloneTables(override.tables)
+      : cloneTables(base.tables),
+    schemas: override.schemas ? [...override.schemas] : [...base.schemas],
+  });
+
+describe("publication.alter", () => {
+  test("set options serializes assignments and requires publication", async () => {
+    const publication = makePublication({
+      name: "pub_options",
+      publish_delete: false,
+      publish_truncate: false,
+      publish_via_partition_root: true,
+    });
+    const change = new AlterPublicationSetOptions({
+      publication,
+      setPublish: true,
+      setPublishViaPartitionRoot: true,
+    });
+
+    expect(change.requires).toEqual([publication.stableId]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "ALTER PUBLICATION pub_options SET (publish = 'insert, update', publish_via_partition_root = true)",
+    );
+  });
+
+  test("set list serializes object selection and tracks dependencies", async () => {
+    const publication = makePublication({
+      name: "pub_set_list",
+      all_tables: false,
+      tables: [
+        {
+          schema: "public",
+          name: "authors",
+          columns: ["name", "id"],
+          row_filter: null,
+        },
+        {
+          schema: "public",
+          name: "articles",
+          columns: null,
+          row_filter: " published = true ",
+        },
+      ],
+      schemas: ["analytics"],
+    });
+    const change = new AlterPublicationSetList({ publication });
+
+    expect(change.requires).toEqual([
+      publication.stableId,
+      stableId.table("public", "articles"),
+      stableId.table("public", "authors"),
+      stableId.column("public", "authors", "id"),
+      stableId.column("public", "authors", "name"),
+      stableId.schema("analytics"),
+    ]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "ALTER PUBLICATION pub_set_list SET TABLE public.articles WHERE (published = true), TABLE public.authors (id, name), TABLES IN SCHEMA analytics",
+    );
+  });
+
+  test("add tables serializes new tables and tracks dependencies", async () => {
+    const publication = makePublication({ name: "pub_add_tables" });
+    const tables: PublicationTableProps[] = [
+      {
+        schema: "public",
+        name: "logs",
+        columns: null,
+        row_filter: null,
+      },
+      {
+        schema: "audit",
+        name: "events",
+        columns: ["created_at", "id"],
+        row_filter: null,
+      },
+    ];
+    const change = new AlterPublicationAddTables({ publication, tables });
+
+    expect(change.requires).toEqual([
+      publication.stableId,
+      stableId.table("public", "logs"),
+      stableId.table("audit", "events"),
+      stableId.column("audit", "events", "created_at"),
+      stableId.column("audit", "events", "id"),
+    ]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "ALTER PUBLICATION pub_add_tables ADD TABLE public.logs, TABLE audit.events (created_at, id)",
+    );
+  });
+
+  test("drop tables serializes target list and tracks dependencies", async () => {
+    const publication = makePublication({ name: "pub_drop_tables" });
+    const tables: PublicationTableProps[] = [
+      {
+        schema: "public",
+        name: "logs",
+        columns: null,
+        row_filter: null,
+      },
+      {
+        schema: "audit",
+        name: "events",
+        columns: ["id"],
+        row_filter: null,
+      },
+    ];
+    const change = new AlterPublicationDropTables({ publication, tables });
+
+    expect(change.requires).toEqual([
+      publication.stableId,
+      stableId.table("public", "logs"),
+      stableId.table("audit", "events"),
+    ]);
+    expect(change.drops).toEqual([
+      stableId.table("public", "logs"),
+      stableId.table("audit", "events"),
+    ]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "ALTER PUBLICATION pub_drop_tables DROP TABLE public.logs, audit.events",
+    );
+  });
+
+  test("add schemas serializes and tracks dependencies", async () => {
+    const publication = makePublication({ name: "pub_add_schemas" });
+    const change = new AlterPublicationAddSchemas({
+      publication,
+      schemas: ["analytics", "sales"],
+    });
+
+    expect(change.requires).toEqual([
+      publication.stableId,
+      stableId.schema("analytics"),
+      stableId.schema("sales"),
+    ]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "ALTER PUBLICATION pub_add_schemas ADD TABLES IN SCHEMA analytics, TABLES IN SCHEMA sales",
+    );
+  });
+
+  test("drop schemas serializes and tracks dependencies", async () => {
+    const publication = makePublication({ name: "pub_drop_schemas" });
+    const change = new AlterPublicationDropSchemas({
+      publication,
+      schemas: ["analytics", "sales"],
+    });
+
+    expect(change.requires).toEqual([
+      publication.stableId,
+      stableId.schema("analytics"),
+      stableId.schema("sales"),
+    ]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "ALTER PUBLICATION pub_drop_schemas DROP TABLES IN SCHEMA analytics, TABLES IN SCHEMA sales",
+    );
+  });
+
+  test("set owner serializes and tracks dependencies", async () => {
+    const publication = makePublication({ name: "pub_owner" });
+    const change = new AlterPublicationSetOwner({
+      publication,
+      owner: "owner2",
+    });
+
+    expect(change.requires).toEqual([
+      publication.stableId,
+      stableId.role("owner2"),
+    ]);
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "ALTER PUBLICATION pub_owner OWNER TO owner2",
+    );
+  });
+});