---
name: bijection-quick
description: "Evaluate and integrate the Quick component with Bijection."
---

# Quick

A quick Bijection component for Bijection.

- Package: @bijectionhq/quick
- Category: Durable Functions
- Status: Reference
- License: Apache-2.0
- Bijection source (repository access required): https://github.com/bijectionhq/quick/tree/45e3a3cd357335444c4357e5e506343268f4755e
- Upstream: https://github.com/danthegoodman1/quick-convex/tree/31a3a085a5b5871ad8fccb693b1e8e9b82399928
- Documentation: https://docs.bijection.com/components/using
- Directory: https://bijection.com/components/quick

## Get the source

Bijection repository access is required. Request access at https://bijection.com/contact.

```sh
git clone https://github.com/bijectionhq/quick.git
cd quick
git checkout 45e3a3cd357335444c4357e5e506343268f4755e
```

## Before using this component

Read the package README at the recorded revision for setup, dependencies, and API examples. Upstream documentation describes the original package and may differ from the Bijection adaptation. This is a source candidate for evaluation. Catalog inclusion does not establish npm availability or runtime qualification. Check compatibility with your SDK and deployment before adoption. External providers run their own compute.

## Integration workflow

1. Read the source README and package manifest at the recorded revision.
2. Confirm the required SDK, dependency availability, and runtime compatibility.
3. Follow the component's documented setup and configuration. Never invent an npm install command from a catalog package name.
4. Keep credentials in the project's existing secret store.
5. Follow the project's execution rules for verification and report what was actually checked.

## Original upstream skill

The following guidance describes @danthegoodman/quick-convex. Its installation commands and APIs refer to the upstream package. Evaluate compatibility with the Bijection source separately.


# quick-convex

## Instructions

Use quick-convex to implements apple's quick paper as a convex component, providing fifo and priority queue processing with retries and concurrent execution. This Convex component integrates directly with your backend.

### Installation

```bash
npm install @danthegoodman/quick-convex
```

### Capabilities

- Process queued tasks with strict FIFO ordering per domain or priority-based vesting modes
- Handle retry logic automatically with configurable backoff strategies and completion callbacks
- Scale concurrent processing efficiently with pointer-based scanning that minimizes contention
- Batch enqueue multiple jobs with different functions while deduplicating handle creation

## Examples

### how to process user tasks in order with Convex

quick-convex provides strict FIFO ordering per queueId, ensuring tasks for each user are processed sequentially while different users can process in parallel. Use the FIFO mode with userId as the queueId to maintain ordering within each user's task queue.

### Convex job queue with retry logic

quick-convex includes built-in retry mechanisms with exponential backoff and configurable max attempts. Set retry behavior at the class level or override per job, and use onComplete callbacks that are automatically retried up to 2 times on timeout failures.

### priority queue implementation Convex

The vesting mode in quick-convex supports priority levels 0-15 where higher numbers run first. Ready items are dequeued by priority, then by vesting time, allowing high-priority work to jump ahead while maintaining fairness within priority tiers.

### batch job processing Convex component

Use enqueueBatchAction or enqueueBatchMutation to submit multiple jobs at once with different worker functions. The component automatically deduplicates handle creation per unique function in the batch for efficiency.

## When NOT to use

- When a simpler built-in solution exists for your specific use case
- If you are not using Convex as your backend
- When the functionality provided by quick-convex is not needed

## Troubleshooting

**What's the difference between FIFO and vesting modes in quick-convex?**

FIFO mode enforces strict ordering per queueId where delayed items block subsequent items in the same queue. Vesting mode prioritizes throughput, allowing ready items to run immediately even if earlier items are delayed or retrying. Use FIFO for strict ordering requirements and vesting for maximum throughput.

**How does quick-convex compare to Convex Workpools?**

quick-convex offers multiple ordering modes including strict FIFO per domain, while Workpools are lighter weight and officially maintained. quick-convex handles scale-up patterns better and retries onComplete failures, but has more overhead per job at low volumes. Both are production-ready solutions.

**Can I use different retry policies for different jobs?**

Yes, quick-convex supports retry configuration at multiple levels. Set defaults when creating the Quick instance, then override per job with retry: false, retry: true, or retry: { maxAttempts, initialBackoffMs, base } for custom behavior.

**How do I handle job completion and cleanup with quick-convex?**

Use the onComplete callback which runs as a mutation after both successful and failed jobs. quick-convex persists completion state and retries the onComplete handler up to 2 times on failures, ensuring reliable cleanup and post-processing logic.

## Resources

- [npm package](https://www.npmjs.com/package/%40danthegoodman%2Fquick-convex)
- [GitHub repository](https://github.com/danthegoodman1/quick-convex)
- [Convex Components Directory](https://www.convex.dev/components/danthegoodman/quick-convex)
- [Convex documentation](https://docs.convex.dev)