@pgflow/core 0.0.5 → 0.0.7

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from './types.ts';
-export * from './PgflowSqlClient.ts';
-export type { Database } from './database-types.ts';

package/src/types.ts

@@ -1,103 +0,0 @@
-import type {
-  ExtractFlowSteps,
-  StepInput,
-  Simplify,
-  AnyFlow,
-} from '@pgflow/dsl';
-import type { Database } from './database-types.ts';
-
-export type Json =
-  | string
-  | number
-  | boolean
-  | null
-  | { [key: string]: Json | undefined }
-  | Json[];
-
-/**
- * Record representing a task from pgflow.poll_for_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;
-    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<any>, 'run_id' | 'step_slug'>;
-
-/**
- * Interface for interacting with pgflow database functions
- */
-export interface IPgflowClient<TFlow extends AnyFlow = AnyFlow> {
-  /**
-   * Fetches tasks from pgflow
-   * @param queueName - Name
-   * @param batchSize - Number of tasks to fetch
-   * @param visibilityTimeout - Visibility timeout for tasks
-   * @param maxPollSeconds - Maximum time to poll for tasks
-   * @param pollIntervalMs - Poll interval in milliseconds
-   */
-  pollForTasks(
-    queueName: string,
-    batchSize?: number,
-    visibilityTimeout?: number,
-    maxPollSeconds?: number,
-    pollIntervalMs?: number
-  ): Promise<StepTaskRecord<TFlow>[]>;
-
-  /**
-   * Marks a task as completed
-   * @param stepTask - Step task key containing run_id and step_slug
-   * @param output - Output payload for the task
-   */
-  completeTask(stepTask: StepTaskKey, output?: Json): Promise<void>;
-
-  /**
-   * Marks a task as failed
-   * @param stepTask - Step task key containing run_id and step_slug
-   * @param error - Error to fail task with
-   */
-  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'];

package/supabase/config.toml

@@ -1,32 +0,0 @@
-project_id = "core"
-
-[db]
-port = 50422
-shadow_port = 50420
-major_version = 15
-
-# disable unused features
-[db.seed]
-enabled = true
-
-[api]
-port = 50421  # Add custom port for Kong
-enabled = false  # Keep disabled as per your config
-[db.pooler]
-enabled = false
-[edge_runtime]
-enabled = false
-[realtime]
-enabled = false
-[studio]
-enabled = false
-[inbucket]
-enabled = false
-[analytics]
-enabled = false
-[storage]
-enabled = false
-[auth]
-enabled = false
-
-

package/supabase/seed.sql

@@ -1,202 +0,0 @@
-create schema if not exists pgflow_tests;
-
---------------------------------------------------------------------------------
---------- reset_db - clears all tables and drops all queues --------------------
---------------------------------------------------------------------------------
-create or replace function pgflow_tests.reset_db() returns void as $$
-  DELETE FROM pgflow.step_tasks;
-  DELETE FROM pgflow.step_states;
-  DELETE FROM pgflow.runs;
-  DELETE FROM pgflow.deps;
-  DELETE FROM pgflow.steps;
-  DELETE FROM pgflow.flows;
-
-  SELECT pgmq.drop_queue(queue_name) FROM pgmq.list_queues();
-$$ language sql;
-
---------------------------------------------------------------------------------
---------- setup_flow - creates a predefined flow and adds steps to it ----------
---------------------------------------------------------------------------------
-create or replace function pgflow_tests.setup_flow(
-  flow_slug text
-) returns void as $$
-begin
-
-if flow_slug = 'sequential' then
-  PERFORM pgflow.create_flow('sequential', timeout => 1);
-  PERFORM pgflow.add_step('sequential', 'first');
-  PERFORM pgflow.add_step('sequential', 'second', ARRAY['first']);
-  PERFORM pgflow.add_step('sequential', 'last', ARRAY['second']);
-elsif flow_slug = 'sequential_other' then
-  PERFORM pgflow.create_flow('other', timeout => 1);
-  PERFORM pgflow.add_step('other', 'first');
-  PERFORM pgflow.add_step('other', 'second', ARRAY['first']);
-  PERFORM pgflow.add_step('other', 'last', ARRAY['second']);
-elsif flow_slug = 'two_roots' then
-  PERFORM pgflow.create_flow('two_roots', timeout => 1);
-  PERFORM pgflow.add_step('two_roots', 'root_a');
-  PERFORM pgflow.add_step('two_roots', 'root_b');
-  PERFORM pgflow.add_step('two_roots', 'last', ARRAY['root_a', 'root_b']);
-elsif flow_slug = 'two_roots_left_right' then
-  PERFORM pgflow.create_flow('two_roots_left_right', timeout => 1);
-  PERFORM pgflow.add_step('two_roots_left_right', 'connected_root');
-  PERFORM pgflow.add_step('two_roots_left_right', 'disconnected_root');
-  PERFORM pgflow.add_step('two_roots_left_right', 'left', ARRAY['connected_root']);
-  PERFORM pgflow.add_step('two_roots_left_right', 'right', ARRAY['connected_root']);
-else
-  RAISE EXCEPTION 'Unknown test flow: %', flow_slug;
-end if;
-
-end;
-$$ language plpgsql;
-
---------------------------------------------------------------------------------
-------- poll_and_fail - polls for a task and fails it immediately --------------
---------------------------------------------------------------------------------
-create or replace function pgflow_tests.poll_and_fail(
-  flow_slug text,
-  vt integer default 1,
-  qty integer default 1
-) returns setof pgflow.step_tasks as $$
-  -- Poll for a task and complete it in one step
-  WITH task AS (
-    SELECT * FROM pgflow.poll_for_tasks(flow_slug, vt, qty) LIMIT 1
-  )
-  SELECT pgflow.fail_task(
-    (SELECT run_id FROM task),
-    (SELECT step_slug FROM task),
-    0,
-    concat(task.step_slug, ' FAILED')
-  )
-  FROM task;
-$$ language sql;
-
---------------------------------------------------------------------------------
-------- poll_and_complete - polls for a task and completes it immediately ------
---------------------------------------------------------------------------------
-create or replace function pgflow_tests.poll_and_complete(
-  flow_slug text,
-  vt integer default 1,
-  qty integer default 1
-) returns setof pgflow.step_tasks as $$
-  -- Poll for a task and complete it in one step
-  WITH task AS (
-    SELECT * FROM pgflow.poll_for_tasks(flow_slug, vt, qty) LIMIT 1
-  )
-  SELECT pgflow.complete_task(
-    (SELECT run_id FROM task),
-    (SELECT step_slug FROM task),
-    0,
-    jsonb_build_object('input', task.input)
-  )
-  FROM task;
-$$ language sql;
-
---------------------------------------------------------------------------------
-------- message_timing - returns messages with added vt_seconds int ------------
---------------------------------------------------------------------------------
-create or replace function pgflow_tests.message_timing(step_slug text, queue_name text)
-returns table (
-  msg_id bigint,
-  read_ct int,
-  enqueued_at timestamptz,
-  vt timestamptz,
-  message jsonb,
-  vt_seconds int
-)
-language plpgsql
-as $$
-DECLARE
-  qtable TEXT;
-  query TEXT;
-BEGIN
-  qtable := pgmq.format_table_name(queue_name, 'q');
-
-  query := format('
-    SELECT
-      q.msg_id,
-      q.read_ct,
-      q.enqueued_at,
-      q.vt,
-      q.message,
-      extract(epoch from (q.vt - q.enqueued_at))::int as vt_seconds
-    FROM pgmq.%s q
-    JOIN pgflow.step_tasks st ON st.message_id = q.msg_id
-    WHERE st.step_slug = $1', qtable);
-
-  RETURN QUERY EXECUTE query USING step_slug;
-END;
-$$;
-
---------------------------------------------------------------------------------
-------- reset_message_visibility -----------------------------------------------
---------------------------------------------------------------------------------
---
--- Makes all hidden messages in a queue immediately visible by setting their
--- visibility time (vt) to the current timestamp.
---
--- This is a test utility that allows testing retry logic without waiting for
--- actual delays to expire. It directly modifies the pgmq queue table.
---
--- @param queue_name The name of the queue to modify
--- @return The number of messages that were made visible
---
-create or replace function pgflow_tests.reset_message_visibility(
-  queue_name text
-) returns integer as $$
-DECLARE
-  qtable TEXT;
-  query TEXT;
-  updated_count INTEGER;
-BEGIN
-  -- Get the formatted table name for the queue
-  qtable := pgmq.format_table_name(queue_name, 'q');
-
-  -- Construct and execute the query to update all messages' visibility time
-  query := format('
-    UPDATE pgmq.%s
-    SET vt = clock_timestamp()
-    WHERE vt > clock_timestamp()
-    RETURNING 1', qtable);
-
-  -- Execute the query and count the number of updated rows
-  EXECUTE query INTO updated_count;
-
-  -- Return the number of messages that were made visible
-  RETURN COALESCE(updated_count, 0);
-END;
-$$ language plpgsql;
-
-
---------------------------------------------------------------------------------
-------- assert_retry_delay -----------------------------------------------------
---------------------------------------------------------------------------------
---
--- Asserts that the calculated retry delay matches the expected value.
---
--- @param step_slug The slug of the step to check
--- @param queue_name The name of the queue to check
--- @param expected_delay The expected delay value
--- @param description A description of the test case
--- @return TEXT result from the is() function
---
-create or replace function pgflow_tests.assert_retry_delay(
-  queue_name text,
-  step_slug text,
-  expected_delay integer,
-  description text
-) returns text as $$
-DECLARE
-  actual_delay INTEGER;
-BEGIN
-  SELECT vt_seconds INTO actual_delay
-  FROM pgflow_tests.message_timing(step_slug, queue_name)
-  LIMIT 1;
-
-  RETURN is(
-    actual_delay,
-    expected_delay,
-    description
-  );
-END;
-$$ language plpgsql;

package/supabase/tests/add_step/basic_step_addition.test.sql

@@ -1,29 +0,0 @@
-begin;
-select plan(3);
-select pgflow_tests.reset_db();
-
--- Setup
-select pgflow.create_flow('test_flow');
-
--- Test
-select pgflow.add_step('test_flow', 'first_step');
-select results_eq(
-  $$ SELECT step_slug FROM pgflow.steps WHERE flow_slug = 'test_flow' $$,
-  array['first_step']::text [],
-  'Step should be added to the steps table'
-);
-select is_empty(
-  $$ SELECT * FROM pgflow.deps WHERE flow_slug = 'test_flow' $$,
-  'No dependencies should be added for step with no dependencies'
-);
-select is(
-  (
-    select deps_count::int from pgflow.steps
-    where flow_slug = 'test_flow'
-  ),
-  0::int,
-  'deps_count should be 0 because there are no dependencies'
-);
-
-select * from finish();
-rollback;

package/supabase/tests/add_step/circular_dependency.test.sql

@@ -1,21 +0,0 @@
-begin;
-select plan(1);
-select pgflow_tests.reset_db();
-
--- Setup
-select pgflow.create_flow('test_flow');
-select pgflow.add_step('test_flow', 'first_step');
-select pgflow.add_step('test_flow', 'second_step', array['first_step']);
-select pgflow.add_step('test_flow', 'third_step', array['second_step']);
-select
-  pgflow.add_step('test_flow', 'fourth_step', array['second_step', 'third_step']);
-
--- Test
-select throws_ok(
-  $$ SELECT pgflow.add_step('test_flow', 'circular_step', ARRAY['fourth_step', 'circular_step']) $$,
-  'new row for relation "deps" violates check constraint "deps_check"',
-  'Should not allow self-depending steps'
-);
-
-select * from finish();
-rollback;

package/supabase/tests/add_step/flow_isolation.test.sql

@@ -1,26 +0,0 @@
-begin;
-select plan(1);
-select pgflow_tests.reset_db();
-
--- Setup
-select pgflow.create_flow('test_flow');
-select pgflow.add_step('test_flow', 'first_step');
-select pgflow.create_flow('another_flow');
-
--- Test
-select pgflow.add_step('another_flow', 'first_step');
-select pgflow.add_step('another_flow', 'another_step', array['first_step']);
-select set_eq(
-  $$
-      SELECT flow_slug, step_slug
-      FROM pgflow.steps WHERE flow_slug = 'another_flow'
-    $$,
-  $$ VALUES
-       ('another_flow', 'another_step'),
-       ('another_flow', 'first_step')
-    $$,
-  'Steps in second flow should be isolated from first flow'
-);
-
-select * from finish();
-rollback;

package/supabase/tests/add_step/idempotent_step_addition.test.sql

@@ -1,20 +0,0 @@
-begin;
-select plan(1);
-select pgflow_tests.reset_db();
-
--- Setup
-select pgflow.create_flow('test_flow');
-select pgflow.add_step('test_flow', 'first_step');
-
--- Test
-select pgflow.add_step('test_flow', 'first_step');
-select results_eq(
-  $$
-      SELECT count(*)::int FROM pgflow.steps WHERE flow_slug = 'test_flow' AND step_slug = 'first_step'
-    $$,
-  array[1]::int [],
-  'Calling add_step again for same step does not create a duplicate'
-);
-
-select * from finish();
-rollback;

package/supabase/tests/add_step/invalid_step_slug.test.sql

@@ -1,16 +0,0 @@
-begin;
-select plan(1);
-select pgflow_tests.reset_db();
-
--- Setup
-select pgflow.create_flow('test_flow');
-
--- Test
-select throws_ok(
-  $$ SELECT pgflow.add_step('test_flow', '1invalid-slug') $$,
-  'new row for relation "steps" violates check constraint "steps_step_slug_check"',
-  'Should detect and prevent invalid step slug'
-);
-
-select * from finish();
-rollback;

package/supabase/tests/add_step/nonexistent_dependency.test.sql

@@ -1,16 +0,0 @@
-begin;
-select plan(1);
-select pgflow_tests.reset_db();
-
--- Setup
-select pgflow.create_flow('test_flow');
-
--- Test
-select throws_ok(
-  $$ SELECT pgflow.add_step('test_flow', 'invalid_dep_step', ARRAY['nonexistent_step']) $$,
-  'insert or update on table "deps" violates foreign key constraint "deps_flow_slug_dep_slug_fkey"',
-  'Should detect and prevent dependency on non-existent step'
-);
-
-select * from finish();
-rollback;

package/supabase/tests/add_step/nonexistent_flow.test.sql

@@ -1,13 +0,0 @@
-begin;
-select plan(1);
-select pgflow_tests.reset_db();
-
--- Test
-select throws_ok(
-  $$ SELECT pgflow.add_step('nonexistent_flow', 'some_step') $$,
-  'insert or update on table "steps" violates foreign key constraint "steps_flow_slug_fkey"',
-  'Should not allow adding step to non-existent flow'
-);
-
-select * from finish();
-rollback;

package/supabase/tests/add_step/options.test.sql

@@ -1,66 +0,0 @@
-begin;
-select plan(6);
-select pgflow_tests.reset_db();
-
--- SETUP: Create flow with steps
-select pgflow.create_flow('test_flow');
-select pgflow.add_step('test_flow', 'default_options');
-select pgflow.add_step('test_flow', 'overriden_max_attempts', max_attempts => 20);
-select pgflow.add_step('test_flow', 'overriden_base_delay', base_delay => 30);
-select pgflow.add_step('test_flow', 'overriden_timeout', timeout => 30);
-
--- TEST: opt_max_attempts, opt_base_delay and opt_timeout are NULL by default
-select results_eq(
-  $$ SELECT opt_max_attempts is null, opt_base_delay is null, opt_timeout is null
-     FROM pgflow.steps
-     WHERE step_slug = 'default_options' $$,
-  $$ VALUES (true, true, true) $$,
-  'opt_max_attempts, opt_base_delay and opt_timeout are NULL by default'
-);
-
--- TEST: opt_max_attempts can be set
-select is(
-  (select opt_max_attempts from pgflow.steps where step_slug = 'overriden_max_attempts'),
-  20,
-  'opt_max_attempts can be set'
-);
-
--- TEST: opt_base_delay can be set
-select is(
-  (select opt_base_delay from pgflow.steps where step_slug = 'overriden_base_delay'),
-  30,
-  'opt_base_delay can be set'
-);
-
--- TEST: opt_timeout can be set
-select is(
-  (select opt_timeout from pgflow.steps where step_slug = 'overriden_timeout'),
-  30,
-  'opt_timeout can be set'
-);
-
--- SETUP: Add same step again to make sure it doesnt get updated
-select pgflow.add_step('test_flow', 'added_twice', max_attempts => 10, base_delay => 15, timeout => 90);
-select pgflow.add_step('test_flow', 'added_twice', max_attempts => 20, base_delay => 30, timeout => 30);
-
---TEST: Should not update opt_max_attempts, opt_base_delay and opt_timeout
-select results_eq(
-  $$ SELECT opt_max_attempts, opt_base_delay, opt_timeout FROM pgflow.steps WHERE step_slug = 'added_twice' $$,
-  $$ VALUES (10, 15, 90) $$,
-  'Should not update opt_max_attempts, opt_base_delay and opt_timeout'
-);
-
--- SETUP: Add step defined with default values again to make sure it doesnt get updated
-select pgflow.add_step('test_flow', 'default_options', max_attempts => 0, base_delay => 15, timeout => 90);
-
--- TEST: Should not update opt_max_attempts, opt_base_delay and opt_timeout
-select results_eq(
-  $$ SELECT opt_max_attempts is null, opt_base_delay is null, opt_timeout is null 
-     FROM pgflow.steps 
-     WHERE step_slug = 'default_options' $$,
-  $$ VALUES (true, true, true) $$,
-  'Should not update opt_max_attempts, opt_base_delay and opt_timeout for step with default values'
-);
-
-select * from finish();
-rollback;

package/supabase/tests/add_step/step_with_dependency.test.sql

@@ -1,36 +0,0 @@
-begin;
-select plan(3);
-select pgflow_tests.reset_db();
-
--- Setup
-select pgflow.create_flow('test_flow');
-select pgflow.add_step('test_flow', 'first_step');
-
--- Test
-select pgflow.add_step('test_flow', 'second_step', array['first_step']);
-select results_eq(
-  $$ SELECT step_slug FROM pgflow.steps WHERE flow_slug = 'test_flow' ORDER BY step_slug $$,
-  array['first_step', 'second_step']::text [],
-  'Second step should be added to the steps table'
-);
-select is(
-  (
-    select deps_count::int
-    from pgflow.steps
-    where flow_slug = 'test_flow' and step_slug = 'second_step'
-  ),
-  1::int,
-  'deps_count should be 1 because "second_step" has one dependency'
-);
-select results_eq(
-  $$
-      SELECT dep_slug, step_slug
-      FROM pgflow.deps WHERE flow_slug = 'test_flow'
-      ORDER BY dep_slug, step_slug
-    $$,
-  $$ VALUES ('first_step', 'second_step') $$,
-  'Dependency should be recorded in deps table'
-);
-
-select * from finish();
-rollback;

package/supabase/tests/add_step/step_with_multiple_dependencies.test.sql

@@ -1,46 +0,0 @@
-begin;
-select plan(3);
-select pgflow_tests.reset_db();
-
--- Setup
-select pgflow.create_flow('test_flow');
-select pgflow.add_step('test_flow', 'first_step');
-select pgflow.add_step('test_flow', 'second_step', array['first_step']);
-
--- Test
-select pgflow.add_step('test_flow', 'third_step', array['second_step']);
-select
-  pgflow.add_step('test_flow', 'fourth_step', array['second_step', 'third_step']);
-select results_eq(
-  $$
-      SELECT step_slug FROM pgflow.steps WHERE flow_slug = 'test_flow' ORDER BY step_slug
-    $$,
-  array['first_step', 'fourth_step', 'second_step', 'third_step']::text [],
-  'All steps should be in the steps table'
-);
-select is(
-  (
-    select deps_count::int
-    from pgflow.steps
-    where flow_slug = 'test_flow' and step_slug = 'fourth_step'
-  ),
-  2::int,
-  'deps_count should be 2 because "fourth_step" have two dependencies'
-);
-select set_eq(
-  $$
-      SELECT dep_slug, step_slug
-      FROM pgflow.deps
-      WHERE flow_slug = 'test_flow'
-    $$,
-  $$ VALUES
-       ('first_step', 'second_step'),
-       ('second_step', 'third_step'),
-       ('second_step', 'fourth_step'),
-       ('third_step', 'fourth_step')
-    $$,
-  'All dependencies should be correctly recorded'
-);
-
-select * from finish();
-rollback;