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

package/dist/cli/commands/declarative-export.js

@@ -5,10 +5,12 @@ import { mkdir, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { buildCommand } from "@stricli/core";
 import chalk from "chalk";
+import { deserializeCatalog } from "../../core/catalog.snapshot.js";
 import { exportDeclarativeSchema } from "../../core/export/index.js";
+import { compileSerializeDSL, } from "../../core/integrations/serialize/dsl.js";
 import { createPlan } from "../../core/plan/index.js";
 import { assertSafePath, buildFileTree, computeFileDiff, formatExportSummary, } from "../utils/export-display.js";
-import { loadIntegrationDSL } from "../utils/integrations.js";
+import { resolveIntegrationOptions } from "../utils/integrations.js";
 import { isPostgresUrl, loadCatalogFromFile } from "../utils/resolve-input.js";
 function parseJsonFlag(label, value) {
     try {
@@ -142,22 +144,17 @@ After export, a tip is printed with the command to apply the schema to an empty
     `.trim(),
     },
     async func(flags) {
-        const { compileSerializeDSL } = await import("../../core/integrations/serialize/dsl.js");
-        let filterOption = flags.filter;
-        let serializeOption = flags.serialize;
-        let integrationEmptyCatalog;
-        if (flags.integration) {
-            const integrationDSL = await loadIntegrationDSL(flags.integration);
-            filterOption = filterOption ?? integrationDSL.filter;
-            serializeOption = serializeOption ?? integrationDSL.serialize;
-            integrationEmptyCatalog = integrationDSL.emptyCatalog;
-        }
+        const { filter, serialize, emptyCatalog: integrationEmptyCatalog, } = await resolveIntegrationOptions({
+            filter: flags.filter,
+            serialize: flags.serialize,
+            integration: flags.integration,
+        });
         const resolvedSource = flags.source
             ? isPostgresUrl(flags.source)
                 ? flags.source
                 : await loadCatalogFromFile(flags.source)
             : integrationEmptyCatalog
-                ? (await import("../../core/catalog.snapshot.js")).deserializeCatalog(integrationEmptyCatalog)
+                ? deserializeCatalog(integrationEmptyCatalog)
                 : null;
         const resolvedTarget = isPostgresUrl(flags.target)
             ? flags.target
@@ -169,8 +166,8 @@ After export, a tip is printed with the command to apply the schema to an empty
         // changes that depend on filtered objects (e.g. RLS policies that
         // reference auth.uid() when the auth schema is filtered out).
         const planResult = await createPlan(resolvedSource, resolvedTarget, {
-            filter: filterOption,
-            serialize: serializeOption,
+            filter,
+            serialize,
             skipDefaultPrivilegeSubtraction: true,
         });
         if (!planResult) {
@@ -195,9 +192,7 @@ After export, a tip is printed with the command to apply the schema to an empty
                     : undefined,
             };
         }
-        const serializeFn = serializeOption !== undefined
-            ? compileSerializeDSL(serializeOption)
-            : undefined;
+        const serializeFn = serialize !== undefined ? compileSerializeDSL(serialize) : undefined;
         const output = exportDeclarativeSchema(planResult, {
             integration: serializeFn !== undefined ? { serialize: serializeFn } : undefined,
             formatOptions: flags["format-options"] ?? undefined,

package/dist/cli/commands/plan.js

@@ -3,9 +3,10 @@
  */
 import { writeFile } from "node:fs/promises";
 import { buildCommand } from "@stricli/core";
+import { deserializeCatalog } from "../../core/catalog.snapshot.js";
 import { createPlan } from "../../core/plan/index.js";
 import { setCommandExitCode } from "../exit-code.js";
-import { loadIntegrationDSL } from "../utils/integrations.js";
+import { resolveIntegrationOptions } from "../utils/integrations.js";
 import { isPostgresUrl, loadCatalogFromFile } from "../utils/resolve-input.js";
 import { formatPlanForDisplay } from "../utils.js";
 export const planCommand = buildCommand({
@@ -106,29 +107,25 @@ json/sql outputs are available for artifacts or piping.
     `.trim(),
     },
     async func(flags) {
-        let filterOption = flags.filter;
-        let serializeOption = flags.serialize;
-        let integrationEmptyCatalog;
-        if (flags.integration) {
-            const integrationDSL = await loadIntegrationDSL(flags.integration);
-            filterOption = filterOption ?? integrationDSL.filter;
-            serializeOption = serializeOption ?? integrationDSL.serialize;
-            integrationEmptyCatalog = integrationDSL.emptyCatalog;
-        }
+        const { filter, serialize, emptyCatalog: integrationEmptyCatalog, } = await resolveIntegrationOptions({
+            filter: flags.filter,
+            serialize: flags.serialize,
+            integration: flags.integration,
+        });
         const resolvedSource = flags.source
             ? isPostgresUrl(flags.source)
                 ? flags.source
                 : await loadCatalogFromFile(flags.source)
             : integrationEmptyCatalog
-                ? (await import("../../core/catalog.snapshot.js")).deserializeCatalog(integrationEmptyCatalog)
+                ? deserializeCatalog(integrationEmptyCatalog)
                 : null;
         const resolvedTarget = isPostgresUrl(flags.target)
             ? flags.target
             : await loadCatalogFromFile(flags.target);
         const planResult = await createPlan(resolvedSource, resolvedTarget, {
             role: flags.role,
-            filter: filterOption,
-            serialize: serializeOption,
+            filter,
+            serialize,
         });
         if (!planResult) {
             this.process.stdout.write("No changes detected.\n");

package/dist/cli/commands/sync.js

@@ -4,7 +4,7 @@
 import { buildCommand } from "@stricli/core";
 import { applyPlan } from "../../core/plan/apply.js";
 import { createPlan } from "../../core/plan/index.js";
-import { loadIntegrationDSL } from "../utils/integrations.js";
+import { resolveIntegrationOptions } from "../utils/integrations.js";
 import { formatPlanForDisplay, handleApplyResult, promptConfirmation, validatePlanRisk, } from "../utils.js";
 export const syncCommand = buildCommand({
     parameters: {
@@ -91,20 +91,16 @@ Exit codes:
     `.trim(),
     },
     async func(flags) {
-        // Load integration if provided and extract filter/serialize DSL
-        let filterOption = flags.filter;
-        let serializeOption = flags.serialize;
-        if (flags.integration) {
-            const integrationDSL = await loadIntegrationDSL(flags.integration);
-            // Use integration DSL if explicit flags not provided
-            filterOption = filterOption ?? integrationDSL.filter;
-            serializeOption = serializeOption ?? integrationDSL.serialize;
-        }
+        const { filter, serialize } = await resolveIntegrationOptions({
+            filter: flags.filter,
+            serialize: flags.serialize,
+            integration: flags.integration,
+        });
         // 1. Create the plan
         const planResult = await createPlan(flags.source, flags.target, {
             role: flags.role,
-            filter: filterOption,
-            serialize: serializeOption,
+            filter,
+            serialize,
         });
         if (!planResult) {
             this.process.stdout.write("No changes detected.\n");

package/dist/cli/utils/integrations.d.ts

@@ -1,14 +1,38 @@
 /**
  * Utilities for loading integrations from files.
  */
+import type { CatalogSnapshot } from "../../core/catalog.snapshot.ts";
+import type { FilterDSL } from "../../core/integrations/filter/dsl.ts";
 import type { IntegrationDSL } from "../../core/integrations/integration-dsl.ts";
+import type { SerializeDSL } from "../../core/integrations/serialize/dsl.ts";
 /**
- * Load an integration DSL from a file or core integration.
- * If the path ends with .json, treats it as a JSON file path directly.
- * Otherwise, tries to load from core integrations (TypeScript) first,
- * then falls back to treating as a JSON file path.
+ * Load an integration DSL, recursively resolving `extends` chains.
  *
- * @param nameOrPath - Integration name (e.g., "supabase") or file path (e.g., "./my-integration.json")
- * @returns The loaded IntegrationDSL
+ * When an integration has `extends`, the referenced integration(s) are loaded
+ * and merged: filters are AND-combined, serialize rules concatenated (base first),
+ * and emptyCatalog uses the most-specific value.
+ *
+ * Circular extends are detected and rejected with a descriptive error.
+ *
+ * @param nameOrPath - Integration name (e.g., "supabase") or file path
+ * @returns The fully resolved IntegrationDSL
  */
 export declare function loadIntegrationDSL(nameOrPath: string): Promise<IntegrationDSL>;
+interface ResolvedIntegrationOptions {
+    filter?: FilterDSL;
+    serialize?: SerializeDSL;
+    emptyCatalog?: CatalogSnapshot;
+}
+/**
+ * Load an integration (if provided) and merge its filter/serialize with CLI flags.
+ *
+ * - Filters are AND-combined (integration ∧ CLI flag)
+ * - Serialize rules are concatenated (integration first = higher priority)
+ * - emptyCatalog is extracted from the integration
+ */
+export declare function resolveIntegrationOptions(options: {
+    filter?: FilterDSL;
+    serialize?: SerializeDSL;
+    integration?: string;
+}): Promise<ResolvedIntegrationOptions>;
+export {};

package/dist/cli/utils/integrations.js

@@ -10,16 +10,14 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import { readFile } from "node:fs/promises";
+import { mergeIntegrations } from "../../core/integrations/merge.js";
 /**
- * Load an integration DSL from a file or core integration.
- * If the path ends with .json, treats it as a JSON file path directly.
- * Otherwise, tries to load from core integrations (TypeScript) first,
- * then falls back to treating as a JSON file path.
+ * Load a raw integration DSL from a file or core integration (without resolving extends).
  *
  * @param nameOrPath - Integration name (e.g., "supabase") or file path (e.g., "./my-integration.json")
- * @returns The loaded IntegrationDSL
+ * @returns The loaded IntegrationDSL (unresolved)
  */
-export async function loadIntegrationDSL(nameOrPath) {
+async function loadRawIntegrationDSL(nameOrPath) {
     // If path ends with .json, treat it as a JSON file path directly
     if (nameOrPath.endsWith(".json")) {
         const content = await readFile(nameOrPath, "utf-8");
@@ -42,3 +40,97 @@ export async function loadIntegrationDSL(nameOrPath) {
     const content = await readFile(nameOrPath, "utf-8");
     return JSON.parse(content);
 }
+/**
+ * Load a core integration DSL by name only (no file path fallback).
+ *
+ * Used for resolving `extends` chains, which only support core integration names
+ * (e.g., "supabase"), not file paths.
+ *
+ * @param name - Core integration name (e.g., "supabase")
+ * @returns The loaded IntegrationDSL (unresolved)
+ */
+async function loadCoreIntegrationDSL(name) {
+    try {
+        const module = await import(__rewriteRelativeImportExtension(`../../core/integrations/${name}.ts`));
+        if (name in module) {
+            return module[name];
+        }
+    }
+    catch {
+        // Module not found
+    }
+    throw new Error(`Unknown core integration: "${name}". extends only supports core integration names (e.g., "supabase").`);
+}
+/**
+ * Load an integration DSL, recursively resolving `extends` chains.
+ *
+ * When an integration has `extends`, the referenced integration(s) are loaded
+ * and merged: filters are AND-combined, serialize rules concatenated (base first),
+ * and emptyCatalog uses the most-specific value.
+ *
+ * Circular extends are detected and rejected with a descriptive error.
+ *
+ * @param nameOrPath - Integration name (e.g., "supabase") or file path
+ * @returns The fully resolved IntegrationDSL
+ */
+export async function loadIntegrationDSL(nameOrPath) {
+    return resolveIntegration(nameOrPath, new Set());
+}
+async function resolveIntegration(nameOrPath, visited, preloadedRaw) {
+    if (visited.has(nameOrPath)) {
+        throw new Error(`Circular extends detected: ${[...visited, nameOrPath].join(" → ")}`);
+    }
+    visited.add(nameOrPath);
+    const raw = preloadedRaw ?? (await loadRawIntegrationDSL(nameOrPath));
+    if (!raw.extends) {
+        return raw;
+    }
+    // Resolve base integrations (extends only supports core integration names)
+    const extendsArray = Array.isArray(raw.extends) ? raw.extends : [raw.extends];
+    const baseIntegrations = [];
+    for (const baseName of extendsArray) {
+        const baseRaw = await loadCoreIntegrationDSL(baseName);
+        baseIntegrations.push(await resolveIntegration(baseName, new Set(visited), baseRaw));
+    }
+    // Remove extends from the current integration before merging
+    const { extends: _, ...current } = raw;
+    // Merge: bases first (higher priority serialize), then current (most-specific)
+    return mergeIntegrations([...baseIntegrations, current]);
+}
+/**
+ * Load an integration (if provided) and merge its filter/serialize with CLI flags.
+ *
+ * - Filters are AND-combined (integration ∧ CLI flag)
+ * - Serialize rules are concatenated (integration first = higher priority)
+ * - emptyCatalog is extracted from the integration
+ */
+export async function resolveIntegrationOptions(options) {
+    if (!options.integration) {
+        return {
+            filter: options.filter,
+            serialize: options.serialize,
+        };
+    }
+    const integrationDSL = await loadIntegrationDSL(options.integration);
+    // AND-combine integration filter with CLI --filter
+    let filter;
+    if (integrationDSL.filter && options.filter) {
+        filter = { and: [integrationDSL.filter, options.filter] };
+    }
+    else {
+        filter = options.filter ?? integrationDSL.filter;
+    }
+    // Concatenate serialize rules (integration first = higher priority)
+    let serialize;
+    if (integrationDSL.serialize && options.serialize) {
+        serialize = [...integrationDSL.serialize, ...options.serialize];
+    }
+    else {
+        serialize = options.serialize ?? integrationDSL.serialize;
+    }
+    return {
+        filter,
+        serialize,
+        emptyCatalog: integrationDSL.emptyCatalog,
+    };
+}

package/dist/core/change-utils.d.ts

@@ -0,0 +1,9 @@
+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 declare function getSchema(change: Change): string | null;

package/dist/core/change-utils.js

@@ -0,0 +1,71 @@
+/**
+ * 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) {
+    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 = change;
+            return _exhaustive;
+        }
+    }
+}

package/dist/core/change.types.d.ts

@@ -19,4 +19,26 @@ import type { TableChange } from "./objects/table/changes/table.types.ts";
 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 | DomainChange | ExtensionChange | IndexChange | LanguageChange | MaterializedViewChange | SubscriptionChange | PublicationChange | ProcedureChange | RlsPolicyChange | RoleChange | SchemaChange | SequenceChange | TableChange | TriggerChange | EventTriggerChange | RuleChange | 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 declare const OBJECT_TYPE_TO_PROPERTY_KEY: {
+    [K in Change["objectType"]]: string;
+};

package/dist/core/change.types.js

@@ -1 +1,37 @@
-export {};
+/**
+ * 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 = {
+    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/dist/core/depend.js

@@ -1390,6 +1390,29 @@ export async function extractDepends(pool) {
     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
@@ -1803,6 +1826,8 @@ export async function extractDepends(pool) {
     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/dist/core/export/file-mapper.d.ts

@@ -2,7 +2,7 @@
  * Map changes to declarative schema file paths.
  */
 import type { Change } from "../change.types.ts";
-import type { FilePath, Grouping } from "./types.ts";
+import type { FilePath, Grouping, GroupingPattern } from "./types.ts";
 export declare function getFilePath(change: Change): FilePath;
 /** A compiled grouping pattern: pre-built RegExp + group name. */
 export interface CompiledPattern {
@@ -20,7 +20,7 @@ interface CompilePatternsResult {
  * (no throw), so the returned `compiled` array may be shorter than the input.
  * Any skipped patterns are reported in `warnings`.
  */
-export declare function compilePatterns(patterns: import("./types.ts").GroupingPattern[]): CompilePatternsResult;
+export declare function compilePatterns(patterns: GroupingPattern[]): CompilePatternsResult;
 /**
  * Create a file mapper that applies regex-based grouping on top of the
  * default `getFilePath` mapping.