@pgflow/core 0.0.5 → 0.0.7

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

@@ -1,39 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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;

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

@@ -1,25 +0,0 @@
-begin;
-select plan(2);
-select pgflow_tests.reset_db();
-select pgflow_tests.setup_flow('sequential');
-select pgflow_tests.setup_flow('sequential_other');
-
--- SETUP: Start a flow run
-select pgflow.start_flow('sequential', '"hello"'::jsonb);
-
--- TEST: All step states from flow should be created
-select set_eq(
-  $$ SELECT step_slug
-       FROM pgflow.step_states WHERE flow_slug = 'sequential' $$,
-  array['first', 'second', 'last']::text [],
-  'All step states from flow should be created'
-);
-
--- TEST: No steps from other flows should be created
-select is_empty(
-  $$ SELECT * FROM pgflow.step_states WHERE flow_slug <> 'sequential' $$,
-  'No steps from other flows should be created'
-);
-
-select finish();
-rollback;

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

@@ -1,54 +0,0 @@
-begin;
-select plan(5);
-select pgflow_tests.reset_db();
-select pgflow_tests.setup_flow('two_roots');
-
-select pgflow.start_flow('two_roots', '"hello"'::jsonb);
-
--- TEST: A step_task record should be created only for the root step
-select is(
-  (
-    select
-      array_agg(
-        step_slug
-        order by step_slug
-      )
-    from pgflow.step_tasks
-    where flow_slug = 'two_roots'
-  ),
-  array['root_a', 'root_b']::text [],
-  'A step_task record should be created for each root step'
-);
-
--- TEST: Two messages should be in the queue, one per each root step
-select is(
-  (select count(*)::int from pgmq.q_two_roots),
-  2::int,
-  'Two messages should be in the queue, one per each root step'
-);
-
--- TEST; Messages have appropriate flow slugs
-select is(
-  (select array_agg(message ->> 'flow_slug') from pgmq.q_two_roots),
-  array['two_roots', 'two_roots'],
-  'Messages have appropriate flow slugs'
-);
-
--- TEST: Messages have appropriate step slugs
-select is(
-  (select array_agg(message ->> 'step_slug') from pgmq.q_two_roots),
-  array['root_a', 'root_b']::text [],
-  'Messages have appropriate step slugs'
-);
-
-select is(
-  (select array_agg(message ->> 'run_id') from pgmq.q_two_roots),
-  (
-    select array_agg(run_id::text) from pgflow.step_tasks
-    where flow_slug = 'two_roots'
-  ),
-  'Messages have appropriate run_ids'
-);
-
-select finish();
-rollback;

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

@@ -1,24 +0,0 @@
-begin;
-select plan(2);
-select pgflow_tests.reset_db();
-select pgflow_tests.setup_flow('sequential');
-select pgflow_tests.setup_flow('two_roots');
-
--- TEST: start_flow() returns started step states
-select results_eq(
-  $$ SELECT flow_slug, status, input
-       FROM pgflow.start_flow('sequential', '"hello"'::jsonb) $$,
-  $$ VALUES ('sequential', 'started', '"hello"'::jsonb) $$,
-  'start_flow() should return a run'
-);
-
--- TEST: start_flow() returns started step states
-select results_eq(
-  $$ SELECT flow_slug, status, input
-       FROM pgflow.start_flow('sequential', '"world"'::jsonb) $$,
-  $$ VALUES ('sequential', 'started', '"world"'::jsonb) $$,
-  'start_flow() should return a single run even for flow that have two root steps'
-);
-
-select finish();
-rollback;

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

@@ -1,50 +0,0 @@
-begin;
-select plan(2);
-select pgflow_tests.reset_db();
-select pgflow_tests.setup_flow('sequential');
-
-select pgflow.start_flow('sequential', '"hello"'::jsonb);
-
--- TEST: A step_task record should be created only for the root step
-select is(
-  (
-    select
-      array_agg(
-        step_slug
-        order by step_slug
-      )
-    from pgflow.step_tasks
-    where flow_slug = 'sequential'
-  ),
-  array['first']::text [],
-  'A step_task record should be created only for the root step'
-);
-
--- TEST: The message in the queue should contain the correct step info
-select is(
-  (
-    select q.message
-    from pgflow.step_tasks as st
-      inner join pgmq.q_sequential as q
-        on st.message_id = q.msg_id
-    where
-      st.flow_slug = 'sequential'
-      and st.step_slug = 'first'
-  ),
-  jsonb_build_object(
-    'flow_slug', 'sequential',
-    'run_id', (
-      select run_id
-      from pgflow.step_tasks
-      where
-        flow_slug = 'sequential'
-        and step_slug = 'first'
-    ),
-    'step_slug', 'first',
-    'task_index', 0
-  ),
-  'The message in the queue should contain the correct step info'
-);
-
-select finish();
-rollback;