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

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

@@ -0,0 +1,280 @@
+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 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 type ExtensionProps = z.infer<typeof extensionPropsSchema>;
+
+export class Extension extends BasePgModel {
+  public readonly name: ExtensionProps["name"];
+  public readonly schema: ExtensionProps["schema"];
+  public readonly relocatable: ExtensionProps["relocatable"];
+  public readonly version: ExtensionProps["version"];
+  public readonly owner: ExtensionProps["owner"];
+  public readonly comment: ExtensionProps["comment"];
+  public readonly members: ExtensionProps["members"];
+
+  constructor(props: ExtensionProps) {
+    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:${string}` {
+    // 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(pool: Pool): Promise<Extension[]> {
+  const { rows: extensionRows } = await pool.query<ExtensionProps>(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: unknown) =>
+    extensionPropsSchema.parse(row),
+  );
+  return validatedRows.map((row: ExtensionProps) => new Extension(row));
+}

package/src/core/objects/foreign-data-wrapper/foreign-data-wrapper/changes/foreign-data-wrapper.alter.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../../test-utils/assert-valid-sql.ts";
+import {
+  ForeignDataWrapper,
+  type ForeignDataWrapperProps,
+} from "../foreign-data-wrapper.model.ts";
+import {
+  AlterForeignDataWrapperChangeOwner,
+  AlterForeignDataWrapperSetOptions,
+} from "./foreign-data-wrapper.alter.ts";
+
+describe.concurrent("foreign-data-wrapper", () => {
+  describe("alter", () => {
+    test("change owner", async () => {
+      const props: ForeignDataWrapperProps = {
+        name: "test_fdw",
+        owner: "old_owner",
+        handler: null,
+        validator: null,
+        options: null,
+        comment: null,
+        privileges: [],
+      };
+      const fdw = new ForeignDataWrapper(props);
+      const change = new AlterForeignDataWrapperChangeOwner({
+        foreignDataWrapper: fdw,
+        owner: "new_owner",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN DATA WRAPPER test_fdw OWNER TO new_owner",
+      );
+    });
+
+    test("set options ADD", async () => {
+      const props: ForeignDataWrapperProps = {
+        name: "test_fdw",
+        owner: "test",
+        handler: null,
+        validator: null,
+        options: null,
+        comment: null,
+        privileges: [],
+      };
+      const fdw = new ForeignDataWrapper(props);
+      const change = new AlterForeignDataWrapperSetOptions({
+        foreignDataWrapper: fdw,
+        options: [
+          { action: "ADD", option: "host", value: "localhost" },
+          { action: "ADD", option: "port", value: "5432" },
+        ],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN DATA WRAPPER test_fdw OPTIONS (ADD host 'localhost', ADD port '5432')",
+      );
+    });
+
+    test("set options SET", async () => {
+      const props: ForeignDataWrapperProps = {
+        name: "test_fdw",
+        owner: "test",
+        handler: null,
+        validator: null,
+        options: null,
+        comment: null,
+        privileges: [],
+      };
+      const fdw = new ForeignDataWrapper(props);
+      const change = new AlterForeignDataWrapperSetOptions({
+        foreignDataWrapper: fdw,
+        options: [{ action: "SET", option: "host", value: "newhost" }],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN DATA WRAPPER test_fdw OPTIONS (SET host 'newhost')",
+      );
+    });
+
+    test("set options DROP", async () => {
+      const props: ForeignDataWrapperProps = {
+        name: "test_fdw",
+        owner: "test",
+        handler: null,
+        validator: null,
+        options: null,
+        comment: null,
+        privileges: [],
+      };
+      const fdw = new ForeignDataWrapper(props);
+      const change = new AlterForeignDataWrapperSetOptions({
+        foreignDataWrapper: fdw,
+        options: [{ action: "DROP", option: "host" }],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN DATA WRAPPER test_fdw OPTIONS (DROP host)",
+      );
+    });
+
+    test("set options mixed ADD/SET/DROP", async () => {
+      const props: ForeignDataWrapperProps = {
+        name: "test_fdw",
+        owner: "test",
+        handler: null,
+        validator: null,
+        options: null,
+        comment: null,
+        privileges: [],
+      };
+      const fdw = new ForeignDataWrapper(props);
+      const change = new AlterForeignDataWrapperSetOptions({
+        foreignDataWrapper: fdw,
+        options: [
+          { action: "ADD", option: "new_option", value: "new_value" },
+          { action: "SET", option: "existing_option", value: "updated_value" },
+          { action: "DROP", option: "old_option" },
+        ],
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER FOREIGN DATA WRAPPER test_fdw OPTIONS (ADD new_option 'new_value', SET existing_option 'updated_value', DROP old_option)",
+      );
+    });
+  });
+});

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

@@ -0,0 +1,102 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
+import { quoteLiteral } from "../../../base.change.ts";
+import { stableId } from "../../../utils.ts";
+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 class AlterForeignDataWrapperChangeOwner extends AlterForeignDataWrapperChange {
+  public readonly foreignDataWrapper: ForeignDataWrapper;
+  public readonly owner: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: {
+    foreignDataWrapper: ForeignDataWrapper;
+    owner: string;
+  }) {
+    super();
+    this.foreignDataWrapper = props.foreignDataWrapper;
+    this.owner = props.owner;
+  }
+
+  get requires() {
+    return [this.foreignDataWrapper.stableId, stableId.role(this.owner)];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    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 {
+  public readonly foreignDataWrapper: ForeignDataWrapper;
+  public readonly options: Array<{
+    action: "ADD" | "SET" | "DROP";
+    option: string;
+    value?: string;
+  }>;
+  public readonly scope = "object" as const;
+
+  constructor(props: {
+    foreignDataWrapper: ForeignDataWrapper;
+    options: Array<{
+      action: "ADD" | "SET" | "DROP";
+      option: string;
+      value?: string;
+    }>;
+  }) {
+    super();
+    this.foreignDataWrapper = props.foreignDataWrapper;
+    this.options = props.options;
+  }
+
+  get requires() {
+    return [this.foreignDataWrapper.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const optionParts: string[] = [];
+    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/src/core/objects/foreign-data-wrapper/foreign-data-wrapper/changes/foreign-data-wrapper.base.ts

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

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

@@ -0,0 +1,73 @@
+import type { SerializeOptions } from "../../../../integrations/serialize/serialize.types.ts";
+import { quoteLiteral } from "../../../base.change.ts";
+import { stableId } from "../../../utils.ts";
+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 class CreateCommentOnForeignDataWrapper extends CreateForeignDataWrapperChange {
+  public readonly foreignDataWrapper: ForeignDataWrapper;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { foreignDataWrapper: ForeignDataWrapper }) {
+    super();
+    this.foreignDataWrapper = props.foreignDataWrapper;
+  }
+
+  get creates() {
+    return [stableId.comment(this.foreignDataWrapper.stableId)];
+  }
+
+  get requires() {
+    return [this.foreignDataWrapper.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON FOREIGN DATA WRAPPER",
+      this.foreignDataWrapper.name,
+      "IS",
+      // biome-ignore lint/style/noNonNullAssertion: comment is not nullable in this case
+      quoteLiteral(this.foreignDataWrapper.comment!),
+    ].join(" ");
+  }
+}
+
+export class DropCommentOnForeignDataWrapper extends DropForeignDataWrapperChange {
+  public readonly foreignDataWrapper: ForeignDataWrapper;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { foreignDataWrapper: ForeignDataWrapper }) {
+    super();
+    this.foreignDataWrapper = props.foreignDataWrapper;
+  }
+
+  get drops() {
+    return [stableId.comment(this.foreignDataWrapper.stableId)];
+  }
+
+  get requires() {
+    return [
+      stableId.comment(this.foreignDataWrapper.stableId),
+      this.foreignDataWrapper.stableId,
+    ];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON FOREIGN DATA WRAPPER",
+      this.foreignDataWrapper.name,
+      "IS NULL",
+    ].join(" ");
+  }
+}