@zukhruf/sqlite-queue 0.0.0-stage → 0.3.41

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ezzabuzaid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,152 @@
-# Temporary Holding Version
+# @zukhruf/sqlite-queue
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A program sends jobs to a queue, and workers do the jobs later, also after the program restarts. [pg-boss](https://github.com/timgit/pg-boss) is a job queue that keeps its jobs in Postgres. A program that has no Postgres server, for example a desktop app or a CLI, cannot use it. This package keeps the jobs in one SQLite file through `node:sqlite`, and gives the API of pg-boss: the same method names, the same options, the same results and the same errors. The API is a declared subset of pg-boss: 13 methods of `PgBoss`.
+
+Zero divergence is the contract. A parity suite runs each scenario on real pg-boss 12.35.1 over PGlite, and on this package. Then it compares what each engine returned, stored and emitted. A test passes only when the two are equal. Thus a program can change from one engine to the other and keep its code.
+
+The words in these documents have one meaning each. See the glossary in [CONTEXT.md](./CONTEXT.md).
+
+## Use it
+
+This project is an experiment. It uses `node:sqlite`, and it uses pg-boss for its types and some of its values.
+
+```sh
+npm install @zukhruf/sqlite-queue
+```
+
+```ts
+import { mkdtempDisposable } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { type JobQueue, SqliteJobQueue } from '@zukhruf/sqlite-queue';
+
+await using scratch = await mkdtempDisposable(join(tmpdir(), 'queue-'));
+const queue: JobQueue = new SqliteJobQueue({
+  path: join(scratch.path, 'jobs.sqlite'),
+});
+queue.on('error', (error) => console.error(error));
+await queue.start();
+await queue.createQueue('email', { retryLimit: 2 });
+await queue.send('email', { to: 'ada@example.com' });
+
+const sent = Promise.withResolvers<void>();
+await queue.work('email', async ([job]) => {
+  console.log('send to', job?.data);
+  sent.resolve();
+});
+await sent.promise;
+await queue.stop();
+```
+
+Output:
+
+```
+send to { to: 'ada@example.com' }
+```
+
+A `PgBoss` is also a `JobQueue`. Thus the same code runs on Postgres:
+
+```ts
+import { PgBoss } from 'pg-boss';
+
+const queue: JobQueue = new PgBoss(process.env.DATABASE_URL);
+```
+
+## The rules
+
+- `new SqliteJobQueue({ path })` owns the database file. `start()` opens it and makes the tables, and `stop()` closes it.
+- `new SqliteJobQueue({ database })` uses a `DatabaseSync` that the caller opened. The caller closes it.
+- With no `path` and no `database`, the queue keeps its jobs in memory.
+- The other options are the options of pg-boss with the same names: `clock`, `supervise`, `superviseIntervalSeconds`, `monitorIntervalSeconds`, `maintenanceIntervalSeconds`, `queueCacheIntervalSeconds`, `warningQueueSize`, `useListenNotify`, `schedule`, `cronMonitorIntervalSeconds`, `cronWorkerIntervalSeconds` and `clockMonitorIntervalSeconds`. The defaults are the defaults of pg-boss.
+- The types of the options, the jobs and the results come from pg-boss. Import them from `pg-boss`, for example `import type { Job, SendOptions } from 'pg-boss'`.
+- Job data is `unknown`. `work()` gives each handler `Job<unknown>`, and `findJobs()` gives `FoundJob<unknown>`. Validate the data that you read.
+- A listener for `error` is necessary. A failure in work that no caller awaits, for example a worker poll, goes to the `error` event. With no listener, `EventEmitter` throws.
+- `useListenNotify` wakes the workers of this `SqliteJobQueue` only. In pg-boss, each listener on the schema hears a `NOTIFY`. Here, another instance on the same file does not hear it.
+
+## Upgrades
+
+A new release can change the tables. A file that an earlier release made keeps its jobs and its schedules ([ADR 0004](./docs/adr/0004-the-schema-is-a-declaration-and-keeps-the-jobs.md)).
+
+- The schema is a declaration of [`@zukhruf/sqlite-drift`](../drift) with `rows: 'keep'`. `start()` compares the tables and the indexes in the file with the declaration.
+- `start()` makes each missing object. It rebuilds each stale table and keeps its rows, and it replaces each stale index.
+- No release writes a migration, and no file keeps a version number.
+- When a kept row does not fit the declared table, `start()` fails with the error of SQLite, and the file stays as it was.
+- When `pgboss_queue` is stale, the rebuild turns foreign keys off around its own transaction. Do not call `start()` in a transaction of your own.
+
+## Schedules
+
+A schedule sends a job to its queue at each time that its cron or rrule rule gives. The timekeeper of pg-boss does this work, and this package copies it ([ADR 0003](./docs/adr/0003-the-timekeeper-is-ported-literally.md)).
+
+- `schedule` is `true` by default, as in pg-boss. `start()` then makes the queue `__pgboss__send-it`, starts one worker on it, and starts the cron pass. `schedule: false` starts none of them.
+- The cron pass runs at start, then every `cronMonitorIntervalSeconds` (30 by default) on the clock. It finds the occurrences of each schedule in the last 60 seconds. For each occurrence, it puts one job in `__pgboss__send-it`, in the slot of the minute of the occurrence. A unique index keeps one job for each schedule and slot, so the next pass does not send the same occurrence again.
+- The worker of `__pgboss__send-it` polls every `cronWorkerIntervalSeconds` (5 by default). It sends each job to the queue of its schedule, with the data and the options of the schedule. Thus a job goes out up to 35 seconds after its time, as in pg-boss.
+- A cron expression without `tz` uses UTC. An rrule without `DTSTART` counts from 1970-01-01, so `FREQ=MINUTELY;INTERVAL=2` gives the even minutes.
+- `missed` tells the pass what to do after a time when no pass ran, for example when the program was stopped. With `skip` (the default), the pass sends only the occurrences of the last 60 seconds. With `once`, the pass also sends the latest occurrence of that time, but not one from before the schedule was written.
+- When the send to the queue of the schedule fails, the failure goes to the `error` event, and the job in `__pgboss__send-it` completes. The pass does not send the occurrence again.
+- `__pgboss__send-it` is a queue like the others: `findJobs` reads its jobs. Its worker is not in the `wip` events.
+- `clockMonitorIntervalSeconds` is validated only. pg-boss uses it to measure the difference between its clock and the clock of Postgres. Here the clock of the queue is the clock of the database.
+
+## The subset
+
+| Method                                                                          | What it does                                                                                        |
+| ------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
+| `on('error', listener)`                                                         | Receives the failures that no caller awaits.                                                        |
+| `start()`, `stop(options)`                                                      | Start and stop the queue. A second call while one runs shares it.                                   |
+| `createQueue(name, options)`, `updateQueue(name, options)`, `deleteQueue(name)` | Make, change and remove a queue, with its policy, retries, expiry, retention and dead letter queue. |
+| `send(name, data, options)`, `send({ name, data, options })`                    | Add a job. It gives the id of the job, or `null` when a singleton or throttle refuses the job.      |
+| `work(name, handler)`, `work(name, options, handler)`                           | Start workers that fetch jobs and give them to the handler. It gives the id of the work.            |
+| `offWork(name, options)`                                                        | Stop the workers of a queue.                                                                        |
+| `findJobs(name, options)`                                                       | Find jobs by id, key, data or queued state.                                                         |
+| `cancel(name, id)`, `fail(name, id, data)`                                      | Cancel or fail jobs by id or by attempt.                                                            |
+| `schedule(name, cron, data, options)`, `unschedule(name, key)`                  | Send a job on a cron or rrule schedule, and remove the schedule.                                    |
+
+Other methods of `PgBoss` are not in the subset, for example `getQueue`, `getJobById`, `complete`, `retry`, `resume`, `deleteJob`, `sendAfter`, `insert` and `getDb`. A method that needs Postgres itself, for example `getDb` and its SQL, will not come.
+
+## Errors
+
+| Error                                      | When                                                                                                                                                                                                       |
+| ------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `DatabaseError`                            | The same refusal that Postgres gives pg-boss, with its message and its SQLSTATE in `code`. For example `23503` for a dead letter queue that does not exist, `22P05` for `\u0000` in a JSON value, `23505`. |
+| `UnsupportedStartAfterError`               | A `startAfter` string outside the forms that this package resolves: a `Date`, seconds, an ISO 8601 date time or duration, or Postgres interval units with integer amounts.                                 |
+| The `Error` or `AssertionError` of pg-boss | A refused argument, with the message that pg-boss gives. For example `Workers are disabled. pg-boss is stopped`.                                                                                           |
+| The error of SQLite                        | All other failures.                                                                                                                                                                                        |
+
+Code that runs on both engines examines `code`, not the class. On Postgres, the error comes from the driver, not from this package, and `instanceof DatabaseError` is false. The `code` is the same on both engines.
+
+## The same concepts in other systems
+
+| System                                              | What it does                                                                                                                                                               |
+| --------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [pg-boss](https://github.com/timgit/pg-boss)        | The job queue that this package copies. It keeps the jobs in Postgres, and uses `SKIP LOCKED` to give each job to one worker.                                              |
+| [Oban](https://hexdocs.pm/oban) and its Lite engine | A job queue for Elixir. Its engine is a part apart from its API: the Basic engine uses Postgres, and the Lite engine uses SQLite. The API does not change with the engine. |
+| [Solid Queue](https://github.com/rails/solid_queue) | The job queue of Rails 8. It keeps the jobs in the database of the app: Postgres, MySQL or SQLite.                                                                         |
+
+## Documentation
+
+- [0001 pg-boss's API on SQLite](./docs/adr/0001-pg-boss-api-on-sqlite.md)
+- [0002 The parity suite is the contract](./docs/adr/0002-the-parity-suite-is-the-contract.md)
+- [0003 The timekeeper is ported literally](./docs/adr/0003-the-timekeeper-is-ported-literally.md)
+- [0004 The schema is a declaration and keeps the jobs](./docs/adr/0004-the-schema-is-a-declaration-and-keeps-the-jobs.md)
+
+## Development
+
+This package is part of the [zukhruf](../../../README.md) workspace. Run the commands from the workspace root.
+
+```sh
+npm install
+npx nx run sqlite-queue:test        # builds, then runs the unit tests and the parity suite
+npx nx run sqlite-queue:typecheck   # formats, lints, then type checks
+npx nx run sqlite-queue:build       # compiles src/ to dist/
+```
+
+The test target sets `TZ=Asia/Kolkata`. The parity suite needs a zone that is not UTC, because pg-boss reads a throttle slot as local time.
+
+```
+src/
+  index.ts           SqliteJobQueue and the exports
+  job-queue.ts       JobQueue, the subset, and FoundJob
+  *.ts               the parts of the port, each one cites the pg-boss code that it copies
+  *.test.ts          the unit tests, for behavior that only SQLite has
+  parity/            the parity suite: each scenario on pg-boss over PGlite and on SQLite
+```

package/dist/activity.d.ts

@@ -0,0 +1,10 @@
+import type { AttachableClock, Clock } from 'pg-boss';
+export declare class Activity {
+    #private;
+    static isAttachable(clock: Clock): clock is AttachableClock;
+    attach(clock: AttachableClock): Promise<AsyncDisposable>;
+    query<T>(statement: () => T): Promise<T>;
+    deliver(notification: () => void): Promise<void>;
+    idle(): Promise<boolean>;
+}
+//# sourceMappingURL=activity.d.ts.map

package/dist/activity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.d.ts","sourceRoot":"","sources":["../src/activity.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,KAAK,EAAM,MAAM,SAAS,CAAC;AAM1D,qBAAa,QAAQ;;IAenB,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,IAAI,eAAe;IAK3D,MAAM,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IAUxD,KAAK,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAkBxC,OAAO,CAAC,YAAY,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IA2B1C,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC;CAgB/B"}

package/dist/activity.js

@@ -0,0 +1,93 @@
+import { setImmediate } from 'node:timers/promises';
+// pg-boss counts the statements it has in flight so an attached TestClock
+// lets them finish before it moves time on (node_modules/pg-boss/dist/
+// activity.js:14-95). node:sqlite answers at once, so what this counts are
+// the event-loop turns standing in for pg-boss's I/O.
+export class Activity {
+    // The queue binds clock.now() into its own statements, so the Postgres
+    // clock table an attachment writes (clock.js:140-145, 189) has no receiver.
+    static #database = {
+        executeSql: async () => ({ rows: [] }),
+    };
+    // Dispose drops the clock table once no target shares the schema
+    // (clock.js:158), so this names no schema a PgBoss could use.
+    static #schema = 'sqlite job queue';
+    #inFlight = 0;
+    #started = 0;
+    #waiters = [];
+    // clock.js:10-12; pg-boss's root exports only TestClock and systemClock.
+    static isAttachable(clock) {
+        return 'attach' in clock && typeof clock.attach === 'function';
+    }
+    // index.js:152-154
+    attach(clock) {
+        return clock.attach({
+            db: Activity.#database,
+            schema: Activity.#schema,
+            idle: () => this.idle(),
+        });
+    }
+    // Runs a statement at once, as PGlite runs each in the order it arrives,
+    // and settles with its outcome one turn later, as pg-boss's I/O does.
+    query(statement) {
+        let outcome;
+        try {
+            outcome = { value: statement() };
+        }
+        catch (error) {
+            outcome = { error };
+        }
+        return this.#counted(async () => {
+            await setImmediate();
+            if ('error' in outcome) {
+                throw outcome.error;
+            }
+            return outcome.value;
+        });
+    }
+    // Runs `notification` one counted turn from now: pg-boss wakes its notify
+    // workers at start only after the listener's own I/O (notifier.js:55-57).
+    deliver(notification) {
+        return this.#counted(async () => {
+            await setImmediate();
+            notification();
+        });
+    }
+    // Counted while in flight (activity.js:18-33).
+    async #counted(work) {
+        this.#inFlight++;
+        this.#started++;
+        try {
+            return await work();
+        }
+        finally {
+            this.#inFlight--;
+            if (this.#inFlight === 0) {
+                const settled = this.#waiters;
+                this.#waiters = [];
+                for (const resolve of settled) {
+                    resolve();
+                }
+            }
+        }
+    }
+    // activity.js:77-93: true if it had to wait. A caller whose turn just
+    // ended runs on in microtasks and may start another before this one ends.
+    async idle() {
+        let waited = false;
+        for (;;) {
+            if (this.#inFlight > 0) {
+                waited = true;
+                await new Promise((resolve) => this.#waiters.push(resolve));
+                continue;
+            }
+            const seen = this.#started;
+            await setImmediate();
+            if (this.#inFlight === 0 && this.#started === seen) {
+                return waited;
+            }
+            waited = true;
+        }
+    }
+}
+//# sourceMappingURL=activity.js.map

package/dist/activity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.js","sourceRoot":"","sources":["../src/activity.ts"],"names":[],"mappings":"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"}

package/dist/attorney.d.ts

@@ -0,0 +1,35 @@
+import { type Clock, type JobAttempt, type SendOptions } from 'pg-boss';
+import type { TimekeeperConfig } from './timekeeper.ts';
+export type SuperviseIntervals = {
+    superviseIntervalSeconds: number;
+    maintenanceIntervalSeconds: number;
+    monitorIntervalSeconds: number;
+    queueCacheIntervalSeconds: number;
+};
+export declare class Attorney {
+    #private;
+    static readonly MAX_EXPIRATION_HOURS = 24;
+    static readonly MIN_POLLING_INTERVAL_MS = 500;
+    static applyClockConfig(clock: Clock | undefined): Clock;
+    static applyOpsConfig(config: object): SuperviseIntervals;
+    static applyScheduleConfig(config: object): TimekeeperConfig;
+    static validateWarningConfig(config: object): void;
+    static checkWorkArgs(name: unknown, args: readonly unknown[]): {
+        pollingInterval: number;
+        notifyPollingInterval: number;
+    };
+    static assertObjectName(value: unknown, name: string): void;
+    static mapAttemptArg(id: string | string[] | JobAttempt | JobAttempt[], funcName: string): {
+        ids: string[];
+        attempts?: number[];
+    };
+    static assertKey(key: unknown): void;
+    static assertQueueName(name: unknown): asserts name is string;
+    static validateQueueArgs(config: object): void;
+    static checkSendArgs(args: readonly unknown[]): {
+        name: unknown;
+        data: unknown;
+        options: SendOptions;
+    };
+}
+//# sourceMappingURL=attorney.d.ts.map

package/dist/attorney.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attorney.d.ts","sourceRoot":"","sources":["../src/attorney.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,KAAK,EACV,KAAK,UAAU,EACf,KAAK,WAAW,EAEjB,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAIxD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,wBAAwB,EAAE,MAAM,CAAC;IACjC,0BAA0B,EAAE,MAAM,CAAC;IACnC,sBAAsB,EAAE,MAAM,CAAC;IAC/B,yBAAyB,EAAE,MAAM,CAAC;CACnC,CAAC;AAOF,qBAAa,QAAQ;;IAEnB,MAAM,CAAC,QAAQ,CAAC,oBAAoB,MAAM;IAE1C,MAAM,CAAC,QAAQ,CAAC,uBAAuB,OAAO;IAW9C,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,GAAG,KAAK;IAexD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB;IA2CzD,MAAM,CAAC,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB;IAmC5D,MAAM,CAAC,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IA4DlD,MAAM,CAAC,aAAa,CAClB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,SAAS,OAAO,EAAE,GACvB;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,qBAAqB,EAAE,MAAM,CAAA;KAAE;IAkN7D,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAS3D,MAAM,CAAC,aAAa,CAClB,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,UAAU,GAAG,UAAU,EAAE,EACjD,QAAQ,EAAE,MAAM,GACf;QAAE,GAAG,EAAE,MAAM,EAAE,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE;IA0BzC,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IASpC,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,IAAI,MAAM;IAO7D,MAAM,CAAC,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IA0B9C,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG;QAC9C,IAAI,EAAE,OAAO,CAAC;QACd,IAAI,EAAE,OAAO,CAAC;QACd,OAAO,EAAE,WAAW,CAAC;KACtB;CAwIF"}