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

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

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Language } from "../language.model.ts";
+import { DropLanguage } from "./language.drop.ts";
+
+describe("language", () => {
+  test("drop", async () => {
+    const language = new Language({
+      name: "plpgsql",
+      is_trusted: true,
+      is_procedural: true,
+      call_handler: "plpgsql_call_handler",
+      inline_handler: "plpgsql_inline_handler",
+      validator: "plpgsql_validator",
+      owner: "test",
+      comment: null,
+      privileges: [],
+    });
+
+    const change = new DropLanguage({
+      language,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe("DROP LANGUAGE plpgsql");
+  });
+});

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

@@ -0,0 +1,39 @@
+import type { Language } from "../language.model.ts";
+import { DropLanguageChange } from "./language.base.ts";
+
+/**
+ * Drop a language.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-droplanguage.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP [ PROCEDURAL ] LANGUAGE [ IF EXISTS ] name [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropLanguage extends DropLanguageChange {
+  public readonly language: Language;
+  public readonly scope = "object" as const;
+
+  constructor(props: { language: Language }) {
+    super();
+    this.language = props.language;
+  }
+
+  get drops() {
+    return [this.language.stableId];
+  }
+
+  get requires() {
+    return [this.language.stableId];
+  }
+
+  serialize(): string {
+    const parts: string[] = ["DROP"];
+
+    // Do not print optional keywords (e.g., PROCEDURAL). Keep the statement minimal.
+    parts.push("LANGUAGE", this.language.name);
+
+    return parts.join(" ");
+  }
+}

package/src/core/objects/language/changes/language.privilege.ts

@@ -0,0 +1,172 @@
+import {
+  formatObjectPrivilegeList,
+  getObjectKindPrefix,
+} from "../../base.privilege.ts";
+import { stableId } from "../../utils.ts";
+import type { Language } from "../language.model.ts";
+import { AlterLanguageChange } from "./language.base.ts";
+
+export type LanguagePrivilege =
+  | GrantLanguagePrivileges
+  | RevokeLanguagePrivileges
+  | RevokeGrantOptionLanguagePrivileges;
+
+/**
+ * Grant privileges on a language.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-grant.html
+ *
+ * Synopsis
+ * ```sql
+ * GRANT { USAGE | ALL [ PRIVILEGES ] }
+ *    ON LANGUAGE language_name [, ...]
+ *    TO role_specification [, ...] [ WITH GRANT OPTION ]
+ *    [ GRANTED BY role_specification ]
+ * ```
+ */
+export class GrantLanguagePrivileges extends AlterLanguageChange {
+  public readonly language: Language;
+  public readonly grantee: string;
+  public readonly privileges: { privilege: string; grantable: boolean }[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    language: Language;
+    grantee: string;
+    privileges: { privilege: string; grantable: boolean }[];
+    version?: number;
+  }) {
+    super();
+    this.language = props.language;
+    this.grantee = props.grantee;
+    this.privileges = props.privileges;
+    this.version = props.version;
+  }
+
+  get creates() {
+    return [stableId.acl(this.language.stableId, this.grantee)];
+  }
+
+  get requires() {
+    return [this.language.stableId, stableId.role(this.grantee)];
+  }
+
+  serialize(): string {
+    const hasGrantable = this.privileges.some((p) => p.grantable);
+    const hasBase = this.privileges.some((p) => !p.grantable);
+    if (hasGrantable && hasBase) {
+      throw new Error(
+        "GrantLanguagePrivileges expects privileges with uniform grantable flag",
+      );
+    }
+    const withGrant = hasGrantable ? " WITH GRANT OPTION" : "";
+    const kindPrefix = getObjectKindPrefix("LANGUAGE");
+    const list = this.privileges.map((p) => p.privilege);
+    const privSql = formatObjectPrivilegeList("LANGUAGE", list, this.version);
+    return `GRANT ${privSql} ${kindPrefix} ${this.language.name} TO ${this.grantee}${withGrant}`;
+  }
+}
+
+/**
+ * Revoke privileges on a language.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ *
+ * Synopsis
+ * ```sql
+ * REVOKE [ GRANT OPTION FOR ]
+ *     { USAGE | ALL [ PRIVILEGES ] }
+ *     ON LANGUAGE language_name [, ...]
+ *     FROM role_specification [, ...]
+ *     [ GRANTED BY role_specification ]
+ *     [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class RevokeLanguagePrivileges extends AlterLanguageChange {
+  public readonly language: Language;
+  public readonly grantee: string;
+  public readonly privileges: { privilege: string; grantable: boolean }[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    language: Language;
+    grantee: string;
+    privileges: { privilege: string; grantable: boolean }[];
+    version?: number;
+  }) {
+    super();
+    this.language = props.language;
+    this.grantee = props.grantee;
+    this.privileges = props.privileges;
+    this.version = props.version;
+  }
+
+  get drops() {
+    // Return ACL ID for dependency tracking, even though this is an ALTER operation
+    // Phase assignment now uses operation type, so this won't affect phase placement
+    return [stableId.acl(this.language.stableId, this.grantee)];
+  }
+
+  get requires() {
+    return [
+      stableId.acl(this.language.stableId, this.grantee),
+      this.language.stableId,
+      stableId.role(this.grantee),
+    ];
+  }
+
+  serialize(): string {
+    const kindPrefix = getObjectKindPrefix("LANGUAGE");
+    const list = this.privileges.map((p) => p.privilege);
+    const privSql = formatObjectPrivilegeList("LANGUAGE", list, this.version);
+    return `REVOKE ${privSql} ${kindPrefix} ${this.language.name} FROM ${this.grantee}`;
+  }
+}
+
+/**
+ * Revoke grant option for privileges on a language.
+ *
+ * This removes the ability to grant the privilege to others, but keeps the privilege itself.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-revoke.html
+ */
+export class RevokeGrantOptionLanguagePrivileges extends AlterLanguageChange {
+  public readonly language: Language;
+  public readonly grantee: string;
+  public readonly privilegeNames: string[];
+  public readonly version: number | undefined;
+  public readonly scope = "privilege" as const;
+
+  constructor(props: {
+    language: Language;
+    grantee: string;
+    privilegeNames: string[];
+    version?: number;
+  }) {
+    super();
+    this.language = props.language;
+    this.grantee = props.grantee;
+    this.privilegeNames = [...new Set(props.privilegeNames)].sort();
+    this.version = props.version;
+  }
+
+  get requires() {
+    return [
+      stableId.acl(this.language.stableId, this.grantee),
+      this.language.stableId,
+      stableId.role(this.grantee),
+    ];
+  }
+
+  serialize(): string {
+    const kindPrefix = getObjectKindPrefix("LANGUAGE");
+    const privSql = formatObjectPrivilegeList(
+      "LANGUAGE",
+      this.privilegeNames,
+      this.version,
+    );
+    return `REVOKE GRANT OPTION FOR ${privSql} ${kindPrefix} ${this.language.name} FROM ${this.grantee}`;
+  }
+}

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

@@ -0,0 +1,12 @@
+import type { AlterLanguage } from "./language.alter.ts";
+import type { CommentLanguage } from "./language.comment.ts";
+import type { CreateLanguage } from "./language.create.ts";
+import type { DropLanguage } from "./language.drop.ts";
+import type { LanguagePrivilege } from "./language.privilege.ts";
+
+export type LanguageChange =
+  | AlterLanguage
+  | CommentLanguage
+  | CreateLanguage
+  | DropLanguage
+  | LanguagePrivilege;

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

@@ -0,0 +1,135 @@
+import { describe, expect, test } from "bun:test";
+import type { ObjectDiffContext } from "../diff-context.ts";
+import { AlterLanguageChangeOwner } from "./changes/language.alter.ts";
+import {
+  CreateCommentOnLanguage,
+  DropCommentOnLanguage,
+} from "./changes/language.comment.ts";
+import { CreateLanguage } from "./changes/language.create.ts";
+import { DropLanguage } from "./changes/language.drop.ts";
+import {
+  GrantLanguagePrivileges,
+  RevokeGrantOptionLanguagePrivileges,
+  RevokeLanguagePrivileges,
+} from "./changes/language.privilege.ts";
+import { diffLanguages } from "./language.diff.ts";
+import { Language, type LanguageProps } from "./language.model.ts";
+
+const base: LanguageProps = {
+  name: "plpgsql",
+  is_trusted: true,
+  is_procedural: true,
+  call_handler: null,
+  inline_handler: null,
+  validator: null,
+  owner: "o1",
+  comment: null,
+  privileges: [],
+};
+
+const makeLanguage = (override: Partial<LanguageProps> = {}) =>
+  new Language({
+    ...base,
+    ...override,
+    privileges: override.privileges ?? [...base.privileges],
+  });
+
+const ctx: Pick<ObjectDiffContext, "version"> = {
+  version: 170000,
+};
+
+describe.concurrent("language.diff", () => {
+  test("create and drop", () => {
+    const l = new Language(base);
+    const created = diffLanguages(ctx, {}, { [l.stableId]: l });
+    expect(created[0]).toBeInstanceOf(CreateLanguage);
+
+    const dropped = diffLanguages(ctx, { [l.stableId]: l }, {});
+    expect(dropped[0]).toBeInstanceOf(DropLanguage);
+  });
+
+  test("alter owner", () => {
+    const main = new Language(base);
+    const branch = new Language({ ...base, owner: "o2" });
+    const changes = diffLanguages(
+      ctx,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes[0]).toBeInstanceOf(AlterLanguageChangeOwner);
+  });
+
+  test("drop + create on non-alterable change", () => {
+    const main = new Language(base);
+    const branch = new Language({ ...base, call_handler: "handler()" });
+    const changes = diffLanguages(
+      ctx,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+    expect(changes).toHaveLength(2);
+    expect(changes[0]).toBeInstanceOf(DropLanguage);
+    expect(changes[1]).toBeInstanceOf(CreateLanguage);
+  });
+
+  test("create with comment emits create comment change", () => {
+    const l = makeLanguage({ comment: "my language" });
+    const changes = diffLanguages(ctx, {}, { [l.stableId]: l });
+    expect(changes[0]).toBeInstanceOf(CreateLanguage);
+    expect(changes.some((c) => c instanceof CreateCommentOnLanguage)).toBe(
+      true,
+    );
+  });
+
+  test("comment changes emit create/drop comment statements", () => {
+    const main = makeLanguage();
+    const withComment = makeLanguage({ comment: "lang comment" });
+
+    const addComment = diffLanguages(
+      ctx,
+      { [main.stableId]: main },
+      { [withComment.stableId]: withComment },
+    );
+    expect(addComment[0]).toBeInstanceOf(CreateCommentOnLanguage);
+
+    const dropComment = diffLanguages(
+      ctx,
+      { [withComment.stableId]: withComment },
+      { [main.stableId]: main },
+    );
+    expect(dropComment[0]).toBeInstanceOf(DropCommentOnLanguage);
+  });
+
+  test("privilege diffs emit grant, revoke, and revoke grant option statements", () => {
+    const main = makeLanguage({
+      privileges: [
+        { grantee: "role_usage", privilege: "USAGE", grantable: false },
+        { grantee: "role_with_option", privilege: "USAGE", grantable: true },
+        { grantee: "role_removed", privilege: "USAGE", grantable: false },
+      ],
+    });
+    const branch = makeLanguage({
+      privileges: [
+        { grantee: "role_usage", privilege: "USAGE", grantable: true },
+        { grantee: "role_with_option", privilege: "USAGE", grantable: false },
+        { grantee: "role_new", privilege: "USAGE", grantable: false },
+      ],
+    });
+
+    const changes = diffLanguages(
+      ctx,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+
+    expect(changes.some((c) => c instanceof GrantLanguagePrivileges)).toBe(
+      true,
+    );
+    expect(changes.some((c) => c instanceof RevokeLanguagePrivileges)).toBe(
+      true,
+    );
+    expect(
+      changes.some((c) => c instanceof RevokeGrantOptionLanguagePrivileges),
+    ).toBe(true);
+  });
+});

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

@@ -0,0 +1,144 @@
+import type { Change } from "../../change.types.ts";
+import { diffObjects } from "../base.diff.ts";
+import {
+  diffPrivileges,
+  emitObjectPrivilegeChanges,
+  filterPublicBuiltInDefaults,
+} from "../base.privilege-diff.ts";
+import type { ObjectDiffContext } from "../diff-context.ts";
+import { hasNonAlterableChanges } from "../utils.ts";
+import { AlterLanguageChangeOwner } from "./changes/language.alter.ts";
+import {
+  CreateCommentOnLanguage,
+  DropCommentOnLanguage,
+} from "./changes/language.comment.ts";
+import { CreateLanguage } from "./changes/language.create.ts";
+import { DropLanguage } from "./changes/language.drop.ts";
+import {
+  GrantLanguagePrivileges,
+  RevokeGrantOptionLanguagePrivileges,
+  RevokeLanguagePrivileges,
+} from "./changes/language.privilege.ts";
+import type { Language } from "./language.model.ts";
+
+/**
+ * Diff two sets of languages from main and branch catalogs.
+ *
+ * @param ctx - Context containing version information.
+ * @param main - The languages in the main catalog.
+ * @param branch - The languages in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffLanguages(
+  ctx: Pick<ObjectDiffContext, "version">,
+  main: Record<string, Language>,
+  branch: Record<string, Language>,
+): Change[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
+
+  const changes: Change[] = [];
+
+  for (const languageId of created) {
+    const lang = branch[languageId];
+    changes.push(new CreateLanguage({ language: lang }));
+    if (lang.comment !== null) {
+      changes.push(new CreateCommentOnLanguage({ language: lang }));
+    }
+  }
+
+  for (const languageId of dropped) {
+    changes.push(new DropLanguage({ language: main[languageId] }));
+  }
+
+  for (const languageId of altered) {
+    const mainLanguage = main[languageId];
+    const branchLanguage = branch[languageId];
+
+    // Check if non-alterable properties have changed
+    // These require dropping and recreating the language
+    const NON_ALTERABLE_FIELDS: Array<keyof Language> = [
+      "is_trusted",
+      "is_procedural",
+      "call_handler",
+      "inline_handler",
+      "validator",
+    ];
+    const nonAlterablePropsChanged = hasNonAlterableChanges(
+      mainLanguage,
+      branchLanguage,
+      NON_ALTERABLE_FIELDS,
+    );
+
+    if (nonAlterablePropsChanged) {
+      // Replace the entire language (drop + create)
+      changes.push(
+        new DropLanguage({ language: mainLanguage }),
+        new CreateLanguage({ language: branchLanguage }),
+      );
+    } else {
+      // Only alterable properties changed - check each one
+
+      // OWNER
+      if (mainLanguage.owner !== branchLanguage.owner) {
+        changes.push(
+          new AlterLanguageChangeOwner({
+            language: mainLanguage,
+            owner: branchLanguage.owner,
+          }),
+        );
+      }
+
+      // COMMENT
+      if (mainLanguage.comment !== branchLanguage.comment) {
+        if (branchLanguage.comment === null) {
+          changes.push(new DropCommentOnLanguage({ language: mainLanguage }));
+        } else {
+          changes.push(
+            new CreateCommentOnLanguage({ language: branchLanguage }),
+          );
+        }
+      }
+
+      // Note: Language renaming would also use ALTER LANGUAGE ... RENAME TO ...
+      // But since our Language model uses 'name' as the identity field,
+      // a name change would be handled as drop + create by diffObjects()
+
+      // PRIVILEGES
+      // Filter out PUBLIC's built-in default USAGE privilege from main catalog
+      // (PostgreSQL grants it automatically, so we shouldn't compare it)
+      const mainPrivilegesFiltered = filterPublicBuiltInDefaults(
+        "language",
+        mainLanguage.privileges,
+      );
+      // Filter out PUBLIC's built-in default USAGE privilege from branch catalog
+      const branchPrivilegesFiltered = filterPublicBuiltInDefaults(
+        "language",
+        branchLanguage.privileges,
+      );
+      // Filter out owner privileges - owner always has ALL privileges implicitly
+      // and shouldn't be compared. Use branch owner as the reference.
+      const privilegeResults = diffPrivileges(
+        mainPrivilegesFiltered,
+        branchPrivilegesFiltered,
+        branchLanguage.owner,
+      );
+
+      changes.push(
+        ...(emitObjectPrivilegeChanges(
+          privilegeResults,
+          branchLanguage,
+          mainLanguage,
+          "language",
+          {
+            Grant: GrantLanguagePrivileges,
+            Revoke: RevokeLanguagePrivileges,
+            RevokeGrantOption: RevokeGrantOptionLanguagePrivileges,
+          },
+          ctx.version,
+        ) as Change[]),
+      );
+    }
+  }
+
+  return changes;
+}

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

@@ -0,0 +1,150 @@
+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";
+
+/**
+ * All properties exposed by CREATE LANGUAGE statement are included in diff output.
+ * https://www.postgresql.org/docs/current/sql-createlanguage.html
+ *
+ * ALTER LANGUAGE statement can only be used to rename the language or change the owner.
+ * https://www.postgresql.org/docs/current/sql-alterlanguage.html
+ *
+ * Other properties require dropping and creating a new language.
+ */
+
+const languagePropsSchema = z.object({
+  name: z.string(),
+  is_trusted: z.boolean(),
+  is_procedural: z.boolean(),
+  call_handler: z.string().nullable(),
+  inline_handler: z.string().nullable(),
+  validator: z.string().nullable(),
+  owner: z.string(),
+  comment: z.string().nullable(),
+  privileges: z.array(privilegePropsSchema),
+});
+
+type LanguagePrivilegeProps = PrivilegeProps;
+export type LanguageProps = z.infer<typeof languagePropsSchema>;
+
+export class Language extends BasePgModel {
+  public readonly name: LanguageProps["name"];
+  public readonly is_trusted: LanguageProps["is_trusted"];
+  public readonly is_procedural: LanguageProps["is_procedural"];
+  public readonly call_handler: LanguageProps["call_handler"];
+  public readonly inline_handler: LanguageProps["inline_handler"];
+  public readonly validator: LanguageProps["validator"];
+  public readonly owner: LanguageProps["owner"];
+  public readonly comment: LanguageProps["comment"];
+  public readonly privileges: LanguagePrivilegeProps[];
+
+  constructor(props: LanguageProps) {
+    super();
+
+    // Identity fields
+    this.name = props.name;
+
+    // Data fields
+    this.is_trusted = props.is_trusted;
+    this.is_procedural = props.is_procedural;
+    this.call_handler = props.call_handler;
+    this.inline_handler = props.inline_handler;
+    this.validator = props.validator;
+    this.owner = props.owner;
+    this.comment = props.comment;
+    this.privileges = props.privileges;
+  }
+
+  get stableId(): `language:${string}` {
+    return `language:${this.name}`;
+  }
+
+  get identityFields() {
+    return {
+      name: this.name,
+    };
+  }
+
+  get dataFields() {
+    const sortedPrivileges = [...this.privileges].sort((a, b) => {
+      return (
+        a.grantee.localeCompare(b.grantee) ||
+        a.privilege.localeCompare(b.privilege) ||
+        Number(a.grantable) - Number(b.grantable)
+      );
+    });
+
+    return {
+      is_trusted: this.is_trusted,
+      is_procedural: this.is_procedural,
+      call_handler: this.call_handler,
+      inline_handler: this.inline_handler,
+      validator: this.validator,
+      owner: this.owner,
+      comment: this.comment,
+      privileges: sortedPrivileges,
+    };
+  }
+}
+
+async function _extractLanguages(pool: Pool): Promise<Language[]> {
+  const { rows: languageRows } = await pool.query<LanguageProps>(sql`
+    with extension_oids as (
+      select
+        objid
+      from
+        pg_depend d
+      where
+        d.refclassid = 'pg_extension'::regclass
+        and d.classid = 'pg_language'::regclass
+    )
+    select
+      quote_ident(lan.lanname) as name,
+      lan.lanpltrusted as is_trusted,
+      lan.lanispl as is_procedural,
+      lan.lanplcallfoid::regprocedure::text as call_handler,
+      lan.laninline::regprocedure::text as inline_handler,
+      lan.lanvalidator::regprocedure::text as validator,
+      lan.lanowner::regrole::text as owner,
+      obj_description(lan.oid, 'pg_language') 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(lan.lanacl) as x(grantor, grantee, privilege_type, is_grantable)
+        ), '[]'
+      ) as privileges
+    from
+      pg_catalog.pg_language lan
+      left outer join extension_oids e on lan.oid = e.objid
+      -- <EXCLUDE_INTERNAL and default>
+      where lan.lanname not in ('internal', 'c')
+    order by
+      lan.lanname
+  `);
+
+  // Process rows to handle "-" as null values
+  const processedRows = languageRows.map((row) => ({
+    ...row,
+    call_handler: row.call_handler === "-" ? null : row.call_handler,
+    inline_handler: row.inline_handler === "-" ? null : row.inline_handler,
+    validator: row.validator === "-" ? null : row.validator,
+  }));
+
+  // Validate and parse each row using the Zod schema
+  const validatedRows = processedRows.map((row: unknown) =>
+    languagePropsSchema.parse(row),
+  );
+  return validatedRows.map((row: LanguageProps) => new Language(row));
+}