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

package/src/core/change-utils.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from "bun:test";
+import type { Change } from "./change.types.ts";
+import { getSchema } from "./change-utils.ts";
+
+describe("getSchema", () => {
+  test("returns schema for table", () => {
+    const change = {
+      objectType: "table",
+      table: { schema: "public" },
+    } as unknown as Change;
+    expect(getSchema(change)).toBe("public");
+  });
+
+  test("returns schema for view", () => {
+    const change = {
+      objectType: "view",
+      view: { schema: "app" },
+    } as unknown as Change;
+    expect(getSchema(change)).toBe("app");
+  });
+
+  test("returns schema for enum", () => {
+    const change = {
+      objectType: "enum",
+      enum: { schema: "types" },
+    } as unknown as Change;
+    expect(getSchema(change)).toBe("types");
+  });
+
+  test("returns schema.name for schema type", () => {
+    const change = {
+      objectType: "schema",
+      schema: { name: "auth" },
+    } as unknown as Change;
+    expect(getSchema(change)).toBe("auth");
+  });
+
+  test("returns null for role", () => {
+    const change = {
+      objectType: "role",
+      role: { name: "admin" },
+    } as unknown as Change;
+    expect(getSchema(change)).toBeNull();
+  });
+
+  test("returns null for publication", () => {
+    const change = {
+      objectType: "publication",
+      publication: { name: "pub1" },
+    } as unknown as Change;
+    expect(getSchema(change)).toBeNull();
+  });
+
+  test("returns null for language", () => {
+    const change = {
+      objectType: "language",
+      language: { name: "plpgsql" },
+    } as unknown as Change;
+    expect(getSchema(change)).toBeNull();
+  });
+});

package/src/core/change-utils.ts

@@ -0,0 +1,73 @@
+import type { Change } from "./change.types.ts";
+
+/**
+ * Extract the schema name from a Change using the model sub-object.
+ *
+ * This is a convenience function used by the filter DSL (for schema
+ * normalization) and the sort module. It reads the `schema` (or `name`
+ * for schema objectType) from the model sub-object.
+ */
+export function getSchema(change: Change): string | null {
+  if (change.scope === "default_privilege") {
+    return change.inSchema;
+  }
+  switch (change.objectType) {
+    case "aggregate":
+      return change.aggregate.schema;
+    case "collation":
+      return change.collation.schema;
+    case "composite_type":
+      return change.compositeType.schema;
+    case "domain":
+      return change.domain.schema;
+    case "enum":
+      return change.enum.schema;
+    case "event_trigger":
+      return change.eventTrigger.function_schema;
+    case "extension":
+      return change.extension.schema;
+    case "index":
+      return change.index.schema;
+    case "language":
+      return null;
+    case "materialized_view":
+      return change.materializedView.schema;
+    case "procedure":
+      return change.procedure.schema;
+    case "publication":
+      return null;
+    case "range":
+      return change.range.schema;
+    case "rls_policy":
+      return change.policy.schema;
+    case "role":
+      return null;
+    case "rule":
+      return change.rule.schema;
+    case "schema":
+      return change.schema.name;
+    case "sequence":
+      return change.sequence.schema;
+    case "subscription":
+      return null;
+    case "table":
+      return change.table.schema;
+    case "trigger":
+      return change.trigger.schema;
+    case "view":
+      return change.view.schema;
+    case "foreign_data_wrapper":
+      return null;
+    case "server":
+      return null;
+    case "user_mapping":
+      return null;
+    case "foreign_table":
+      return change.foreignTable.schema;
+    default: {
+      // exhaustiveness check
+      const _exhaustive: never = change;
+      return _exhaustive;
+    }
+  }
+}

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/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[] = [];