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

package/dist/core/export/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * Declarative schema export.
  */
-import type { Integration } from "../integrations/integration.types.ts";
+import { type Integration } from "../integrations/integration.types.ts";
 import type { createPlan } from "../plan/create.ts";
 import type { SqlFormatOptions } from "../plan/sql-format/types.ts";
 import type { DeclarativeSchemaOutput, Grouping } from "./types.ts";
@@ -12,7 +12,7 @@ import type { DeclarativeSchemaOutput, Grouping } from "./types.ts";
 type PlanResult = NonNullable<Awaited<ReturnType<typeof createPlan>>>;
 export interface ExportOptions {
     /** Integration for custom serialization */
-    integration?: Integration;
+    integration?: Pick<Integration, "serialize">;
     /**
      * SQL formatter options to control the output style.
      * Merged on top of the default export options (maxWidth: 180, keywordCase: "upper").

package/dist/core/export/index.js

@@ -2,6 +2,7 @@
  * Declarative schema export.
  */
 import { buildPlanScopeFingerprint, hashStableIds } from "../fingerprint.js";
+import { resolveIntegration, } from "../integrations/integration.types.js";
 import { DEFAULT_OPTIONS } from "../plan/sql-format/constants.js";
 import { formatSqlScript } from "../plan/statements.js";
 import { createFileMapper } from "./file-mapper.js";
@@ -22,7 +23,9 @@ import { groupChangesByFile } from "./grouper.js";
  */
 export function exportDeclarativeSchema(planResult, options) {
     const { ctx, sortedChanges } = planResult;
-    const integration = options?.integration;
+    const integration = options?.integration
+        ? resolveIntegration(options?.integration)
+        : {};
     const formatOptions = options?.formatOptions === null
         ? undefined
         : {

package/dist/core/integrations/integration.types.d.ts

@@ -1,6 +1,31 @@
+import { type FilterDSL } from "./filter/dsl.ts";
 import type { ChangeFilter } from "./filter/filter.types.ts";
+import { type SerializeDSL } from "./serialize/dsl.ts";
 import type { ChangeSerializer } from "./serialize/serialize.types.ts";
-export type Integration = {
+/**
+ * A resolved integration is an integration that has been compiled to a function.
+ */
+export type ResolvedIntegration = {
     filter?: ChangeFilter;
     serialize?: ChangeSerializer;
 };
+/**
+ * A raw integration is an integration that has not been compiled to a function.
+ */
+export type IntegrationDSL = {
+    filter?: FilterDSL;
+    serialize?: SerializeDSL;
+};
+/**
+ * An integration is a raw integration that has not been compiled to a function.
+ */
+export type Integration = {
+    filter?: ResolvedIntegration["filter"] | IntegrationDSL["filter"];
+    serialize?: ResolvedIntegration["serialize"] | IntegrationDSL["serialize"];
+};
+/**
+ * Resolve an integration either DSL or already resovled into a ResolvedIntegration.
+ * @param integration - The integration to resolve.
+ * @returns The resolved integration.
+ */
+export declare function resolveIntegration(integration: Integration): ResolvedIntegration | undefined;

package/dist/core/integrations/integration.types.js

@@ -1 +1,31 @@
-export {};
+import { compileFilterDSL } from "./filter/dsl.js";
+import { compileSerializeDSL } from "./serialize/dsl.js";
+/**
+ * Resolve an integration either DSL or already resovled into a ResolvedIntegration.
+ * @param integration - The integration to resolve.
+ * @returns The resolved integration.
+ */
+export function resolveIntegration(integration) {
+    // Determine if filter/serialize are DSL or functions, and extract DSL for storage
+    const isFilterDSL = integration.filter && typeof integration.filter !== "function";
+    const isSerializeDSL = integration.serialize && typeof integration.serialize !== "function";
+    const filterDSL = isFilterDSL ? integration.filter : undefined;
+    const serializeDSL = isSerializeDSL
+        ? integration.serialize
+        : undefined;
+    // Build final integration: compile DSL if needed, use functions directly otherwise
+    if (integration.filter || integration.serialize) {
+        return {
+            filter: typeof integration.filter === "function"
+                ? integration.filter
+                : filterDSL
+                    ? compileFilterDSL(filterDSL)
+                    : undefined,
+            serialize: typeof integration.serialize === "function"
+                ? integration.serialize
+                : serializeDSL
+                    ? compileSerializeDSL(serializeDSL)
+                    : undefined,
+        };
+    }
+}

package/dist/core/plan/create.js

@@ -5,8 +5,7 @@ import { escapeIdentifier } from "pg";
 import { diffCatalogs } from "../catalog.diff.js";
 import { createEmptyCatalog, extractCatalog } from "../catalog.model.js";
 import { buildPlanScopeFingerprint, hashStableIds } from "../fingerprint.js";
-import { compileFilterDSL, } from "../integrations/filter/dsl.js";
-import { compileSerializeDSL, } from "../integrations/serialize/dsl.js";
+import { resolveIntegration, } from "../integrations/integration.types.js";
 import { createManagedPool, endPool } from "../postgres-config.js";
 import { sortChanges } from "../sort/sort-changes.js";
 import { classifyChangesRisk } from "./risk.js";
@@ -103,21 +102,10 @@ function buildPlanForCatalogs(fromCatalog, toCatalog, options = {}) {
         ? serializeOption
         : undefined;
     // Build final integration: compile DSL if needed, use functions directly otherwise
-    let finalIntegration;
-    if (filterOption || serializeOption) {
-        finalIntegration = {
-            filter: typeof filterOption === "function"
-                ? filterOption
-                : filterDSL
-                    ? compileFilterDSL(filterDSL)
-                    : undefined,
-            serialize: typeof serializeOption === "function"
-                ? serializeOption
-                : serializeDSL
-                    ? compileSerializeDSL(serializeDSL)
-                    : undefined,
-        };
-    }
+    const finalIntegration = resolveIntegration({
+        filter: filterOption,
+        serialize: serializeOption,
+    });
     // Use filter from final integration
     const filterFn = finalIntegration?.filter;
     let filteredChanges = filterFn

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

@@ -3,10 +3,7 @@
  */
 import z from "zod";
 import type { Change } from "../change.types.ts";
-import type { FilterDSL } from "../integrations/filter/dsl.ts";
-import type { ChangeFilter } from "../integrations/filter/filter.types.ts";
-import type { SerializeDSL } from "../integrations/serialize/dsl.ts";
-import type { ChangeSerializer } from "../integrations/serialize/serialize.types.ts";
+import type { Integration } from "../integrations/integration.types.ts";
 export type PlanRisk = {
     level: "safe";
 } | {
@@ -133,9 +130,9 @@ export type Plan = z.infer<typeof PlanSchema>;
  */
 export interface CreatePlanOptions {
     /** Filter - either FilterDSL (stored in plan) or ChangeFilter function (not stored) */
-    filter?: FilterDSL | ChangeFilter;
+    filter?: Integration["filter"];
     /** Serialize - either SerializeDSL (stored in plan) or ChangeSerializer function (not stored) */
-    serialize?: SerializeDSL | ChangeSerializer;
+    serialize?: Integration["serialize"];
     /** Role to use when executing the migration (SET ROLE will be added to statements) */
     role?: string;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/pg-delta",
-  "version": "1.0.0-alpha.12",
+  "version": "1.0.0-alpha.13",
   "description": "PostgreSQL migrations made easy",
   "type": "module",
   "sideEffects": false,

package/src/core/export/index.ts

@@ -4,7 +4,11 @@
 
 import type { Change } from "../change.types.ts";
 import { buildPlanScopeFingerprint, hashStableIds } from "../fingerprint.ts";
-import type { Integration } from "../integrations/integration.types.ts";
+import {
+  type Integration,
+  type ResolvedIntegration,
+  resolveIntegration,
+} from "../integrations/integration.types.ts";
 import type { createPlan } from "../plan/create.ts";
 import { DEFAULT_OPTIONS } from "../plan/sql-format/constants.ts";
 import type { SqlFormatOptions } from "../plan/sql-format/types.ts";
@@ -29,7 +33,7 @@ type PlanResult = NonNullable<Awaited<ReturnType<typeof createPlan>>>;
 
 export interface ExportOptions {
   /** Integration for custom serialization */
-  integration?: Integration;
+  integration?: Pick<Integration, "serialize">;
   /**
    * SQL formatter options to control the output style.
    * Merged on top of the default export options (maxWidth: 180, keywordCase: "upper").
@@ -64,7 +68,9 @@ export function exportDeclarativeSchema(
   options?: ExportOptions,
 ): DeclarativeSchemaOutput {
   const { ctx, sortedChanges } = planResult;
-  const integration = options?.integration;
+  const integration = options?.integration
+    ? resolveIntegration(options?.integration)
+    : {};
   const formatOptions: SqlFormatOptions | undefined =
     options?.formatOptions === null
       ? undefined
@@ -108,7 +114,10 @@ export function exportDeclarativeSchema(
   };
 }
 
-function serializeChange(change: Change, integration?: Integration): string {
+function serializeChange(
+  change: Change,
+  integration?: ResolvedIntegration,
+): string {
   return integration?.serialize?.(change) ?? change.serialize();
 }
 

package/src/core/integrations/integration.types.ts

@@ -1,7 +1,65 @@
+import { compileFilterDSL, type FilterDSL } from "./filter/dsl.ts";
 import type { ChangeFilter } from "./filter/filter.types.ts";
+import { compileSerializeDSL, type SerializeDSL } from "./serialize/dsl.ts";
 import type { ChangeSerializer } from "./serialize/serialize.types.ts";
 
-export type Integration = {
+/**
+ * A resolved integration is an integration that has been compiled to a function.
+ */
+export type ResolvedIntegration = {
   filter?: ChangeFilter;
   serialize?: ChangeSerializer;
 };
+
+/**
+ * A raw integration is an integration that has not been compiled to a function.
+ */
+export type IntegrationDSL = {
+  filter?: FilterDSL;
+  serialize?: SerializeDSL;
+};
+
+/**
+ * An integration is a raw integration that has not been compiled to a function.
+ */
+export type Integration = {
+  filter?: ResolvedIntegration["filter"] | IntegrationDSL["filter"];
+  serialize?: ResolvedIntegration["serialize"] | IntegrationDSL["serialize"];
+};
+
+/**
+ * Resolve an integration either DSL or already resovled into a ResolvedIntegration.
+ * @param integration - The integration to resolve.
+ * @returns The resolved integration.
+ */
+export function resolveIntegration(
+  integration: Integration,
+): ResolvedIntegration | undefined {
+  // Determine if filter/serialize are DSL or functions, and extract DSL for storage
+  const isFilterDSL =
+    integration.filter && typeof integration.filter !== "function";
+  const isSerializeDSL =
+    integration.serialize && typeof integration.serialize !== "function";
+  const filterDSL = isFilterDSL ? (integration.filter as FilterDSL) : undefined;
+  const serializeDSL = isSerializeDSL
+    ? (integration.serialize as SerializeDSL)
+    : undefined;
+
+  // Build final integration: compile DSL if needed, use functions directly otherwise
+  if (integration.filter || integration.serialize) {
+    return {
+      filter:
+        typeof integration.filter === "function"
+          ? integration.filter
+          : filterDSL
+            ? compileFilterDSL(filterDSL)
+            : undefined,
+      serialize:
+        typeof integration.serialize === "function"
+          ? integration.serialize
+          : serializeDSL
+            ? compileSerializeDSL(serializeDSL)
+            : undefined,
+    };
+  }
+}

package/src/core/plan/create.ts

@@ -10,15 +10,12 @@ import { createEmptyCatalog, extractCatalog } from "../catalog.model.ts";
 import type { Change } from "../change.types.ts";
 import type { DiffContext } from "../context.ts";
 import { buildPlanScopeFingerprint, hashStableIds } from "../fingerprint.ts";
+import type { FilterDSL } from "../integrations/filter/dsl.ts";
 import {
-  compileFilterDSL,
-  type FilterDSL,
-} from "../integrations/filter/dsl.ts";
-import type { Integration } from "../integrations/integration.types.ts";
-import {
-  compileSerializeDSL,
-  type SerializeDSL,
-} from "../integrations/serialize/dsl.ts";
+  type ResolvedIntegration,
+  resolveIntegration,
+} from "../integrations/integration.types.ts";
+import type { SerializeDSL } from "../integrations/serialize/dsl.ts";
 import { createManagedPool, endPool } from "../postgres-config.ts";
 import { sortChanges } from "../sort/sort-changes.ts";
 import type { PgDependRow } from "../sort/types.ts";
@@ -155,23 +152,10 @@ function buildPlanForCatalogs(
     : undefined;
 
   // Build final integration: compile DSL if needed, use functions directly otherwise
-  let finalIntegration: Integration | undefined;
-  if (filterOption || serializeOption) {
-    finalIntegration = {
-      filter:
-        typeof filterOption === "function"
-          ? filterOption
-          : filterDSL
-            ? compileFilterDSL(filterDSL)
-            : undefined,
-      serialize:
-        typeof serializeOption === "function"
-          ? serializeOption
-          : serializeDSL
-            ? compileSerializeDSL(serializeDSL)
-            : undefined,
-    };
-  }
+  const finalIntegration = resolveIntegration({
+    filter: filterOption,
+    serialize: serializeOption,
+  });
 
   // Use filter from final integration
   const filterFn = finalIntegration?.filter;
@@ -317,7 +301,7 @@ function buildPlan(
   options?: CreatePlanOptions,
   filterDSL?: FilterDSL,
   serializeDSL?: SerializeDSL,
-  integration?: Integration,
+  integration?: ResolvedIntegration,
 ): Plan {
   const role = options?.role;
   const statements = generateStatements(changes, {
@@ -350,7 +334,7 @@ function buildPlan(
 function generateStatements(
   changes: Change[],
   options?: {
-    integration?: Integration;
+    integration?: ResolvedIntegration;
     role?: string;
   },
 ): string[] {

package/src/core/plan/types.ts

@@ -4,10 +4,7 @@
 
 import z from "zod";
 import type { Change } from "../change.types.ts";
-import type { FilterDSL } from "../integrations/filter/dsl.ts";
-import type { ChangeFilter } from "../integrations/filter/filter.types.ts";
-import type { SerializeDSL } from "../integrations/serialize/dsl.ts";
-import type { ChangeSerializer } from "../integrations/serialize/serialize.types.ts";
+import type { Integration } from "../integrations/integration.types.ts";
 
 // ============================================================================
 // Core Types
@@ -157,9 +154,9 @@ export type Plan = z.infer<typeof PlanSchema>;
  */
 export interface CreatePlanOptions {
   /** Filter - either FilterDSL (stored in plan) or ChangeFilter function (not stored) */
-  filter?: FilterDSL | ChangeFilter;
+  filter?: Integration["filter"];
   /** Serialize - either SerializeDSL (stored in plan) or ChangeSerializer function (not stored) */
-  serialize?: SerializeDSL | ChangeSerializer;
+  serialize?: Integration["serialize"];
   /** Role to use when executing the migration (SET ROLE will be added to statements) */
   role?: string;
   /**