@shivaedev/jobs 0.31.0 → 0.32.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.32.0 - 2026-11-03
+
+### Added
+
+- Expose `PgBossInspection` for stored jobs, deferrals, expiry, queue diagnostics and scoped PostgreSQL queue-change signals. Jobs runtimes also expose the service through `inspection()`.
+- Refresh cached queue statistics through `testing.refreshQueueStats(queue?)` before reading health.
+- Read and await jobs with null payloads through `testing.jobs({ name, schema: Schema.Null })` and `testing.untilJob`.
+- Queues accept `id: ["field", ...]` to derive deterministic UUIDs from the queue name and typed scalar payload parts. Repeated parts deduplicate while pg-boss retains the job. Enqueueing rejects conflicting IDs owned by a queue definition.
+
+### Changed
+
+- The testing controller reads through inspection and waits on committed queue changes, including work done by another client, without production testing hooks or private settlement spies.
+
+### Fixed
+
+- Apply testing expiry controls to triggered schedule runs.
+
+### Breaking
+
+- Import `SnapshotQueue` and `UnfinishedJob` from `@shivaedev/jobs/server/inspection.ts` instead of `server/testing.ts`.
+- Remove `__test__enableSpies` from client options. Replace `EngineClient.getSpy` waits with inspection `changes()`. Replace `getJobById(name, id)` with `storedJobs({ name }, { id })`, taking the first result; missing jobs return an empty array.
+- `testing.trigger(schedule)` returns the run ID, or null when pg-boss suppresses the send, instead of void. Consumers that require an `Effect<void>` should apply `Effect.asVoid` to the result.
+- Replace singleton `key: (payload) => string` callbacks with `key: ["field", ...]`, naming required string, number, boolean or null fields in the decoded payload schema. Use `key: []` for a queue-wide singleton key. To preserve application-specific normalization, put the normalized value in a payload field and name it as a part. Derived singleton key strings use typed tuples; drain existing singleton work before switching producers and workers together so old and new keys do not run concurrently.
+
 ## 0.31.0 - 2026-11-03
 
 ### Added

package/README.md

@@ -260,19 +260,37 @@ const PullRequestJobs = defineQueue({
 		Schema.TaggedStruct("Reconcile", { pullRequestId: Schema.NumberFromString }),
 	]),
 	queue: { policy: "singleton" },
-	key: ({ pullRequestId }) => `pr:${pullRequestId.toFixed(0)}`,
+	key: ["pullRequestId"],
 	worker: { batchSize: 1, localConcurrency: 3 },
 });
 
 const refresh = Effect.flatMap(Jobs, (jobs) => jobs.enqueue(PullRequestJobs, { _tag: "Refresh", pullRequestId: 42 }));
 ```
 
-`queue.policy` accepts pg-boss's policy literals and rejects typos. The `singleton` policy requires `key: (payload) => string`. The callback sees the decoded payload, so `pullRequestId` is a number. `enqueue` supplies pg-boss's `singletonKey` automatically; callers cannot supply a conflicting key in send options.
+`queue.policy` accepts pg-boss's policy literals and rejects typos. The `singleton` policy requires `key: ["field", ...]`. Each part names a required scalar field in the decoded payload schema, so `pullRequestId` contributes its numeric value. `enqueue` supplies pg-boss's `singletonKey` automatically; callers cannot supply a conflicting key in send options.
 
 PostgreSQL guarantees one active job per key across workers, including different job kinds in this queue. Different keys can run in parallel when workers have capacity. A job waiting to retry frees its key for another job; exhausting retries sends it to the dead-letter queue and leaves the key available.
 
 Singleton guarantees one active job per key, not order. Ordering stays the application's job. Keep handlers idempotent and write state only when the source is newer than what is stored, so an older event or retry cannot overwrite newer state.
 
+### Deterministic job IDs
+
+Declare the payload fields that identify a job:
+
+```ts
+const Revisions = defineQueue({
+	name: "revisions",
+	schema: Schema.Struct({ tenant: Schema.String, revision: Schema.NumberFromString, note: Schema.String }),
+	id: ["tenant", "revision"],
+	key: ["tenant"],
+	queue: { policy: "singleton" },
+});
+```
+
+`id` derives a deterministic UUID from the queue name and its ordered payload parts. Enqueuing the same parts again returns `None` while pg-boss retains that job, even if other fields change. Different queue names have separate identities. Here, different revisions create separate jobs while sharing the tenant's singleton key. Callers cannot pass an `id` or `singletonKey` that the queue owns.
+
+Both declarations accept fields whose decoded values are strings, numbers, booleans or null. Parts preserve value types and field boundaries, including separators in strings. An empty list gives every payload the same identity within the queue. Omit `id` to keep pg-boss's generated IDs or caller-supplied IDs. Identity is separate from tracing metadata.
+
 ### Size batches against expiry
 
 pg-boss marks every job in a fetched batch active together. Each job's expiry window starts at its stored `startedOn`, including time waiting for earlier handlers. Size each queue's batch so its sequential work fits within that window; use a small batch for long-running work and keep the default for short work:
@@ -402,6 +420,16 @@ export const readJobCounts = Effect.gen(function* () {
 
 `health([{ name: "cleanup-mail" }])` reads only the supplied queues, in order, even when another runtime registered them. Omitting the argument keeps the Layer's registered names. Admin pages use this to include worker-only schedules without registering those schedules in the request runtime.
 
+### Inspect stored work
+
+`PgBossInspection` from `@shivaedev/jobs/server/inspection.ts` exposes the shared read service used by admin pages and the testing controller. Provide `PgBossInspection.layer` with your `pgBossLayer`, or obtain the same reads from a configured jobs runtime with `yield* jobs.inspection()`.
+
+`storedJobs(queue, options?)` reads native stored metadata and encoded payloads. `jobs(queue, options?)` decodes stored payloads through the supplied queue Schema and includes native state, `startAfter`, `expireInSeconds`, `startedOn` and `keepUntil`. These reads include unredacted payloads; keep them inside trusted server code. The admin-facing `getJob`, `failedJobs` and `deadLetteredJobs` reads retain their payload redaction. `deferred(queue)` reads stored RetryAt reasons and requested times, while `snapshot(queues)` lists unfinished work with future RetryAt attempts marked `deferred`. `counts`, `health`, `queue`, `schedules`, `schemaVersion` and `busy` serve queue diagnostics and controller readouts.
+
+`changes(queue?)` acquires a scoped PostgreSQL listener and returns `revision` and `waitForChange(after)`. Capture its revision before reading, then wait against that revision to avoid missing a change between the read and the wait. The signal wakes for committed job changes from any client, optionally filtered to one queue. It is a hint to read again, not a durable event log. The caller owns the listener's scope.
+
+Automatic migration and `installPgBossSchema` install the queue-change trigger. Applications using `migrate: false` run `installPgBossSchema` before using change signals. Custom clients need `getDb().listen` to subscribe.
+
 ### Administer queues and schedules
 
 `unschedule(schedule)` removes the registration named by the schedule definition and its `scheduleOptions.key` (the empty key by default). Other keys for that queue stay registered. A missing registration fails with `PgBossNotFoundError`, carrying `operation: "unschedule"`, `queue` and `key`.
@@ -527,7 +555,7 @@ Include every target queue in `jobs`, as either a worker or a producer-only defi
 
 `linkedWorkerSpans(sender, spans)` from `@shivaedev/jobs/server/testing.ts` reads native recorded Effect spans and returns the pg-boss consumer spans whose links match both the sender's `traceId` and `spanId`. It returns every matching attempt, including retries, and no matches before a worker runs. An untraced job has no sender link. Settle the workers before reading their completed attempts; this readout does not wait or read queue storage.
 
-`testing.ts` gives story kits a controller for one real pg-boss client. Create a fresh controller per runtime, pass its `clientFactory` to `pgBossLayer`, and keep that Layer scoped as usual. `jobs(queue, options?)` returns jobs-owned `Job` metadata with `data` decoded through the queue's Schema, including traced payloads. Invalid durable data fails with `PgBossPayloadError`; decoding services remain in the Effect's requirements.
+`testing.ts` gives story kits a controller for one real pg-boss client. Create a fresh controller per runtime, pass its `clientFactory` to `pgBossLayer`, and keep that Layer scoped as usual. `jobs(queue, options?)` returns jobs-owned `Job` metadata with `data` decoded through the queue's Schema, including traced payloads. For a scheduled run with no payload, pass `{ name: Cleanup.name, schema: Schema.Null }` to read `data: null`. Invalid durable data fails with `PgBossPayloadError`; decoding services remain in the Effect's requirements.
 
 This producer story uses the `SendEmail` definition and `Jobs` service from above. `databaseUrl` points to the story's PostgreSQL database:
 
@@ -563,13 +591,15 @@ emailStories.it("decodes the queued email", [], function* ({ enqueue, testing })
 
 Set `retryPolicy: testRetryPolicy` through the controller to override queue and send settings with `retryDelay: 0` and `retryBackoff: false`. A failing worker can then exhaust its native retries without production backoff. The policy applies to subsequently sent jobs; it does not rewrite jobs already stored.
 
-`schedules()` lists registered schedules as `{ name, cron, timezone }` entries from PostgreSQL. `trigger(schedule)` takes a schedule definition, such as `Cleanup`, and enqueues one run now using its stored schedule data and options. Register `Cleanup.run(effect)` in the testing Layer first, then yield `testing.trigger(Cleanup)` and `testing.waitForIdle` before observing the Effect's result. An unregistered schedule fails with `PgBossTestingError` (`operation: "trigger"`).
+`schedules()` lists registered schedules as `{ name, cron, timezone }` entries from PostgreSQL. `trigger(schedule)` takes a schedule definition, such as `Cleanup`, and enqueues one run now using its stored schedule data and options. It returns the run ID, or null when pg-boss suppresses the send. Register `Cleanup.run(effect)` in the testing Layer first, then yield `testing.trigger(Cleanup)` and `testing.waitForIdle` before observing the Effect's result. An unregistered schedule fails with `PgBossTestingError` (`operation: "trigger"`).
+
+`refreshQueueStats(queue?)` requests a native pg-boss supervisor pass for one queue, or all queues when omitted, before reading cached counts through the jobs service's `health`. Like the service method, it performs native queue maintenance and respects pg-boss monitor intervals and backoff.
 
 `failNextSend(queue)` arms one send failure for that queue. The next valid `enqueue` fails with the usual typed `PgBossError` (`operation: "enqueue"`); the following send proceeds normally.
 
 `expireAfter(queue, n)` takes a positive attempt count: configure it before enqueueing to limit subsequent jobs to `n` attempts. Each successful send keeps its own expiry rule; later changes and duplicate-ID sends do not alter pending jobs. Earlier attempts run the handler normally; on attempt `n`, the controller expires the claimed job instead of invoking its handler. PostgreSQL supervision performs the terminal failure and dead lettering. A job that succeeds earlier completes normally.
 
-`expireIn(queue, duration)` takes an Effect `Duration.Input`, such as `"1 second"`, and sets the expiry of subsequent sends, rounded up to whole seconds. Durations below one second or nonfinite durations fail with `PgBossTestingError` (`operation: "expireIn"`). Earlier sends retain their expiry, and later calls and duplicate-ID sends do not change stored jobs. It can be combined with `expireAfter`: one sets each attempt's time budget, the other limits attempts. A stuck handler is interrupted at its deadline, and the same worker can fetch its retry after pg-boss fails the attempt. The testing expiry hooks support pg-boss schema version 46.
+`expireIn(queue, duration)` takes an Effect `Duration.Input`, such as `"1 second"`, and sets the expiry of subsequent sends, rounded up to whole seconds. Durations below one second or nonfinite durations fail with `PgBossTestingError` (`operation: "expireIn"`). Earlier sends retain their expiry, and later calls and duplicate-ID sends do not change stored jobs. Both expiry controls also apply to runs sent by `trigger(schedule)`. It can be combined with `expireAfter`: one sets each attempt's time budget, the other limits attempts. A stuck handler is interrupted at its deadline, and the same worker can fetch its retry after pg-boss fails the attempt. The testing expiry hooks support pg-boss schema version 46.
 
 `runDueNow(queue)` makes future jobs in the queue's `created` or `retry` state due at the database's current time and wakes local workers. It includes delayed sends (`startAfter`), native retries and `RetryAt` deferrals. Yield `waitForIdle` afterwards before observing handler results; future jobs do not hold that wait open. It leaves active and terminal jobs and other queues unchanged.
 
@@ -583,7 +613,7 @@ Set `retryPolicy: testRetryPolicy` through the controller to override queue and
 
 A kit can also capture `revision` before reading jobs and yield `waitForChange(revision)` when its condition is unmet. The wait resumes after a local send, settlement or worker fetch, and when a local worker returns to idle as `waitForIdle` defines it, including terminal native worker timeouts. It also resumes immediately if a change occurred between the read and the wait. This signal observes the controller's client; external clients, future scheduled work and external database writes need their own wake source. Stories should retain a bounded test timeout.
 
-`untilJob(queue, id, state)` waits that way for one job: it reads the job, waits for the next change when the job is in another state, and returns the job with `data` decoded through the queue's Schema once it reaches `state`. `fetchesPass(queue, n)` completes once `n` worker fetches on the queue that began after the wait started have finished, whether or not they claimed anything, so a story can show that a job stayed untaken by fetches that could have claimed it. Each fetch also counts as a change for `waitForChange`. Both waits give up after `within` (default 20 seconds) of wall time, which a story's `TestClock` does not move, and fail with `PgBossWaitError`, whose message names what the wait expected and what it last saw:
+`untilJob(queue, id, state)` waits that way for one job: it reads the job, waits for the next change when the job is in another state, and returns the job with `data` decoded through the queue's Schema once it reaches `state`. It also accepts `{ name, schema: Schema.Null }` for a triggered schedule's run. `fetchesPass(queue, n)` completes once `n` worker fetches on the queue that began after the wait started have finished, whether or not they claimed anything, so a story can show that a job stayed untaken by fetches that could have claimed it. Each fetch also counts as a change for `waitForChange`. Both waits give up after `within` (default 20 seconds) of wall time, which a story's `TestClock` does not move, and fail with `PgBossWaitError`, whose message names what the wait expected and what it last saw:
 
 ```ts
 yield* testing.untilJob(SendEmail, id, "completed", { within: "5 seconds" });
@@ -594,26 +624,27 @@ yield* testing.untilJob(SendEmail, id, "completed", { within: "5 seconds" });
 
 Import the module that defines the name; the package has no root entry.
 
-| Module                                                    | Public names                                                                                                                                                                                                                                      |
-| --------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `@shivaedev/jobs/display.ts`                              | `QueueDisplay`, `SubjectColumn`                                                                                                                                                                                                                   |
-| `@shivaedev/jobs/server/definition.ts`                    | `defineQueue`, `jobContext`, `RetryAt`; `DefineQueueOptions`, `DefineScheduleOptions`, `JobContext`, `JobPayloadSchema`, `JobRegistration`, `QueueDefinition`, `QueueWorker`, `RegistrationRequirements`, `ScheduleDefinition`, `ScheduledWorker` |
-| `@shivaedev/jobs/server/service.ts`                       | `makePgBoss`, `pgBossLayer`; `PgBossDefinition`, `PgBossLayerOptions`, `PgBossOptions`, `PgBossService`                                                                                                                                           |
-| `@shivaedev/jobs/server/PgBoss.ts`                        | `PgBoss`: the shared client Context service.                                                                                                                                                                                                      |
-| `@shivaedev/jobs/server/schema.ts`                        | `installPgBossSchema`, `pgBossSchema`; `PgBossSchemaOptions`                                                                                                                                                                                      |
-| `@shivaedev/jobs/server/health.ts`                        | `deadLetterQueueName`; `DeadLetteredJob`, `JobPage`, `JobPageOptions`, `JobsHealth`, `ListedJob`, `QueueCounts`, `QueueHealth`                                                                                                                    |
-| `@shivaedev/jobs/server/error.ts`                         | `PgBossError`, `PgBossNotFoundError`, `PgBossPayloadError`, `PgBossQueueNamesError`, `PgBossQueueOptionsError`, `PgBossClientOptionsError`, `PgBossTestingError`, `PgBossWaitError`, `toPgBossError`; `PgBossOperation`                           |
-| `@shivaedev/jobs/server/queueOptions.ts`                  | `QueueOptions`, `QueuePolicy`, `RetryOptions`                                                                                                                                                                                                     |
-| `@shivaedev/jobs/server/workerOptions.ts`                 | `WorkerOptions`, `GroupConcurrencyConfig`                                                                                                                                                                                                         |
-| `@shivaedev/jobs/server/enqueueOptions.ts`                | `EnqueueOptions`, `ScheduleOptions`                                                                                                                                                                                                               |
-| `@shivaedev/jobs/server/job.ts`                           | `Job`, `JobState`, `WorkerJob`                                                                                                                                                                                                                    |
-| `@shivaedev/jobs/server/clientOptions.ts`                 | `ClientOptions`, `StopOptions`, `Clock`, `ReindexOptions`, `IndexBloatOptions`                                                                                                                                                                    |
-| `@shivaedev/jobs/server/ClientDatabase.ts`                | `ClientDatabase`                                                                                                                                                                                                                                  |
-| `@shivaedev/jobs/server/engineClient.ts`                  | `EngineClient`, `EngineSchedule`                                                                                                                                                                                                                  |
-| `@shivaedev/jobs/server/client.ts`                        | `PgBossClient`, `PgBossClientFactory`                                                                                                                                                                                                             |
-| `@shivaedev/jobs/server/testing.ts`                       | `makePgBossTesting`, `testRetryPolicy`; `PgBossTesting`, `PgBossTestingOptions`, `PgBossTestingWaitOptions`, `SnapshotQueue`, `UnfinishedJob`                                                                                                     |
-| `@shivaedev/jobs/server/defineSchedule.ts`                | `defineSchedule`                                                                                                                                                                                                                                  |
-| `@shivaedev/jobs/server/adapters/defaultClientFactory.ts` | `defaultClientFactory`                                                                                                                                                                                                                            |
+| Module                                                    | Public names                                                                                                                                                                                                                                                      |
+| --------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@shivaedev/jobs/display.ts`                              | `QueueDisplay`, `SubjectColumn`                                                                                                                                                                                                                                   |
+| `@shivaedev/jobs/server/definition.ts`                    | `defineQueue`, `jobContext`, `RetryAt`; `DefineQueueOptions`, `DefineScheduleOptions`, `JobContext`, `JobPayloadSchema`, `JobRegistration`, `PayloadParts`, `QueueDefinition`, `QueueWorker`, `RegistrationRequirements`, `ScheduleDefinition`, `ScheduledWorker` |
+| `@shivaedev/jobs/server/service.ts`                       | `makePgBoss`, `pgBossLayer`; `PgBossDefinition`, `PgBossLayerOptions`, `PgBossOptions`, `PgBossService`                                                                                                                                                           |
+| `@shivaedev/jobs/server/PgBoss.ts`                        | `PgBoss`: the shared client Context service.                                                                                                                                                                                                                      |
+| `@shivaedev/jobs/server/schema.ts`                        | `installPgBossSchema`, `pgBossSchema`; `PgBossSchemaOptions`                                                                                                                                                                                                      |
+| `@shivaedev/jobs/server/health.ts`                        | `deadLetterQueueName`; `DeadLetteredJob`, `JobPage`, `JobPageOptions`, `JobsHealth`, `ListedJob`, `QueueCounts`, `QueueHealth`                                                                                                                                    |
+| `@shivaedev/jobs/server/error.ts`                         | `PgBossError`, `PgBossNotFoundError`, `PgBossPayloadError`, `PgBossQueueNamesError`, `PgBossQueueOptionsError`, `PgBossClientOptionsError`, `PgBossTestingError`, `PgBossWaitError`, `toPgBossError`; `PgBossOperation`                                           |
+| `@shivaedev/jobs/server/queueOptions.ts`                  | `QueueOptions`, `QueuePolicy`, `RetryOptions`                                                                                                                                                                                                                     |
+| `@shivaedev/jobs/server/workerOptions.ts`                 | `WorkerOptions`, `GroupConcurrencyConfig`                                                                                                                                                                                                                         |
+| `@shivaedev/jobs/server/enqueueOptions.ts`                | `EnqueueOptions`, `QueueEnqueueOptions`, `ScheduleOptions`                                                                                                                                                                                                        |
+| `@shivaedev/jobs/server/job.ts`                           | `Job`, `JobState`, `WorkerJob`                                                                                                                                                                                                                                    |
+| `@shivaedev/jobs/server/clientOptions.ts`                 | `ClientOptions`, `StopOptions`, `Clock`, `ReindexOptions`, `IndexBloatOptions`                                                                                                                                                                                    |
+| `@shivaedev/jobs/server/ClientDatabase.ts`                | `ClientDatabase`                                                                                                                                                                                                                                                  |
+| `@shivaedev/jobs/server/engineClient.ts`                  | `EngineClient`, `EngineSchedule`                                                                                                                                                                                                                                  |
+| `@shivaedev/jobs/server/client.ts`                        | `PgBossClient`, `PgBossClientFactory`                                                                                                                                                                                                                             |
+| `@shivaedev/jobs/server/inspection.ts`                    | `PgBossInspection`; `PgBossInspectionService`                                                                                                                                                                                                                     |
+| `@shivaedev/jobs/server/testing.ts`                       | `makePgBossTesting`, `testRetryPolicy`; `PgBossTesting`, `PgBossTestingOptions`, `PgBossTestingWaitOptions`                                                                                                                                                       |
+| `@shivaedev/jobs/server/defineSchedule.ts`                | `defineSchedule`                                                                                                                                                                                                                                                  |
+| `@shivaedev/jobs/server/adapters/defaultClientFactory.ts` | `defaultClientFactory`                                                                                                                                                                                                                                            |
 
 Jobs declares its public types independently of pg-boss. The option fields keep their familiar names: `queue` uses `QueueOptions`, including literal `QueuePolicy` values and `maxDeferrals`; `worker` uses `WorkerOptions`; a schedule's `schedule` uses `ScheduleOptions`; enqueueing uses `EnqueueOptions`. A queue also requires `name` and `schema`; a schedule requires `name` and `cron`.
 

package/dist/server/adapters/inspection.d.ts

@@ -0,0 +1,5 @@
+import { Effect } from "effect";
+import type { PgBossClient } from "#server/client.ts";
+import type { PgBossInspectionService } from "#server/inspection.ts";
+export declare function inspection(client: PgBossClient, schema?: string): Effect.Effect<PgBossInspectionService>;
+//# sourceMappingURL=inspection.d.ts.map

package/dist/server/adapters/inspection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspection.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/inspection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AASrE,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,SAAW,GAAG,MAAM,CAAC,MAAM,CAAC,uBAAuB,CAAC,CAkB1G"}

package/dist/server/adapters/inspection.js

@@ -0,0 +1,25 @@
+import { Effect } from "effect";
+import { jobEngine } from "#server/adapters/jobEngine.ts";
+import { countsFor } from "#server/internal/countsFor.ts";
+import { JobEngine } from "#server/internal/engine.ts";
+import { healthFor } from "#server/internal/healthFor.ts";
+import { jobControl } from "#server/internal/jobControl.ts";
+import { jobListings } from "#server/internal/jobListings.ts";
+import { inspectionChanges } from "./inspectionChanges.js";
+import { inspectionReads } from "./inspectionReads.js";
+export function inspection(client, schema = "pgboss") {
+    const engine = jobEngine(client, schema);
+    return Effect.gen(function* () {
+        const listings = yield* jobListings;
+        const { getJob } = yield* jobControl;
+        return {
+            ...inspectionReads(client, schema),
+            ...listings,
+            changes: (queue) => inspectionChanges(client, schema, queue?.name),
+            counts: (queue) => countsFor(client, schema, queue.name),
+            getJob,
+            health: (queues) => healthFor(client, queues.map((queue) => queue.name)),
+        };
+    }).pipe(Effect.provideService(JobEngine, engine));
+}
+//# sourceMappingURL=inspection.js.map

package/dist/server/adapters/inspection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspection.js","sourceRoot":"","sources":["../../../src/server/adapters/inspection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAG1D,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,UAAU,UAAU,CAAC,MAAoB,EAAE,MAAM,GAAG,QAAQ;IACjE,MAAM,MAAM,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,OAAO,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QAC1B,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,WAAW,CAAC;QACpC,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC,UAAU,CAAC;QACrC,OAAO;YACN,GAAG,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC;YAClC,GAAG,QAAQ;YACX,OAAO,EAAE,CAAC,KAAiC,EAAE,EAAE,CAAC,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC;YAC9F,MAAM,EAAE,CAAC,KAAgC,EAAE,EAAE,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC;YACnF,MAAM;YACN,MAAM,EAAE,CAAC,MAA4C,EAAE,EAAE,CACxD,SAAS,CACR,MAAM,EACN,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CACjC;SACF,CAAC;IACH,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC;AACnD,CAAC"}

package/dist/server/adapters/inspectionChanges.d.ts

@@ -0,0 +1,7 @@
+import { Effect } from "effect";
+import type { PgBossClient } from "#server/client.ts";
+export declare const inspectionChanges: (client: PgBossClient, schema: string, queue?: string | undefined) => Effect.Effect<{
+    revision: Effect.Effect<number, never, never>;
+    waitForChange: (after: number) => Effect.Effect<number>;
+}, import("#server/error.ts").PgBossError, import("effect/Scope").Scope>;
+//# sourceMappingURL=inspectionChanges.d.ts.map

package/dist/server/adapters/inspectionChanges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectionChanges.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/inspectionChanges.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAItD,eAAO,MAAM,iBAAiB;;;wEAwB5B,CAAC"}

package/dist/server/adapters/inspectionChanges.js

@@ -0,0 +1,23 @@
+import { Effect } from "effect";
+import { inspectionChannel } from "#server/adapters/inspectionPlan.ts";
+import { toPgBossError } from "#server/error.ts";
+import { queueSignal } from "./queueSignal.js";
+export const inspectionChanges = Effect.fnUntraced(function* (client, schema, queue) {
+    const signal = queueSignal();
+    yield* Effect.acquireRelease(Effect.tryPromise({
+        catch: (error) => toPgBossError("inspect", error, queue),
+        try: () => {
+            const db = client.getDb?.();
+            if (db?.listen === undefined) {
+                throw new TypeError("This pg-boss client does not support listen");
+            }
+            return db.listen(inspectionChannel(schema), (name) => {
+                if (queue === undefined || name === queue) {
+                    signal.changed();
+                }
+            }, signal.changed);
+        },
+    }), (listener) => Effect.promise(() => listener.close()));
+    return { revision: signal.revision, waitForChange: signal.waitForChange };
+});
+//# sourceMappingURL=inspectionChanges.js.map

package/dist/server/adapters/inspectionChanges.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectionChanges.js","sourceRoot":"","sources":["../../../src/server/adapters/inspectionChanges.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAEvE,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAoB,EAAE,MAAc,EAAE,KAAc;IACjH,MAAM,MAAM,GAAG,WAAW,EAAE,CAAC;IAC7B,KAAK,CAAC,CAAC,MAAM,CAAC,cAAc,CAC3B,MAAM,CAAC,UAAU,CAAC;QACjB,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,aAAa,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC;QACxD,GAAG,EAAE,GAAG,EAAE;YACT,MAAM,EAAE,GAAG,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC;YAC5B,IAAI,EAAE,EAAE,MAAM,KAAK,SAAS,EAAE,CAAC;gBAC9B,MAAM,IAAI,SAAS,CAAC,6CAA6C,CAAC,CAAC;YACpE,CAAC;YACD,OAAO,EAAE,CAAC,MAAM,CACf,iBAAiB,CAAC,MAAM,CAAC,EACzB,CAAC,IAAI,EAAE,EAAE;gBACR,IAAI,KAAK,KAAK,SAAS,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC;oBAC3C,MAAM,CAAC,OAAO,EAAE,CAAC;gBAClB,CAAC;YACF,CAAC,EACD,MAAM,CAAC,OAAO,CACd,CAAC;QACH,CAAC;KACD,CAAC,EACF,CAAC,QAAQ,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CACpD,CAAC;IACF,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,CAAC,aAAa,EAAE,CAAC;AAC3E,CAAC,CAAC,CAAC"}

package/dist/server/adapters/inspectionDeferrals.d.ts

@@ -0,0 +1,10 @@
+import { DateTime, Effect } from "effect";
+import type { PgBossClient } from "#server/client.ts";
+import type { QueueDefinition } from "#server/definition.ts";
+export declare function inspectionDeferrals(client: PgBossClient): {
+    deferred: (queue: Pick<QueueDefinition, "name">) => Effect.Effect<{
+        at: DateTime.Utc;
+        reason: string;
+    }[], import("../error.ts").PgBossError, never>;
+};
+//# sourceMappingURL=inspectionDeferrals.d.ts.map

package/dist/server/adapters/inspectionDeferrals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectionDeferrals.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/inspectionDeferrals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAI7D,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY;IAGtD,QAAQ,UAAU,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC;;;;EAUhD"}

package/dist/server/adapters/inspectionDeferrals.js

@@ -0,0 +1,13 @@
+import { DateTime, Effect } from "effect";
+import { deferralOf } from "#server/internal/deferral.ts";
+import { inspectionJobs } from "./inspectionJobs.js";
+export function inspectionDeferrals(client) {
+    const { storedJobs } = inspectionJobs(client);
+    return {
+        deferred: (queue) => storedJobs(queue).pipe(Effect.map((jobs) => jobs.flatMap((job) => {
+            const deferral = job.state === "retry" && job.startedOn === null ? deferralOf(job) : undefined;
+            return deferral === undefined ? [] : [{ at: DateTime.makeUnsafe(job.startAfter), reason: deferral.reason }];
+        }))),
+    };
+}
+//# sourceMappingURL=inspectionDeferrals.js.map

package/dist/server/adapters/inspectionDeferrals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectionDeferrals.js","sourceRoot":"","sources":["../../../src/server/adapters/inspectionDeferrals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAG1C,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,MAAM,UAAU,mBAAmB,CAAC,MAAoB;IACvD,MAAM,EAAE,UAAU,EAAE,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;IAC9C,OAAO;QACN,QAAQ,EAAE,CAAC,KAAoC,EAAE,EAAE,CAClD,UAAU,CAAC,KAAK,CAAC,CAAC,IAAI,CACrB,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CACnB,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;YACpB,MAAM,QAAQ,GAAG,GAAG,CAAC,KAAK,KAAK,OAAO,IAAI,GAAG,CAAC,SAAS,KAAK,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAC/F,OAAO,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;QAC7G,CAAC,CAAC,CACF,CACD;KACF,CAAC;AACH,CAAC"}

package/dist/server/adapters/inspectionJobs.d.ts

@@ -0,0 +1,50 @@
+import { Effect, type Schema } from "effect";
+import type { JobReadOptions, PgBossClient } from "#server/client.ts";
+import type { JobPayloadSchema } from "#server/definition.ts";
+export declare function inspectionJobs(client: PgBossClient): {
+    jobs: <TName extends string, TPayload extends JobPayloadSchema | typeof Schema.Null>(queue: {
+        readonly name: TName;
+        readonly schema: TPayload;
+    }, options?: JobReadOptions) => Effect.Effect<{
+        expireInSeconds: number;
+        groupId?: string | null;
+        groupTier?: string | null;
+        heartbeatSeconds: number | null;
+        id: string;
+        name: string;
+        retryCount: number;
+        signal: AbortSignal;
+        blocked: boolean;
+        blocking: boolean;
+        completedOn: Date | null;
+        createdOn: Date;
+        deadLetter: string;
+        deleteAfterSeconds: number;
+        heartbeatOn: Date | null;
+        keepUntil: Date;
+        output: object | null;
+        pendingDependencies: number;
+        policy: string;
+        priority: number;
+        retryBackoff: boolean;
+        retryDelay: number;
+        retryDelayMax?: number;
+        retryLimit: number;
+        singletonKey: string | null;
+        singletonOn: Date | null;
+        sourceCreatedOn: Date | null;
+        sourceId: string | null;
+        sourceName: string | null;
+        sourceOutput: object | null;
+        sourceRetryCount: number | null;
+        sourceRootId: string | null;
+        startAfter: Date;
+        startedOn: Date | null;
+        state: import("../job.ts").JobState;
+        data: TPayload["Type"];
+    }[], import("#server/error.ts").PgBossError | import("#server/error.ts").PgBossPayloadError, TPayload["DecodingServices"]>;
+    storedJobs: (queue: {
+        readonly name: string;
+    }, options?: JobReadOptions) => Effect.Effect<readonly import("../job.ts").Job<unknown>[], import("#server/error.ts").PgBossError, never>;
+};
+//# sourceMappingURL=inspectionJobs.d.ts.map

package/dist/server/adapters/inspectionJobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectionJobs.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/inspectionJobs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAI9D,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY;WAYpC,KAAK,SAAS,MAAM,EAAE,QAAQ,SAAS,gBAAgB,GAAG,OAAO,MAAM,CAAC,IAAI,SAClF;QAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAA;KAAE,YAChD,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAbE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,YAAY,cAAc;EAoB9E"}

package/dist/server/adapters/inspectionJobs.js

@@ -0,0 +1,21 @@
+import { Effect } from "effect";
+import { toPgBossError } from "#server/error.ts";
+import { decodeStoredData } from "#server/internal/storedRows.ts";
+export function inspectionJobs(client) {
+    function storedJobs(queue, options) {
+        return Effect.tryPromise({
+            catch: (error) => toPgBossError("inspect", error, queue.name),
+            try: () => {
+                if (client.findJobs === undefined) {
+                    throw new TypeError("This pg-boss client does not support findJobs");
+                }
+                return client.findJobs(queue.name, options);
+            },
+        });
+    }
+    function jobs(queue, options) {
+        return storedJobs(queue, options).pipe(Effect.flatMap((rows) => Effect.forEach(rows, (job) => decodeStoredData(queue, job.data).pipe(Effect.map((data) => ({ ...job, data }))))));
+    }
+    return { jobs, storedJobs };
+}
+//# sourceMappingURL=inspectionJobs.js.map

package/dist/server/adapters/inspectionJobs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectionJobs.js","sourceRoot":"","sources":["../../../src/server/adapters/inspectionJobs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAe,MAAM,QAAQ,CAAC;AAG7C,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAElE,MAAM,UAAU,cAAc,CAAC,MAAoB;IAClD,SAAS,UAAU,CAAC,KAAgC,EAAE,OAAwB;QAC7E,OAAO,MAAM,CAAC,UAAU,CAAC;YACxB,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,aAAa,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC;YAC7D,GAAG,EAAE,GAAG,EAAE;gBACT,IAAI,MAAM,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;oBACnC,MAAM,IAAI,SAAS,CAAC,+CAA+C,CAAC,CAAC;gBACtE,CAAC;gBACD,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;YAC7C,CAAC;SACD,CAAC,CAAC;IACJ,CAAC;IACD,SAAS,IAAI,CACZ,KAA0D,EAC1D,OAAwB;QAExB,OAAO,UAAU,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,IAAI,CACrC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,gBAAgB,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CACzI,CAAC;IACH,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AAC7B,CAAC"}

package/dist/server/adapters/inspectionOperation.d.ts

@@ -0,0 +1,3 @@
+import { Effect } from "effect";
+export declare function inspectionOperation<A>(run: () => Promise<A>, queue?: string): Effect.Effect<A, import("#server/error.ts").PgBossError, never>;
+//# sourceMappingURL=inspectionOperation.d.ts.map

package/dist/server/adapters/inspectionOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectionOperation.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/inspectionOperation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,mEAE3E"}

package/dist/server/adapters/inspectionOperation.js

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import { toPgBossError } from "#server/error.ts";
+export function inspectionOperation(run, queue) {
+    return Effect.tryPromise({ catch: (error) => toPgBossError("inspect", error, queue), try: run });
+}
+//# sourceMappingURL=inspectionOperation.js.map

package/dist/server/adapters/inspectionOperation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectionOperation.js","sourceRoot":"","sources":["../../../src/server/adapters/inspectionOperation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,MAAM,UAAU,mBAAmB,CAAI,GAAqB,EAAE,KAAc;IAC3E,OAAO,MAAM,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,aAAa,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC;AAClG,CAAC"}

package/dist/server/adapters/inspectionPlan.d.ts

@@ -0,0 +1,3 @@
+export declare function inspectionChannel(schema: string): string;
+export declare function inspectionPlan(schema: string): string;
+//# sourceMappingURL=inspectionPlan.d.ts.map

package/dist/server/adapters/inspectionPlan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectionPlan.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/inspectionPlan.ts"],"names":[],"mappings":"AAEA,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAcrD"}

package/dist/server/adapters/inspectionPlan.js

@@ -0,0 +1,20 @@
+import { quotedSchema } from "#server/internal/storedRows.ts";
+export function inspectionChannel(schema) {
+    return `jobs:${schema}`;
+}
+export function inspectionPlan(schema) {
+    const quoted = quotedSchema(schema);
+    const channel = inspectionChannel(schema).replaceAll("'", "''");
+    const body = `BEGIN
+	CREATE OR REPLACE FUNCTION ${quoted}.effect_job_changed() RETURNS trigger LANGUAGE plpgsql AS $body$
+	BEGIN
+		PERFORM pg_notify('${channel}', COALESCE(NEW.name, OLD.name));
+		RETURN NULL;
+	END
+	$body$;
+	CREATE OR REPLACE TRIGGER effect_job_changed AFTER INSERT OR UPDATE OR DELETE ON ${quoted}.job
+	FOR EACH ROW EXECUTE FUNCTION ${quoted}.effect_job_changed();
+	END`;
+    return `DO '${body.replaceAll("'", "''")}'`;
+}
+//# sourceMappingURL=inspectionPlan.js.map

package/dist/server/adapters/inspectionPlan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectionPlan.js","sourceRoot":"","sources":["../../../src/server/adapters/inspectionPlan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAE9D,MAAM,UAAU,iBAAiB,CAAC,MAAc;IAC/C,OAAO,QAAQ,MAAM,EAAE,CAAC;AACzB,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,MAAc;IAC5C,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;IACpC,MAAM,OAAO,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IAChE,MAAM,IAAI,GAAG;8BACgB,MAAM;;uBAEb,OAAO;;;;oFAIsD,MAAM;iCACzD,MAAM;KAClC,CAAC;IACL,OAAO,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC;AAC7C,CAAC"}

package/dist/server/adapters/inspectionReads.d.ts

@@ -0,0 +1,59 @@
+import { Schema } from "effect";
+import type { PgBossClient } from "#server/client.ts";
+import type { QueueDefinition } from "#server/definition.ts";
+export declare function inspectionReads(client: PgBossClient, schema: string): {
+    jobs: <TName extends string, TPayload extends import("#server/definition.ts").JobPayloadSchema | typeof Schema.Null>(queue: {
+        readonly name: TName;
+        readonly schema: TPayload;
+    }, options?: import("#server/client.ts").JobReadOptions) => import("effect/Effect").Effect<{
+        expireInSeconds: number;
+        groupId?: string | null;
+        groupTier?: string | null;
+        heartbeatSeconds: number | null;
+        id: string;
+        name: string;
+        retryCount: number;
+        signal: AbortSignal;
+        blocked: boolean;
+        blocking: boolean;
+        completedOn: Date | null;
+        createdOn: Date;
+        deadLetter: string;
+        deleteAfterSeconds: number;
+        heartbeatOn: Date | null;
+        keepUntil: Date;
+        output: object | null;
+        pendingDependencies: number;
+        policy: string;
+        priority: number;
+        retryBackoff: boolean;
+        retryDelay: number;
+        retryDelayMax?: number;
+        retryLimit: number;
+        singletonKey: string | null;
+        singletonOn: Date | null;
+        sourceCreatedOn: Date | null;
+        sourceId: string | null;
+        sourceName: string | null;
+        sourceOutput: object | null;
+        sourceRetryCount: number | null;
+        sourceRootId: string | null;
+        startAfter: Date;
+        startedOn: Date | null;
+        state: import("../job.ts").JobState;
+        data: TPayload["Type"];
+    }[], import("../error.ts").PgBossError | import("../error.ts").PgBossPayloadError, TPayload["DecodingServices"]>;
+    storedJobs: (queue: {
+        readonly name: string;
+    }, options?: import("#server/client.ts").JobReadOptions) => import("effect/Effect").Effect<readonly import("../job.ts").Job<unknown>[], import("../error.ts").PgBossError, never>;
+    deferred: (queue: Pick<QueueDefinition, "name">) => import("effect/Effect").Effect<{
+        at: import("effect/DateTime").Utc;
+        reason: string;
+    }[], import("../error.ts").PgBossError, never>;
+    busy: (queues: readonly Pick<QueueDefinition, "name">[]) => import("effect/Effect").Effect<boolean, import("../error.ts").PgBossError, never>;
+    queue: (queue: Pick<QueueDefinition, "name">) => import("effect/Effect").Effect<import("#server/client.ts").ClientQueue | null, import("../error.ts").PgBossError, never>;
+    schedules: (name?: string, key?: string) => import("effect/Effect").Effect<import("../engineClient.ts").EngineSchedule[], import("../error.ts").PgBossError, never>;
+    schemaVersion: () => import("effect/Effect").Effect<number | null, import("../error.ts").PgBossError, never>;
+    snapshot: <const TQueues extends readonly import("../inspection.ts").SnapshotQueue[]>(queues: TQueues) => import("effect/Effect").Effect<readonly import("../inspection.ts").UnfinishedJob<TQueues[number]>[], import("../error.ts").PgBossPayloadError | import("../error.ts").PgBossError, TQueues[number]["schema"]["DecodingServices"]>;
+};
+//# sourceMappingURL=inspectionReads.d.ts.map

package/dist/server/adapters/inspectionReads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectionReads.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/inspectionReads.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAKhC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAI7D,wBAAgB,eAAe,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAWnD,SAAS,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,EAAE;mBAaxC,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC;uBACzB,MAAM,QAAQ,MAAM;;;EAmBxC"}

package/dist/server/adapters/inspectionReads.js

@@ -0,0 +1,44 @@
+import { Schema } from "effect";
+import { inspectionDeferrals } from "#server/adapters/inspectionDeferrals.ts";
+import { inspectionJobs } from "#server/adapters/inspectionJobs.ts";
+import { inspectionOperation } from "#server/adapters/inspectionOperation.ts";
+import { inspectionSnapshot } from "#server/adapters/inspectionSnapshot.ts";
+import { quotedSchema } from "#server/internal/storedRows.ts";
+const Busy = Schema.Struct({ busy: Schema.Boolean });
+export function inspectionReads(client, schema) {
+    const quoted = quotedSchema(schema);
+    function query(text, values) {
+        const db = client.getDb?.();
+        if (db === undefined) {
+            throw new TypeError("This pg-boss client does not support getDb");
+        }
+        return db.executeSql(text, values);
+    }
+    return {
+        ...inspectionDeferrals(client),
+        busy: (queues) => inspectionOperation(async () => {
+            const { rows } = await query(`/* jobs inspection busy */ SELECT EXISTS (
+				SELECT 1 FROM ${quoted}.job WHERE name = ANY($1::text[]) AND (
+					(state < 'active' AND NOT blocked AND start_after <= ${quoted}.job_now()) OR state = 'active'
+				)
+			) AS busy`, [queues.map(({ name }) => name)]);
+            return Schema.decodeUnknownSync(Busy)(rows[0]).busy;
+        }),
+        ...inspectionJobs(client),
+        queue: (queue) => inspectionOperation(() => client.getQueue(queue.name), queue.name),
+        schedules: (name, key) => inspectionOperation(() => {
+            if (client.getSchedules === undefined) {
+                throw new TypeError("This pg-boss client does not support getSchedules");
+            }
+            return client.getSchedules(name, key);
+        }),
+        schemaVersion: () => inspectionOperation(() => {
+            if (client.schemaVersion === undefined) {
+                throw new TypeError("This pg-boss client does not support schemaVersion");
+            }
+            return client.schemaVersion();
+        }),
+        snapshot: inspectionSnapshot(() => client, () => schema),
+    };
+}
+//# sourceMappingURL=inspectionReads.js.map

package/dist/server/adapters/inspectionReads.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectionReads.js","sourceRoot":"","sources":["../../../src/server/adapters/inspectionReads.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAC9E,OAAO,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAG5E,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAE9D,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;AACrD,MAAM,UAAU,eAAe,CAAC,MAAoB,EAAE,MAAc;IACnE,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;IACpC,SAAS,KAAK,CAAC,IAAY,EAAE,MAAkB;QAC9C,MAAM,EAAE,GAAG,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC;QAC5B,IAAI,EAAE,KAAK,SAAS,EAAE,CAAC;YACtB,MAAM,IAAI,SAAS,CAAC,4CAA4C,CAAC,CAAC;QACnE,CAAC;QACD,OAAO,EAAE,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACpC,CAAC;IACD,OAAO;QACN,GAAG,mBAAmB,CAAC,MAAM,CAAC;QAC9B,IAAI,EAAE,CAAC,MAAgD,EAAE,EAAE,CAC1D,mBAAmB,CAAC,KAAK,IAAI,EAAE;YAC9B,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,KAAK,CAC3B;oBACe,MAAM;4DACkC,MAAM;;aAErD,EACR,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAChC,CAAC;YACF,OAAO,MAAM,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACrD,CAAC,CAAC;QACH,GAAG,cAAc,CAAC,MAAM,CAAC;QACzB,KAAK,EAAE,CAAC,KAAoC,EAAE,EAAE,CAAC,mBAAmB,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC;QACnH,SAAS,EAAE,CAAC,IAAa,EAAE,GAAY,EAAE,EAAE,CAC1C,mBAAmB,CAAC,GAAG,EAAE;YACxB,IAAI,MAAM,CAAC,YAAY,KAAK,SAAS,EAAE,CAAC;gBACvC,MAAM,IAAI,SAAS,CAAC,mDAAmD,CAAC,CAAC;YAC1E,CAAC;YACD,OAAO,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QACvC,CAAC,CAAC;QACH,aAAa,EAAE,GAAG,EAAE,CACnB,mBAAmB,CAAC,GAAG,EAAE;YACxB,IAAI,MAAM,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;gBACxC,MAAM,IAAI,SAAS,CAAC,oDAAoD,CAAC,CAAC;YAC3E,CAAC;YACD,OAAO,MAAM,CAAC,aAAa,EAAE,CAAC;QAC/B,CAAC,CAAC;QACH,QAAQ,EAAE,kBAAkB,CAC3B,GAAG,EAAE,CAAC,MAAM,EACZ,GAAG,EAAE,CAAC,MAAM,CACZ;KACD,CAAC;AACH,CAAC"}

package/dist/server/adapters/inspectionSnapshot.d.ts

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import type { PgBossClient } from "#server/client.ts";
+import type { PgBossError, PgBossPayloadError } from "#server/error.ts";
+import type { SnapshotQueue, UnfinishedJob } from "#server/inspection.ts";
+export declare function inspectionSnapshot(client: () => PgBossClient, schema: () => string): <const TQueues extends readonly SnapshotQueue[]>(queues: TQueues) => Effect.Effect<readonly UnfinishedJob<TQueues[number]>[], PgBossPayloadError | PgBossError, TQueues[number]["schema"]["DecodingServices"]>;
+//# sourceMappingURL=inspectionSnapshot.d.ts.map

package/dist/server/adapters/inspectionSnapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectionSnapshot.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/inspectionSnapshot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAC;AAExC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAa1E,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,YAAY,EAAE,MAAM,EAAE,MAAM,MAAM,IAC1E,KAAK,CAAC,OAAO,SAAS,SAAS,aAAa,EAAE,UAC7C,OAAO,KACb,MAAM,CAAC,MAAM,CAAC,SAAS,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,kBAAkB,GAAG,WAAW,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAiC5I"}