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

package/src/core/change.types.ts

@@ -20,6 +20,16 @@ import type { TriggerChange } from "./objects/trigger/changes/trigger.types.ts";
 import type { TypeChange } from "./objects/type/type.types.ts";
 import type { ViewChange } from "./objects/view/changes/view.types.ts";
 
+/**
+ * Discriminated union of all PostgreSQL object change types.
+ *
+ * Every member shares a common `objectType` discriminant (e.g. `"table"`,
+ * `"view"`, `"role"`) that the filter DSL pattern-matches against. Use
+ * {@link OBJECT_TYPE_TO_PROPERTY_KEY} to map an `objectType` value to the
+ * corresponding JS property key on the Change instance.
+ *
+ * @category Change Types
+ */
 export type Change =
   | AggregateChange
   | CollationChange
@@ -42,3 +52,43 @@ export type Change =
   | TypeChange
   | ViewChange
   | ForeignDataWrapperChange;
+
+/**
+ * Exhaustive map from every `objectType` discriminant value to the JS property
+ * key that holds the model sub-object on the corresponding {@link Change}.
+ *
+ * Used internally by the filter DSL flattening logic to locate nested
+ * properties and expose them as `<objectType>/<field>` paths.
+ *
+ * @category Change Types
+ */
+export const OBJECT_TYPE_TO_PROPERTY_KEY: {
+  [K in Change["objectType"]]: string;
+} = {
+  aggregate: "aggregate",
+  collation: "collation",
+  composite_type: "compositeType",
+  domain: "domain",
+  enum: "enum",
+  event_trigger: "eventTrigger",
+  extension: "extension",
+  foreign_data_wrapper: "foreignDataWrapper",
+  foreign_table: "foreignTable",
+  index: "index",
+  language: "language",
+  materialized_view: "materializedView",
+  procedure: "procedure",
+  publication: "publication",
+  range: "range",
+  rls_policy: "policy",
+  role: "role",
+  rule: "rule",
+  schema: "schema",
+  sequence: "sequence",
+  server: "server",
+  subscription: "subscription",
+  table: "table",
+  trigger: "trigger",
+  user_mapping: "userMapping",
+  view: "view",
+};

package/src/core/depend.ts

@@ -1420,6 +1420,29 @@ export async function extractDepends(pool: Pool): Promise<PgDepend[]> {
     JOIN pg_namespace ns ON ns.oid = idx_rel.relnamespace
     WHERE idx_rel.relkind = 'i'
   ),
+  index_extension_deps AS (
+    -- Indexes depend on extensions that provide their operator classes
+    -- (e.g. gin_trgm_ops from pg_trgm). Without this, CREATE INDEX can be
+    -- ordered before CREATE EXTENSION when schemas sort alphabetically.
+    SELECT DISTINCT
+      format('index:%I.%I.%I', ns.nspname, tbl.relname, idx_rel.relname) AS dependent_stable_id,
+      format('extension:%I', ext.extname) AS referenced_stable_id,
+      'n'::"char" AS deptype,
+      ns.nspname AS dep_schema,
+      NULL::text AS ref_schema
+    FROM pg_class idx_rel
+    JOIN pg_index idx ON idx.indexrelid = idx_rel.oid
+    JOIN pg_class tbl ON tbl.oid = idx.indrelid
+    JOIN pg_namespace ns ON ns.oid = idx_rel.relnamespace
+    JOIN LATERAL unnest(idx.indclass) WITH ORDINALITY AS oc(oid, ord) ON true
+    JOIN pg_opclass opcl ON opcl.oid = oc.oid
+    JOIN pg_depend d ON d.classid = 'pg_opclass'::regclass
+      AND d.objid = opcl.oid
+      AND d.refclassid = 'pg_extension'::regclass
+      AND d.deptype = 'e'
+    JOIN pg_extension ext ON ext.oid = d.refobjid
+    WHERE idx_rel.relkind IN ('i', 'I')
+  ),
   ownership_deps AS (
     -- Schema ownership dependencies
     SELECT DISTINCT
@@ -1833,6 +1856,8 @@ export async function extractDepends(pool: Pool): Promise<PgDepend[]> {
     UNION ALL
     SELECT dependent_stable_id, referenced_stable_id, deptype, dep_schema, ref_schema FROM index_table_deps
     UNION ALL
+    SELECT dependent_stable_id, referenced_stable_id, deptype, dep_schema, ref_schema FROM index_extension_deps
+    UNION ALL
     SELECT dependent_stable_id, referenced_stable_id, deptype, dep_schema, ref_schema FROM ownership_deps
     UNION ALL
     SELECT dependent_stable_id, referenced_stable_id, deptype, dep_schema, ref_schema FROM publication_deps

package/src/core/expand-replace-dependencies.test.ts

@@ -1,7 +1,16 @@
 import { describe, expect, test } from "bun:test";
-import { createEmptyCatalog } from "./catalog.model.ts";
+import { Catalog, createEmptyCatalog } from "./catalog.model.ts";
 import type { Change } from "./change.types.ts";
 import { expandReplaceDependencies } from "./expand-replace-dependencies.ts";
+import { DefaultPrivilegeState } from "./objects/base.default-privileges.ts";
+import { CreateSequence } from "./objects/sequence/changes/sequence.create.ts";
+import { DropSequence } from "./objects/sequence/changes/sequence.drop.ts";
+import { diffSequences } from "./objects/sequence/sequence.diff.ts";
+import { Sequence } from "./objects/sequence/sequence.model.ts";
+import { AlterTableAlterColumnSetDefault } from "./objects/table/changes/table.alter.ts";
+import { CreateTable } from "./objects/table/changes/table.create.ts";
+import { DropTable } from "./objects/table/changes/table.drop.ts";
+import { Table } from "./objects/table/table.model.ts";
 
 function mockChange(overrides: {
   creates?: string[];
@@ -67,4 +76,120 @@ describe("expandReplaceDependencies", () => {
     });
     expect(result).toBe(changes);
   });
+
+  test("does not replace the owning table for an owned sequence recreation", async () => {
+    const baseline = await createEmptyCatalog(170000, "postgres");
+    const mainSequence = new Sequence({
+      schema: "public",
+      name: "user_id_seq",
+      data_type: "integer",
+      start_value: 1,
+      minimum_value: 1n,
+      maximum_value: 2147483647n,
+      increment: 1,
+      cycle_option: false,
+      cache_size: 1,
+      persistence: "p",
+      owned_by_schema: "public",
+      owned_by_table: "users",
+      owned_by_column: "id",
+      comment: null,
+      privileges: [],
+      owner: "postgres",
+    });
+    const branchSequence = new Sequence({
+      ...mainSequence,
+      data_type: "bigint",
+      maximum_value: 9223372036854775807n,
+    });
+    const usersTable = new Table({
+      schema: "public",
+      name: "users",
+      persistence: "p",
+      row_security: false,
+      force_row_security: false,
+      has_indexes: false,
+      has_rules: false,
+      has_triggers: false,
+      has_subclasses: false,
+      is_populated: true,
+      replica_identity: "d",
+      is_partition: false,
+      options: null,
+      partition_bound: null,
+      partition_by: null,
+      owner: "postgres",
+      comment: null,
+      parent_schema: null,
+      parent_name: null,
+      columns: [
+        {
+          name: "id",
+          position: 1,
+          data_type: "bigint",
+          data_type_str: "bigint",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: true,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: "nextval('public.user_id_seq'::regclass)",
+          comment: null,
+        },
+      ],
+      privileges: [],
+    });
+    const changes = diffSequences(
+      {
+        version: 170000,
+        currentUser: "postgres",
+        defaultPrivilegeState: new DefaultPrivilegeState({}),
+      },
+      { [mainSequence.stableId]: mainSequence },
+      { [branchSequence.stableId]: branchSequence },
+      { [usersTable.stableId]: usersTable },
+    );
+    const mainCatalog = new Catalog({
+      ...baseline,
+      sequences: { [mainSequence.stableId]: mainSequence },
+      tables: { [usersTable.stableId]: usersTable },
+      depends: [
+        {
+          dependent_stable_id: mainSequence.stableId,
+          referenced_stable_id: "column:public.users.id",
+          deptype: "a",
+        },
+        {
+          dependent_stable_id: "column:public.users.id",
+          referenced_stable_id: mainSequence.stableId,
+          deptype: "n",
+        },
+      ],
+    });
+    const branchCatalog = new Catalog({
+      ...baseline,
+      sequences: { [branchSequence.stableId]: branchSequence },
+      tables: { [usersTable.stableId]: usersTable },
+      depends: [],
+    });
+
+    const expanded = expandReplaceDependencies({
+      changes,
+      mainCatalog,
+      branchCatalog,
+    });
+
+    expect(changes[0]).toBeInstanceOf(DropSequence);
+    expect(changes[1]).toBeInstanceOf(CreateSequence);
+    expect(changes[3]).toBeInstanceOf(AlterTableAlterColumnSetDefault);
+    expect(expanded.some((change) => change instanceof DropTable)).toBe(false);
+    expect(expanded.some((change) => change instanceof CreateTable)).toBe(
+      false,
+    );
+  });
 });

package/src/core/expand-replace-dependencies.ts

@@ -19,6 +19,7 @@ import { CreateEnum } from "./objects/type/enum/changes/enum.create.ts";
 import { DropEnum } from "./objects/type/enum/changes/enum.drop.ts";
 import { CreateRange } from "./objects/type/range/changes/range.create.ts";
 import { DropRange } from "./objects/type/range/changes/range.drop.ts";
+import { stableId } from "./objects/utils.ts";
 import { CreateView } from "./objects/view/changes/view.create.ts";
 import { DropView } from "./objects/view/changes/view.drop.ts";
 
@@ -121,6 +122,17 @@ export function expandReplaceDependencies({
     if (!dependents) continue;
 
     for (const dependentRaw of dependents) {
+      if (
+        isOwnedSequenceColumnDependency(
+          refId,
+          dependentRaw,
+          mainCatalog,
+          branchCatalog,
+        )
+      ) {
+        continue;
+      }
+
       // Continue traversing the dependency graph from the raw dependent id.
       if (!visitedRefs.has(dependentRaw)) {
         visitedRefs.add(dependentRaw);
@@ -181,6 +193,44 @@ export function expandReplaceDependencies({
   return [...changes, ...additions];
 }
 
+function isOwnedSequenceColumnDependency(
+  referencedId: string,
+  dependentId: string,
+  mainCatalog: Catalog,
+  branchCatalog: Catalog,
+): boolean {
+  // When a sequence replace root is still OWNED BY the same column, the
+  // sequence->column pg_depend edge is bookkeeping for ownership, not a signal
+  // that the whole owning table needs to be replaced. Skipping that edge keeps
+  // expandReplaceDependencies focused on recreating the sequence itself.
+  if (
+    !referencedId.startsWith("sequence:") ||
+    !dependentId.startsWith("column:")
+  ) {
+    return false;
+  }
+
+  const sequence =
+    branchCatalog.sequences[referencedId] ??
+    mainCatalog.sequences[referencedId];
+  if (
+    !sequence?.owned_by_schema ||
+    !sequence.owned_by_table ||
+    !sequence.owned_by_column
+  ) {
+    return false;
+  }
+
+  return (
+    dependentId ===
+    stableId.column(
+      sequence.owned_by_schema,
+      sequence.owned_by_table,
+      sequence.owned_by_column,
+    )
+  );
+}
+
 function normalizeDependentId(dependentId: string): string | null {
   let id = dependentId;
 

package/src/core/export/file-mapper.ts

@@ -9,7 +9,12 @@ import {
   getObjectSchema,
   getParentInfo,
 } from "../plan/serialize.ts";
-import type { FileCategory, FilePath, Grouping } from "./types.ts";
+import type {
+  FileCategory,
+  FilePath,
+  Grouping,
+  GroupingPattern,
+} from "./types.ts";
 
 const debugExport = createDebug("pg-delta:export");
 
@@ -380,7 +385,7 @@ interface CompilePatternsResult {
  * Any skipped patterns are reported in `warnings`.
  */
 export function compilePatterns(
-  patterns: import("./types.ts").GroupingPattern[],
+  patterns: GroupingPattern[],
 ): CompilePatternsResult {
   const compiled: CompiledPattern[] = [];
   const warnings: string[] = [];