@supabase/pg-delta 1.0.0-alpha.1 → 1.0.0-alpha.11

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

@@ -0,0 +1,79 @@
+import type { Collation } from "../collation.model.ts";
+import { AlterCollationChange } from "./collation.base.ts";
+
+/**
+ * Alter a collation.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-altercollation.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER COLLATION name REFRESH VERSION
+ * ALTER COLLATION name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ * ALTER COLLATION name RENAME TO new_name
+ * ```
+ */
+
+export type AlterCollation =
+  | AlterCollationChangeOwner
+  | AlterCollationRefreshVersion;
+
+/**
+ * ALTER COLLATION ... OWNER TO ...
+ */
+export class AlterCollationChangeOwner extends AlterCollationChange {
+  public readonly collation: Collation;
+  public readonly owner: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { collation: Collation; owner: string }) {
+    super();
+    this.collation = props.collation;
+    this.owner = props.owner;
+  }
+
+  get requires() {
+    return [this.collation.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "ALTER COLLATION",
+      `${this.collation.schema}.${this.collation.name}`,
+      "OWNER TO",
+      this.owner,
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER COLLATION ... REFRESH VERSION
+ */
+export class AlterCollationRefreshVersion extends AlterCollationChange {
+  public readonly collation: Collation;
+  public readonly scope = "object" as const;
+
+  constructor(props: { collation: Collation }) {
+    super();
+    this.collation = props.collation;
+  }
+
+  get requires() {
+    return [this.collation.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "ALTER COLLATION",
+      `${this.collation.schema}.${this.collation.name}`,
+      "REFRESH VERSION",
+    ].join(" ");
+  }
+}
+
+/**
+ * Replace a collation by dropping and recreating it.
+ * This is used when properties that cannot be altered via ALTER COLLATION change.
+ */
+// NOTE: ReplaceCollation has been removed. Non-alterable property changes
+// are modeled as separate DropCollation + CreateCollation changes in collation.diff.ts.

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

@@ -0,0 +1,20 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Collation } from "../collation.model.ts";
+
+abstract class BaseCollationChange extends BaseChange {
+  abstract readonly collation: Collation;
+  abstract readonly scope: "object" | "comment";
+  readonly objectType: "collation" = "collation";
+}
+
+export abstract class CreateCollationChange extends BaseCollationChange {
+  readonly operation = "create" as const;
+}
+
+export abstract class AlterCollationChange extends BaseCollationChange {
+  readonly operation = "alter" as const;
+}
+
+export abstract class DropCollationChange extends BaseCollationChange {
+  readonly operation = "drop" as const;
+}

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

@@ -0,0 +1,68 @@
+import { quoteLiteral } from "../../base.change.ts";
+import { stableId } from "../../utils.ts";
+import type { Collation } from "../collation.model.ts";
+import {
+  CreateCollationChange,
+  DropCollationChange,
+} from "./collation.base.ts";
+
+export type CommentCollation =
+  | CreateCommentOnCollation
+  | DropCommentOnCollation;
+
+/**
+ * Create/drop comments on collations.
+ */
+export class CreateCommentOnCollation extends CreateCollationChange {
+  public readonly collation: Collation;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { collation: Collation }) {
+    super();
+    this.collation = props.collation;
+  }
+
+  get creates() {
+    return [stableId.comment(this.collation.stableId)];
+  }
+
+  get requires() {
+    return [this.collation.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "COMMENT ON COLLATION",
+      `${this.collation.schema}.${this.collation.name}`,
+      "IS",
+      // biome-ignore lint/style/noNonNullAssertion: collation comment is not nullable in this case
+      quoteLiteral(this.collation.comment!),
+    ].join(" ");
+  }
+}
+
+export class DropCommentOnCollation extends DropCollationChange {
+  public readonly collation: Collation;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { collation: Collation }) {
+    super();
+    this.collation = props.collation;
+  }
+
+  get requires() {
+    return [this.collation.stableId, stableId.comment(this.collation.stableId)];
+  }
+
+  get drops() {
+    return [stableId.comment(this.collation.stableId)];
+  }
+
+  serialize(): string {
+    return [
+      "COMMENT ON COLLATION",
+      `${this.collation.schema}.${this.collation.name}`,
+      "IS NULL",
+    ].join(" ");
+  }
+}

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

@@ -0,0 +1,56 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Collation } from "../collation.model.ts";
+import { CreateCollation } from "./collation.create.ts";
+
+describe("collation", () => {
+  test("create minimal", async () => {
+    const collation = new Collation({
+      schema: "public",
+      name: "test",
+      provider: "d",
+      is_deterministic: true,
+      encoding: 1,
+      collate: "C",
+      locale: null,
+      version: null,
+      ctype: "C",
+      icu_rules: null,
+      owner: "owner",
+      comment: null,
+    });
+
+    const change = new CreateCollation({ collation });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      `CREATE COLLATION public.test (LC_COLLATE = 'C', LC_CTYPE = 'C')`,
+    );
+  });
+
+  test("create with all options", async () => {
+    const collation = new Collation({
+      schema: "public",
+      name: "test",
+      provider: "i",
+      is_deterministic: false,
+      encoding: 1,
+      collate: "en_US",
+      locale: "en_US",
+      version: "1.0",
+      ctype: "en_US",
+      icu_rules: "& A < a <<< à",
+      owner: "owner",
+      comment: null,
+    });
+
+    const change = new CreateCollation({ collation });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      `CREATE COLLATION public.test (LOCALE = 'en_US', LC_COLLATE = 'en_US', LC_CTYPE = 'en_US', PROVIDER = icu, DETERMINISTIC = false, RULES = '& A < a <<< à', VERSION = '1.0')`,
+    );
+  });
+});

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

@@ -0,0 +1,106 @@
+import { quoteLiteral } from "../../base.change.ts";
+import { stableId } from "../../utils.ts";
+import type { Collation } from "../collation.model.ts";
+import { CreateCollationChange } from "./collation.base.ts";
+
+/**
+ * Create a collation.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createcollation.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE COLLATION [ IF NOT EXISTS ] name (
+ *     [ LOCALE = locale, ]
+ *     [ LC_COLLATE = lc_collate, ]
+ *     [ LC_CTYPE = lc_ctype, ]
+ *     [ PROVIDER = provider, ]
+ *     [ DETERMINISTIC = boolean, ]
+ *     [ RULES = rules, ]
+ *     [ VERSION = version ]
+ * )
+ *
+ * CREATE COLLATION [ IF NOT EXISTS ] name FROM existing_collation
+ * ```
+ */
+export class CreateCollation extends CreateCollationChange {
+  public readonly collation: Collation;
+  public readonly scope = "object" as const;
+
+  constructor(props: { collation: Collation }) {
+    super();
+    this.collation = props.collation;
+  }
+
+  get creates() {
+    return [this.collation.stableId];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // Schema dependency
+    dependencies.add(stableId.schema(this.collation.schema));
+
+    // Owner dependency
+    dependencies.add(stableId.role(this.collation.owner));
+
+    return Array.from(dependencies);
+  }
+
+  serialize(): string {
+    const parts: string[] = ["CREATE COLLATION"];
+
+    // Add schema and name (already quoted in model extraction)
+    parts.push(`${this.collation.schema}.${this.collation.name}`);
+
+    // Add properties
+    const properties: string[] = [];
+
+    // LOCALE
+    if (this.collation.locale) {
+      properties.push(`LOCALE = ${quoteLiteral(this.collation.locale)}`);
+    }
+
+    // LC_COLLATE
+    if (this.collation.collate) {
+      properties.push(`LC_COLLATE = ${quoteLiteral(this.collation.collate)}`);
+    }
+
+    // LC_CTYPE
+    if (this.collation.ctype) {
+      properties.push(`LC_CTYPE = ${quoteLiteral(this.collation.ctype)}`);
+    }
+
+    // PROVIDER
+    const providerMap: Record<string, string> = {
+      c: "libc",
+      i: "icu",
+      b: "builtin",
+    };
+    // provider 'd' means default provider in catalog; omit PROVIDER clause
+    if (this.collation.provider !== "d") {
+      properties.push(`PROVIDER = ${providerMap[this.collation.provider]}`);
+    }
+
+    // DETERMINISTIC
+    // DETERMINISTIC (only emit when false; true is default in PG)
+    if (this.collation.is_deterministic === false) {
+      properties.push(`DETERMINISTIC = false`);
+    }
+
+    // RULES (ICU rules)
+    if (this.collation.icu_rules) {
+      properties.push(`RULES = ${quoteLiteral(this.collation.icu_rules)}`);
+    }
+
+    // VERSION
+    if (this.collation.version) {
+      properties.push(`VERSION = ${quoteLiteral(this.collation.version)}`);
+    }
+
+    parts.push(["(", properties.join(", "), ")"].join(""));
+
+    return parts.join(" ");
+  }
+}

package/src/core/objects/collation/changes/collation.drop.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Collation } from "../collation.model.ts";
+import { DropCollation } from "./collation.drop.ts";
+
+describe("collation", () => {
+  test("drop", async () => {
+    const collation = new Collation({
+      schema: "public",
+      name: "test",
+      provider: "c",
+      is_deterministic: true,
+      encoding: 1,
+      collate: "en_US",
+      locale: "en_US",
+      version: "1.0",
+      ctype: "test",
+      icu_rules: "test",
+      owner: "test",
+      comment: null,
+    });
+
+    const change = new DropCollation({
+      collation,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe("DROP COLLATION public.test");
+  });
+});

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

@@ -0,0 +1,37 @@
+import type { Collation } from "../collation.model.ts";
+import { DropCollationChange } from "./collation.base.ts";
+
+/**
+ * Drop a collation.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropcollation.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP COLLATION [ IF EXISTS ] name [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropCollation extends DropCollationChange {
+  public readonly collation: Collation;
+  public readonly scope = "object" as const;
+
+  constructor(props: { collation: Collation }) {
+    super();
+    this.collation = props.collation;
+  }
+
+  get requires() {
+    return [this.collation.stableId];
+  }
+
+  get drops() {
+    return [this.collation.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "DROP COLLATION",
+      `${this.collation.schema}.${this.collation.name}`,
+    ].join(" ");
+  }
+}

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

@@ -0,0 +1,11 @@
+import type { AlterCollation } from "./collation.alter.ts";
+import type { CommentCollation } from "./collation.comment.ts";
+import type { CreateCollation } from "./collation.create.ts";
+import type { DropCollation } from "./collation.drop.ts";
+
+/** Union of all collation-related change variants (`objectType: "collation"`). @category Change Types */
+export type CollationChange =
+  | AlterCollation
+  | CommentCollation
+  | CreateCollation
+  | DropCollation;

package/src/core/objects/collation/collation.diff.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, test } from "bun:test";
+import type { ObjectDiffContext } from "../diff-context.ts";
+import {
+  AlterCollationChangeOwner,
+  AlterCollationRefreshVersion,
+} from "./changes/collation.alter.ts";
+import { CreateCollation } from "./changes/collation.create.ts";
+import { DropCollation } from "./changes/collation.drop.ts";
+import { diffCollations } from "./collation.diff.ts";
+import { Collation, type CollationProps } from "./collation.model.ts";
+
+const ctx: Pick<ObjectDiffContext, "currentUser"> = {
+  currentUser: "postgres",
+};
+
+describe.concurrent("collation.diff", () => {
+  test("create and drop", () => {
+    const props: CollationProps = {
+      schema: "public",
+      name: "c1",
+      provider: "c",
+      is_deterministic: true,
+      encoding: 1,
+      collate: "en_US",
+      ctype: "en_US",
+      locale: "en_US",
+      icu_rules: null,
+      version: "1.0",
+      owner: "postgres",
+      comment: null,
+    };
+    const c = new Collation(props);
+
+    const created = diffCollations(ctx, {}, { [c.stableId]: c });
+    expect(created).toHaveLength(1);
+    expect(created[0]).toBeInstanceOf(CreateCollation);
+
+    const dropped = diffCollations(ctx, { [c.stableId]: c }, {});
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0]).toBeInstanceOf(DropCollation);
+  });
+
+  test("alter: refresh version and change owner", () => {
+    const base: Omit<CollationProps, "version" | "owner"> = {
+      schema: "public",
+      name: "c1",
+      provider: "c",
+      is_deterministic: true,
+      encoding: 1,
+      collate: "en_US",
+      ctype: "en_US",
+      locale: "en_US",
+      icu_rules: null,
+      comment: null,
+    };
+    const main = new Collation({ ...base, version: "1.0", owner: "o1" });
+    const branch = new Collation({ ...base, version: "2.0", owner: "o2" });
+
+    const changes = diffCollations(
+      ctx,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes.some((c) => c instanceof AlterCollationRefreshVersion)).toBe(
+      true,
+    );
+    expect(changes.some((c) => c instanceof AlterCollationChangeOwner)).toBe(
+      true,
+    );
+  });
+
+  test("drop + create when non-alterable changes", () => {
+    const base: Omit<CollationProps, "provider"> = {
+      schema: "public",
+      name: "c1",
+      is_deterministic: true,
+      encoding: 1,
+      collate: "en_US",
+      ctype: "en_US",
+      locale: "en_US",
+      icu_rules: null,
+      comment: null,
+      version: "1.0",
+      owner: "o1",
+    };
+    const main = new Collation({ ...base, provider: "c" });
+    const branch = new Collation({ ...base, provider: "i" });
+    const changes = diffCollations(
+      ctx,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes).toHaveLength(2);
+    expect(changes[0]).toBeInstanceOf(DropCollation);
+    expect(changes[1]).toBeInstanceOf(CreateCollation);
+  });
+});

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

@@ -0,0 +1,127 @@
+import { diffObjects } from "../base.diff.ts";
+import type { ObjectDiffContext } from "../diff-context.ts";
+import { hasNonAlterableChanges } from "../utils.ts";
+import {
+  AlterCollationChangeOwner,
+  AlterCollationRefreshVersion,
+} from "./changes/collation.alter.ts";
+import {
+  CreateCommentOnCollation,
+  DropCommentOnCollation,
+} from "./changes/collation.comment.ts";
+import { CreateCollation } from "./changes/collation.create.ts";
+import { DropCollation } from "./changes/collation.drop.ts";
+import type { CollationChange } from "./changes/collation.types.ts";
+import type { Collation } from "./collation.model.ts";
+
+/**
+ * Diff two sets of collations from main and branch catalogs.
+ *
+ * @param ctx - Context containing currentUser
+ * @param main - The collations in the main catalog.
+ * @param branch - The collations in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffCollations(
+  ctx: Pick<ObjectDiffContext, "currentUser">,
+  main: Record<string, Collation>,
+  branch: Record<string, Collation>,
+): CollationChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+
+  const changes: CollationChange[] = [];
+
+  for (const collationId of created) {
+    const coll = branch[collationId];
+    changes.push(new CreateCollation({ collation: coll }));
+
+    // OWNER: If the collation should be owned by someone other than the current user,
+    // emit ALTER COLLATION ... OWNER TO after creation
+    if (coll.owner !== ctx.currentUser) {
+      changes.push(
+        new AlterCollationChangeOwner({
+          collation: coll,
+          owner: coll.owner,
+        }),
+      );
+    }
+
+    if (coll.comment !== null) {
+      changes.push(new CreateCommentOnCollation({ collation: coll }));
+    }
+  }
+
+  for (const collationId of dropped) {
+    changes.push(new DropCollation({ collation: main[collationId] }));
+  }
+
+  for (const collationId of altered) {
+    const mainCollation = main[collationId];
+    const branchCollation = branch[collationId];
+
+    // Check if non-alterable properties have changed
+    // These require dropping and recreating the collation
+    const NON_ALTERABLE_FIELDS: Array<keyof Collation> = [
+      "provider",
+      "is_deterministic",
+      "encoding",
+      "collate",
+      "ctype",
+      "locale",
+      "icu_rules",
+    ];
+    const nonAlterablePropsChanged = hasNonAlterableChanges(
+      mainCollation,
+      branchCollation,
+      NON_ALTERABLE_FIELDS,
+    );
+
+    if (nonAlterablePropsChanged) {
+      // Replace the entire collation (drop + create)
+      changes.push(
+        new DropCollation({ collation: mainCollation }),
+        new CreateCollation({ collation: branchCollation }),
+      );
+    } else {
+      // Only alterable properties changed - check each one
+
+      // VERSION
+      if (mainCollation.version !== branchCollation.version) {
+        changes.push(
+          new AlterCollationRefreshVersion({
+            collation: mainCollation,
+          }),
+        );
+      }
+
+      // OWNER
+      if (mainCollation.owner !== branchCollation.owner) {
+        changes.push(
+          new AlterCollationChangeOwner({
+            collation: mainCollation,
+            owner: branchCollation.owner,
+          }),
+        );
+      }
+
+      // COMMENT
+      if (mainCollation.comment !== branchCollation.comment) {
+        if (branchCollation.comment === null) {
+          changes.push(
+            new DropCommentOnCollation({ collation: mainCollation }),
+          );
+        } else {
+          changes.push(
+            new CreateCommentOnCollation({ collation: branchCollation }),
+          );
+        }
+      }
+
+      // Note: Collation renaming would also use ALTER COLLATION ... RENAME TO ...
+      // But since our Collation model uses 'name' as the identity field,
+      // a name change would be handled as drop + create by diffObjects()
+    }
+  }
+
+  return changes;
+}