@pgflow/core 0.0.0-pgflow-installer-45a8ec76-20251211182851 → 0.0.0-pgflow-installer-53178542-20251211201625

package/dist/migrations/_generated/m_20251104080523.js

@@ -1,98 +0,0 @@
-export const migration = {
-    timestamp: '20251104080523',
-    filename: '20251104080523_pgflow_upgrade_pgmq_1_5_1.sql',
-    content: `-- 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/migrations/_generated/m_20251130000000.d.ts

@@ -1,3 +0,0 @@
-import type { Migration } from '../types.js';
-export declare const migration: Migration;
-//# sourceMappingURL=m_20251130000000.d.ts.map

package/dist/migrations/_generated/m_20251130000000.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"m_20251130000000.d.ts","sourceRoot":"","sources":["../../../src/migrations/_generated/m_20251130000000.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,eAAO,MAAM,SAAS,EAAE,SAgRvB,CAAC"}

package/dist/migrations/_generated/m_20251130000000.js

@@ -1,273 +0,0 @@
-export const migration = {
-    timestamp: '20251130000000',
-    filename: '20251130000000_pgflow_auto_compilation.sql',
-    content: `-- 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/migrations/_generated/m_20251209074533.d.ts

@@ -1,3 +0,0 @@
-import type { Migration } from '../types.js';
-export declare const migration: Migration;
-//# sourceMappingURL=m_20251209074533.d.ts.map

package/dist/migrations/_generated/m_20251209074533.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"m_20251209074533.d.ts","sourceRoot":"","sources":["../../../src/migrations/_generated/m_20251209074533.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,eAAO,MAAM,SAAS,EAAE,SAqRvB,CAAC"}

package/dist/migrations/_generated/m_20251209074533.js

@@ -1,278 +0,0 @@
-export const migration = {
-    timestamp: '20251209074533',
-    filename: '20251209074533_pgflow_worker_management.sql',
-    content: `-- Create extension "pg_net" if not exists
-CREATE EXTENSION IF NOT EXISTS "pg_net" WITH SCHEMA "public";
--- Create extension "pg_cron" if not exists
-CREATE EXTENSION IF NOT EXISTS "pg_cron";
--- Modify "workers" table
-ALTER TABLE "pgflow"."workers" ADD COLUMN "stopped_at" timestamptz NULL;
--- Create "worker_functions" table
-CREATE TABLE "pgflow"."worker_functions" (
-  "function_name" text NOT NULL,
-  "enabled" boolean NOT NULL DEFAULT true,
-  "debounce" interval NOT NULL DEFAULT '00:00:06'::interval,
-  "last_invoked_at" timestamptz NULL,
-  "created_at" timestamptz NOT NULL DEFAULT now(),
-  "updated_at" timestamptz NOT NULL DEFAULT now(),
-  PRIMARY KEY ("function_name"),
-  CONSTRAINT "worker_functions_debounce_check" CHECK (debounce >= '00:00:01'::interval)
-);
--- Set comment to table: "worker_functions"
-COMMENT ON TABLE "pgflow"."worker_functions" IS 'Registry of edge functions that run pgflow workers, used by ensure_workers() cron';
--- Set comment to column: "function_name" on table: "worker_functions"
-COMMENT ON COLUMN "pgflow"."worker_functions"."function_name" IS 'Name of the Supabase Edge Function';
--- Set comment to column: "enabled" on table: "worker_functions"
-COMMENT ON COLUMN "pgflow"."worker_functions"."enabled" IS 'Whether ensure_workers() should ping this function';
--- Set comment to column: "debounce" on table: "worker_functions"
-COMMENT ON COLUMN "pgflow"."worker_functions"."debounce" IS 'Minimum interval between invocation attempts for this function';
--- Set comment to column: "last_invoked_at" on table: "worker_functions"
-COMMENT ON COLUMN "pgflow"."worker_functions"."last_invoked_at" IS 'When ensure_workers() last pinged this function (used for debouncing)';
--- Create "cleanup_ensure_workers_logs" function
-CREATE FUNCTION "pgflow"."cleanup_ensure_workers_logs" ("retention_hours" integer DEFAULT 24) RETURNS TABLE ("cron_deleted" bigint) LANGUAGE sql SECURITY DEFINER SET "search_path" = pgflow, cron, pg_temp AS $$
-with deleted as (
-    delete from cron.job_run_details
-    where job_run_details.end_time < now() - (cleanup_ensure_workers_logs.retention_hours || ' hours')::interval
-    returning 1
-  )
-  select count(*)::bigint as cron_deleted from deleted
-$$;
--- Set comment to function: "cleanup_ensure_workers_logs"
-COMMENT ON FUNCTION "pgflow"."cleanup_ensure_workers_logs" IS 'Cleans up old cron job run details to prevent table growth.
-Default retention is 24 hours. HTTP response logs (net._http_response) are
-automatically cleaned by pg_net with a 6-hour TTL, so they are not cleaned here.
-This function follows the standard pg_cron maintenance pattern recommended by
-AWS RDS, Neon, and Supabase documentation.';
--- Create "is_local" function
-CREATE FUNCTION "pgflow"."is_local" () RETURNS boolean LANGUAGE sql STABLE PARALLEL SAFE SET "search_path" = '' AS $$
-select coalesce(
-    current_setting('app.settings.jwt_secret', true)
-      = 'super-secret-jwt-token-with-at-least-32-characters-long',
-    false
-  )
-$$;
--- Create "ensure_flow_compiled" function
-CREATE FUNCTION "pgflow"."ensure_flow_compiled" ("flow_slug" text, "shape" jsonb) RETURNS jsonb LANGUAGE plpgsql SET "search_path" = '' AS $$
-DECLARE
-  v_lock_key int;
-  v_flow_exists boolean;
-  v_db_shape jsonb;
-  v_differences text[];
-  v_is_local boolean;
-BEGIN
-  -- Generate lock key from flow_slug (deterministic hash)
-  v_lock_key := hashtext(ensure_flow_compiled.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 = ensure_flow_compiled.flow_slug)
-  INTO v_flow_exists;
-
-  -- 2. If flow missing: compile (both environments)
-  IF NOT v_flow_exists THEN
-    PERFORM pgflow._create_flow_from_shape(ensure_flow_compiled.flow_slug, ensure_flow_compiled.shape);
-    RETURN jsonb_build_object('status', 'compiled', 'differences', '[]'::jsonb);
-  END IF;
-
-  -- 3. Get current shape from DB
-  v_db_shape := pgflow._get_flow_shape(ensure_flow_compiled.flow_slug);
-
-  -- 4. Compare shapes
-  v_differences := pgflow._compare_flow_shapes(ensure_flow_compiled.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 - auto-detect environment via is_local()
-  v_is_local := pgflow.is_local();
-
-  IF v_is_local THEN
-    -- Recompile in local/dev: full deletion + fresh compile
-    PERFORM pgflow.delete_flow_and_data(ensure_flow_compiled.flow_slug);
-    PERFORM pgflow._create_flow_from_shape(ensure_flow_compiled.flow_slug, ensure_flow_compiled.shape);
-    RETURN jsonb_build_object('status', 'recompiled', 'differences', to_jsonb(v_differences));
-  ELSE
-    -- Fail in production
-    RETURN jsonb_build_object('status', 'mismatch', 'differences', to_jsonb(v_differences));
-  END IF;
-END;
-$$;
--- Create "ensure_workers" function
-CREATE FUNCTION "pgflow"."ensure_workers" () RETURNS TABLE ("function_name" text, "invoked" boolean, "request_id" bigint) LANGUAGE sql AS $$
-with
-    -- Detect environment
-    env as (
-      select pgflow.is_local() as is_local
-    ),
-
-    -- Get credentials: Local mode uses hardcoded URL, production uses vault secrets
-    -- Empty strings are treated as NULL using nullif()
-    credentials as (
-      select
-        case
-          when (select is_local from env) then null
-          else nullif((select decrypted_secret from vault.decrypted_secrets where name = 'supabase_service_role_key'), '')
-        end as service_role_key,
-        case
-          when (select is_local from env) then 'http://kong:8000/functions/v1'
-          else (select 'https://' || nullif(decrypted_secret, '') || '.supabase.co/functions/v1' from vault.decrypted_secrets where name = 'supabase_project_id')
-        end as base_url
-    ),
-
-    -- Find functions that pass the debounce check
-    debounce_passed as (
-      select wf.function_name, wf.debounce
-      from pgflow.worker_functions as wf
-      where wf.enabled = true
-        and (
-          wf.last_invoked_at is null
-          or wf.last_invoked_at < now() - wf.debounce
-        )
-    ),
-
-    -- Find functions that have at least one alive worker
-    functions_with_alive_workers as (
-      select distinct w.function_name
-      from pgflow.workers as w
-      inner join debounce_passed as dp on w.function_name = dp.function_name
-      where w.stopped_at is null
-        and w.deprecated_at is null
-        and w.last_heartbeat_at > now() - dp.debounce
-    ),
-
-    -- Determine which functions should be invoked
-    -- Local mode: all enabled functions (bypass debounce AND alive workers check)
-    -- Production mode: only functions that pass debounce AND have no alive workers
-    functions_to_invoke as (
-      select wf.function_name
-      from pgflow.worker_functions as wf
-      where wf.enabled = true
-        and (
-          pgflow.is_local() = true  -- Local: all enabled functions
-          or (
-            -- Production: debounce + no alive workers
-            wf.function_name in (select dp.function_name from debounce_passed as dp)
-            and wf.function_name not in (select faw.function_name from functions_with_alive_workers as faw)
-          )
-        )
-    ),
-
-    -- Make HTTP requests and capture request_ids
-    http_requests as (
-      select
-        fti.function_name,
-        net.http_post(
-          url => c.base_url || '/' || fti.function_name,
-          headers => case
-            when e.is_local then '{}'::jsonb
-            else jsonb_build_object(
-              'Content-Type', 'application/json',
-              'Authorization', 'Bearer ' || c.service_role_key
-            )
-          end,
-          body => '{}'::jsonb
-        ) as request_id
-      from functions_to_invoke as fti
-      cross join credentials as c
-      cross join env as e
-      where c.base_url is not null
-        and (e.is_local or c.service_role_key is not null)
-    ),
-
-    -- Update last_invoked_at for invoked functions
-    updated as (
-      update pgflow.worker_functions as wf
-      set last_invoked_at = clock_timestamp()
-      from http_requests as hr
-      where wf.function_name = hr.function_name
-      returning wf.function_name
-    )
-
-  select u.function_name, true as invoked, hr.request_id
-  from updated as u
-  inner join http_requests as hr on u.function_name = hr.function_name
-$$;
--- Set comment to function: "ensure_workers"
-COMMENT ON FUNCTION "pgflow"."ensure_workers" IS 'Ensures worker functions are running by pinging them via HTTP when needed.
-In local mode: pings ALL enabled functions (ignores debounce AND alive workers check).
-In production mode: only pings functions that pass debounce AND have no alive workers.
-Debounce: skips functions pinged within their debounce interval (production only).
-Credentials: Uses Vault secrets (supabase_service_role_key, supabase_project_id) or local fallbacks.
-URL is built from project_id: https://{project_id}.supabase.co/functions/v1
-Returns request_id from pg_net for each HTTP request made.';
--- Create "mark_worker_stopped" function
-CREATE FUNCTION "pgflow"."mark_worker_stopped" ("worker_id" uuid) RETURNS void LANGUAGE sql AS $$
-update pgflow.workers
-  set stopped_at = clock_timestamp()
-  where workers.worker_id = mark_worker_stopped.worker_id;
-$$;
--- Set comment to function: "mark_worker_stopped"
-COMMENT ON FUNCTION "pgflow"."mark_worker_stopped" IS 'Marks a worker as stopped for graceful shutdown. Called by workers on beforeunload.';
--- Create "setup_ensure_workers_cron" function
-CREATE FUNCTION "pgflow"."setup_ensure_workers_cron" ("cron_interval" text DEFAULT '1 second') RETURNS text LANGUAGE plpgsql SECURITY DEFINER SET "search_path" = pgflow, cron, pg_temp AS $$
-declare
-  ensure_workers_job_id bigint;
-  cleanup_job_id bigint;
-begin
-  -- Remove existing jobs if they exist (ignore errors if not found)
-  begin
-    perform cron.unschedule('pgflow_ensure_workers');
-  exception when others then
-    -- Job doesn't exist, continue
-  end;
-
-  begin
-    perform cron.unschedule('pgflow_cleanup_logs');
-  exception when others then
-    -- Job doesn't exist, continue
-  end;
-
-  -- Schedule ensure_workers job with the specified interval
-  ensure_workers_job_id := cron.schedule(
-    job_name => 'pgflow_ensure_workers',
-    schedule => setup_ensure_workers_cron.cron_interval,
-    command => 'select pgflow.ensure_workers()'
-  );
-
-  -- Schedule cleanup job to run hourly
-  cleanup_job_id := cron.schedule(
-    job_name => 'pgflow_cleanup_logs',
-    schedule => '0 * * * *',
-    command => 'select pgflow.cleanup_ensure_workers_logs()'
-  );
-
-  return format(
-    'Scheduled pgflow_ensure_workers (every %s, job_id=%s) and pgflow_cleanup_logs (hourly, job_id=%s)',
-    setup_ensure_workers_cron.cron_interval,
-    ensure_workers_job_id,
-    cleanup_job_id
-  );
-end;
-$$;
--- Set comment to function: "setup_ensure_workers_cron"
-COMMENT ON FUNCTION "pgflow"."setup_ensure_workers_cron" IS 'Sets up cron jobs for worker management.
-Schedules pgflow_ensure_workers at the specified cron_interval (default: 1 second) to keep workers running.
-Schedules pgflow_cleanup_logs hourly to clean up old cron job logs.
-Replaces existing jobs if they exist (idempotent).
-Returns a confirmation message with job IDs.';
--- Create "track_worker_function" function
-CREATE FUNCTION "pgflow"."track_worker_function" ("function_name" text) RETURNS void LANGUAGE sql AS $$
-insert into pgflow.worker_functions (function_name, updated_at)
-  values (track_worker_function.function_name, clock_timestamp())
-  on conflict (function_name)
-  do update set
-    updated_at = clock_timestamp();
-$$;
--- Set comment to function: "track_worker_function"
-COMMENT ON FUNCTION "pgflow"."track_worker_function" IS 'Registers an edge function for monitoring. Called by workers on startup.';
--- Drop "ensure_flow_compiled" function
-DROP FUNCTION "pgflow"."ensure_flow_compiled" (text, jsonb, text);
--- Auto-install ensure_workers cron job (1 second interval)
-SELECT pgflow.setup_ensure_workers_cron('1 second');
-`,
-};

package/dist/migrations/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * Auto-generated migration exports
- *
- * This file is regenerated by scripts/generate-migrations.ts
- * Do not edit manually.
- */
-import type { Migration } from './types.js';
-export declare const migrations: Migration[];
-export declare function getMigrations(): Migration[];
-export type { Migration };
-//# sourceMappingURL=index.d.ts.map

package/dist/migrations/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/migrations/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAgB5C,eAAO,MAAM,UAAU,EAAE,SAAS,EAejC,CAAC;AAEF,wBAAgB,aAAa,IAAI,SAAS,EAAE,CAE3C;AAED,YAAY,EAAE,SAAS,EAAE,CAAC"}