@pgflow/core 0.0.5-prealpha.2

package/supabase/tests/fail_task/mark_as_failed_if_no_retries_available.test.sql

@@ -0,0 +1,49 @@
+begin;
+select plan(5);
+select pgflow_tests.reset_db();
+
+-- SETUP
+select pgflow.create_flow('with_retry');
+select pgflow.add_step('with_retry', 'first', max_attempts => 0, base_delay => 0);
+select pgflow.start_flow('with_retry', '{"test": true}'::JSONB);
+
+-- max_attempts is 0, so failing once should mark the task as failed
+select pgflow_tests.poll_and_fail('with_retry');
+
+-- TEST: The task should be queued
+select is(
+  (select status from pgflow.step_tasks where flow_slug = 'with_retry' and step_slug = 'first'),
+  'failed',
+  'The task should be failed'
+);
+
+-- TEST: The task should have null error_message
+select is(
+  (select error_message from pgflow.step_tasks where flow_slug = 'with_retry' and step_slug = 'first'),
+  'first FAILED',
+  'The task should have attempts_count incremented'
+);
+
+-- TEST: The task's message should be in the queue
+select is(
+  (select count(*)::INT from pgmq.q_with_retry),
+  0,
+  'There should be no messages in the queue'
+);
+
+-- TEST: The step should be marked as failed
+select is(
+  (select status from pgflow.step_states where flow_slug = 'with_retry' and step_slug = 'first' limit 1),
+  'failed',
+  'The step should be marked as failed'
+);
+
+-- TEST: The run should be marked as failed
+select is(
+  (select status from pgflow.runs where flow_slug = 'with_retry' limit 1),
+  'failed',
+  'The run should be marked as failed'
+);
+
+select finish();
+rollback;

package/supabase/tests/fail_task/respects_flow_retry_settings.test.sql

@@ -0,0 +1,48 @@
+begin;
+select plan(3);
+select pgflow_tests.reset_db();
+
+-- SETUP: Create a flow with custom retry settings
+select pgflow.create_flow('custom_retry', max_attempts => 2, base_delay => 0);
+select pgflow.add_step('custom_retry', 'test_step');
+
+-- Start the flow
+select pgflow.start_flow('custom_retry', '{"test": true}'::JSONB);
+
+-- Fail the task first time
+select pgflow_tests.poll_and_fail('custom_retry');
+
+-- TEST: The task should be queued (first retry)
+select is(
+  (select status from pgflow.step_tasks limit 1),
+  'queued',
+  'Task should be queued after first failure (1st attempt of 2)'
+);
+
+-- Fail the task second time
+select pgflow_tests.poll_and_fail('custom_retry');
+
+-- TEST: The task should be queued (second retry)
+select is(
+  (
+    select status from pgflow.step_tasks
+    where
+      run_id = (select run_id from pgflow.runs where flow_slug = 'custom_retry')
+      and step_slug = 'test_step'
+  ),
+  'failed',
+  'Task should be failed after second failure (2nd attempt of 2)'
+);
+
+-- TEST: The run should be failed
+select is(
+  (
+    select status from pgflow.runs
+    where flow_slug = 'custom_retry'
+  ),
+  'failed',
+  'Run should be failed after exceeding retry limit'
+);
+
+select finish();
+rollback;

package/supabase/tests/fail_task/respects_step_retry_settings.test.sql

@@ -0,0 +1,48 @@
+begin;
+select plan(3);
+select pgflow_tests.reset_db();
+
+-- SETUP: Create a flow with custom retry settings
+select pgflow.create_flow('custom_retry', max_attempts => 10, base_delay => 10);
+select pgflow.add_step('custom_retry', 'test_step', max_attempts => 2, base_delay => 0);
+
+-- Start the flow
+select pgflow.start_flow('custom_retry', '{"test": true}'::JSONB);
+
+-- Fail the task first time
+select pgflow_tests.poll_and_fail('custom_retry');
+
+-- TEST: The task should be queued (first retry)
+select is(
+  (select status from pgflow.step_tasks limit 1),
+  'queued',
+  'Task should be queued after first failure (1st attempt of 2)'
+);
+
+-- Fail the task second time
+select pgflow_tests.poll_and_fail('custom_retry');
+
+-- TEST: The task should be queued (second retry)
+select is(
+  (
+    select status from pgflow.step_tasks
+    where
+      run_id = (select run_id from pgflow.runs where flow_slug = 'custom_retry')
+      and step_slug = 'test_step'
+  ),
+  'failed',
+  'Task should be failed after second failure (2nd attempt of 2)'
+);
+
+-- TEST: The run should be failed
+select is(
+  (
+    select status from pgflow.runs
+    where flow_slug = 'custom_retry'
+  ),
+  'failed',
+  'Run should be failed after exceeding retry limit'
+);
+
+select finish();
+rollback;

package/supabase/tests/fail_task/retry_task_if_retries_available.test.sql

@@ -0,0 +1,39 @@
+begin;
+select plan(4);
+select pgflow_tests.reset_db();
+select pgflow_tests.setup_flow('sequential');
+
+-- SETUP
+select pgflow.start_flow('sequential', '{"test": true}'::JSONB);
+select pgflow_tests.poll_and_fail('sequential');
+
+-- TEST: The task should be queued
+select is(
+  (select status from pgflow.step_tasks where flow_slug = 'sequential' and step_slug = 'first'),
+  'queued',
+  'The task should be queued'
+);
+
+-- TEST: The task should have attempts_count incremented
+select is(
+  (select attempts_count from pgflow.step_tasks where flow_slug = 'sequential' and step_slug = 'first'),
+  1,
+  'The task should have attempts_count incremented'
+);
+
+-- TEST: The task should have null error_message
+select is(
+  (select error_message from pgflow.step_tasks where flow_slug = 'sequential' and step_slug = 'first'),
+  'first FAILED',
+  'The task should have attempts_count incremented'
+);
+
+-- TEST: The task's message should be in the queue
+select is(
+  (select message ->> 'step_slug' from pgmq.q_sequential limit 1),
+  'first',
+  'The task''s message should be in the queue'
+);
+
+select finish();
+rollback;

package/supabase/tests/is_valid_slug.test.sql

@@ -0,0 +1,72 @@
+begin;
+select plan(11);
+select pgflow_tests.reset_db();
+
+-- TEST: Null input
+select ok(
+  not pgflow.is_valid_slug(null),
+  'is_valid_slug returns false for NULL input'
+);
+
+-- TEST: Empty string
+select ok(
+  not pgflow.is_valid_slug(''),
+  'is_valid_slug returns false for empty string'
+);
+
+-- TEST: Too long string (128+ chars)
+select ok(
+  not pgflow.is_valid_slug(repeat('x', 129)),
+  'is_valid_slug returns false for strings longer than 128 chars'
+);
+
+-- TEST: String with dashes
+select ok(
+  not pgflow.is_valid_slug('test-slug'),
+  'is_valid_slug returns false for strings with dashes'
+);
+
+-- TEST: String with spaces
+select ok(
+  not pgflow.is_valid_slug('test slug'),
+  'is_valid_slug returns false for strings with spaces'
+);
+
+-- TEST: String starting with number
+select ok(
+  not pgflow.is_valid_slug('123test'),
+  'is_valid_slug returns false for strings starting with numbers'
+);
+
+-- TEST: Valid single word
+select ok(
+  pgflow.is_valid_slug('valid'),
+  'is_valid_slug returns true for single word'
+);
+
+-- TEST: Valid with underscore
+select ok(
+  pgflow.is_valid_slug('valid_slug'),
+  'is_valid_slug returns true for string with underscore'
+);
+
+-- TEST: Valid with numbers (not at start)
+select ok(
+  pgflow.is_valid_slug('valid123'),
+  'is_valid_slug returns true for string with numbers not at start'
+);
+
+-- TEST: Valid mixed case
+select ok(
+  pgflow.is_valid_slug('validSlug'),
+  'is_valid_slug returns true for mixed case string'
+);
+
+-- TEST:
+select ok(
+  not pgflow.is_valid_slug('run'),
+  'is_valid_slug returns false for reserved word'
+);
+
+select finish();
+rollback;

package/supabase/tests/poll_for_tasks/builds_proper_input_from_deps_outputs.test.sql

@@ -0,0 +1,35 @@
+begin;
+select plan(1);
+select pgflow_tests.reset_db();
+select pgflow_tests.setup_flow('two_roots');
+
+-- Start the flow and complete the root steps
+select pgflow.start_flow('two_roots', '"root input"'::jsonb);
+select pgflow.poll_for_tasks('two_roots', 1, 2);
+select pgflow.complete_task(
+  (select run_id from pgflow.runs limit 1),
+  'root_a',
+  0,
+  '"root_a output"'::jsonb
+);
+select pgflow.complete_task(
+  (select run_id from pgflow.runs limit 1),
+  'root_b',
+  0,
+  '"root_b output"'::jsonb
+);
+
+-- TEST: Verify that the queued message have the proper input
+select is(
+  (select input from pgflow.poll_for_tasks('two_roots', 1, 1)),
+  jsonb_build_object(
+    'run', 'root input',
+    'root_a', 'root_a output',
+    'root_b', 'root_b output'
+  )
+);
+
+select finish();
+rollback;
+
+select '"yolox"'::jsonb @> '"yolo"'::jsonb;

package/supabase/tests/poll_for_tasks/hides_messages.test.sql

@@ -0,0 +1,35 @@
+begin;
+select * from plan(2);
+select pgflow_tests.reset_db();
+select pgflow_tests.setup_flow('sequential');
+
+-- SETUP: Start a flow run which will put a single task in the queue
+select pgflow.start_flow('sequential', '"hello"'::jsonb);
+
+-- TEST: Poll a single task with big visibility timeout (vt = 10)
+select is(
+  (select count(*)::integer from pgflow.poll_for_tasks(
+    queue_name => 'sequential'::text,
+    vt => 5,
+    qty => 1,
+    max_poll_seconds => 1
+  )),
+  1::integer,
+  'First poll should get the available task'
+);
+
+-- TEST: Immediate second poll (simulating concurrent access) should get nothing
+-- because the message is hidden with vt=5
+select is(
+  (select count(*)::integer from pgflow.poll_for_tasks(
+    queue_name => 'sequential'::text,
+    vt => 5,
+    qty => 1,
+    max_poll_seconds => 1
+  )),
+  0::integer,
+  'Concurrent poll should not get the same task (due to visibility timeout)'
+);
+
+select * from finish();
+rollback;

package/supabase/tests/poll_for_tasks/increments_attempts_count.test.sql

@@ -0,0 +1,35 @@
+begin;
+select plan(2);
+select pgflow_tests.reset_db();
+
+select pgflow.create_flow('simple', max_attempts => 3, base_delay => 0);
+select pgflow.add_step('simple', 'first');
+select pgflow.add_step('simple', 'last');
+select pgflow.start_flow('simple', '"hello"'::jsonb);
+
+-- SETUP: poll twice, first fialing them completing
+select pgflow_tests.poll_and_fail('simple', 1, 1);
+select pgflow_tests.poll_and_complete('simple', 1, 1);
+
+-- TEST: polling increments, regardless of failure/completion
+select is(
+  (select attempts_count::int from pgflow.step_tasks where step_slug = 'first'),
+  2,
+  'Polling a task should increment its attempts_count, regardless of status'
+);
+
+-- SETUP:
+select pgflow_tests.poll_and_fail('simple', 1, 1);
+select pgflow_tests.poll_and_fail('simple', 1, 1);
+select pgflow_tests.poll_and_fail('simple', 1, 1);
+
+-- TEST: polling increments, regardless of failure/completion
+select is(
+  (select attempts_count::int from pgflow.step_tasks where step_slug = 'last'),
+  3,
+  'Polling a task should increment its attempts_count'
+);
+
+
+select finish();
+rollback;

package/supabase/tests/poll_for_tasks/multiple_task_processing.test.sql

@@ -0,0 +1,24 @@
+begin;
+select plan(1);
+select pgflow_tests.reset_db();
+select pgflow_tests.setup_flow('sequential');
+
+-- SETUP: Start multiple flow runs which will put multiple tasks in the queue
+select pgflow.start_flow('sequential', '{"id": 1}'::jsonb);
+select pgflow.start_flow('sequential', '{"id": 2}'::jsonb);
+select pgflow.start_flow('sequential', '{"id": 3}'::jsonb);
+
+-- TEST: Poll multiple tasks at once (qty = 3)
+select is(
+  (select count(*)::integer from pgflow.poll_for_tasks(
+    queue_name => 'sequential'::text,
+    vt => 5,
+    qty => 3,
+    max_poll_seconds => 1
+  )),
+  3::integer,
+  'Should return 3 tasks when qty=3 and 3 tasks are available'
+);
+
+select finish();
+rollback;

package/supabase/tests/poll_for_tasks/polls_only_queued_tasks.test.sql

@@ -0,0 +1,35 @@
+begin;
+select plan(1);
+select pgflow_tests.reset_db();
+select pgflow_tests.setup_flow('sequential');
+
+-- This is a regression test for a bug that was showing up when messages
+-- were not archived properly after being completed
+-- It manifested as completed tasks being updated to 'started'
+
+-- SETUP: Start a flow, poll and complete the first task
+select pgflow.start_flow('sequential', '"hello"'::jsonb);
+select pgflow.poll_for_tasks('sequential'::text, 0, 1);
+select pgflow.complete_task(
+  (
+    select run_id
+    from pgflow.runs
+    where flow_slug = 'sequential'
+    order by run_id
+    limit 1
+  ),
+  'first',
+  0,
+  '"first completed"'::jsonb
+);
+select pgflow.poll_for_tasks('sequential'::text, 0, 1);
+
+-- TEST: Already completed tasks should not be changed
+select is(
+  (select status from pgflow.step_tasks where step_slug = 'first'),
+  'completed',
+  'Already completed task should not be changed'
+);
+
+select finish();
+rollback;

package/supabase/tests/poll_for_tasks/reads_messages.test.sql

@@ -0,0 +1,38 @@
+begin;
+select plan(1);
+select pgflow_tests.reset_db();
+select pgflow_tests.setup_flow('sequential');
+
+-- SETUP: Start a flow run
+select pgflow.start_flow('sequential', '"hello"'::jsonb);
+
+-- Prepare the actual query
+PREPARE actual AS
+SELECT flow_slug, run_id, step_slug, input, msg_id
+FROM pgflow.poll_for_tasks (
+queue_name => 'sequential',
+vt => 1,
+qty => 1
+)
+LIMIT 1 ;
+
+-- Prepare the expected result
+PREPARE expected AS
+SELECT 'sequential'::text AS flow_slug,
+(SELECT run_id FROM pgflow.runs WHERE flow_slug = 'sequential' LIMIT 1) AS run_id,
+'first'::text AS step_slug,
+jsonb_build_object ('run', 'hello')::jsonb AS input,
+(SELECT message_id FROM pgflow.step_tasks
+WHERE flow_slug = 'sequential'
+AND step_slug = 'first'
+LIMIT 1) AS msg_id ;
+
+-- Compare the results
+SELECT results_eq (
+'actual',
+'expected',
+'poll_for_tasks() returns the expected worker task'
+) ;
+
+SELECT finish () ;
+ROLLBACK ;

package/supabase/tests/poll_for_tasks/returns_no_tasks_if_no_step_task_for_message.test.sql

@@ -0,0 +1,34 @@
+begin;
+select * from plan(1);
+select pgflow_tests.reset_db();
+select pgflow_tests.setup_flow('sequential');
+
+-- SETUP: Start a flow run which will put a task in the queue
+select * from pgflow.start_flow('sequential', '{"id": 1}'::jsonb);
+
+-- Manually delete a step_task but keep the message in the queue
+-- This simulates an inconsistent state where a message exists
+-- but there's no corresponding step_task
+delete from pgflow.step_tasks
+where
+  run_id = (
+    select run_id from pgflow.runs
+    where flow_slug = 'sequential' limit 1
+  )
+  and step_slug = 'first';
+
+-- TEST: Polling should not return tasks for missing step_tasks
+-- even though messages might exist in the queue
+select is(
+  (select count(*)::integer from pgflow.poll_for_tasks(
+    queue_name => 'sequential'::text,
+    vt => 5,
+    qty => 1,
+    max_poll_seconds => 1
+  )),
+  0::integer,
+  'Should not return tasks when step_tasks row is missing'
+);
+
+select * from finish();
+rollback;

package/supabase/tests/poll_for_tasks/returns_no_tasks_if_queue_is_empty.test.sql

@@ -0,0 +1,19 @@
+begin;
+select * from plan(1);
+select pgflow_tests.reset_db();
+select pgflow_tests.setup_flow('sequential');
+
+-- TEST: Polling from an empty queue returns no tasks
+select is(
+  (select count(*)::integer from pgflow.poll_for_tasks(
+    queue_name => 'sequential'::text,
+    vt => 5,
+    qty => 10,
+    max_poll_seconds => 1
+  )),
+  0::integer,
+  'Should return no tasks when queue is empty'
+);
+
+select * from finish();
+rollback;

package/supabase/tests/poll_for_tasks/returns_no_tasks_when_qty_set_to_0.test.sql

@@ -0,0 +1,22 @@
+begin;
+select * from plan(1);
+select pgflow_tests.reset_db();
+select pgflow_tests.setup_flow('sequential');
+
+-- SETUP: Start a flow run which will put a task in the queue
+select pgflow.start_flow('sequential', '{"id": 1}'::jsonb);
+
+-- TEST: Calling with qty = 0 should return no tasks
+select is(
+  (select count(*)::integer from pgflow.poll_for_tasks(
+    queue_name => 'sequential'::text,
+    vt => 5,
+    qty => 0,
+    max_poll_seconds => 1
+  )),
+  0::integer,
+  'Should return no tasks when qty=0'
+);
+
+select * from finish();
+rollback;

package/supabase/tests/poll_for_tasks/sets_vt_delay_based_on_opt_timeout.test.sql

@@ -0,0 +1,41 @@
+begin;
+select * from plan(3);
+select pgflow_tests.reset_db();
+
+-- Create a flow with two root steps, each with different opt_timeout values
+select pgflow.create_flow('timeout_test', timeout => 60);
+select pgflow.add_step('timeout_test', 'step_with_flow_timeout');
+select pgflow.add_step('timeout_test', 'step_30', timeout => 30);
+select pgflow.add_step('timeout_test', 'step_45', timeout => 45);
+
+-- Start the flow which will create tasks for both root steps
+select pgflow.start_flow('timeout_test', '"test_input"'::jsonb);
+
+-- Poll for both tasks (qty=2)
+select * from pgflow.poll_for_tasks('timeout_test', vt => 1, qty => 999);
+
+-- Assert that vt_delay is set to opt_timeout + 2 for each step
+select pgflow_tests.assert_retry_delay(
+  'timeout_test',
+  'step_30',
+  32, -- 30 + 2
+  'step_30 should have vt_delay set to opt_timeout (30) + 2 seconds'
+);
+
+select pgflow_tests.assert_retry_delay(
+  'timeout_test',
+  'step_45',
+  47, -- 45 + 2
+  'step_45 should have vt_delay set to opt_timeout (45) + 2 seconds'
+);
+
+-- Assert that by default it will use flow opt_timeout + 2 if not overridden
+select pgflow_tests.assert_retry_delay(
+  'timeout_test',
+  'step_with_flow_timeout',
+  62, -- 60 + 2
+  'step_with_flow_timeout should have vt_delay set to flow opt_timeout (60) + 2 seconds'
+);
+
+select * from finish();
+rollback;

package/supabase/tests/poll_for_tasks/tasks_reapppear_if_not_processed_in_time.test.sql

@@ -0,0 +1,59 @@
+begin;
+select * from plan(4);
+select pgflow_tests.reset_db();
+select pgflow_tests.setup_flow('sequential');
+
+-- SETUP: Start a flow run which will put a single task in the queue
+select pgflow.start_flow('sequential', '"hello"'::jsonb);
+
+-- TEST: Poll a single task 
+select is(
+  (select count(*)::integer from pgflow.poll_for_tasks(
+    queue_name => 'sequential'::text,
+    vt => 1,
+    qty => 1,
+    max_poll_seconds => 1
+  )),
+  1::integer,
+  'First poll should get the available task'
+);
+
+-- TEST: Second poll before vt expires should not get the task
+select is(
+  (select count(*)::integer from pgflow.poll_for_tasks(
+    queue_name => 'sequential'::text,
+    vt => 1,
+    qty => 1,
+    max_poll_seconds => 1
+  )),
+  0::integer,
+  'Second poll before vt expires should not get the task'
+);
+
+-- Wait longer than the visibility timeout
+select pg_sleep(2);
+
+-- TEST: Second poll should get the task again because visibility timeout expired
+select is(
+  (select count(*)::integer from pgflow.poll_for_tasks(
+    queue_name => 'sequential'::text,
+    vt => 1,
+    qty => 1,
+    max_poll_seconds => 1
+  )),
+  1::integer,
+  'Second poll should get the task again after visibility timeout expired'
+);
+
+-- Verify the task was re-polled (should be the same task)
+select is(
+  (
+    select status from pgflow.step_tasks
+    where flow_slug = 'sequential' and step_slug = 'first'
+  ),
+  'queued',
+  'The task should be queued'
+);
+
+select * from finish();
+rollback;

package/supabase/tests/start_flow/creates_run.test.sql

@@ -0,0 +1,24 @@
+begin;
+select plan(2);
+select pgflow_tests.reset_db();
+select pgflow_tests.setup_flow('sequential');
+
+-- SETUP: Start a flow run
+select pgflow.start_flow('sequential', '"hello"'::jsonb);
+
+-- TEST: Run should be created
+select results_eq(
+  $$ SELECT flow_slug, status, input from pgflow.runs $$,
+  $$ VALUES ('sequential', 'started', '"hello"'::jsonb) $$,
+  'Run should be created with appropriate status and input'
+);
+
+-- TEST: remaining_steps should be equal to number of steps
+select is(
+  (select remaining_steps::int from pgflow.runs limit 1),
+  3::int,
+  'remaining_steps should be equal to number of steps'
+);
+
+select finish();
+rollback;