@pgflow/dsl 0.0.0-array-map-steps-fixed-types-38a198ae-20251011160533 → 0.0.0-condition-acd3e0e8-20260109190810

package/dist/example-flow.js

@@ -5,14 +5,23 @@ export const AnalyzeWebsite = new Flow({
     baseDelay: 5,
     timeout: 10,
 })
-    .step({ slug: 'website' }, async (input) => await scrapeWebsite(input.run.url))
-    .step({ slug: 'sentiment', dependsOn: ['website'], timeout: 30, maxAttempts: 5 }, async (input) => await analyzeSentiment(input.website.content))
-    .step({ slug: 'summary', dependsOn: ['website'] }, async (input) => await summarizeWithAI(input.website.content))
-    .step({ slug: 'saveToDb', dependsOn: ['sentiment', 'summary'] }, async (input) => {
+    .step({ slug: 'website' }, 
+// Root step: receives flowInput directly
+async (flowInput) => await scrapeWebsite(flowInput.url))
+    .step({ slug: 'sentiment', dependsOn: ['website'], timeout: 30, maxAttempts: 5 }, 
+// Dependent step: receives deps, flowInput via context
+async (deps) => await analyzeSentiment(deps.website.content))
+    .step({ slug: 'summary', dependsOn: ['website'] }, 
+// Dependent step: receives deps
+async (deps) => await summarizeWithAI(deps.website.content))
+    .step({ slug: 'saveToDb', dependsOn: ['sentiment', 'summary'] }, 
+// Dependent step needing flowInput: access via await ctx.flowInput
+async (deps, ctx) => {
+    const flowInput = await ctx.flowInput;
     const results = await saveToDb({
-        websiteUrl: input.run.url,
-        sentiment: input.sentiment.score,
-        summary: input.summary.aiSummary,
+        websiteUrl: flowInput.url,
+        sentiment: deps.sentiment.score,
+        summary: deps.summary.aiSummary,
     });
     return results.status;
 });

package/dist/flow-shape.d.ts

@@ -0,0 +1,99 @@
+import { AnyFlow, WhenUnmetMode, RetriesExhaustedMode, Json } from './dsl.js';
+/**
+ * Input pattern wrapper - explicit representation to avoid null vs JSON-null ambiguity.
+ * - { defined: false } means no pattern (don't check)
+ * - { defined: true, value: Json } means pattern is set (check against value)
+ */
+export type InputPattern = {
+    defined: false;
+} | {
+    defined: true;
+    value: Json;
+};
+/**
+ * Step-level options that can be included in the shape for creation,
+ * but are NOT compared during shape comparison (runtime tunable).
+ */
+export interface StepShapeOptions {
+    maxAttempts?: number;
+    baseDelay?: number;
+    timeout?: number;
+    startDelay?: number;
+}
+/**
+ * Flow-level options that can be included in the shape for creation,
+ * but are NOT compared during shape comparison (runtime tunable).
+ */
+export interface FlowShapeOptions {
+    maxAttempts?: number;
+    baseDelay?: number;
+    timeout?: number;
+}
+/**
+ * StepShape captures the structural definition of a step for drift detection.
+ *
+ * The `options` field is included for flow creation but NOT compared during
+ * shape comparison. Options can be tuned at runtime via SQL without
+ * requiring recompilation. See: /deploy/tune-flow-config/
+ *
+ * `whenUnmet`, `whenFailed`, and pattern fields ARE structural - they affect
+ * DAG execution semantics and must match between worker and database.
+ */
+export interface StepShape {
+    slug: string;
+    stepType: 'single' | 'map';
+    dependencies: string[];
+    whenUnmet: WhenUnmetMode;
+    whenFailed: RetriesExhaustedMode;
+    requiredInputPattern: InputPattern;
+    forbiddenInputPattern: InputPattern;
+    options?: StepShapeOptions;
+}
+/**
+ * FlowShape captures the structural definition of a flow for drift detection.
+ *
+ * This represents the DAG topology - which steps exist, their types, and how
+ * they connect via dependencies.
+ *
+ * The `options` field is included for flow creation but NOT compared during
+ * shape comparison. Options can be tuned at runtime via SQL without recompilation.
+ *
+ * Note: flowSlug is intentionally excluded - it's an identifier, not structural
+ * data. The slug comes from context (URL, registry lookup, function parameter).
+ */
+export interface FlowShape {
+    steps: StepShape[];
+    options?: FlowShapeOptions;
+}
+/**
+ * Result of comparing two FlowShapes.
+ */
+export interface ShapeComparisonResult {
+    match: boolean;
+    differences: string[];
+}
+/**
+ * Extracts a FlowShape from a Flow object.
+ * The shape captures structural information needed for drift detection,
+ * plus options for flow creation.
+ *
+ * Options are included in the shape for proper flow/step creation, but
+ * are NOT compared during shape comparison (they're runtime tunable).
+ *
+ * @param flow - The Flow object to extract shape from
+ * @returns A FlowShape representing the flow's structure and options
+ */
+export declare function extractFlowShape(flow: AnyFlow): FlowShape;
+/**
+ * Compares two FlowShapes and returns detailed differences.
+ * Used by ControlPlane for Layer 1 comparison (Worker vs ControlPlane).
+ *
+ * Only compares structural aspects (steps, types, dependencies).
+ * Runtime options are not compared as they can be tuned independently.
+ *
+ * @param a - First FlowShape (typically from worker)
+ * @param b - Second FlowShape (typically from ControlPlane or database)
+ * @returns ShapeComparisonResult with match status and list of differences
+ */
+export declare function compareFlowShapes(a: FlowShape, b: FlowShape): ShapeComparisonResult;
+//# sourceMappingURL=flow-shape.d.ts.map

package/dist/flow-shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-shape.d.ts","sourceRoot":"","sources":["../src/flow-shape.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAM9E;;;;GAIG;AACH,MAAM,MAAM,YAAY,GACpB;IAAE,OAAO,EAAE,KAAK,CAAA;CAAE,GAClB;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,IAAI,CAAA;CAAE,CAAC;AAEnC;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC;IAC3B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,oBAAoB,CAAC;IACjC,oBAAoB,EAAE,YAAY,CAAC;IACnC,qBAAqB,EAAE,YAAY,CAAC;IACpC,OAAO,CAAC,EAAE,gBAAgB,CAAC;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,gBAAgB,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,OAAO,CAAC;IACf,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAyBD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,CAoDzD;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,SAAS,EACZ,CAAC,EAAE,SAAS,GACX,qBAAqB,CAiCvB"}

package/dist/flow-shape.js

@@ -0,0 +1,148 @@
+// ========================
+// SHAPE EXTRACTION
+// ========================
+/**
+ * Checks if an options object has any defined (non-undefined) values.
+ */
+function hasDefinedOptions(options) {
+    return Object.values(options).some((v) => v !== undefined);
+}
+/**
+ * Filters out undefined values from an options object.
+ * Returns only the keys with defined values.
+ */
+function filterDefinedOptions(options) {
+    return Object.fromEntries(Object.entries(options).filter(([_, v]) => v !== undefined));
+}
+/**
+ * Extracts a FlowShape from a Flow object.
+ * The shape captures structural information needed for drift detection,
+ * plus options for flow creation.
+ *
+ * Options are included in the shape for proper flow/step creation, but
+ * are NOT compared during shape comparison (they're runtime tunable).
+ *
+ * @param flow - The Flow object to extract shape from
+ * @returns A FlowShape representing the flow's structure and options
+ */
+export function extractFlowShape(flow) {
+    const steps = flow.stepOrder.map((stepSlug) => {
+        const stepDef = flow.getStepDefinition(stepSlug);
+        const stepShape = {
+            slug: stepSlug,
+            stepType: stepDef.stepType ?? 'single',
+            // Sort dependencies alphabetically for deterministic comparison
+            dependencies: [...stepDef.dependencies].sort(),
+            // Condition modes are structural - they affect DAG execution semantics
+            whenUnmet: stepDef.options.whenUnmet ?? 'skip',
+            whenFailed: stepDef.options.retriesExhausted ?? 'fail',
+            // Input patterns use explicit wrapper to avoid null vs JSON-null ambiguity
+            requiredInputPattern: stepDef.options.if !== undefined
+                ? { defined: true, value: stepDef.options.if }
+                : { defined: false },
+            forbiddenInputPattern: stepDef.options.ifNot !== undefined
+                ? { defined: true, value: stepDef.options.ifNot }
+                : { defined: false },
+        };
+        // Only include options if at least one is defined
+        const stepOptions = {
+            maxAttempts: stepDef.options.maxAttempts,
+            baseDelay: stepDef.options.baseDelay,
+            timeout: stepDef.options.timeout,
+            startDelay: stepDef.options.startDelay,
+        };
+        if (hasDefinedOptions(stepOptions)) {
+            stepShape.options = filterDefinedOptions(stepOptions);
+        }
+        return stepShape;
+    });
+    const shape = { steps };
+    // Only include flow options if at least one is defined
+    const flowOptions = {
+        maxAttempts: flow.options.maxAttempts,
+        baseDelay: flow.options.baseDelay,
+        timeout: flow.options.timeout,
+    };
+    if (hasDefinedOptions(flowOptions)) {
+        shape.options = filterDefinedOptions(flowOptions);
+    }
+    return shape;
+}
+// ========================
+// SHAPE COMPARISON
+// ========================
+/**
+ * Compares two FlowShapes and returns detailed differences.
+ * Used by ControlPlane for Layer 1 comparison (Worker vs ControlPlane).
+ *
+ * Only compares structural aspects (steps, types, dependencies).
+ * Runtime options are not compared as they can be tuned independently.
+ *
+ * @param a - First FlowShape (typically from worker)
+ * @param b - Second FlowShape (typically from ControlPlane or database)
+ * @returns ShapeComparisonResult with match status and list of differences
+ */
+export function compareFlowShapes(a, b) {
+    const differences = [];
+    // Compare step counts
+    if (a.steps.length !== b.steps.length) {
+        differences.push(`Step count differs: ${a.steps.length} vs ${b.steps.length}`);
+    }
+    // Compare steps by index (order matters)
+    const maxLen = Math.max(a.steps.length, b.steps.length);
+    for (let i = 0; i < maxLen; i++) {
+        const aStep = a.steps[i];
+        const bStep = b.steps[i];
+        if (!aStep) {
+            differences.push(`Step at index ${i}: missing in first shape (second has '${bStep.slug}')`);
+        }
+        else if (!bStep) {
+            differences.push(`Step at index ${i}: missing in second shape (first has '${aStep.slug}')`);
+        }
+        else {
+            compareSteps(aStep, bStep, i, differences);
+        }
+    }
+    return {
+        match: differences.length === 0,
+        differences,
+    };
+}
+/**
+ * Compares two steps at the same index and adds differences to the list.
+ */
+function compareSteps(a, b, index, differences) {
+    // Compare slug (order matters, so slugs must match at same index)
+    if (a.slug !== b.slug) {
+        differences.push(`Step at index ${index}: slug differs '${a.slug}' vs '${b.slug}'`);
+    }
+    // Compare step type
+    if (a.stepType !== b.stepType) {
+        differences.push(`Step at index ${index}: type differs '${a.stepType}' vs '${b.stepType}'`);
+    }
+    // Compare dependencies (already sorted)
+    const aDeps = a.dependencies.join(',');
+    const bDeps = b.dependencies.join(',');
+    if (aDeps !== bDeps) {
+        differences.push(`Step at index ${index}: dependencies differ [${a.dependencies.join(', ')}] vs [${b.dependencies.join(', ')}]`);
+    }
+    // Compare condition modes (structural - affects DAG execution semantics)
+    if (a.whenUnmet !== b.whenUnmet) {
+        differences.push(`Step at index ${index}: whenUnmet differs '${a.whenUnmet}' vs '${b.whenUnmet}'`);
+    }
+    if (a.whenFailed !== b.whenFailed) {
+        differences.push(`Step at index ${index}: whenFailed differs '${a.whenFailed}' vs '${b.whenFailed}'`);
+    }
+    // Compare pattern fields (structural - affects DAG execution semantics)
+    // Uses wrapper objects: { defined: false } or { defined: true, value: Json }
+    const aReqPattern = JSON.stringify(a.requiredInputPattern);
+    const bReqPattern = JSON.stringify(b.requiredInputPattern);
+    if (aReqPattern !== bReqPattern) {
+        differences.push(`Step at index ${index}: requiredInputPattern differs '${aReqPattern}' vs '${bReqPattern}'`);
+    }
+    const aForbPattern = JSON.stringify(a.forbiddenInputPattern);
+    const bForbPattern = JSON.stringify(b.forbiddenInputPattern);
+    if (aForbPattern !== bForbPattern) {
+        differences.push(`Step at index ${index}: forbiddenInputPattern differs '${aForbPattern}' vs '${bForbPattern}'`);
+    }
+}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './dsl.js';
 export * from './compile-flow.js';
+export * from './flow-shape.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC"}

package/dist/index.js

@@ -1,2 +1,3 @@
 export * from './dsl.js';
 export * from './compile-flow.js';
+export * from './flow-shape.js';

package/dist/package.json

@@ -1,6 +1,12 @@
 {
   "name": "@pgflow/dsl",
-  "version": "0.0.0-array-map-steps-fixed-types-38a198ae-20251011160533",
+  "version": "0.0.0-condition-acd3e0e8-20260109190810",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pgflow-dev/pgflow",
+    "directory": "pkgs/dsl"
+  },
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/dist/platforms/supabase.d.ts

@@ -1,19 +1,20 @@
-import type { Sql } from 'postgres';
+import type postgres from 'postgres';
 import type { SupabaseClient } from '@supabase/supabase-js';
 import { Flow as CoreFlow, type AnyInput, type AnySteps, type AnyDeps, EmptySteps, EmptyDeps, type Env } from '../index.js';
 export interface SupabaseResources extends Record<string, unknown> {
-    sql: Sql;
+    sql: postgres.Sql;
     /**
      * Supabase client with service role key for full database access
      */
     supabase: SupabaseClient;
 }
 export interface SupabaseEnv extends Env {
-    EDGE_WORKER_DB_URL: string;
+    SUPABASE_DB_URL: string;
     SUPABASE_URL: string;
     SUPABASE_ANON_KEY: string;
     SUPABASE_SERVICE_ROLE_KEY: string;
     SB_EXECUTION_ID: string;
+    EDGE_WORKER_DB_URL?: string;
     EDGE_WORKER_LOG_LEVEL?: string;
 }
 export type SupabasePlatformContext = SupabaseResources;

package/dist/platforms/supabase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"supabase.d.ts","sourceRoot":"","sources":["../../src/platforms/supabase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EACL,IAAI,IAAI,QAAQ,EAChB,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,KAAK,OAAO,EAC1C,UAAU,EAAE,SAAS,EAAE,KAAK,GAAG,EAChC,MAAM,aAAa,CAAC;AAGrB,MAAM,WAAW,iBAAkB,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAChE,GAAG,EAAc,GAAG,CAAC;IACrB;;OAEG;IACH,QAAQ,EAAS,cAAc,CAAC;CACjC;AAGD,MAAM,WAAW,WAAY,SAAQ,GAAG;IACtC,kBAAkB,EAAQ,MAAM,CAAC;IACjC,YAAY,EAAc,MAAM,CAAC;IACjC,iBAAiB,EAAQ,MAAM,CAAC;IAChC,yBAAyB,EAAE,MAAM,CAAC;IAClC,eAAe,EAAW,MAAM,CAAC;IACjC,qBAAqB,CAAC,EAAI,MAAM,CAAC;CAClC;AAMD,MAAM,MAAM,uBAAuB,GAAG,iBAAiB,CAAC;AAGxD,qBAAa,IAAI,CACf,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAE7B,SAAS,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,EAC9C,CAAC,SAAS,QAAQ,GAAG,UAAU,EAC/B,CAAC,SAAS,OAAO,GAAK,SAAS,EAC/B,IAAI,SAAS,GAAG,GAAG,WAAW,CAC9B,SAAQ,QAAQ,CAChB,CAAC,EACD,uBAAuB,GAAG,SAAS,EACnC,CAAC,EAAE,CAAC,EACJ,IAAI,CACL;CAAG"}
+{"version":3,"file":"supabase.d.ts","sourceRoot":"","sources":["../../src/platforms/supabase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AACrC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EACL,IAAI,IAAI,QAAQ,EAChB,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,KAAK,OAAO,EAC1C,UAAU,EAAE,SAAS,EAAE,KAAK,GAAG,EAChC,MAAM,aAAa,CAAC;AAGrB,MAAM,WAAW,iBAAkB,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAChE,GAAG,EAAc,QAAQ,CAAC,GAAG,CAAC;IAC9B;;OAEG;IACH,QAAQ,EAAS,cAAc,CAAC;CACjC;AAGD,MAAM,WAAW,WAAY,SAAQ,GAAG;IACtC,eAAe,EAAY,MAAM,CAAC;IAClC,YAAY,EAAe,MAAM,CAAC;IAClC,iBAAiB,EAAU,MAAM,CAAC;IAClC,yBAAyB,EAAE,MAAM,CAAC;IAClC,eAAe,EAAY,MAAM,CAAC;IAClC,kBAAkB,CAAC,EAAQ,MAAM,CAAC;IAClC,qBAAqB,CAAC,EAAK,MAAM,CAAC;CACnC;AAMD,MAAM,MAAM,uBAAuB,GAAG,iBAAiB,CAAC;AAGxD,qBAAa,IAAI,CACf,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAE7B,SAAS,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,EAC9C,CAAC,SAAS,QAAQ,GAAG,UAAU,EAC/B,CAAC,SAAS,OAAO,GAAK,SAAS,EAC/B,IAAI,SAAS,GAAG,GAAG,WAAW,CAC9B,SAAQ,QAAQ,CAChB,CAAC,EACD,uBAAuB,GAAG,SAAS,EACnC,CAAC,EAAE,CAAC,EACJ,IAAI,CACL;CAAG"}

package/package.json

@@ -1,6 +1,12 @@
 {
   "name": "@pgflow/dsl",
-  "version": "0.0.0-array-map-steps-fixed-types-38a198ae-20251011160533",
+  "version": "0.0.0-condition-acd3e0e8-20260109190810",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pgflow-dev/pgflow",
+    "directory": "pkgs/dsl"
+  },
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",