@pgflow/core 0.0.0-add-workerconfig-to-context--20250905094004-b98e1fec-20250905074005

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 Wojciech Majewski <owner@pgflow.dev>
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,393 @@
+# pgflow SQL Core
+
+PostgreSQL-native workflow engine for defining, managing, and tracking DAG-based workflows directly in your database.
+
+> [!NOTE]
+> This project and all its components are licensed under [Apache 2.0](./LICENSE) license.
+
+> [!WARNING]
+> This project uses [Atlas](https://atlasgo.io/docs) to manage the schemas and migrations.
+> See [ATLAS.md](ATLAS.md) for more details.
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Key Features](#key-features)
+- [Architecture](#architecture)
+  - [Schema Design](#schema-design)
+  - [Execution Model](#execution-model)
+- [Example Flow and its life](#example-flow-and-its-life)
+  - [Defining a Workflow](#defining-a-workflow)
+  - [Starting a Workflow Run](#starting-a-workflow-run)
+  - [Workflow Execution](#workflow-execution)
+    - [Task Polling](#task-polling)
+    - [Task Completion](#task-completion)
+    - [Error Handling](#error-handling)
+    - [Retries and Timeouts](#retries-and-timeouts)
+- [TypeScript Flow DSL](#typescript-flow-dsl)
+  - [Overview](#overview-1)
+  - [Type Inference System](#type-inference-system)
+  - [Basic Example](#basic-example)
+  - [How Payload Types Are Built](#how-payload-types-are-built)
+  - [Benefits of Automatic Type Inference](#benefits-of-automatic-type-inference)
+- [Data Flow](#data-flow)
+  - [Input and Output Handling](#input-and-output-handling)
+  - [Run Completion](#run-completion)
+
+## Overview
+
+The pgflow SQL Core provides the data model, state machine, and transactional functions for workflow management. It treats workflows as Directed Acyclic Graphs (DAGs) of steps, each step being a simple state machine.
+
+This package focuses on:
+
+- Defining and storing workflow shapes
+- Managing workflow state transitions
+- Exposing transactional functions for workflow operations
+- Providing two-phase APIs for reliable task polling and status updates
+
+The actual execution of workflow tasks is handled by the [Edge Worker](../edge-worker/README.md), which calls back to the SQL Core to acknowledge task completion or failure.
+
+## Key Features
+
+- **Declarative Workflows**: Define flows and steps via SQL tables
+- **Dependency Management**: Explicit step dependencies with atomic transitions
+- **Configurable Behavior**: Per-flow and per-step options for timeouts, retries, and delays
+- **Queue Integration**: Built on pgmq for reliable task processing
+- **Transactional Guarantees**: All state transitions are ACID-compliant
+
+## Architecture
+
+### Schema Design
+
+[Schema ERD Diagram (click to enlarge)](./assets/schema.svg)
+
+<a href="./assets/schema.svg">
+  <img src="./assets/schema.svg" alt="Schema ERD Diagram" width="25%" height="25%">
+</a>
+
+---
+
+The schema consists of two main categories of tables:
+
+#### Static definition tables
+
+- `flows` (just an identity for the workflow with some global options)
+- `steps` (DAG nodes belonging to particular `flows`, with option overrides)
+- `deps` (DAG edges between `steps`)
+
+#### Runtime state tables
+
+- `runs` (execution instances of `flows`)
+- `step_states` (states of individual `steps` within a `run`)
+- `step_tasks` (units of work for individual `steps` within a `run`, so we can have fanouts)
+
+### Execution Model
+
+The SQL Core handles the workflow lifecycle through these key operations:
+
+1. **Definition**: Workflows are defined using `create_flow` and `add_step`
+2. **Instantiation**: Workflow instances are started with `start_flow`, creating a new run
+3. **Task Retrieval**: The [Edge Worker](../edge-worker/README.md) uses two-phase polling - first `read_with_poll` to reserve queue messages, then `start_tasks` to convert them to executable tasks
+4. **State Transitions**: When the Edge Worker reports back using `complete_task` or `fail_task`, the SQL Core handles state transitions and schedules dependent steps
+
+[Flow lifecycle diagram (click to enlarge)](./assets/flow-lifecycle.svg)
+
+<a href="./assets/flow-lifecycle.svg"><img src="./assets/flow-lifecycle.svg" alt="Flow Lifecycle" width="25%" height="25%"></a>
+
+## Example flow and its life
+
+Let's walk through creating and running a workflow that fetches a website,
+does summarization and sentiment analysis in parallel steps
+and saves the results to a database.
+
+![example flow graph](./assets/example-flow.svg)
+
+### Defining a Workflow
+
+Workflows are defined using two SQL functions: `create_flow` and `add_step`.
+
+In this example, we'll create a workflow with:
+
+- `website` as the entry point ("root step")
+- `sentiment` and `summary` as parallel steps that depend on `website`
+- `saveToDb` as the final step, depending on both parallel steps
+
+```sql
+-- Define workflow with parallel steps
+SELECT pgflow.create_flow('analyze_website');
+SELECT pgflow.add_step('analyze_website', 'website');
+SELECT pgflow.add_step('analyze_website', 'sentiment', deps_slugs => ARRAY['website']);
+SELECT pgflow.add_step('analyze_website', 'summary', deps_slugs => ARRAY['website']);
+SELECT pgflow.add_step('analyze_website', 'saveToDb', deps_slugs => ARRAY['sentiment', 'summary']);
+```
+
+> [!WARNING]
+> You need to call `add_step` in topological order, which is enforced by foreign key constraints.
+
+> [!NOTE]
+> You can have multiple "root steps" in a workflow. You can even create a root-steps-only workflow
+> to process a single input in parallel, because at the end, all of the outputs from steps
+> that does not have dependents ("final steps") are aggregated and saved as run's `output`.
+
+### Starting a Workflow Run
+
+To start a workflow, call `start_flow` with a flow slug and input arguments:
+
+```sql
+SELECT * FROM pgflow.start_flow(
+  flow_slug => 'analyze_website',
+  input => '{"url": "https://example.com"}'::jsonb
+);
+
+--     run_id  | flow_slug       | status  |  input                         | output | remaining_steps
+-- ------------+-----------------+---------+--------------------------------+--------+-----------------
+--  <run uuid> | analyze_website | started | {"url": "https://example.com"} | [NULL] |               4
+```
+
+When a workflow starts:
+
+- A new `run` record is created
+- Initial states for all steps are created
+- Root steps are marked as `started`
+- Tasks are created for root steps
+- Messages are enqueued on PGMQ for worker processing
+
+> [!NOTE]
+> The `input` argument must be a valid JSONB object: string, number, boolean, array, object or null.
+
+### Workflow Execution
+
+#### Task Polling
+
+The Edge Worker uses a two-phase approach to retrieve and start tasks:
+
+**Phase 1 - Reserve Messages:**
+```sql
+SELECT * FROM pgflow.read_with_poll(
+  queue_name => 'analyze_website',
+  vt => 60, -- visibility timeout in seconds
+  qty => 5  -- maximum number of messages to fetch
+);
+```
+
+**Phase 2 - Start Tasks:**
+```sql
+SELECT * FROM pgflow.start_tasks(
+  flow_slug => 'analyze_website',
+  msg_ids => ARRAY[101, 102, 103], -- message IDs from phase 1
+  worker_id => '550e8400-e29b-41d4-a716-446655440000'::uuid
+);
+```
+
+**How it works:**
+
+1. **read_with_poll** reserves raw queue messages and hides them from other workers
+2. **start_tasks** finds matching step_tasks, increments attempts counter, and builds task inputs
+3. Task metadata and input are returned to the worker for execution
+
+This two-phase approach ensures tasks always exist before processing begins, eliminating race conditions that could occur with single-phase polling.
+
+#### Task Completion
+
+After successful processing, the worker acknowledges completion:
+
+```sql
+SELECT pgflow.complete_task(
+  run_id => '<run_uuid>',
+  step_slug => 'website',
+  task_index => 0, -- we will have multiple tasks for a step in the future
+  output => '{"content": "HTML content", "status": 200}'::jsonb
+);
+```
+
+When a task completes:
+
+1. The task status is updated to 'completed' and the output is saved
+2. The message is archived in PGMQ
+3. The step state is updated to 'completed'
+4. Dependent steps with all dependencies completed are automatically started
+5. The run's remaining_steps counter is decremented
+6. If all steps are completed, the run is marked as completed with aggregated outputs
+
+#### Error Handling
+
+If a task fails, the worker acknowledges this using `fail_task`:
+
+```sql
+SELECT pgflow.fail_task(
+  run_id => '<run_uuid>',
+  step_slug => 'website',
+  task_index => 0,
+  error_message => 'Connection timeout when fetching URL'::text
+);
+```
+
+The system handles failures by:
+
+1. Checking if retry attempts are available
+2. For available retries:
+   - Keeping the task in 'queued' status
+   - Applying exponential backoff for visibility
+   - Preventing processing until the visibility timeout expires
+3. When retries are exhausted:
+   - Marking the task as 'failed'
+   - Marking the step as 'failed'
+   - Marking the run as 'failed'
+   - Archiving the message in PGMQ
+   - Notifying workers to abort pending tasks (future feature)
+
+#### Retries and Timeouts
+
+Retry behavior can be configured at both the flow and step level:
+
+```sql
+-- Flow-level defaults
+SELECT pgflow.create_flow(
+  flow_slug => 'analyze_website',
+  max_attempts => 3,    -- Maximum retry attempts (including first attempt)
+  base_delay => 5,      -- Base delay in seconds for exponential backoff
+  timeout => 60         -- Task timeout in seconds
+);
+
+-- Step-level overrides
+SELECT pgflow.add_step(
+  flow_slug => 'analyze_website',
+  step_slug => 'sentiment',
+  deps_slugs => ARRAY['website']::text[],
+  max_attempts => 5,    -- Override max attempts for this step
+  base_delay => 2,      -- Override base delay for exponential backoff
+  timeout => 30         -- Override timeout for this step
+);
+```
+
+The system applies exponential backoff for retries using the formula:
+
+```
+delay = base_delay * (2 ^ attempts_count)
+```
+
+Timeouts are enforced by setting the message visibility timeout to the step's timeout value plus a small buffer. If a worker doesn't acknowledge completion or failure within this period, the task becomes visible again and can be retried.
+
+## TypeScript Flow DSL
+
+> [!NOTE]
+> TypeScript Flow DSL is a Work In Progress and is not ready yet!
+
+### Overview
+
+While the SQL Core engine handles workflow definitions and state management, the primary way to define and work with your workflow logic is via the Flow DSL in TypeScript. This DSL offers a fluent API that makes it straightforward to outline the steps in your flow with full type safety.
+
+### Type Inference System
+
+The most powerful feature of the Flow DSL is its **automatic type inference system**:
+
+1. You only need to annotate the initial Flow input type
+2. The return type of each step is automatically inferred from your handler function
+3. These return types become available in the payload of dependent steps
+4. The TypeScript compiler builds a complete type graph matching your workflow DAG
+
+This means you get full IDE autocompletion and type checking throughout your workflow without manual type annotations.
+
+### Basic Example
+
+Here's an example that matches our website analysis workflow:
+
+```ts
+// Provide a type for the input of the Flow
+type Input = {
+  url: string;
+};
+
+const AnalyzeWebsite = new Flow<Input>({
+  slug: 'analyze_website',
+  maxAttempts: 3,
+  baseDelay: 5,
+  timeout: 10,
+})
+  .step(
+    { slug: 'website' },
+    async (input) => await scrapeWebsite(input.run.url)
+  )
+  .step(
+    { slug: 'sentiment', dependsOn: ['website'], timeout: 30, maxAttempts: 5 },
+    async (input) => await analyzeSentiment(input.website.content)
+  )
+  .step(
+    { slug: 'summary', dependsOn: ['website'] },
+    async (input) => await summarizeWithAI(input.website.content)
+  )
+  .step(
+    { slug: 'saveToDb', dependsOn: ['sentiment', 'summary'] },
+    async (input) =>
+      await saveToDb({
+        websiteUrl: input.run.url,
+        sentiment: input.sentiment.score,
+        summary: input.summary,
+      }).status
+  );
+```
+
+### How Payload Types Are Built
+
+The payload object for each step is constructed dynamically based on:
+
+1. **The `run` property**: Always contains the original workflow input
+2. **Dependency outputs**: Each dependency's output is available under a key matching the dependency's ID
+3. **DAG structure**: Only outputs from direct dependencies are included in the payload
+
+This means your step handlers receive exactly the data they need, properly typed, without any manual type declarations beyond the initial Flow input type.
+
+### Benefits of Automatic Type Inference
+
+- **Refactoring safety**: Change a step's output, and TypeScript will flag all dependent steps that need updates
+- **Discoverability**: IDE autocompletion shows exactly what data is available in each step
+- **Error prevention**: Catch typos and type mismatches at compile time, not runtime
+- **Documentation**: The types themselves serve as living documentation of your workflow's data flow
+
+## Data Flow
+
+### Input and Output Handling
+
+Handlers in pgflow **must return** JSON-serializable values that are captured and saved when `complete_task` is called. These outputs become available as inputs to dependent steps, allowing data to flow through your workflow pipeline.
+
+When a step is executed, it receives an input object where:
+
+- Each key is a step_slug of a completed dependency
+- Each value is that step's output
+- A special "run" key contains the original workflow input
+
+#### Example: `sentiment`
+
+When the `sentiment` step runs, it receives:
+
+```json
+{
+  "run": { "url": "https://example.com" },
+  "website": { "content": "HTML content", "status": 200 }
+}
+```
+
+#### Example: `saveToDb`
+
+The `saveToDb` step depends on both `sentiment` and `summary`:
+
+```json
+{
+  "run": { "url": "https://example.com" },
+  "sentiment": { "score": 0.85, "label": "positive" },
+  "summary": "This website discusses various topics related to technology and innovation."
+}
+```
+
+### Run Completion
+
+When all steps in a run are completed, the run status is automatically updated to 'completed' and its output is set. The output is an aggregation of all the outputs from final steps (steps that have no dependents):
+
+```sql
+-- Example of a completed run with output
+SELECT run_id, status, output FROM pgflow.runs WHERE run_id = '<run_uuid>';
+
+--     run_id  | status    | output
+-- ------------+-----------+-----------------------------------------------------
+--  <run uuid> | completed | {"saveToDb": {"status": "success"}}
+```

package/dist/ATLAS.md

@@ -0,0 +1,32 @@
+# Atlas setup
+
+We use [Atlas](https://atlasgo.io/docs) to generate migrations from the declarative schemas stored in `./schemas/` folder.
+
+## Configuration
+
+The setup is configured in `atlas.hcl`.
+
+It is set to compare `schemas/` to what is in `supabase/migrations/`.
+
+### Docker dev image
+
+Atlas requires a dev database to be available for computing diffs.
+The database must be empty, but contain everything needed for the schemas to apply.
+
+We need a configured [PGMQ](https://github.com/tembo-io/pgmq) extension, which Atlas does not support
+in their dev images.
+
+That's why this setup relies on a custom built image `jumski/postgres-15-pgmq:latest`.
+
+Inspect `Dockerfile.atlas` to see how it is built.
+
+See also `./scripts/build-atlas-postgres-image` and `./scripts/push-atlas-postgres-image` scripts for building and pushing the image.
+
+## Workflow
+
+1. Make sure you start with a clean database (`pnpm supabase db reset`).
+1. Modify the schemas in `schemas/` to a desired state.
+1. Run `./scripts/atlas-migrate-diff <migration-name>` to create a new migration based on the diff.
+1. Run `pnpm supabase migration up` to apply the migration.
+1. In case of any errors, remove the generated migration file, make changes in `schemas/` and repeat the process.
+1. After the migration is applied, verify it does not break tests with `nx test:pgtap`