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

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,25 @@
+import { describe, expect, test } from "bun:test";
+import { Extension } from "../extension.model.ts";
+import { CreateExtension } from "./extension.create.ts";
+
+describe("extension", () => {
+  test("create", () => {
+    const extension = new Extension({
+      name: "test_extension",
+      schema: "public",
+      relocatable: true,
+      version: "1.0",
+      owner: "test",
+      comment: null,
+      members: [],
+    });
+
+    const change = new CreateExtension({
+      extension,
+    });
+
+    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,23 @@
+import { describe, expect, test } from "bun:test";
+import { Extension } from "../extension.model.ts";
+import { DropExtension } from "./extension.drop.ts";
+
+describe("extension", () => {
+  test("drop", () => {
+    const extension = new Extension({
+      name: "test_extension",
+      schema: "public",
+      relocatable: true,
+      version: "1.0",
+      owner: "test",
+      comment: null,
+      members: [],
+    });
+
+    const change = new DropExtension({
+      extension,
+    });
+
+    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;
+}