@supabase/pg-delta 1.0.0-alpha.2 → 1.0.0-alpha.20

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

@@ -0,0 +1,287 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import { stableId } from "../../utils.ts";
+import type { Domain, DomainConstraintProps } from "../domain.model.ts";
+import { AlterDomainChange, DropDomainChange } from "./domain.base.ts";
+
+/**
+ * Alter a domain.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterdomain.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER DOMAIN name
+ *     { SET DEFAULT expression | DROP DEFAULT }
+ * ALTER DOMAIN name
+ *     { SET | DROP } NOT NULL
+ * ALTER DOMAIN name
+ *     ADD domain_constraint [ NOT VALID ]
+ * ALTER DOMAIN name
+ *     DROP CONSTRAINT [ IF EXISTS ] constraint_name [ RESTRICT | CASCADE ]
+ * ALTER DOMAIN name
+ *     RENAME CONSTRAINT constraint_name TO new_constraint_name
+ * ALTER DOMAIN name
+ *     VALIDATE CONSTRAINT constraint_name
+ * ALTER DOMAIN name
+ *     OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ * ALTER DOMAIN name
+ *     RENAME TO new_name
+ * ALTER DOMAIN name
+ *     SET SCHEMA new_schema
+ *
+ * where domain_constraint is:
+ *
+ *     [ CONSTRAINT constraint_name ]
+ *     { NOT NULL | CHECK (expression) }
+ * ```
+ */
+
+export type AlterDomain =
+  | AlterDomainAddConstraint
+  | AlterDomainChangeOwner
+  | AlterDomainDropConstraint
+  | AlterDomainDropDefault
+  | AlterDomainDropNotNull
+  | AlterDomainSetDefault
+  | AlterDomainSetNotNull
+  | AlterDomainValidateConstraint;
+
+/**
+ * ALTER DOMAIN ... SET DEFAULT ...
+ */
+export class AlterDomainSetDefault extends AlterDomainChange {
+  public readonly domain: Domain;
+  public readonly defaultValue: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { domain: Domain; defaultValue: string }) {
+    super();
+    this.domain = props.domain;
+    this.defaultValue = props.defaultValue;
+  }
+
+  get requires() {
+    return [this.domain.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return `ALTER DOMAIN ${this.domain.schema}.${this.domain.name} SET DEFAULT ${this.defaultValue}`;
+  }
+}
+
+/**
+ * ALTER DOMAIN ... DROP DEFAULT
+ */
+export class AlterDomainDropDefault extends AlterDomainChange {
+  public readonly domain: Domain;
+  public readonly scope = "object" as const;
+
+  constructor(props: { domain: Domain }) {
+    super();
+    this.domain = props.domain;
+  }
+
+  get requires() {
+    return [this.domain.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return `ALTER DOMAIN ${this.domain.schema}.${this.domain.name} DROP DEFAULT`;
+  }
+}
+
+/**
+ * ALTER DOMAIN ... SET NOT NULL
+ */
+export class AlterDomainSetNotNull extends AlterDomainChange {
+  public readonly domain: Domain;
+  public readonly scope = "object" as const;
+
+  constructor(props: { domain: Domain }) {
+    super();
+    this.domain = props.domain;
+  }
+
+  get requires() {
+    return [this.domain.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return `ALTER DOMAIN ${this.domain.schema}.${this.domain.name} SET NOT NULL`;
+  }
+}
+
+/**
+ * ALTER DOMAIN ... DROP NOT NULL
+ */
+export class AlterDomainDropNotNull extends AlterDomainChange {
+  public readonly domain: Domain;
+  public readonly scope = "object" as const;
+
+  constructor(props: { domain: Domain }) {
+    super();
+    this.domain = props.domain;
+  }
+
+  get requires() {
+    return [this.domain.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return `ALTER DOMAIN ${this.domain.schema}.${this.domain.name} DROP NOT NULL`;
+  }
+}
+
+/**
+ * ALTER DOMAIN ... OWNER TO ...
+ */
+export class AlterDomainChangeOwner extends AlterDomainChange {
+  public readonly domain: Domain;
+  public readonly owner: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { domain: Domain; owner: string }) {
+    super();
+    this.domain = props.domain;
+    this.owner = props.owner;
+  }
+
+  get requires() {
+    return [this.domain.stableId, stableId.role(this.owner)];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return `ALTER DOMAIN ${this.domain.schema}.${this.domain.name} OWNER TO ${this.owner}`;
+  }
+}
+
+/**
+ * ALTER DOMAIN ... ADD CONSTRAINT ... [ NOT VALID ]
+ */
+export class AlterDomainAddConstraint extends AlterDomainChange {
+  public readonly domain: Domain;
+  public readonly constraint: DomainConstraintProps;
+  public readonly scope = "object" as const;
+
+  constructor(props: { domain: Domain; constraint: DomainConstraintProps }) {
+    super();
+    this.domain = props.domain;
+    this.constraint = props.constraint;
+  }
+
+  get creates() {
+    return [
+      stableId.constraint(
+        this.domain.schema,
+        this.domain.name,
+        this.constraint.name,
+      ),
+    ];
+  }
+
+  get requires() {
+    return [this.domain.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const domainName = `${this.domain.schema}.${this.domain.name}`;
+    const parts: string[] = [
+      "ALTER DOMAIN",
+      domainName,
+      "ADD CONSTRAINT",
+      this.constraint.name,
+    ];
+    if (this.constraint.check_expression) {
+      parts.push(`CHECK (${this.constraint.check_expression})`);
+    }
+    if (!this.constraint.validated) {
+      parts.push("NOT VALID");
+    }
+    return parts.join(" ");
+  }
+}
+
+/**
+ * ALTER DOMAIN ... DROP CONSTRAINT ...
+ */
+export class AlterDomainDropConstraint extends DropDomainChange {
+  public readonly domain: Domain;
+  public readonly constraint: DomainConstraintProps;
+  public readonly scope = "object" as const;
+
+  constructor(props: { domain: Domain; constraint: DomainConstraintProps }) {
+    super();
+    this.domain = props.domain;
+    this.constraint = props.constraint;
+  }
+
+  get requires() {
+    return [
+      this.domain.stableId,
+      stableId.constraint(
+        this.domain.schema,
+        this.domain.name,
+        this.constraint.name,
+      ),
+    ];
+  }
+
+  get drops() {
+    return [
+      stableId.constraint(
+        this.domain.schema,
+        this.domain.name,
+        this.constraint.name,
+      ),
+    ];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const domainName = `${this.domain.schema}.${this.domain.name}`;
+    return [
+      "ALTER DOMAIN",
+      domainName,
+      "DROP CONSTRAINT",
+      this.constraint.name,
+    ].join(" ");
+  }
+}
+
+// Constraint renames are modeled as drop+add because the constraint name
+// is part of the identity used in diffing and dependency resolution.
+
+/**
+ * ALTER DOMAIN ... VALIDATE CONSTRAINT ...
+ */
+export class AlterDomainValidateConstraint extends AlterDomainChange {
+  public readonly domain: Domain;
+  public readonly constraint: DomainConstraintProps;
+  public readonly scope = "object" as const;
+
+  constructor(props: { domain: Domain; constraint: DomainConstraintProps }) {
+    super();
+    this.domain = props.domain;
+    this.constraint = props.constraint;
+  }
+
+  get requires() {
+    return [
+      this.domain.stableId,
+      stableId.constraint(
+        this.domain.schema,
+        this.domain.name,
+        this.constraint.name,
+      ),
+    ];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const domainName = `${this.domain.schema}.${this.domain.name}`;
+    return [
+      "ALTER DOMAIN",
+      domainName,
+      "VALIDATE CONSTRAINT",
+      this.constraint.name,
+    ].join(" ");
+  }
+}

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

@@ -0,0 +1,20 @@
+import { BaseChange } from "../../base.change.ts";
+import type { Domain } from "../domain.model.ts";
+
+abstract class BaseDomainChange extends BaseChange {
+  abstract readonly domain: Domain;
+  abstract readonly scope: "object" | "comment" | "privilege";
+  readonly objectType: "domain" = "domain";
+}
+
+export abstract class CreateDomainChange extends BaseDomainChange {
+  readonly operation = "create" as const;
+}
+
+export abstract class AlterDomainChange extends BaseDomainChange {
+  readonly operation = "alter" as const;
+}
+
+export abstract class DropDomainChange extends BaseDomainChange {
+  readonly operation = "drop" as const;
+}

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

@@ -0,0 +1,60 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import { quoteLiteral } from "../../base.change.ts";
+import { stableId } from "../../utils.ts";
+import type { Domain } from "../domain.model.ts";
+import { CreateDomainChange, DropDomainChange } from "./domain.base.ts";
+
+export type CommentDomain = CreateCommentOnDomain | DropCommentOnDomain;
+
+/**
+ * Create/drop comments on domains.
+ */
+export class CreateCommentOnDomain extends CreateDomainChange {
+  public readonly domain: Domain;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { domain: Domain }) {
+    super();
+    this.domain = props.domain;
+  }
+
+  get creates() {
+    return [stableId.comment(this.domain.stableId)];
+  }
+
+  get requires() {
+    return [this.domain.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON DOMAIN",
+      `${this.domain.schema}.${this.domain.name}`,
+      "IS",
+      // biome-ignore lint/style/noNonNullAssertion: domain comment is not nullable in this case
+      quoteLiteral(this.domain.comment!),
+    ].join(" ");
+  }
+}
+
+export class DropCommentOnDomain extends DropDomainChange {
+  public readonly domain: Domain;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { domain: Domain }) {
+    super();
+    this.domain = props.domain;
+  }
+
+  get requires() {
+    return [stableId.comment(this.domain.stableId), this.domain.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return [
+      "COMMENT ON DOMAIN",
+      `${this.domain.schema}.${this.domain.name}`,
+      "IS NULL",
+    ].join(" ");
+  }
+}

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

@@ -0,0 +1,95 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Domain } from "../domain.model.ts";
+import { CreateDomain } from "./domain.create.ts";
+
+describe("domain", () => {
+  test("create minimal", async () => {
+    const domain = new Domain({
+      schema: "public",
+      name: "test_domain",
+      base_type: "integer",
+      base_type_schema: "pg_catalog",
+      base_type_str: "integer",
+      not_null: false,
+      type_modifier: null,
+      array_dimensions: null,
+      collation: null,
+      default_bin: null,
+      default_value: null,
+      owner: "test",
+      comment: null,
+      constraints: [],
+      privileges: [],
+    });
+
+    const change = new CreateDomain({ domain });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      "CREATE DOMAIN public.test_domain AS integer",
+    );
+  });
+
+  test("create with all options", async () => {
+    const domain = new Domain({
+      schema: "public",
+      name: "test_domain_all",
+      base_type: "text",
+      base_type_schema: "custom",
+      base_type_str: "text",
+      not_null: true,
+      type_modifier: null,
+      array_dimensions: 2,
+      collation: "mycoll",
+      default_bin: null,
+      default_value: "'hello'",
+      owner: "test",
+      comment: null,
+      constraints: [
+        {
+          name: "c1",
+          validated: true,
+          is_local: true,
+          no_inherit: false,
+          check_expression: "VALUE <> ''",
+        },
+      ],
+      privileges: [],
+    });
+
+    const change = new CreateDomain({ domain });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe(
+      `CREATE DOMAIN public.test_domain_all AS custom.text[][] COLLATE mycoll DEFAULT 'hello' NOT NULL CHECK (VALUE <> '')`,
+    );
+  });
+
+  test("create with already schema-qualified base type (format_type)", async () => {
+    const domain = new Domain({
+      schema: "app",
+      name: "email_address",
+      base_type: "citext",
+      base_type_schema: "extensions",
+      base_type_str: "extensions.citext",
+      not_null: false,
+      type_modifier: null,
+      array_dimensions: null,
+      collation: null,
+      default_bin: null,
+      default_value: null,
+      owner: "test",
+      comment: null,
+      constraints: [],
+      privileges: [],
+    });
+    const change = new CreateDomain({ domain });
+    await assertValidSql(change.serialize());
+    expect(change.serialize()).toBe(
+      "CREATE DOMAIN app.email_address AS extensions.citext",
+    );
+  });
+});

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

@@ -0,0 +1,141 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import {
+  isUserDefinedTypeSchema,
+  parseTypeString,
+  stableId,
+} from "../../utils.ts";
+import type { Domain } from "../domain.model.ts";
+import { CreateDomainChange } from "./domain.base.ts";
+
+/**
+ * Create a domain.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createdomain.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE DOMAIN name [ AS ] data_type
+ * [ COLLATE collation ]
+ * [ DEFAULT expression ]
+ * [ domain_constraint [ ... ] ]
+ *
+ * where domain_constraint is:
+ *
+ * [ CONSTRAINT constraint_name ]
+ * { NOT NULL | NULL | CHECK (expression) }
+ * ```
+ */
+export class CreateDomain extends CreateDomainChange {
+  public readonly domain: Domain;
+  public readonly scope = "object" as const;
+
+  constructor(props: { domain: Domain }) {
+    super();
+    this.domain = props.domain;
+  }
+
+  get creates() {
+    const creates: Array<
+      `domain:${string}` | `constraint:${string}.${string}.${string}`
+    > = [this.domain.stableId];
+
+    for (const constraint of this.domain.constraints) {
+      if (constraint.check_expression && constraint.validated) {
+        creates.push(
+          stableId.constraint(
+            this.domain.schema,
+            this.domain.name,
+            constraint.name,
+          ),
+        );
+      }
+    }
+
+    return creates;
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // Schema dependency
+    dependencies.add(stableId.schema(this.domain.schema));
+
+    // Owner dependency
+    dependencies.add(stableId.role(this.domain.owner));
+
+    // Base type dependency (if user-defined)
+    if (
+      this.domain.base_type_schema &&
+      isUserDefinedTypeSchema(this.domain.base_type_schema)
+    ) {
+      dependencies.add(
+        stableId.type(this.domain.base_type_schema, this.domain.base_type),
+      );
+    }
+
+    // Collation dependency (if non-default and user-defined)
+    if (this.domain.collation) {
+      const unquotedCollation = this.domain.collation.replace(/^"|"$/g, "");
+      const collationParts = unquotedCollation.split(".");
+      if (collationParts.length === 2) {
+        const [collationSchema, collationName] = collationParts;
+        if (isUserDefinedTypeSchema(collationSchema)) {
+          dependencies.add(stableId.collation(collationSchema, collationName));
+        }
+      }
+    }
+
+    return Array.from(dependencies);
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    const parts: string[] = [];
+
+    // Schema-qualified name
+    const domainName = `${this.domain.schema}.${this.domain.name}`;
+
+    // Base type (use formatted string for type+typmod and add schema if needed)
+    let baseType = this.domain.base_type_str as string;
+    const alreadyQualified = parseTypeString(baseType);
+    if (
+      !alreadyQualified &&
+      this.domain.base_type_schema &&
+      this.domain.base_type_schema !== "pg_catalog"
+    ) {
+      baseType = `${this.domain.base_type_schema}.${baseType}`;
+    }
+
+    // Array dimensions
+    if (this.domain.array_dimensions && this.domain.array_dimensions > 0) {
+      baseType += "[]".repeat(this.domain.array_dimensions);
+    }
+
+    parts.push(`CREATE DOMAIN ${domainName} AS ${baseType}`);
+
+    // Collation
+    if (this.domain.collation) {
+      parts.push(`COLLATE ${this.domain.collation}`);
+    }
+
+    // Default value
+    if (this.domain.default_value) {
+      parts.push(`DEFAULT ${this.domain.default_value}`);
+    }
+
+    // NOT NULL constraint
+    if (this.domain.not_null) {
+      parts.push("NOT NULL");
+    }
+
+    // Inline CHECK constraints that are already validated
+    if (this.domain.constraints && this.domain.constraints.length > 0) {
+      for (const c of this.domain.constraints) {
+        if (c.check_expression && c.validated !== false) {
+          parts.push(`CHECK (${c.check_expression})`);
+        }
+      }
+    }
+
+    return parts.join(" ");
+  }
+}

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

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { Domain } from "../domain.model.ts";
+import { DropDomain } from "./domain.drop.ts";
+
+describe("domain", () => {
+  test("drop", async () => {
+    const domain = new Domain({
+      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 change = new DropDomain({
+      domain,
+    });
+
+    await assertValidSql(change.serialize());
+
+    expect(change.serialize()).toBe("DROP DOMAIN public.test_domain");
+  });
+});

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

@@ -0,0 +1,35 @@
+import type { SerializeOptions } from "../../../integrations/serialize/serialize.types.ts";
+import type { Domain } from "../domain.model.ts";
+import { DropDomainChange } from "./domain.base.ts";
+
+/**
+ * Drop a domain.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropdomain.html
+ *
+ * Synopsis
+ * ```sql
+ * DROP DOMAIN [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]
+ * ```
+ */
+export class DropDomain extends DropDomainChange {
+  public readonly domain: Domain;
+  public readonly scope = "object" as const;
+
+  constructor(props: { domain: Domain }) {
+    super();
+    this.domain = props.domain;
+  }
+
+  get requires() {
+    return [this.domain.stableId];
+  }
+
+  get drops() {
+    return [this.domain.stableId];
+  }
+
+  serialize(_options?: SerializeOptions): string {
+    return `DROP DOMAIN ${this.domain.schema}.${this.domain.name}`;
+  }
+}