@pgflow/core 0.0.5-prealpha.2

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

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

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

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

package/supabase/tests/complete_task/archives_message.test.sql

@@ -0,0 +1,67 @@
+begin;
+select plan(5);
+select pgflow_tests.reset_db();
+select pgflow_tests.setup_flow('sequential');
+
+-- SETUP
+select pgflow.start_flow('sequential', '{"test": true}'::JSONB);
+
+-- TEST: First message shoud be in the queue
+select is(
+  (select message ->> 'step_slug' from pgmq.q_sequential limit 1),
+  'first',
+  'First message should be in the queue'
+);
+
+-- SETUP
+select pgflow.complete_task(
+  (select run_id from pgflow.runs limit 1),
+  'first',
+  0,
+  '"first was successful"'::JSONB
+);
+
+-- TEST: First message shoud be archived
+select is(
+  (
+    select count(*)::INT
+    from pgmq.q_sequential
+    where message ->> 'step_slug' = 'first'
+  ),
+  0::INT,
+  'There should be no messages in the queue'
+);
+select is(
+  (
+    select count(*)::INT
+    from pgmq.a_sequential
+    where message ->> 'step_slug' = 'first'
+    limit 1
+  ),
+  1::INT,
+  'The message should be archived'
+);
+
+-- TEST: Other messages shoud not be archived
+select is(
+  (
+    select count(*)::INT
+    from pgmq.q_sequential
+    where message ->> 'step_slug' = 'second'
+  ),
+  1::INT,
+  'There should be no messages in the queue'
+);
+select is(
+  (
+    select count(*)::INT
+    from pgmq.a_sequential
+    where message ->> 'step_slug' = 'second'
+    limit 1
+  ),
+  0::INT,
+  'The other message should not be archived'
+);
+
+select finish();
+rollback;

package/supabase/tests/complete_task/completes_run_if_no_more_remaining_steps.test.sql

@@ -0,0 +1,62 @@
+begin;
+select plan(4);
+select pgflow_tests.reset_db();
+select pgflow_tests.setup_flow('sequential');
+
+-- Start the flow
+select pgflow.start_flow('sequential', '{"test": true}'::JSONB);
+
+-- TEST: Initial remaining_steps should be 3 and status should be 'started'
+select results_eq(
+  $$ SELECT remaining_steps::int, status FROM pgflow.runs LIMIT 1 $$,
+  $$ VALUES (3::int, 'started'::text) $$,
+  'Initial remaining_steps should be 3 and status should be started'
+);
+
+-- Complete the first step's task
+select pgflow.complete_task(
+  (select run_id from pgflow.runs limit 1),
+  'first',
+  0,
+  '"first was successful"'::JSONB
+);
+
+-- TEST: After completing first step, remaining_steps should be 2 and status still 'started'
+select results_eq(
+  $$ SELECT remaining_steps::int, status FROM pgflow.runs LIMIT 1 $$,
+  $$ VALUES (2::int, 'started'::text) $$,
+  'After completing first step, remaining_steps should be 2 and status still started'
+);
+
+-- Complete the second step's task
+select pgflow.complete_task(
+  (select run_id from pgflow.runs limit 1),
+  'second',
+  0,
+  '"second was successful"'::JSONB
+);
+
+-- TEST: After completing second step, remaining_steps should be 1 and status still 'started'
+select results_eq(
+  $$ SELECT remaining_steps::int, status FROM pgflow.runs LIMIT 1 $$,
+  $$ VALUES (1::int, 'started'::text) $$,
+  'After completing second step, remaining_steps should be 1 and status still started'
+);
+
+-- Complete the last step's task
+select pgflow.complete_task(
+  (select run_id from pgflow.runs limit 1),
+  'last',
+  0,
+  '"last was successful"'::JSONB
+);
+
+-- TEST: Final remaining_steps should be 0 and status should be 'completed'
+select results_eq(
+  $$ SELECT remaining_steps::int, status FROM pgflow.runs LIMIT 1 $$,
+  $$ VALUES (0::int, 'completed'::text) $$,
+  'Final remaining_steps should be 0 and status should be completed'
+);
+
+select finish();
+rollback;

package/supabase/tests/complete_task/completes_task_and_updates_dependents.test.sql

@@ -0,0 +1,64 @@
+begin;
+select plan(5);
+select pgflow_tests.reset_db();
+select pgflow_tests.setup_flow('sequential');
+
+-- Start a flow run
+select pgflow.start_flow('sequential', '"hello"'::jsonb);
+
+-- Complete the first task
+select pgflow.complete_task(
+  (select run_id from pgflow.runs limit 1),
+  'first',
+  0,
+  '{"result": "first completed"}'::jsonb
+);
+
+-- TEST: Task should be marked as completed with correct output
+select results_eq(
+  $$ SELECT status, output FROM pgflow.step_tasks
+     WHERE run_id = (SELECT run_id FROM pgflow.runs LIMIT 1)
+     AND step_slug = 'first' AND task_index = 0 $$,
+  $$ VALUES ('completed', '{"result": "first completed"}'::jsonb) $$,
+  'Task should be marked as completed with correct output'
+);
+
+-- TEST: Step state should be marked as completed
+select results_eq(
+  $$ SELECT status, remaining_tasks FROM pgflow.step_states
+     WHERE run_id = (SELECT run_id FROM pgflow.runs LIMIT 1)
+     AND step_slug = 'first' $$,
+  $$ VALUES ('completed', 0) $$,
+  'Step state should be marked as completed with no remaining tasks'
+);
+
+-- TEST: Dependent step should have remaining_deps decremented
+select results_eq(
+  $$ SELECT remaining_deps FROM pgflow.step_states
+     WHERE run_id = (SELECT run_id FROM pgflow.runs LIMIT 1)
+     AND step_slug = 'second' $$,
+  $$ VALUES (0) $$,
+  'Dependent step should have remaining_deps decremented to 0'
+);
+
+-- TEST: Dependent step task should be created and queued
+select results_eq(
+  $$ SELECT status FROM pgflow.step_tasks
+     WHERE run_id = (SELECT run_id FROM pgflow.runs LIMIT 1)
+     AND step_slug = 'second' $$,
+  $$ VALUES ('queued') $$,
+  'Dependent step task should be created and queued'
+);
+
+-- TEST: Message should be in the queue for the dependent step
+select is(
+  (
+    select count(*)::int from pgmq.q_sequential
+    where message ->> 'step_slug' = 'second'
+  ),
+  1::int,
+  'Message should be in the queue for the dependent step'
+);
+
+select finish();
+rollback;

package/supabase/tests/complete_task/decrements_remaining_steps_if_completing_step.test.sql

@@ -0,0 +1,62 @@
+begin;
+select plan(4);
+select pgflow_tests.reset_db();
+select pgflow_tests.setup_flow('sequential');
+
+-- Start the flow
+select pgflow.start_flow('sequential', '{"test": true}'::JSONB);
+
+-- TEST: Initial remaining_steps should be 3
+select is(
+  (select remaining_steps::INT from pgflow.runs limit 1),
+  3::INT,
+  'Initial remaining_steps should be 3'
+);
+
+-- Complete the first step's task
+select pgflow.complete_task(
+  (select run_id from pgflow.runs limit 1),
+  'first',
+  0,
+  '{"result": "success"}'::JSONB
+);
+
+-- TEST: After completing first step, remaining_steps should be 2
+select is(
+  (select remaining_steps::INT from pgflow.runs limit 1),
+  2::INT,
+  'After completing first step, remaining_steps should be 2'
+);
+
+-- Complete the second step's task
+select pgflow.complete_task(
+  (select run_id from pgflow.runs limit 1),
+  'second',
+  0,
+  '{"result": "success"}'::JSONB
+);
+
+-- TEST: After completing second step, remaining_steps should be 1
+select is(
+  (select remaining_steps::INT from pgflow.runs limit 1),
+  1::INT,
+  'After completing second step, remaining_steps should be 1'
+);
+
+-- Complete the last step's task
+select pgflow.complete_task(
+  (select run_id from pgflow.runs limit 1),
+  'last',
+  0,
+  '{"result": "success"}'::JSONB
+);
+
+-- TEST: Final remaining_steps should be 0
+select is(
+  (select remaining_steps::INT from pgflow.runs limit 1),
+  0::INT,
+  'Final remaining_steps should be 0'
+);
+
+select finish();
+rollback;

package/supabase/tests/complete_task/saves_output_when_completing_run.test.sql

@@ -0,0 +1,57 @@
+begin;
+select plan(2);
+select pgflow_tests.reset_db();
+select pgflow_tests.setup_flow('two_roots_left_right');
+
+-- Start the flow
+select pgflow.start_flow('two_roots_left_right', '"hello"'::JSONB);
+
+-- Complete all the steps
+select pgflow.complete_task(
+  (select run_id from pgflow.runs limit 1),
+  'connected_root',
+  0,
+  '"root successful"'::JSONB
+);
+select pgflow.complete_task(
+  (select run_id from pgflow.runs limit 1),
+  'left',
+  0,
+  '"left successful"'::JSONB
+);
+select pgflow.complete_task(
+  (select run_id from pgflow.runs limit 1),
+  'right',
+  0,
+  '"right successful"'::JSONB
+);
+select pgflow.complete_task(
+  (select run_id from pgflow.runs limit 1),
+  'disconnected_root',
+  0,
+  '"disconnected successful"'::JSONB
+);
+
+-- TEST: Make sure that run is completed
+select results_eq(
+  $$ SELECT status::text, remaining_steps::int FROM pgflow.runs LIMIT 1 $$,
+  $$ VALUES ('completed'::text, 0::int) $$,
+  'Run was completed'
+);
+
+-- noqa: disable=all
+PREPARE expected_output AS SELECT
+    jsonb_build_object(
+        'disconnected_root', '"disconnected successful"'::JSONB,
+        'left', '"left successful"'::JSONB,
+        'right', '"right successful"'::JSONB
+    );
+-- noqa: enable=all
+SELECT results_eq (
+$$ SELECT output FROM pgflow.runs LIMIT 1 $$,
+'expected_output',
+'Outputs of all final steps were saved as run output'
+) ;
+
+SELECT finish () ;
+ROLLBACK ;

package/supabase/tests/create_flow/flow_creation.test.sql

@@ -0,0 +1,27 @@
+begin;
+select plan(2);
+select pgflow_tests.reset_db();
+
+-- Clean up any existing test queue
+select pgmq.drop_queue('test_flow')
+from pgmq.list_queues()
+where queue_name = 'test_flow'
+limit 1;
+
+-- TEST: Flow should be added to the flows table
+select pgflow.create_flow('test_flow');
+select results_eq(
+  $$ SELECT flow_slug FROM pgflow.flows $$,
+  array['test_flow']::text [],
+  'Flow should be added to the flows table'
+);
+
+-- TEST: Creating a flow should create a PGMQ queue with the same name
+select results_eq(
+  $$ SELECT EXISTS(SELECT 1 FROM pgmq.list_queues() WHERE queue_name = 'test_flow') $$,
+  array[true],
+  'Creating a flow should create a PGMQ queue with the same name'
+);
+
+select * from finish();
+rollback;

package/supabase/tests/create_flow/idempotency_and_duplicates.test.sql

@@ -0,0 +1,26 @@
+begin;
+select plan(2);
+select pgflow_tests.reset_db();
+
+-- Setup initial flow
+select pgflow.create_flow('test_flow');
+
+-- SETUP: Create flow again to ensure it doesn't throw
+select pgflow.create_flow('test_flow');
+
+-- TEST: No duplicate flow should be created
+select results_eq(
+  $$ SELECT flow_slug FROM pgflow.flows $$,
+  array['test_flow']::text [],
+  'No duplicate flow should be created'
+);
+
+--TEST: Creating a flow with existing flow_slug should still return the flow
+select results_eq(
+  $$ SELECT flow_slug FROM pgflow.create_flow('test_flow') $$,
+  $$ VALUES ('test_flow') $$,
+  'Creating a flow with existing flow_slug should still return the flow'
+);
+
+select * from finish();
+rollback;

package/supabase/tests/create_flow/invalid_slug.test.sql

@@ -0,0 +1,13 @@
+begin;
+select plan(1);
+select pgflow_tests.reset_db();
+
+-- TEST: Should detect and prevent invalid flow slug
+select throws_ok(
+  $$ SELECT pgflow.create_flow('invalid-flow') $$,
+  'new row for relation "flows" violates check constraint "slug_is_valid"',
+  'Should detect and prevent invalid flow slug'
+);
+
+select * from finish();
+rollback;

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

@@ -0,0 +1,57 @@
+begin;
+select plan(5);
+select pgflow_tests.reset_db();
+
+-- SETUP: flow with all default values
+select pgflow.create_flow('test_flow');
+
+--TEST: Should create flow with default max_attempts, base_delay and timeout
+select results_eq(
+  $$ SELECT opt_max_attempts, opt_base_delay, opt_timeout FROM pgflow.create_flow('test_flow') $$,
+  $$ VALUES (3, 5, 60) $$,
+  'Should create flow with default opt_max_attempts, opt_base_delay and opt_timeout'
+);
+
+-- SETUP: flow with overriden max_attempts
+select pgflow.create_flow('test_flow_2', max_attempts => 10);
+
+--TEST: Should allow overriding opt_max_attempts
+select results_eq(
+  $$ SELECT opt_max_attempts, opt_base_delay, opt_timeout FROM pgflow.create_flow('test_flow_2') $$,
+  $$ VALUES (10, 5, 60) $$,
+  'Should allow overriding opt_max_attempts'
+);
+
+-- SETUP: flow with overriden opt_base_delay
+select pgflow.create_flow('test_flow_3', base_delay => 10);
+
+--TEST: Should allow overriding base_delay
+select results_eq(
+  $$ SELECT opt_max_attempts, opt_base_delay, opt_timeout FROM pgflow.create_flow('test_flow_3') $$,
+  $$ VALUES (3, 10, 60) $$,
+  'Should allow overriding opt_base_delay'
+);
+
+-- SETUP: flow with overriden opt_timeout
+select pgflow.create_flow('test_flow_5', timeout => 7200);
+
+--TEST: Should allow overriding timeout
+select results_eq(
+  $$ SELECT opt_max_attempts, opt_base_delay, opt_timeout FROM pgflow.create_flow('test_flow_5') $$,
+  $$ VALUES (3, 5, 7200) $$,
+  'Should allow overriding opt_timeout'
+);
+
+-- SETUP: create same flow again to make sure it doesnt get updated
+select pgflow.create_flow('test_flow_4', max_attempts => 10, base_delay => 15, timeout => 30);
+select pgflow.create_flow('test_flow_4', max_attempts => 20, base_delay => 30, timeout => 60);
+
+--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.create_flow('test_flow_4') $$,
+  $$ VALUES (10, 15, 30) $$,
+  'Should not update opt_max_attempts, opt_base_delay and opt_timeout'
+);
+
+select * from finish();
+rollback;

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

@@ -0,0 +1,70 @@
+begin;
+select plan(4);
+select pgflow_tests.reset_db();
+
+-- create a test flow with two steps that have different base delays
+select pgflow.create_flow('backoff_test');
+select pgflow.add_step('backoff_test', 'first', max_attempts => 3, base_delay => 1);
+select pgflow.add_step('backoff_test', 'last', max_attempts => 4, base_delay => 2);
+
+-- start the flow with test data
+select pgflow.start_flow('backoff_test', '{"test": true}'::jsonb);
+
+-- simulate a task failure
+select pgflow_tests.poll_and_fail('backoff_test', 1, 1);
+
+-- make the message immediately visible (bypassing the retry delay)
+select pgflow_tests.reset_message_visibility('backoff_test');
+
+-- simulate a task failure
+select pgflow_tests.poll_and_fail('backoff_test', 1, 1);
+
+-- TEST: make sure we have proper attempts_count
+select is(
+  (select attempts_count::int from pgflow.step_tasks where step_slug = 'first'),
+  2::int,
+  'first task should have 2 attempts'
+);
+
+-- TEST: verify exponential backoff is set properly
+select is(
+  (select vt_seconds from pgflow_tests.message_timing('first', 'backoff_test') limit 1),
+  pgflow.calculate_retry_delay(1, 2),
+  'first step task should have visible time set to at least the base delay'
+);
+
+-- SETUP: proceed to next step
+select pgflow_tests.reset_message_visibility('backoff_test');
+select pgflow_tests.poll_and_complete('backoff_test', 1, 1);
+select pgflow_tests.reset_message_visibility('backoff_test');
+
+-- SETUP: fail twice to verify appropriate backoff
+select pgflow_tests.poll_and_fail('backoff_test', 1, 1);
+select pgflow_tests.reset_message_visibility('backoff_test');
+select pgflow_tests.poll_and_fail('backoff_test', 1, 1);
+select pgflow_tests.reset_message_visibility('backoff_test');
+select pgflow_tests.poll_and_fail('backoff_test', 1, 1);
+--
+-- TEST: make sure we have proper attempts_count
+select is(
+  (select attempts_count from pgflow.step_tasks where step_slug = 'last'),
+  3,
+  'last task should have 3 attempts'
+);
+
+-- TEST: verify exponential backoff is set properly
+select pgflow_tests.assert_retry_delay(
+  queue_name => 'backoff_test',
+  step_slug => 'last',
+  expected_delay => pgflow.calculate_retry_delay(2, 3),
+  description => 'last step task should have visible time set to at least the base delay'
+);
+
+-- select is(
+--   (select vt_seconds from pgflow_tests.message_timing('last', 'backoff_test') limit 1),
+--   pgflow.calculate_retry_delay(2, 3),
+--   'last step task should have visible time set to at least the base delay'
+-- );
+
+select finish();
+rollback;