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

package/src/core/objects/type/type.types.ts

@@ -0,0 +1,5 @@
+import type { CompositeTypeChange } from "./composite-type/changes/composite-type.types.ts";
+import type { EnumChange } from "./enum/changes/enum.types.ts";
+import type { RangeChange } from "./range/changes/range.types.ts";
+
+export type TypeChange = CompositeTypeChange | EnumChange | RangeChange;

package/src/core/objects/utils.ts

@@ -0,0 +1,171 @@
+type Comparator<T> = (a: T, b: T) => boolean;
+
+type Indexable<T> = { [P in keyof T]: unknown };
+
+/**
+ * JSON.stringify replacement that safely serializes BigInt values by converting
+ * them to strings. This ensures stable serialization for deep equality checks
+ * without throwing on BigInt instances.
+ */
+export function stringifyWithBigInt(value: unknown, space: number = 2): string {
+  return JSON.stringify(
+    value,
+    (_key, v) => (typeof v === "bigint" ? v.toString() : v),
+    space,
+  );
+}
+
+export function hasNonAlterableChanges<T, K extends keyof T>(
+  main: T,
+  branch: T,
+  keys: ReadonlyArray<K>,
+  comparators?: Partial<Record<K, Comparator<unknown>>>,
+): boolean {
+  const mainIndexable = main as unknown as Indexable<T>;
+  const branchIndexable = branch as unknown as Indexable<T>;
+  for (const key of keys) {
+    // Prefer custom comparator when provided; fallback to strict equality
+    const equals =
+      (comparators?.[key] as Comparator<unknown>) ??
+      ((a: unknown, b: unknown) => a === b);
+    if (!equals(mainIndexable[key], branchIndexable[key])) return true;
+  }
+  return false;
+}
+
+export const deepEqual: Comparator<unknown> = (a: unknown, b: unknown) =>
+  stringifyWithBigInt(a) === stringifyWithBigInt(b);
+
+// Helpers for stableId that aren't encoded in a class, mostly for sub-entities or meta entities.
+export const stableId = {
+  schema(schema: string) {
+    return `schema:${schema}` as const;
+  },
+  table(schema: string, table: string) {
+    return `table:${schema}.${table}` as const;
+  },
+  view(schema: string, view: string) {
+    return `view:${schema}.${view}` as const;
+  },
+  materializedView(schema: string, view: string) {
+    return `materializedView:${schema}.${view}` as const;
+  },
+  acl(objectStableId: string, grantee: string) {
+    return `acl:${objectStableId}::grantee:${grantee}` as const;
+  },
+  /**
+   *
+   * 'defacl:' || grantor || ':' || objtype || ':' || coalesce('schema:' || in_schema, 'global') || ':grantee:' || grantee as dependent_stable_id,
+   */
+  defacl(
+    grantor: string,
+    objtype: string,
+    schema: string | null,
+    grantee: string,
+  ) {
+    return `defacl:${grantor}:${objtype}:${schema ? `schema:${schema}` : "global"}:grantee:${grantee}` as const;
+  },
+  column(schema: string, table: string, column: string) {
+    return `column:${schema}.${table}.${column}` as const;
+  },
+  constraint(schema: string, table: string, constraint: string) {
+    return `constraint:${schema}.${table}.${constraint}` as const;
+  },
+  comment(objectStableId: string) {
+    return `comment:${objectStableId}` as const;
+  },
+  role(role: string) {
+    return `role:${role}` as const;
+  },
+  type(schema: string, name: string) {
+    return `type:${schema}.${name}` as const;
+  },
+  collation(schema: string, name: string) {
+    return `collation:${schema}.${name}` as const;
+  },
+  procedure(schema: string, name: string, args: string = "") {
+    return `procedure:${schema}.${name}(${args})` as const;
+  },
+  membership(role: string, member: string) {
+    return `membership:${role}->${member}` as const;
+  },
+  foreignDataWrapper(name: string) {
+    return `foreignDataWrapper:${name}` as const;
+  },
+  server(name: string) {
+    return `server:${name}` as const;
+  },
+  userMapping(server: string, user: string) {
+    return `userMapping:${server}:${user}` as const;
+  },
+  foreignTable(schema: string, name: string) {
+    return `foreignTable:${schema}.${name}` as const;
+  },
+};
+
+/**
+ * Check if a schema name represents a user-defined type (not pg_catalog or information_schema).
+ * Used to filter out system types when building dependency lists.
+ */
+export function isUserDefinedTypeSchema(
+  schema: string | null | undefined,
+): boolean {
+  return (
+    schema != null && schema !== "pg_catalog" && schema !== "information_schema"
+  );
+}
+
+/**
+ * Parse a procedure reference string (from regprocedure::text) to extract schema and function name.
+ * Format: "schema.function_name(argtypes)" or "function_name(argtypes)"
+ * Returns null if parsing fails or if it's a system procedure.
+ */
+export function parseProcedureReference(
+  procRef: string | null | undefined,
+): { schema: string; name: string } | null {
+  if (!procRef) return null;
+
+  // Format is "schema.function_name(argtypes)" or "function_name(argtypes)"
+  // Extract everything before the opening parenthesis
+  const match = procRef.match(/^([^(]+)\(/);
+  if (!match) return null;
+
+  const qualifiedName = match[1];
+  const parts = qualifiedName.split(".");
+  if (parts.length === 1) {
+    // No schema prefix - assume current schema (we can't determine it here)
+    // For now, skip these as we need schema info
+    return null;
+  }
+  if (parts.length === 2) {
+    const [schema, name] = parts;
+    if (isUserDefinedTypeSchema(schema)) {
+      return { schema, name };
+    }
+  }
+  return null;
+}
+
+/**
+ * Parse a type string (from format_type) to extract schema and type name if it's schema-qualified.
+ * Format: "type_name" or "schema.type_name" or "schema.type_name[]"
+ * Returns null if it's not schema-qualified or if it's a system type.
+ */
+export function parseTypeString(
+  typeStr: string | null | undefined,
+): { schema: string; name: string } | null {
+  if (!typeStr) return null;
+
+  // Remove array brackets for parsing
+  const baseType = typeStr.replace(/\[\]+$/, "");
+
+  // Check if it's schema-qualified (contains a dot)
+  const parts = baseType.split(".");
+  if (parts.length === 2) {
+    const [schema, name] = parts;
+    if (isUserDefinedTypeSchema(schema)) {
+      return { schema, name };
+    }
+  }
+  return null;
+}

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

@@ -0,0 +1,110 @@
+import { describe, expect, test } from "bun:test";
+import { View, type ViewProps } from "../view.model.ts";
+import {
+  AlterViewChangeOwner,
+  AlterViewResetOptions,
+  AlterViewSetOptions,
+} from "./view.alter.ts";
+
+describe.concurrent("view", () => {
+  describe("alter", () => {
+    test("change owner", () => {
+      const props: Omit<ViewProps, "owner"> = {
+        schema: "public",
+        name: "test_view",
+        definition: "SELECT * FROM test_table",
+        row_security: false,
+        force_row_security: false,
+        has_indexes: false,
+        has_rules: false,
+        has_triggers: false,
+        has_subclasses: false,
+        is_populated: false,
+        replica_identity: "d",
+        is_partition: false,
+        options: null,
+        partition_bound: null,
+        comment: null,
+        columns: [],
+        privileges: [],
+      };
+      const main = new View({
+        ...props,
+        owner: "old_owner",
+      });
+      // branch no longer needed for constructor; we only pass explicit owner
+
+      const change = new AlterViewChangeOwner({
+        view: main,
+        owner: "new_owner",
+      });
+
+      expect(change.serialize()).toBe(
+        "ALTER VIEW public.test_view OWNER TO new_owner",
+      );
+    });
+  });
+
+  test("set options", () => {
+    const props: Omit<ViewProps, "options"> = {
+      schema: "public",
+      name: "test_view",
+      definition: "SELECT * FROM test_table",
+      row_security: false,
+      force_row_security: false,
+      has_indexes: false,
+      has_rules: false,
+      has_triggers: false,
+      has_subclasses: false,
+      is_populated: false,
+      replica_identity: "d",
+      is_partition: false,
+      partition_bound: null,
+      owner: "test",
+      comment: null,
+      columns: [],
+      privileges: [],
+    };
+    const main = new View({ ...props, options: ["security_barrier=true"] });
+    // branch no longer needed; we pass explicit options list
+
+    const change = new AlterViewSetOptions({
+      view: main,
+      options: ["security_barrier=false"],
+    });
+    expect(change.serialize()).toBe(
+      "ALTER VIEW public.test_view SET (security_barrier=false)",
+    );
+  });
+
+  test("reset options", () => {
+    const view = new View({
+      schema: "public",
+      name: "test_view",
+      definition: "SELECT * FROM test_table",
+      row_security: false,
+      force_row_security: false,
+      has_indexes: false,
+      has_rules: false,
+      has_triggers: false,
+      has_subclasses: false,
+      is_populated: false,
+      replica_identity: "d",
+      is_partition: false,
+      options: ["security_barrier=true", "check_option=local"],
+      partition_bound: null,
+      owner: "test",
+      comment: null,
+      columns: [],
+      privileges: [],
+    });
+
+    const change = new AlterViewResetOptions({
+      view,
+      params: ["check_option"],
+    });
+    expect(change.serialize()).toBe(
+      "ALTER VIEW public.test_view RESET (check_option)",
+    );
+  });
+});

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

@@ -0,0 +1,112 @@
+import type { View } from "../view.model.ts";
+import { AlterViewChange } from "./view.base.ts";
+
+/**
+ * Alter a view.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-alterview.html
+ *
+ * Synopsis
+ * ```sql
+ * ALTER VIEW [ IF EXISTS ] name ALTER [ COLUMN ] column_name SET DEFAULT expression
+ * ALTER VIEW [ IF EXISTS ] name ALTER [ COLUMN ] column_name DROP DEFAULT
+ * ALTER VIEW [ IF EXISTS ] name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
+ * ALTER VIEW [ IF EXISTS ] name RENAME [ COLUMN ] column_name TO new_column_name
+ * ALTER VIEW [ IF EXISTS ] name RENAME TO new_name
+ * ALTER VIEW [ IF EXISTS ] name SET SCHEMA new_schema
+ * ALTER VIEW [ IF EXISTS ] name SET ( view_option_name [= view_option_value] [, ... ] )
+ * ALTER VIEW [ IF EXISTS ] name RESET ( view_option_name [, ... ] )
+ * ```
+ */
+
+export type AlterView =
+  | AlterViewChangeOwner
+  | AlterViewResetOptions
+  | AlterViewSetOptions;
+
+/**
+ * ALTER VIEW ... OWNER TO ...
+ */
+export class AlterViewChangeOwner extends AlterViewChange {
+  public readonly view: View;
+  public readonly owner: string;
+  public readonly scope = "object" as const;
+
+  constructor(props: { view: View; owner: string }) {
+    super();
+    this.view = props.view;
+    this.owner = props.owner;
+  }
+
+  get requires() {
+    return [this.view.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "ALTER VIEW",
+      `${this.view.schema}.${this.view.name}`,
+      "OWNER TO",
+      this.owner,
+    ].join(" ");
+  }
+}
+
+// NOTE: ReplaceView removed. Non-alterable changes are emitted as CREATE OR REPLACE in view.diff.ts.
+
+/**
+ * ALTER VIEW ... SET ( ... )
+ */
+export class AlterViewSetOptions extends AlterViewChange {
+  public readonly view: View;
+  public readonly options: string[];
+  public readonly scope = "object" as const;
+
+  constructor(props: { view: View; options: string[] }) {
+    super();
+    this.view = props.view;
+    this.options = props.options;
+  }
+
+  get requires() {
+    return [this.view.stableId];
+  }
+
+  serialize(): string {
+    const opts = this.options.join(", ");
+    return [
+      "ALTER VIEW",
+      `${this.view.schema}.${this.view.name}`,
+      "SET",
+      `(${opts})`,
+    ].join(" ");
+  }
+}
+
+/**
+ * ALTER VIEW ... RESET ( ... )
+ */
+export class AlterViewResetOptions extends AlterViewChange {
+  public readonly view: View;
+  public readonly params: string[];
+  public readonly scope = "object" as const;
+
+  constructor(props: { view: View; params: string[] }) {
+    super();
+    this.view = props.view;
+    this.params = props.params;
+  }
+
+  get requires() {
+    return [this.view.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "ALTER VIEW",
+      `${this.view.schema}.${this.view.name}`,
+      "RESET",
+      `(${this.params.join(", ")})`,
+    ].join(" ");
+  }
+}

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

@@ -0,0 +1,20 @@
+import { BaseChange } from "../../base.change.ts";
+import type { View } from "../view.model.ts";
+
+abstract class BaseViewChange extends BaseChange {
+  abstract readonly view: View;
+  abstract readonly scope: "object" | "comment" | "privilege";
+  readonly objectType: "view" = "view";
+}
+
+export abstract class CreateViewChange extends BaseViewChange {
+  readonly operation = "create" as const;
+}
+
+export abstract class AlterViewChange extends BaseViewChange {
+  readonly operation = "alter" as const;
+}
+
+export abstract class DropViewChange extends BaseViewChange {
+  readonly operation = "drop" as const;
+}

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

@@ -0,0 +1,59 @@
+import { quoteLiteral } from "../../base.change.ts";
+import { stableId } from "../../utils.ts";
+import type { View } from "../view.model.ts";
+import { CreateViewChange, DropViewChange } from "./view.base.ts";
+
+export type CommentView = CreateCommentOnView | DropCommentOnView;
+
+export class CreateCommentOnView extends CreateViewChange {
+  public readonly view: View;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { view: View }) {
+    super();
+    this.view = props.view;
+  }
+
+  get creates() {
+    return [stableId.comment(this.view.stableId)];
+  }
+
+  get requires() {
+    return [this.view.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "COMMENT ON VIEW",
+      `${this.view.schema}.${this.view.name}`,
+      "IS",
+      quoteLiteral(this.view.comment as string),
+    ].join(" ");
+  }
+}
+
+export class DropCommentOnView extends DropViewChange {
+  public readonly view: View;
+  public readonly scope = "comment" as const;
+
+  constructor(props: { view: View }) {
+    super();
+    this.view = props.view;
+  }
+
+  get drops() {
+    return [stableId.comment(this.view.stableId)];
+  }
+
+  get requires() {
+    return [stableId.comment(this.view.stableId), this.view.stableId];
+  }
+
+  serialize(): string {
+    return [
+      "COMMENT ON VIEW",
+      `${this.view.schema}.${this.view.name}`,
+      "IS NULL",
+    ].join(" ");
+  }
+}

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

@@ -0,0 +1,65 @@
+import { describe, expect, test } from "bun:test";
+import { View } from "../view.model.ts";
+import { CreateView } from "./view.create.ts";
+
+describe("view", () => {
+  test("create", () => {
+    const view = new View({
+      schema: "public",
+      name: "test_view",
+      definition: "SELECT * FROM test_table",
+      row_security: false,
+      force_row_security: false,
+      has_indexes: false,
+      has_rules: false,
+      has_triggers: false,
+      has_subclasses: false,
+      is_populated: false,
+      replica_identity: "d",
+      is_partition: false,
+      options: null,
+      partition_bound: null,
+      owner: "test",
+      comment: null,
+      columns: [],
+      privileges: [],
+    });
+
+    const change = new CreateView({
+      view,
+    });
+
+    expect(change.serialize()).toBe(
+      "CREATE VIEW public.test_view AS SELECT * FROM test_table",
+    );
+  });
+
+  test("create with options", () => {
+    const view = new View({
+      schema: "public",
+      name: "test_view",
+      definition: "SELECT * FROM test_table",
+      row_security: false,
+      force_row_security: false,
+      has_indexes: false,
+      has_rules: false,
+      has_triggers: false,
+      has_subclasses: false,
+      is_populated: false,
+      replica_identity: "d",
+      is_partition: false,
+      options: ["security_barrier=true", "check_option=local"],
+      partition_bound: null,
+      owner: "test",
+      comment: null,
+      columns: [],
+      privileges: [],
+    });
+
+    const change = new CreateView({ view });
+
+    expect(change.serialize()).toBe(
+      "CREATE VIEW public.test_view WITH (security_barrier=true, check_option=local) AS SELECT * FROM test_table",
+    );
+  });
+});

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

@@ -0,0 +1,73 @@
+import { stableId } from "../../utils.ts";
+import type { View } from "../view.model.ts";
+import { CreateViewChange } from "./view.base.ts";
+
+/**
+ * Create a view.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-createview.html
+ *
+ * Synopsis
+ * ```sql
+ * CREATE [ OR REPLACE ] [ TEMP | TEMPORARY ] [ RECURSIVE ] VIEW name [ ( column_name [, ...] ) ]
+ *     [ WITH ( view_option_name [= view_option_value] [, ... ] ) ]
+ *     AS query
+ *     [ WITH [ CASCADE | LOCAL ] CHECK OPTION ]
+ * ```
+ */
+export class CreateView extends CreateViewChange {
+  public readonly view: View;
+  public readonly orReplace?: boolean;
+  public readonly scope = "object" as const;
+
+  constructor(props: { view: View; orReplace?: boolean }) {
+    super();
+    this.view = props.view;
+    this.orReplace = props.orReplace;
+  }
+
+  get creates() {
+    return [
+      this.view.stableId,
+      ...this.view.columns.map((column) =>
+        stableId.column(this.view.schema, this.view.name, column.name),
+      ),
+    ];
+  }
+
+  get requires() {
+    const dependencies = new Set<string>();
+
+    // Schema dependency
+    dependencies.add(stableId.schema(this.view.schema));
+
+    // Owner dependency
+    dependencies.add(stableId.role(this.view.owner));
+
+    // Note: View definition dependencies (tables, types, procedures referenced in the query)
+    // are handled via pg_depend for existing objects. For new objects, parsing the SQL
+    // definition would be complex and error-prone, so we rely on pg_depend extraction
+    // for those dependencies.
+
+    return Array.from(dependencies);
+  }
+
+  serialize(): string {
+    const parts: string[] = [
+      `CREATE${this.orReplace ? " OR REPLACE" : ""} VIEW`,
+    ];
+
+    // Add schema and name
+    parts.push(`${this.view.schema}.${this.view.name}`);
+
+    // Add WITH options if specified
+    if (this.view.options && this.view.options.length > 0) {
+      parts.push("WITH", `(${this.view.options.join(", ")})`);
+    }
+
+    // Add AS query (trim to avoid double spaces before SELECT)
+    parts.push("AS", this.view.definition.trim());
+
+    return parts.join(" ");
+  }
+}

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

@@ -0,0 +1,34 @@
+import { describe, expect, test } from "bun:test";
+import { View } from "../view.model.ts";
+import { DropView } from "./view.drop.ts";
+
+describe("view", () => {
+  test("drop", () => {
+    const view = new View({
+      schema: "public",
+      name: "test_view",
+      definition: "SELECT * FROM test_table",
+      row_security: false,
+      force_row_security: false,
+      has_indexes: false,
+      has_rules: false,
+      has_triggers: false,
+      has_subclasses: false,
+      is_populated: false,
+      replica_identity: "d",
+      is_partition: false,
+      options: null,
+      partition_bound: null,
+      owner: "test",
+      comment: null,
+      columns: [],
+      privileges: [],
+    });
+
+    const change = new DropView({
+      view,
+    });
+
+    expect(change.serialize()).toBe("DROP VIEW public.test_view");
+  });
+});

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

@@ -0,0 +1,40 @@
+import { stableId } from "../../utils.ts";
+import type { View } from "../view.model.ts";
+import { DropViewChange } from "./view.base.ts";
+
+/**
+ * Drops a view from the database.
+ *
+ * @see https://www.postgresql.org/docs/17/sql-dropview.html
+ */
+export class DropView extends DropViewChange {
+  public readonly view: View;
+  public readonly scope = "object" as const;
+
+  constructor(props: { view: View }) {
+    super();
+    this.view = props.view;
+  }
+
+  get drops() {
+    return [
+      this.view.stableId,
+      ...this.view.columns.map((column) =>
+        stableId.column(this.view.schema, this.view.name, column.name),
+      ),
+    ];
+  }
+
+  get requires() {
+    return [
+      this.view.stableId,
+      ...this.view.columns.map((column) =>
+        stableId.column(this.view.schema, this.view.name, column.name),
+      ),
+    ];
+  }
+
+  serialize(): string {
+    return ["DROP VIEW", `${this.view.schema}.${this.view.name}`].join(" ");
+  }
+}