@pgflow/core 0.0.0-test-snapshot-releases-8d5d9bc1-20250922101013 → 0.0.0-testsnap-9294d743-20251207205914

package/dist/supabase/migrations/20251104080523_pgflow_upgrade_pgmq_1_5_1.sql

@@ -0,0 +1,93 @@
+-- Migration tested 2025-11-02:
+-- Successfully verified that this migration fails on pgmq 1.4.4 (Supabase CLI < 2.50.3)
+-- with clear error message guiding users to upgrade pgmq to 1.5.0+
+--
+-- Compatibility check: Ensure pgmq.message_record has headers column (pgmq 1.5.0+)
+DO $$
+DECLARE
+    has_headers BOOLEAN;
+BEGIN
+    SELECT EXISTS (
+        SELECT 1
+        FROM pg_type t
+        JOIN pg_namespace n ON t.typnamespace = n.oid
+        JOIN pg_attribute a ON a.attrelid = t.typrelid
+        WHERE n.nspname = 'pgmq'
+          AND t.typname = 'message_record'
+          AND a.attname = 'headers'
+          AND a.attnum > 0
+          AND NOT a.attisdropped
+    ) INTO has_headers;
+
+    IF NOT has_headers THEN
+        RAISE EXCEPTION E'INCOMPATIBLE PGMQ VERSION DETECTED\n\n'
+            'This migration is part of pgflow 0.8.0+, which requires pgmq 1.5.0 or higher.\n'
+            'The pgmq.message_record type is missing the "headers" column, which indicates you are running pgmq < 1.5.0.\n\n'
+            'pgflow 0.8.0+ is NOT compatible with pgmq versions below 1.5.0.\n\n'
+            'Action required:\n'
+            '  - If using Supabase: Ensure you are running a recent version that includes pgmq 1.5.0+\n'
+            '  - If self-hosting: Upgrade pgmq to version 1.5.0 or higher before running this migration\n\n'
+            'Migration aborted to prevent runtime failures.';
+    END IF;
+END $$;
+
+-- Modify "set_vt_batch" function
+-- Must drop first because we're changing the return type from SETOF to TABLE
+DROP FUNCTION IF EXISTS "pgflow"."set_vt_batch"(text, bigint[], integer[]);
+CREATE FUNCTION "pgflow"."set_vt_batch" (
+    "queue_name" text,
+    "msg_ids" bigint[],
+    "vt_offsets" integer[]
+)
+RETURNS TABLE(
+    msg_id bigint,
+    read_ct integer,
+    enqueued_at timestamp with time zone,
+    vt timestamp with time zone,
+    message jsonb,
+    headers jsonb
+)
+LANGUAGE plpgsql AS $$
+DECLARE
+    qtable TEXT := pgmq.format_table_name(queue_name, 'q');
+    sql    TEXT;
+BEGIN
+    /* ---------- safety checks ---------------------------------------------------- */
+    IF msg_ids IS NULL OR vt_offsets IS NULL OR array_length(msg_ids, 1) = 0 THEN
+        RETURN;                    -- nothing to do, return empty set
+    END IF;
+
+    IF array_length(msg_ids, 1) IS DISTINCT FROM array_length(vt_offsets, 1) THEN
+        RAISE EXCEPTION
+          'msg_ids length (%) must equal vt_offsets length (%)',
+          array_length(msg_ids, 1), array_length(vt_offsets, 1);
+    END IF;
+
+    /* ---------- dynamic statement ------------------------------------------------ */
+    /* One UPDATE joins with the unnested arrays */
+    sql := format(
+        $FMT$
+        WITH input (msg_id, vt_offset) AS (
+            SELECT  unnest($1)::bigint
+                 ,  unnest($2)::int
+        )
+        UPDATE pgmq.%I q
+        SET    vt      = clock_timestamp() + make_interval(secs => input.vt_offset),
+               read_ct = read_ct     -- no change, but keeps RETURNING list aligned
+        FROM   input
+        WHERE  q.msg_id = input.msg_id
+        RETURNING q.msg_id,
+                  q.read_ct,
+                  q.enqueued_at,
+                  q.vt,
+                  q.message,
+                  q.headers
+        $FMT$,
+        qtable
+    );
+
+    RETURN QUERY EXECUTE sql USING msg_ids, vt_offsets;
+END;
+$$;
+-- Drop "read_with_poll" function
+DROP FUNCTION "pgflow"."read_with_poll";

package/dist/supabase/migrations/20251130000000_pgflow_auto_compilation.sql

@@ -0,0 +1,268 @@
+-- Modify "create_flow" function
+CREATE OR REPLACE FUNCTION "pgflow"."create_flow" ("flow_slug" text, "max_attempts" integer DEFAULT NULL::integer, "base_delay" integer DEFAULT NULL::integer, "timeout" integer DEFAULT NULL::integer) RETURNS "pgflow"."flows" LANGUAGE sql SET "search_path" = '' AS $$
+WITH
+  defaults AS (
+    SELECT 3 AS def_max_attempts, 5 AS def_base_delay, 60 AS def_timeout
+  ),
+  flow_upsert AS (
+    INSERT INTO pgflow.flows (flow_slug, opt_max_attempts, opt_base_delay, opt_timeout)
+    SELECT
+      flow_slug,
+      COALESCE(max_attempts, defaults.def_max_attempts),
+      COALESCE(base_delay, defaults.def_base_delay),
+      COALESCE(timeout, defaults.def_timeout)
+    FROM defaults
+    ON CONFLICT (flow_slug) DO UPDATE
+    SET flow_slug = pgflow.flows.flow_slug -- Dummy update
+    RETURNING *
+  ),
+  ensure_queue AS (
+    SELECT pgmq.create(flow_slug)
+    WHERE NOT EXISTS (
+      SELECT 1 FROM pgmq.list_queues() WHERE queue_name = flow_slug
+    )
+  )
+SELECT f.*
+FROM flow_upsert f
+LEFT JOIN (SELECT 1 FROM ensure_queue) _dummy ON true; -- Left join ensures flow is returned
+$$;
+-- Create "_compare_flow_shapes" function
+CREATE FUNCTION "pgflow"."_compare_flow_shapes" ("p_local" jsonb, "p_db" jsonb) RETURNS text[] LANGUAGE plpgsql STABLE SET "search_path" = '' AS $BODY$
+DECLARE
+  v_differences text[] := '{}';
+  v_local_steps jsonb;
+  v_db_steps jsonb;
+  v_local_count int;
+  v_db_count int;
+  v_max_count int;
+  v_idx int;
+  v_local_step jsonb;
+  v_db_step jsonb;
+  v_local_deps text;
+  v_db_deps text;
+BEGIN
+  v_local_steps := p_local->'steps';
+  v_db_steps := p_db->'steps';
+  v_local_count := jsonb_array_length(COALESCE(v_local_steps, '[]'::jsonb));
+  v_db_count := jsonb_array_length(COALESCE(v_db_steps, '[]'::jsonb));
+
+  -- Compare step counts
+  IF v_local_count != v_db_count THEN
+    v_differences := array_append(
+      v_differences,
+      format('Step count differs: %s vs %s', v_local_count, v_db_count)
+    );
+  END IF;
+
+  -- Compare steps by index
+  v_max_count := GREATEST(v_local_count, v_db_count);
+
+  FOR v_idx IN 0..(v_max_count - 1) LOOP
+    v_local_step := v_local_steps->v_idx;
+    v_db_step := v_db_steps->v_idx;
+
+    IF v_local_step IS NULL THEN
+      v_differences := array_append(
+        v_differences,
+        format(
+          $$Step at index %s: missing in first shape (second has '%s')$$,
+          v_idx,
+          v_db_step->>'slug'
+        )
+      );
+    ELSIF v_db_step IS NULL THEN
+      v_differences := array_append(
+        v_differences,
+        format(
+          $$Step at index %s: missing in second shape (first has '%s')$$,
+          v_idx,
+          v_local_step->>'slug'
+        )
+      );
+    ELSE
+      -- Compare slug
+      IF v_local_step->>'slug' != v_db_step->>'slug' THEN
+        v_differences := array_append(
+          v_differences,
+          format(
+            $$Step at index %s: slug differs '%s' vs '%s'$$,
+            v_idx,
+            v_local_step->>'slug',
+            v_db_step->>'slug'
+          )
+        );
+      END IF;
+
+      -- Compare step type
+      IF v_local_step->>'stepType' != v_db_step->>'stepType' THEN
+        v_differences := array_append(
+          v_differences,
+          format(
+            $$Step at index %s: type differs '%s' vs '%s'$$,
+            v_idx,
+            v_local_step->>'stepType',
+            v_db_step->>'stepType'
+          )
+        );
+      END IF;
+
+      -- Compare dependencies (convert arrays to comma-separated strings)
+      SELECT string_agg(dep, ', ' ORDER BY dep)
+      INTO v_local_deps
+      FROM jsonb_array_elements_text(COALESCE(v_local_step->'dependencies', '[]'::jsonb)) AS dep;
+
+      SELECT string_agg(dep, ', ' ORDER BY dep)
+      INTO v_db_deps
+      FROM jsonb_array_elements_text(COALESCE(v_db_step->'dependencies', '[]'::jsonb)) AS dep;
+
+      IF COALESCE(v_local_deps, '') != COALESCE(v_db_deps, '') THEN
+        v_differences := array_append(
+          v_differences,
+          format(
+            $$Step at index %s: dependencies differ [%s] vs [%s]$$,
+            v_idx,
+            COALESCE(v_local_deps, ''),
+            COALESCE(v_db_deps, '')
+          )
+        );
+      END IF;
+    END IF;
+  END LOOP;
+
+  RETURN v_differences;
+END;
+$BODY$;
+-- Create "_create_flow_from_shape" function
+CREATE FUNCTION "pgflow"."_create_flow_from_shape" ("p_flow_slug" text, "p_shape" jsonb) RETURNS void LANGUAGE plpgsql SET "search_path" = '' AS $$
+DECLARE
+  v_step jsonb;
+  v_deps text[];
+  v_flow_options jsonb;
+  v_step_options jsonb;
+BEGIN
+  -- Extract flow-level options (may be null)
+  v_flow_options := p_shape->'options';
+
+  -- Create the flow with options (NULL = use default)
+  PERFORM pgflow.create_flow(
+    p_flow_slug,
+    (v_flow_options->>'maxAttempts')::int,
+    (v_flow_options->>'baseDelay')::int,
+    (v_flow_options->>'timeout')::int
+  );
+
+  -- Iterate over steps in order and add each one
+  FOR v_step IN SELECT * FROM jsonb_array_elements(p_shape->'steps')
+  LOOP
+    -- Convert dependencies jsonb array to text array
+    SELECT COALESCE(array_agg(dep), '{}')
+    INTO v_deps
+    FROM jsonb_array_elements_text(COALESCE(v_step->'dependencies', '[]'::jsonb)) AS dep;
+
+    -- Extract step options (may be null)
+    v_step_options := v_step->'options';
+
+    -- Add the step with options (NULL = use default/inherit)
+    PERFORM pgflow.add_step(
+      flow_slug => p_flow_slug,
+      step_slug => v_step->>'slug',
+      deps_slugs => v_deps,
+      max_attempts => (v_step_options->>'maxAttempts')::int,
+      base_delay => (v_step_options->>'baseDelay')::int,
+      timeout => (v_step_options->>'timeout')::int,
+      start_delay => (v_step_options->>'startDelay')::int,
+      step_type => v_step->>'stepType'
+    );
+  END LOOP;
+END;
+$$;
+-- Create "_get_flow_shape" function
+CREATE FUNCTION "pgflow"."_get_flow_shape" ("p_flow_slug" text) RETURNS jsonb LANGUAGE sql STABLE SET "search_path" = '' AS $$
+SELECT jsonb_build_object(
+    'steps',
+    COALESCE(
+      jsonb_agg(
+        jsonb_build_object(
+          'slug', step.step_slug,
+          'stepType', step.step_type,
+          'dependencies', COALESCE(
+            (
+              SELECT jsonb_agg(dep.dep_slug ORDER BY dep.dep_slug)
+              FROM pgflow.deps AS dep
+              WHERE dep.flow_slug = step.flow_slug
+                AND dep.step_slug = step.step_slug
+            ),
+            '[]'::jsonb
+          )
+        )
+        ORDER BY step.step_index
+      ),
+      '[]'::jsonb
+    )
+  )
+  FROM pgflow.steps AS step
+  WHERE step.flow_slug = p_flow_slug;
+$$;
+-- Create "delete_flow_and_data" function
+CREATE FUNCTION "pgflow"."delete_flow_and_data" ("p_flow_slug" text) RETURNS void LANGUAGE plpgsql SET "search_path" = '' AS $$
+BEGIN
+  -- Drop queue and archive table (pgmq)
+  PERFORM pgmq.drop_queue(p_flow_slug);
+
+  -- Delete all associated data in the correct order (respecting FK constraints)
+  DELETE FROM pgflow.step_tasks AS task WHERE task.flow_slug = p_flow_slug;
+  DELETE FROM pgflow.step_states AS state WHERE state.flow_slug = p_flow_slug;
+  DELETE FROM pgflow.runs AS run WHERE run.flow_slug = p_flow_slug;
+  DELETE FROM pgflow.deps AS dep WHERE dep.flow_slug = p_flow_slug;
+  DELETE FROM pgflow.steps AS step WHERE step.flow_slug = p_flow_slug;
+  DELETE FROM pgflow.flows AS flow WHERE flow.flow_slug = p_flow_slug;
+END;
+$$;
+-- Create "ensure_flow_compiled" function
+CREATE FUNCTION "pgflow"."ensure_flow_compiled" ("p_flow_slug" text, "p_shape" jsonb, "p_mode" text DEFAULT 'production') RETURNS jsonb LANGUAGE plpgsql SET "search_path" = '' AS $$
+DECLARE
+  v_lock_key int;
+  v_flow_exists boolean;
+  v_db_shape jsonb;
+  v_differences text[];
+BEGIN
+  -- Generate lock key from flow_slug (deterministic hash)
+  v_lock_key := hashtext(p_flow_slug);
+
+  -- Acquire transaction-level advisory lock
+  -- Serializes concurrent compilation attempts for same flow
+  PERFORM pg_advisory_xact_lock(1, v_lock_key);
+
+  -- 1. Check if flow exists
+  SELECT EXISTS(SELECT 1 FROM pgflow.flows AS flow WHERE flow.flow_slug = p_flow_slug)
+  INTO v_flow_exists;
+
+  -- 2. If flow missing: compile (both modes)
+  IF NOT v_flow_exists THEN
+    PERFORM pgflow._create_flow_from_shape(p_flow_slug, p_shape);
+    RETURN jsonb_build_object('status', 'compiled', 'differences', '[]'::jsonb);
+  END IF;
+
+  -- 3. Get current shape from DB
+  v_db_shape := pgflow._get_flow_shape(p_flow_slug);
+
+  -- 4. Compare shapes
+  v_differences := pgflow._compare_flow_shapes(p_shape, v_db_shape);
+
+  -- 5. If shapes match: return verified
+  IF array_length(v_differences, 1) IS NULL THEN
+    RETURN jsonb_build_object('status', 'verified', 'differences', '[]'::jsonb);
+  END IF;
+
+  -- 6. Shapes differ - handle by mode
+  IF p_mode = 'development' THEN
+    -- Recompile in dev mode: full deletion + fresh compile
+    PERFORM pgflow.delete_flow_and_data(p_flow_slug);
+    PERFORM pgflow._create_flow_from_shape(p_flow_slug, p_shape);
+    RETURN jsonb_build_object('status', 'recompiled', 'differences', to_jsonb(v_differences));
+  ELSE
+    -- Fail in production mode
+    RETURN jsonb_build_object('status', 'mismatch', 'differences', to_jsonb(v_differences));
+  END IF;
+END;
+$$;

package/dist/tsconfig.lib.tsbuildinfo

@@ -0,0 +1 @@
+{"version":"5.8.3"}

package/dist/types.d.ts

@@ -0,0 +1,93 @@
+import type { ExtractFlowSteps, StepInput, Simplify, AnyFlow, ExtractFlowInput, Json } from '@pgflow/dsl';
+import type { Database } from './database-types.js';
+export type { Json };
+/**
+ * Record representing a task from pgflow.start_tasks
+ *
+ * Same as pgflow.step_task_record type, but with not-null fields and type argument for payload.
+ * The input type is automatically inferred based on the step_slug using a discriminated union.
+ * This ensures that each step only receives inputs from its declared dependencies and the flow's run input.
+ */
+export type StepTaskRecord<TFlow extends AnyFlow> = {
+    [StepSlug in Extract<keyof ExtractFlowSteps<TFlow>, string>]: {
+        flow_slug: string;
+        run_id: string;
+        step_slug: StepSlug;
+        task_index: number;
+        input: Simplify<StepInput<TFlow, StepSlug>>;
+        msg_id: number;
+    };
+}[Extract<keyof ExtractFlowSteps<TFlow>, string>];
+/**
+ * Composite key that is enough to find a particular step task
+ * Contains only the minimum fields needed to identify a task
+ */
+export type StepTaskKey = Pick<StepTaskRecord<AnyFlow>, 'run_id' | 'step_slug' | 'task_index'>;
+/**
+ * Record representing a message from queue polling
+ */
+export type MessageRecord = {
+    msg_id: number;
+    read_ct: number;
+    enqueued_at: string;
+    vt: string;
+    message: Json;
+};
+/**
+ * Interface for interacting with pgflow database functions
+ */
+export interface IPgflowClient<TFlow extends AnyFlow = AnyFlow> {
+    /**
+     * Start a flow with optional run_id
+     */
+    startFlow<TFlow extends AnyFlow>(flow_slug: string, input: ExtractFlowInput<TFlow>, run_id?: string): Promise<RunRow>;
+    /**
+     * Reads messages from queue without starting tasks (phase 1 of two-phase approach)
+     * @param queueName - Name of the queue
+     * @param visibilityTimeout - Visibility timeout for messages
+     * @param batchSize - Number of messages to fetch
+     * @param maxPollSeconds - Maximum time to poll for messages
+     * @param pollIntervalMs - Poll interval in milliseconds
+     */
+    readMessages(queueName: string, visibilityTimeout: number, batchSize: number, maxPollSeconds?: number, pollIntervalMs?: number): Promise<MessageRecord[]>;
+    /**
+     * Starts tasks for given message IDs (phase 2 of two-phase approach)
+     * @param flowSlug - The flow slug to start tasks from
+     * @param msgIds - Array of message IDs from readMessages
+     * @param workerId - ID of the worker starting the tasks
+     */
+    startTasks(flowSlug: string, msgIds: number[], workerId: string): Promise<StepTaskRecord<TFlow>[]>;
+    /**
+     * Mark a task as completed with output
+     */
+    completeTask(stepTask: StepTaskKey, output?: Json): Promise<void>;
+    /**
+     * Mark a task as failed with error
+     */
+    failTask(stepTask: StepTaskKey, error: unknown): Promise<void>;
+}
+/**
+ * Record representing a flow from pgflow.flows
+ */
+export type FlowRow = Database['pgflow']['Tables']['flows']['Row'];
+/**
+ * Record representing a step from pgflow.steps
+ */
+export type StepRow = Database['pgflow']['Tables']['steps']['Row'];
+/**
+ * Record representing a step from pgflow.deps
+ */
+export type DepRow = Database['pgflow']['Tables']['deps']['Row'];
+/**
+ * Record representing a step from pgflow.queues
+ */
+export type RunRow = Database['pgflow']['Tables']['runs']['Row'];
+/**
+ * Record representing a step from pgflow.step_states
+ */
+export type StepStateRow = Database['pgflow']['Tables']['step_states']['Row'];
+/**
+ * Record representing a step from pgflow.step_tasks
+ */
+export type StepTaskRow = Database['pgflow']['Tables']['step_tasks']['Row'];
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pgflow/core",
-  "version": "0.0.0-test-snapshot-releases-8d5d9bc1-20250922101013",
-  "license": "AGPL-3.0",
+  "version": "0.0.0-testsnap-9294d743-20251207205914",
+  "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -19,12 +19,11 @@
     }
   },
   "devDependencies": {
-    "@types/node": "^22.14.1",
-    "supabase": "2.21.1"
+    "@types/node": "^22.14.1"
   },
   "dependencies": {
     "postgres": "^3.4.5",
-    "@pgflow/dsl": "0.0.0-test-snapshot-releases-8d5d9bc1-20250922101013"
+    "@pgflow/dsl": "0.0.0-testsnap-9294d743-20251207205914"
   },
   "publishConfig": {
     "access": "public"