@supabase/pg-delta 1.0.0-alpha.0 → 1.0.0-alpha.10

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

@@ -0,0 +1,224 @@
+import { sql } from "@ts-safeql/sql-tag";
+import type { Pool } from "pg";
+import z from "zod";
+import { extractVersion } from "../../context.ts";
+import { BasePgModel } from "../base.model.ts";
+
+/**
+ * Collation provider codes as stored in pg_collation.collprovider
+ */
+const CollationProviderSchema = z.enum([
+  "d", // database default provider (omit PROVIDER clause)
+  "b", // builtin
+  "c", // libc
+  "i", // icu
+]);
+
+/**
+ * All properties exposed by CREATE COLLATION statement are included in diff output.
+ * https://www.postgresql.org/docs/current/sql-createcollation.html
+ *
+ * ALTER COLLATION statement can only be generated for a subset of properties:
+ *  - version, name, owner, schema
+ * https://www.postgresql.org/docs/current/sql-altercollation.html
+ *
+ * Other properties require dropping and creating a new collation.
+ */
+const collationPropsSchema = z.object({
+  schema: z.string(),
+  name: z.string(),
+  provider: CollationProviderSchema,
+  is_deterministic: z.boolean(),
+  encoding: z.number(),
+  collate: z.string(),
+  ctype: z.string(),
+  locale: z.string().nullable(),
+  icu_rules: z.string().nullable(),
+  version: z.string().nullable(),
+  owner: z.string(),
+  comment: z.string().nullable(),
+});
+
+export type CollationProps = z.infer<typeof collationPropsSchema>;
+
+export class Collation extends BasePgModel {
+  public readonly schema: CollationProps["schema"];
+  public readonly name: CollationProps["name"];
+  public readonly provider: CollationProps["provider"];
+  public readonly is_deterministic: CollationProps["is_deterministic"];
+  public readonly encoding: CollationProps["encoding"];
+  public readonly collate: CollationProps["collate"];
+  public readonly ctype: CollationProps["ctype"];
+  public readonly locale: CollationProps["locale"];
+  public readonly icu_rules: CollationProps["icu_rules"];
+  public readonly version: CollationProps["version"];
+  public readonly owner: CollationProps["owner"];
+  public readonly comment: CollationProps["comment"];
+
+  constructor(props: CollationProps) {
+    super();
+
+    // Identity fields
+    this.schema = props.schema;
+    this.name = props.name;
+
+    // Data fields
+    this.provider = props.provider;
+    this.is_deterministic = props.is_deterministic;
+    this.encoding = props.encoding;
+    this.collate = props.collate;
+    this.ctype = props.ctype;
+    this.locale = props.locale;
+    this.icu_rules = props.icu_rules;
+    this.version = props.version;
+    this.owner = props.owner;
+    this.comment = props.comment;
+  }
+
+  get stableId(): `collation:${string}` {
+    return `collation:${this.schema}.${this.name}`;
+  }
+
+  get identityFields() {
+    return {
+      schema: this.schema,
+      name: this.name,
+    };
+  }
+
+  get dataFields() {
+    return {
+      provider: this.provider,
+      is_deterministic: this.is_deterministic,
+      encoding: this.encoding,
+      collate: this.collate,
+      ctype: this.ctype,
+      locale: this.locale,
+      icu_rules: this.icu_rules,
+      version: this.version,
+      owner: this.owner,
+      comment: this.comment,
+    };
+  }
+}
+
+export async function extractCollations(pool: Pool): Promise<Collation[]> {
+  const version = await extractVersion(pool);
+  const isPostgres17OrGreater = version >= 170000;
+  const isPostgres16OrGreater = version >= 160000;
+
+  let collationRows: CollationProps[];
+
+  if (isPostgres17OrGreater) {
+    const result = await pool.query<CollationProps>(sql`
+      with extension_oids as (
+        select
+          objid
+        from
+          pg_depend d
+        where
+          d.refclassid = 'pg_extension'::regclass
+          and d.classid = 'pg_collation'::regclass
+      )
+      select
+        c.collnamespace::regnamespace::text as schema,
+        quote_ident(c.collname) as name,
+        c.collprovider as provider,
+        c.collisdeterministic as is_deterministic,
+        c.collencoding as encoding,
+        c.collcollate as collate,
+        c.collctype as ctype,
+        c.colllocale as locale,
+        c.collicurules as icu_rules,
+        c.collversion as version,
+        c.collowner::regrole::text as owner,
+        obj_description(c.oid, 'pg_collation') as comment
+      from
+        pg_catalog.pg_collation c
+        left outer join extension_oids e on c.oid = e.objid
+        where not c.collnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+        and e.objid is null
+      order by
+        1, 2
+    `);
+    collationRows = result.rows;
+  } else if (isPostgres16OrGreater) {
+    // On postgres 16 there colllocale column was named colliculocale
+    const result = await pool.query<CollationProps>(sql`
+      with extension_oids as (
+        select
+          objid
+        from
+          pg_depend d
+        where
+          d.refclassid = 'pg_extension'::regclass
+          and d.classid = 'pg_collation'::regclass
+      )
+      select
+        c.collnamespace::regnamespace::text as schema,
+        quote_ident(c.collname) as name,
+        c.collprovider as provider,
+        c.collisdeterministic as is_deterministic,
+        c.collencoding as encoding,
+        c.collcollate as collate,
+        c.collctype as ctype,
+        colliculocale as locale,
+        c.collicurules as icu_rules,
+        c.collversion as version,
+        c.collowner::regrole::text as owner,
+        obj_description(c.oid, 'pg_collation') as comment
+      from
+        pg_catalog.pg_collation c
+        left outer join extension_oids e on c.oid = e.objid
+        -- <EXCLUDE_INTERNAL>
+        where not c.collnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+        and e.objid is null
+        -- </EXCLUDE_INTERNAL>
+      order by
+        1, 2
+    `);
+    collationRows = result.rows;
+  } else {
+    // On postgres 15 icu_rules does not exist
+    const result = await pool.query<CollationProps>(sql`
+      with extension_oids as (
+        select
+          objid
+        from
+          pg_depend d
+        where
+          d.refclassid = 'pg_extension'::regclass
+          and d.classid = 'pg_collation'::regclass
+      )
+      select
+        c.collnamespace::regnamespace::text as schema,
+        quote_ident(c.collname) as name,
+        c.collprovider as provider,
+        c.collisdeterministic as is_deterministic,
+        c.collencoding as encoding,
+        c.collcollate as collate,
+        c.collctype as ctype,
+        colliculocale as locale,
+        null as icu_rules,
+        c.collversion as version,
+        c.collowner::regrole::text as owner,
+        obj_description(c.oid, 'pg_collation') as comment
+      from
+        pg_catalog.pg_collation c
+        left outer join extension_oids e on c.oid = e.objid
+        -- <EXCLUDE_INTERNAL>
+        where not c.collnamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
+        and e.objid is null
+        -- </EXCLUDE_INTERNAL>
+      order by
+        1, 2
+    `);
+    collationRows = result.rows;
+  }
+
+  // Validate and parse each row using the Zod schema
+  const validatedRows = collationRows.map((row: unknown) =>
+    collationPropsSchema.parse(row),
+  );
+  return validatedRows.map((row: CollationProps) => new Collation(row));
+}

package/src/core/objects/diff-context.ts

@@ -0,0 +1,16 @@
+import type { DefaultPrivilegeState } from "./base.default-privileges.ts";
+import type { Role } from "./role/role.model.ts";
+
+/**
+ * Unified context built by `diffCatalogs` and passed to per-object diff
+ * functions.  Each diff declares only the keys it reads via
+ * `Pick<ObjectDiffContext, …>`, so every signature documents its actual
+ * requirements.  The full object is always assignable to every narrower Pick.
+ */
+export interface ObjectDiffContext {
+  version: number;
+  currentUser: string;
+  defaultPrivilegeState: DefaultPrivilegeState;
+  mainRoles: Record<string, Role>;
+  skipDefaultPrivilegeSubtraction?: boolean;
+}

package/src/core/objects/domain/changes/domain.alter.test.ts

@@ -0,0 +1,335 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Domain, type DomainProps } from "../domain.model.ts";
+import {
+  AlterDomainAddConstraint,
+  AlterDomainChangeOwner,
+  AlterDomainDropConstraint,
+  AlterDomainDropDefault,
+  AlterDomainDropNotNull,
+  AlterDomainSetDefault,
+  AlterDomainSetNotNull,
+  AlterDomainValidateConstraint,
+} from "./domain.alter.ts";
+
+describe.concurrent("domain", () => {
+  describe("alter", () => {
+    test("set default", async () => {
+      const props: Omit<DomainProps, "default_value"> = {
+        schema: "public",
+        name: "test_domain",
+        base_type: "integer",
+        base_type_schema: "pg_catalog",
+        not_null: false,
+        type_modifier: null,
+        array_dimensions: null,
+        collation: null,
+        default_bin: null,
+        owner: "test",
+        comment: null,
+        constraints: [],
+        privileges: [],
+      };
+      const domain = new Domain({
+        ...props,
+        default_value: null,
+      });
+
+      const change = new AlterDomainSetDefault({
+        domain,
+        defaultValue: "42",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER DOMAIN public.test_domain SET DEFAULT 42",
+      );
+    });
+
+    test("drop default", async () => {
+      const props: Omit<DomainProps, "default_value"> = {
+        schema: "public",
+        name: "test_domain",
+        base_type: "integer",
+        base_type_schema: "pg_catalog",
+        not_null: false,
+        type_modifier: null,
+        array_dimensions: null,
+        collation: null,
+        default_bin: null,
+        owner: "test",
+        comment: null,
+        constraints: [],
+
+        privileges: [],
+      };
+      const domain = new Domain({
+        ...props,
+        default_value: "42",
+      });
+
+      const change = new AlterDomainDropDefault({
+        domain,
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER DOMAIN public.test_domain DROP DEFAULT",
+      );
+    });
+
+    test("set not null", async () => {
+      const props: Omit<DomainProps, "not_null"> = {
+        schema: "public",
+        name: "test_domain",
+        base_type: "integer",
+        base_type_schema: "pg_catalog",
+        type_modifier: null,
+        array_dimensions: null,
+        collation: null,
+        default_bin: null,
+        default_value: null,
+        owner: "test",
+        comment: null,
+        constraints: [],
+
+        privileges: [],
+      };
+      const domain = new Domain({
+        ...props,
+        not_null: false,
+      });
+
+      const change = new AlterDomainSetNotNull({
+        domain,
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER DOMAIN public.test_domain SET NOT NULL",
+      );
+    });
+
+    test("drop not null", async () => {
+      const props: Omit<DomainProps, "not_null"> = {
+        schema: "public",
+        name: "test_domain",
+        base_type: "integer",
+        base_type_schema: "pg_catalog",
+        type_modifier: null,
+        array_dimensions: null,
+        collation: null,
+        default_bin: null,
+        default_value: null,
+        owner: "test",
+        comment: null,
+        constraints: [],
+
+        privileges: [],
+      };
+      const domain = new Domain({
+        ...props,
+        not_null: true,
+      });
+
+      const change = new AlterDomainDropNotNull({
+        domain,
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER DOMAIN public.test_domain DROP NOT NULL",
+      );
+    });
+
+    test("change owner", async () => {
+      const props: Omit<DomainProps, "owner"> = {
+        schema: "public",
+        name: "test_domain",
+        base_type: "integer",
+        base_type_schema: "pg_catalog",
+        not_null: false,
+        type_modifier: null,
+        array_dimensions: null,
+        collation: null,
+        default_bin: null,
+        default_value: null,
+        comment: null,
+        constraints: [],
+
+        privileges: [],
+      };
+      const domain = new Domain({
+        ...props,
+        owner: "old_owner",
+      });
+
+      const change = new AlterDomainChangeOwner({
+        domain,
+        owner: "new_owner",
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER DOMAIN public.test_domain OWNER TO new_owner",
+      );
+    });
+
+    test("add constraint", async () => {
+      const props: DomainProps = {
+        schema: "public",
+        name: "test_domain",
+        base_type: "integer",
+        base_type_schema: "pg_catalog",
+        not_null: false,
+        type_modifier: null,
+        array_dimensions: null,
+        collation: null,
+        default_bin: null,
+        default_value: null,
+        owner: "test",
+        comment: null,
+        constraints: [],
+
+        privileges: [],
+      };
+      const domain = new Domain(props);
+
+      const change = new AlterDomainAddConstraint({
+        domain,
+        constraint: {
+          name: "test_check",
+          validated: true,
+          is_local: true,
+          no_inherit: false,
+          check_expression: "VALUE > 0",
+        },
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER DOMAIN public.test_domain ADD CONSTRAINT test_check CHECK (VALUE > 0)",
+      );
+    });
+
+    test("add constraint not valid", async () => {
+      const props: DomainProps = {
+        schema: "public",
+        name: "test_domain",
+        base_type: "integer",
+        base_type_schema: "pg_catalog",
+        not_null: false,
+        type_modifier: null,
+        array_dimensions: null,
+        collation: null,
+        default_bin: null,
+        default_value: null,
+        owner: "test",
+        comment: null,
+        constraints: [],
+
+        privileges: [],
+      };
+      const domain = new Domain(props);
+
+      const change = new AlterDomainAddConstraint({
+        domain,
+        constraint: {
+          name: "test_check",
+          validated: false,
+          is_local: true,
+          no_inherit: false,
+          check_expression: "VALUE > 0",
+        },
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER DOMAIN public.test_domain ADD CONSTRAINT test_check CHECK (VALUE > 0) NOT VALID",
+      );
+    });
+
+    test("drop constraint", async () => {
+      const props: DomainProps = {
+        schema: "public",
+        name: "test_domain",
+        base_type: "integer",
+        base_type_schema: "pg_catalog",
+        not_null: false,
+        type_modifier: null,
+        array_dimensions: null,
+        collation: null,
+        default_bin: null,
+        default_value: null,
+        owner: "test",
+        comment: null,
+        constraints: [],
+
+        privileges: [],
+      };
+      const domain = new Domain(props);
+
+      const change = new AlterDomainDropConstraint({
+        domain,
+        constraint: {
+          name: "test_check",
+          validated: true,
+          is_local: true,
+          no_inherit: false,
+          check_expression: "VALUE > 0",
+        },
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER DOMAIN public.test_domain DROP CONSTRAINT test_check",
+      );
+    });
+
+    test("validate constraint", async () => {
+      const props: DomainProps = {
+        schema: "public",
+        name: "test_domain",
+        base_type: "integer",
+        base_type_schema: "pg_catalog",
+        not_null: false,
+        type_modifier: null,
+        array_dimensions: null,
+        collation: null,
+        default_bin: null,
+        default_value: null,
+        owner: "test",
+        comment: null,
+        constraints: [],
+
+        privileges: [],
+      };
+      const domain = new Domain(props);
+
+      const change = new AlterDomainValidateConstraint({
+        domain,
+        constraint: {
+          name: "test_check",
+          validated: true,
+          is_local: true,
+          no_inherit: false,
+          check_expression: "VALUE > 0",
+        },
+      });
+
+      await assertValidSql(change.serialize());
+
+      expect(change.serialize()).toBe(
+        "ALTER DOMAIN public.test_domain VALIDATE CONSTRAINT test_check",
+      );
+    });
+  });
+});