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

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

@@ -0,0 +1,78 @@
+import { quoteLiteral } from "../../base.change.ts";
+import { stableId } from "../../utils.ts";
+import type { Extension } from "../extension.model.ts";
+import { AlterExtensionChange } from "./extension.base.ts";
+
+/**
+ * Alter an extension.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterextension.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER EXTENSION name UPDATE [ TO new_version ]
+ * ALTER EXTENSION name SET SCHEMA new_schema
+ * ALTER EXTENSION name ADD member_object
+ * ALTER EXTENSION name DROP member_object
+ * ```
+ */
+
+export type AlterExtension =
+  | AlterExtensionSetSchema
+  | AlterExtensionUpdateVersion;
+
+/**
+ * ALTER EXTENSION ... UPDATE TO ...
+ */
+export class AlterExtensionUpdateVersion extends AlterExtensionChange {
+  public readonly extension: Extension;
+  public readonly version: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { extension: Extension; version: string }) {
+    super();
+    this.extension = props.extension;
+    this.version = props.version;
+  }
+
+  get requires() {
+    return [this.extension.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "ALTER EXTENSION",
+      this.extension.name,
+      "UPDATE TO",
+      quoteLiteral(this.version),
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER EXTENSION ... SET SCHEMA ...
+ */
+export class AlterExtensionSetSchema extends AlterExtensionChange {
+  public readonly extension: Extension;
+  public readonly schema: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { extension: Extension; schema: string }) {
+    super();
+    this.extension = props.extension;
+    this.schema = props.schema;
+  }
+
+  get requires() {
+    return [this.extension.stableId, stableId.schema(this.schema)];
+  }
+
+  serialize(): string {
+    return [
+      "ALTER EXTENSION",
+      this.extension.name,
+      "SET SCHEMA",
+      this.schema,
+    ].join(" ");
+  }
+}

package/src/core/objects/extension/changes/extension.base.ts

@@ -0,0 +1,20 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Extension } from "../extension.model.ts";
+
+abstract class BaseExtensionChange extends BaseChange {
+  abstract readonly extension: Extension;
+  abstract readonly scope: "object" | "comment";
+  readonly objectType: "extension" = "extension";
+}
+
+export abstract class CreateExtensionChange extends BaseExtensionChange {
+  readonly operation = "create" as const;
+}
+
+export abstract class AlterExtensionChange extends BaseExtensionChange {
+  readonly operation = "alter" as const;
+}
+
+export abstract class DropExtensionChange extends BaseExtensionChange {
+  readonly operation = "drop" as const;
+}

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

@@ -0,0 +1,64 @@
+import { quoteLiteral } from "../../base.change.ts";
+import { stableId } from "../../utils.ts";
+import type { Extension } from "../extension.model.ts";
+import {
+  CreateExtensionChange,
+  DropExtensionChange,
+} from "./extension.base.ts";
+
+export type CommentExtension =
+  | CreateCommentOnExtension
+  | DropCommentOnExtension;
+
+/**
+ * Create/drop comments on extensions.
+ */
+export class CreateCommentOnExtension extends CreateExtensionChange {
+  public readonly extension: Extension;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { extension: Extension }) {
+    super();
+    this.extension = props.extension;
+  }
+
+  get creates() {
+    return [stableId.comment(this.extension.stableId)];
+  }
+
+  get requires() {
+    return [this.extension.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "COMMENT ON EXTENSION",
+      this.extension.name,
+      "IS",
+      // biome-ignore lint/style/noNonNullAssertion: extension comment is not nullable here
+      quoteLiteral(this.extension.comment!),
+    ].join(" ");
+  }
+}
+
+export class DropCommentOnExtension extends DropExtensionChange {
+  public readonly extension: Extension;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { extension: Extension }) {
+    super();
+    this.extension = props.extension;
+  }
+
+  get drops() {
+    return [stableId.comment(this.extension.stableId)];
+  }
+
+  get requires() {
+    return [stableId.comment(this.extension.stableId), this.extension.stableId];
+  }
+
+  serialize(): string {
+    return ["COMMENT ON EXTENSION", this.extension.name, "IS NULL"].join(" ");
+  }
+}

package/src/core/objects/extension/changes/extension.create.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Extension } from "../extension.model.ts";
+import { CreateExtension } from "./extension.create.ts";
+
+describe("extension", () => {
+  test("create", async () => {
+    const extension = new Extension({
+      name: "test_extension",
+      schema: "public",
+      relocatable: true,
+      version: "1.0",
+      owner: "test",
+      comment: null,
+      members: [],
+    });
+
+    const change = new CreateExtension({
+      extension,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      `CREATE EXTENSION test_extension WITH SCHEMA public`,
+    );
+  });
+});

package/src/core/objects/extension/changes/extension.create.ts

@@ -0,0 +1,63 @@
+import { stableId } from "../../utils.ts";
+import type { Extension } from "../extension.model.ts";
+import { CreateExtensionChange } from "./extension.base.ts";
+
+/**
+ * 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 {
+  public readonly extension: Extension;
+  public readonly scope = "object" as const;
+
+  constructor(props: { extension: Extension }) {
+    super();
+    this.extension = props.extension;
+  }
+
+  get creates() {
+    return [this.extension.stableId, ...this.extension.members];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // Schema dependency
+    dependencies.add(stableId.schema(this.extension.schema));
+
+    // Owner dependency
+    dependencies.add(stableId.role(this.extension.owner));
+
+    return Array.from(dependencies);
+  }
+
+  serialize(): string {
+    const parts: string[] = ["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/src/core/objects/extension/changes/extension.drop.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Extension } from "../extension.model.ts";
+import { DropExtension } from "./extension.drop.ts";
+
+describe("extension", () => {
+  test("drop", async () => {
+    const extension = new Extension({
+      name: "test_extension",
+      schema: "public",
+      relocatable: true,
+      version: "1.0",
+      owner: "test",
+      comment: null,
+      members: [],
+    });
+
+    const change = new DropExtension({
+      extension,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe("DROP EXTENSION test_extension");
+  });
+});

package/src/core/objects/extension/changes/extension.drop.ts

@@ -0,0 +1,34 @@
+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 class DropExtension extends DropExtensionChange {
+  public readonly extension: Extension;
+  public readonly scope = "object" as const;
+
+  constructor(props: { extension: Extension }) {
+    super();
+    this.extension = props.extension;
+  }
+
+  get drops() {
+    return [this.extension.stableId, ...this.extension.members];
+  }
+
+  get requires() {
+    return [this.extension.stableId, ...this.extension.members];
+  }
+
+  serialize(): string {
+    return ["DROP EXTENSION", this.extension.name].join(" ");
+  }
+}

package/src/core/objects/extension/changes/extension.types.ts

@@ -0,0 +1,10 @@
+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/src/core/objects/extension/extension.diff.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from "bun:test";
+import { AlterExtensionSetSchema } from "./changes/extension.alter.ts";
+import { CreateExtension } from "./changes/extension.create.ts";
+import { DropExtension } from "./changes/extension.drop.ts";
+import { diffExtensions } from "./extension.diff.ts";
+import { Extension, type ExtensionProps } from "./extension.model.ts";
+
+const base: ExtensionProps = {
+  name: "pgcrypto",
+  schema: "public",
+  relocatable: true,
+  version: "1.0",
+  owner: "o1",
+  comment: null,
+  members: [],
+};
+
+describe.concurrent("extension.diff", () => {
+  test("create and drop", () => {
+    const e = new Extension(base);
+    const created = diffExtensions({}, { [e.stableId]: e });
+    expect(created[0]).toBeInstanceOf(CreateExtension);
+    const dropped = diffExtensions({ [e.stableId]: e }, {});
+    expect(dropped[0]).toBeInstanceOf(DropExtension);
+  });
+
+  test("alter: version, schema", () => {
+    const main = new Extension(base);
+    const branch = new Extension({
+      ...base,
+      version: "1.1",
+      schema: "utils",
+    });
+    const changes = diffExtensions(
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes.some((c) => c instanceof AlterExtensionSetSchema)).toBe(
+      true,
+    );
+  });
+});

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

@@ -0,0 +1,90 @@
+import { diffObjects } from "../base.diff.ts";
+import { AlterExtensionSetSchema } from "./changes/extension.alter.ts";
+import {
+  CreateCommentOnExtension,
+  DropCommentOnExtension,
+} from "./changes/extension.comment.ts";
+import { CreateExtension } from "./changes/extension.create.ts";
+import { DropExtension } from "./changes/extension.drop.ts";
+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 function diffExtensions(
+  main: Record<string, Extension>,
+  branch: Record<string, Extension>,
+): ExtensionChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+
+  const changes: ExtensionChange[] = [];
+
+  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/src/core/objects/extension/extension.model.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from "bun:test";
+import type { Pool } from "pg";
+import { Extension, extractExtensions } from "./extension.model.ts";
+
+describe("Extension", () => {
+  test("stableId returns extension:<name>", () => {
+    const ext = new Extension({
+      name: "plpgsql",
+      schema: "pg_catalog",
+      relocatable: false,
+      version: "1.0",
+      owner: "postgres",
+      comment: null,
+      members: [],
+    });
+    expect(ext.stableId).toBe("extension:plpgsql");
+  });
+
+  test("identityFields returns name", () => {
+    const ext = new Extension({
+      name: "vector",
+      schema: "extensions",
+      relocatable: true,
+      version: "0.7.0",
+      owner: "postgres",
+      comment: "vector type",
+      members: ["type:extensions.vector"],
+    });
+    expect(ext.identityFields).toEqual({ name: "vector" });
+  });
+
+  test("dataFields returns schema, relocatable, version, owner, comment", () => {
+    const ext = new Extension({
+      name: "pgcrypto",
+      schema: "public",
+      relocatable: false,
+      version: "1.3",
+      owner: "postgres",
+      comment: "cryptographic functions",
+      members: ["procedure:public.gen_random_uuid()"],
+    });
+    expect(ext.dataFields).toEqual({
+      schema: "public",
+      relocatable: false,
+      version: "1.3",
+      owner: "postgres",
+      comment: "cryptographic functions",
+    });
+  });
+});
+
+describe("extractExtensions", () => {
+  test("returns empty array when pool returns no rows", async () => {
+    const pool = {
+      query: async () => ({ rows: [] }),
+    } as unknown as Pool;
+    const result = await extractExtensions(pool);
+    expect(result).toEqual([]);
+  });
+
+  test("returns Extension instances for valid rows", async () => {
+    const pool = {
+      query: async () => ({
+        rows: [
+          {
+            name: "plpgsql",
+            schema: "pg_catalog",
+            relocatable: false,
+            version: "1.0",
+            owner: "postgres",
+            comment: null,
+            members: [],
+          },
+          {
+            name: "vector",
+            schema: "extensions",
+            relocatable: true,
+            version: "0.7.0",
+            owner: "postgres",
+            comment: null,
+            members: ["type:extensions.vector", "table:extensions.vector"],
+          },
+        ],
+      }),
+    } as unknown as Pool;
+    const result = await extractExtensions(pool);
+    expect(result).toHaveLength(2);
+    expect(result[0]).toBeInstanceOf(Extension);
+    expect(result[0].name).toBe("plpgsql");
+    expect(result[0].stableId).toBe("extension:plpgsql");
+    expect(result[0].members).toEqual([]);
+    expect(result[1].name).toBe("vector");
+    expect(result[1].members).toEqual([
+      "type:extensions.vector",
+      "table:extensions.vector",
+    ]);
+  });
+});