npm - @daloyjs/core - Versions diffs - 1.2.1 → 1.3.1 - Mend

@daloyjs/core 1.2.1 → 1.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/README.md CHANGED Viewed

@@ -671,6 +671,7 @@ The framework refuses to start (or to construct) when configuration is unsafe:
 - `resilientFetch()` + `CircuitBreaker` outbound resilience at `@daloyjs/core/fetch-resilience`: a dependency-free circuit breaker (`closed → open → half-open`), retry-with-backoff (exponential + full jitter, idempotent-method/transient-status scoped, honours `Retry-After`), and a per-call timeout (`AbortController` → `FetchTimeoutError`) designed to layer **on top of** `fetchGuard()` — an `SsrfBlockedError` is a terminal refusal that is never retried and never trips the breaker, so SSRF protection stays intact under the resilience layer.
 - `createWebhookSender()` + `MemoryWebhookDeadLetterSink` outbound webhook delivery at `@daloyjs/core/webhook-delivery`: the outbound counterpart to `verifyWebhookSignature()` — timestamped HMAC-signed `POST`s (`webhook-id` / `webhook-timestamp` / `webhook-signature`, computed over `"<timestamp>.<body>"` and reused across retries for safe deduping), bounded retry-with-backoff (transient-status + network scoped, honours `Retry-After`), per-attempt timeout, and dead-letter semantics. Transport defaults to `fetchGuard()`, so a subscriber URL pointing at cloud metadata or a private range is refused with a terminal `SsrfBlockedError` (never retried, dead-lettered once). Zero runtime dependencies.
 - `app.cron()` + standalone `Scheduler` in-process scheduled tasks at `@daloyjs/core/scheduler`: a queue-agnostic schedule primitive for periodic housekeeping (cache sweeps, token refresh, reconciliation). Fixed intervals or 5-field cron expressions (lists / ranges / steps / named months & days / `@hourly`–`@yearly` aliases / optional IANA `timeZone`), arithmetic cron parsing (no backtracking regex), fixed-rate **single-flight** (overlapping ticks are skipped, never run concurrently), per-run `timeoutMs` with `AbortSignal`, and graceful-shutdown integration (stop arming → await in-flight → abort after grace). Timers are `unref`'d. `parseCron()` / `nextCronRun()` exported standalone. Zero runtime dependencies.
+- Background jobs (queue-agnostic) at `@daloyjs/core/jobs`: durable `{ name, payload }` units that outlive the HTTP request and the process — `JobStore` SPI (all durability lives behind it; Redis/Postgres/SQS are user adapters, never core deps), `MemoryJobStore` for tests and single-process apps, `createJobQueue()` (name/queue charset allowlists, plain-JSON payloads capped at 64 KiB with prototype-pollution rejection, idempotency-key dedupe with conflict-on-reuse, delayed `runAt`, integer `priority`), and `createJobWorker()` (atomic claims with leases + fencing, auto-heartbeat plus `ctx.heartbeat()`, bounded concurrency, per-attempt `timeoutMs` via `AbortSignal`, retries with exponential backoff + full jitter, dead letters, graceful `stop()` drain, `runOnce()` for tests). Delivery is **at-least-once** — handlers must be idempotent (pass a key through to downstream APIs like Stripe's `Idempotency-Key`); `EnqueueOptions.idempotencyKey` collapses duplicate producers the way `idempotency()` collapses duplicate POSTs. `app.useJobs({ store, handlers, startWorker })` drains the worker on graceful shutdown and warns on a Memory store under production config; `app.cronEnqueue()` turns a cron tick into an idempotent enqueue so multi-replica crons do not double-fire. This is not a workflow/replay engine — no durable functions, no worlds, no `await sleep("7 days")`. Zero runtime dependencies.
 - `clientCertAuth()` mTLS / client-certificate auth at `@daloyjs/core/mtls`: authenticate zero-trust / service-to-service callers by their TLS client certificate from two sources — **native TLS** (the Node adapter lazily reads the peer cert off the socket; plain requests pay nothing) or a **TLS-terminating proxy** (Envoy `X-Forwarded-Client-Cert` and nginx/HAProxy-style structured headers). `requireVerified` by default, exact `allowSubjectCNs` / `allowIssuerCNs`, **constant-time** `allowFingerprints`, `allowSANs` (SPIFFE/DNS/URI/IP, `TYPE:value` or bare), validity-window enforcement, and a custom async `verify()` hook. Missing cert → `401` problem+json with `Cache-Control: no-store`; any failed check → `403` (never echoes cert details). The accepted `ClientCertificate` is stamped on `ctx.state`. `parseForwardedClientCert()` / `normalizePeerCertificate()` exported standalone. Zero runtime dependencies.
 - `autoBan()` adaptive auto-ban (fail2ban-style) at `@daloyjs/core/auto-ban`: temporarily ban abusive clients after repeated suspicious responses (default `401` / `403` / `429`, configurable `watchStatuses`) within a rolling `windowMs`. Bans **escalate** exponentially for repeat offenders (`banMs` → `2×` → `4×`, capped at `maxBanMs`) and **decay** once the client goes quiet. Observes the outgoing status via `onSend` (counts failures from any downstream middleware/handler), enforces in `beforeHandle`. Secure-by-default identity attribution — refuses to construct without `keyGenerator`, `trustedHops`, or `trustProxyHeaders` so one offender can never ban everyone; unattributable requests are skipped. Proxy-header identity is **spoof-resistant**: the client IP is read from the rightmost `X-Forwarded-For` entry (the one your proxy appended) via `resolveForwardedClientIp()`, so rotating spoofed left entries can neither evade strike accumulation nor frame a victim IP for banning; multi-hop chains declare their hop count with `trustedHops` (shared by `rateLimit()`, `loginThrottle()`, `concurrencyLimit()`, `geoBlock()`, `ipRestriction()`, `ipReputation()`, and `botGuard()`). For deployments where the origin itself is reachable, `trustedProxies` (a CIDR allowlist of your proxy peer addresses, accepted by every guard in that list) goes further: the immediate TCP peer is verified against the allowlist before any forwarded header is believed, so a direct-to-origin caller's spoofed `X-Forwarded-For` is ignored entirely — closing victim-IP framing and ban/limit evasion at the framework layer, and failing closed on peer-less edge platforms. Pluggable `AutoBanStore` (mirrors the `rateLimit()` store; in-memory default, Redis-able for multi-instance), `groupId` sharing across route groups, `429`/`403` ban response with `Retry-After`, and `onBan` / `onStrike` hooks. Zero runtime dependencies.
 - `botGuard()` bot / User-Agent management at `@daloyjs/core/bot-guard`: the in-app equivalent of Nginx/WAF bot rules. Blocks empty/missing `User-Agent` (default on) and known-abusive `User-Agent` strings / `RegExp`s, and **verifies declared crawlers** — a request claiming to be Googlebot/Bingbot is confirmed via reverse-DNS + forward-confirm (the method Google and Bing document), so a spoofed `User-Agent` can't impersonate a trusted crawler. Ships `GOOGLEBOT` / `BINGBOT` / `WELL_KNOWN_BOTS` presets and accepts custom `VerifiedBotRule`s. Allowlist-first (`allowUserAgents` bypasses every rule), secure-by-default (`verifiedBots` refuses to construct without an IP source; unverifiable crawlers blocked unless `blockUnverifiableBots: false`), subdomain-boundary-safe domain matching, per-IP verification cache to keep DNS off the hot path, `mode: "log"` monitor mode, `onBlock` callback, and a pluggable `BotResolver` (default lazy `node:dns/promises`). Zero runtime dependencies.

package/dist/app.d.ts CHANGED Viewed

@@ -9,6 +9,7 @@ import { type SecureHeadersOptions } from "./middleware.js";
 import { type LoadSheddingOptions } from "./load-shedding.js";
 import { MetricsRegistry, type HttpMetricsOptions } from "./metrics.js";
 import { Scheduler, type TaskDefinition, type TaskHandler } from "./scheduler.js";
+import { type JobHandler, type JobQueue, type JobQueueOptions, type JobStore, type JobWorker, type JobWorkerOptions } from "./jobs.js";
 import { type BehindProxyConfig } from "./conn-info.js";
 /** @internal Test-only helper to reset the latch between tests. */
 export declare function _resetCrashHandlersForTests(): void;
@@ -1001,6 +1002,13 @@ export declare class App<Routes extends readonly RouteDefinition<any, any, any,
      * is tied to graceful shutdown.
      */
     private scheduler?;
+    /**
+     * Job queue / worker attached by {@link App.useJobs}. Both stay `undefined`
+     * unless the app opts in — serverless isolates must never start a poll
+     * loop implicitly.
+     */
+    private jobQueue?;
+    private jobWorkerRef?;
     /** Idle-connection close hooks (adapter-registered, sync). */
     private idleConnectionCloseHooks;
     private pluginInstalledListeners;
@@ -1492,6 +1500,120 @@ export declare class App<Routes extends readonly RouteDefinition<any, any, any,
      * is owned by the app.
      */
     get scheduledTasks(): Scheduler | undefined;
+    /**
+     * Attach a queue-agnostic background-job queue (and optionally a worker)
+     * to this app. Opt-in by design: nothing in `new App()` starts a poll
+     * loop, so serverless isolates that only ever *enqueue* never pay for (or
+     * accidentally run) a worker.
+     *
+     * The queue answers *&ldquo;run this work somewhere, eventually&rdquo;* —
+     * durable, retried, at-least-once units of `{ name, payload }` that
+     * outlive the HTTP request and, with a durable {@link JobStore} adapter,
+     * the process itself. This is not a workflow engine: there is no replay,
+     * no durable function, no `await sleep("7 days")`.
+     *
+     * - `startWorker: true` creates a {@link JobWorker} over the same store,
+     *   starts it, and registers an `onClose` hook so in-flight jobs are
+     *   drained (then aborted past the grace period) on graceful shutdown.
+     *   Use it on long-lived Node/Bun/Deno processes only — never on Lambda /
+     *   Cloudflare Workers isolates.
+     * - {@link MemoryJobStore} under production config logs a high-severity
+     *   warning (it is process-local and loses every job on restart); pass
+     *   `strictProduction: true` to refuse to boot instead.
+     *
+     * @example
+     * ```ts
+     * app.useJobs({
+     *   store: new MemoryJobStore(), // production: your Redis/Postgres JobStore
+     *   handlers: {
+     *     "email.welcome": async ({ job, signal }) => {
+     *       await sendEmail(job.payload, { signal });
+     *     },
+     *   },
+     *   startWorker: true,
+     * });
+     *
+     * app.post("/users", contract, async (ctx) => {
+     *   const user = await db.insertUser(ctx.body);
+     *   await app.jobs!.enqueue({
+     *     name: "email.welcome",
+     *     payload: { userId: user.id },
+     *     idempotencyKey: jobIdempotencyKey({ tenant: ctx.state.tenant, name: "email.welcome", key: user.id }),
+     *   });
+     *   return { status: 201 as const, body: user };
+     * });
+     * ```
+     *
+     * @param opts - Store, optional handlers, worker and queue tuning.
+     * @returns This `App` instance for chaining.
+     * @throws {@link JobConfigError} when jobs are already configured, when
+     *   `startWorker` lacks handlers, or when `strictProduction` rejects a
+     *   {@link MemoryJobStore} under production config.
+     * @since 1.3.0
+     */
+    useJobs(opts: {
+        store: JobStore;
+        handlers?: Record<string, JobHandler<any>>;
+        startWorker?: boolean;
+        worker?: Omit<JobWorkerOptions, "queue" | "handlers">;
+        queue?: Omit<JobQueueOptions, "store">;
+        strictProduction?: boolean;
+    }): this;
+    /**
+     * The {@link JobQueue} attached by {@link App.useJobs}, or `undefined`
+     * when jobs are not configured. Route handlers enqueue through this;
+     * delivery is at-least-once, so handlers must be idempotent.
+     *
+     * @since 1.3.0
+     */
+    get jobs(): JobQueue | undefined;
+    /**
+     * The {@link JobWorker} created by {@link App.useJobs} with
+     * `startWorker: true`, or `undefined`. Exposed for inspection
+     * (`getState()`) and tests (`runOnce()`); the lifecycle is owned by the app.
+     *
+     * @since 1.3.0
+     */
+    get jobWorker(): JobWorker | undefined;
+    /**
+     * Register a cron task whose tick enqueues a job instead of running the
+     * side effect in-process. This is the production posture for scheduled
+     * work with global side effects (nightly reconciliation, invoice runs):
+     * every replica may tick, but the deterministic idempotency key
+     * `cron:{taskName}:{floor(scheduledFor / tickGranularity)}` collapses the
+     * duplicate enqueues into one job, and exactly one worker claims it.
+     *
+     * `tickGranularity` is the task's `intervalMs` for interval schedules and
+     * one minute for cron expressions (the finest cadence a cron expression
+     * can fire), so two replicas ticking the same slot always derive the same
+     * key. Use plain {@link App.cron} for process-local maintenance (cache
+     * sweeps that must happen in *this* process); use `cronEnqueue` for work
+     * that must happen once, cluster-wide, and survive a restart.
+     *
+     * @example
+     * ```ts
+     * app.cronEnqueue(
+     *   { name: "nightly-reconcile", cron: "0 2 * * *" },
+     *   { name: "ops.reconcile", payload: {} },
+     * );
+     * ```
+     *
+     * @param def - The task definition (schedule), same shape as {@link App.cron}.
+     * @param job - The job to enqueue on each tick. `payload` defaults to
+     *   `{ scheduledFor: <ISO time of the tick slot> }`, floored to the same
+     *   slot the idempotency key uses so replicas ticking milliseconds apart
+     *   enqueue byte-identical payloads and dedupe instead of conflicting.
+     * @returns This `App` instance for chaining.
+     * @throws {@link JobConfigError} (`store_required`) when called before
+     *   {@link App.useJobs} — fail fast at registration, not at the first tick.
+     * @since 1.3.0
+     */
+    cronEnqueue(def: TaskDefinition, job: {
+        name: string;
+        payload?: unknown;
+        queue?: string;
+        priority?: number;
+    }): this;
     private registerHealthRoute;
     /**
      * Register a built-in receiver for CSP / Reporting API

package/dist/app.js CHANGED Viewed

@@ -14,6 +14,7 @@ import { SESSION_HOOK_MARKER, SESSION_SECRETS_MARKER } from "./session.js";
 import { loadShedding as loadSheddingMiddleware, } from "./load-shedding.js";
 import { httpMetrics, MetricsRegistry, PROMETHEUS_CONTENT_TYPE, } from "./metrics.js";
 import { Scheduler, } from "./scheduler.js";
+import { createJobQueue, createJobWorker, JobConfigError, MemoryJobStore, } from "./jobs.js";
 import { securitySchemeRequiresPayloadAuth } from "./security-schemes.js";
 import { assertBehindProxy } from "./conn-info.js";
 const AUTO_SECURE_HEADERS_MARKER = Symbol.for("daloyjs.app.autoSecureHeaders");
@@ -428,6 +429,13 @@ export class App {
      * is tied to graceful shutdown.
      */
     scheduler;
+    /**
+     * Job queue / worker attached by {@link App.useJobs}. Both stay `undefined`
+     * unless the app opts in — serverless isolates must never start a poll
+     * loop implicitly.
+     */
+    jobQueue;
+    jobWorkerRef;
     /** Idle-connection close hooks (adapter-registered, sync). */
     idleConnectionCloseHooks = [];
     pluginInstalledListeners = [];
@@ -2020,6 +2028,167 @@ export class App {
     get scheduledTasks() {
         return this.scheduler;
     }
+    /**
+     * Attach a queue-agnostic background-job queue (and optionally a worker)
+     * to this app. Opt-in by design: nothing in `new App()` starts a poll
+     * loop, so serverless isolates that only ever *enqueue* never pay for (or
+     * accidentally run) a worker.
+     *
+     * The queue answers *&ldquo;run this work somewhere, eventually&rdquo;* —
+     * durable, retried, at-least-once units of `{ name, payload }` that
+     * outlive the HTTP request and, with a durable {@link JobStore} adapter,
+     * the process itself. This is not a workflow engine: there is no replay,
+     * no durable function, no `await sleep("7 days")`.
+     *
+     * - `startWorker: true` creates a {@link JobWorker} over the same store,
+     *   starts it, and registers an `onClose` hook so in-flight jobs are
+     *   drained (then aborted past the grace period) on graceful shutdown.
+     *   Use it on long-lived Node/Bun/Deno processes only — never on Lambda /
+     *   Cloudflare Workers isolates.
+     * - {@link MemoryJobStore} under production config logs a high-severity
+     *   warning (it is process-local and loses every job on restart); pass
+     *   `strictProduction: true` to refuse to boot instead.
+     *
+     * @example
+     * ```ts
+     * app.useJobs({
+     *   store: new MemoryJobStore(), // production: your Redis/Postgres JobStore
+     *   handlers: {
+     *     "email.welcome": async ({ job, signal }) => {
+     *       await sendEmail(job.payload, { signal });
+     *     },
+     *   },
+     *   startWorker: true,
+     * });
+     *
+     * app.post("/users", contract, async (ctx) => {
+     *   const user = await db.insertUser(ctx.body);
+     *   await app.jobs!.enqueue({
+     *     name: "email.welcome",
+     *     payload: { userId: user.id },
+     *     idempotencyKey: jobIdempotencyKey({ tenant: ctx.state.tenant, name: "email.welcome", key: user.id }),
+     *   });
+     *   return { status: 201 as const, body: user };
+     * });
+     * ```
+     *
+     * @param opts - Store, optional handlers, worker and queue tuning.
+     * @returns This `App` instance for chaining.
+     * @throws {@link JobConfigError} when jobs are already configured, when
+     *   `startWorker` lacks handlers, or when `strictProduction` rejects a
+     *   {@link MemoryJobStore} under production config.
+     * @since 1.3.0
+     */
+    useJobs(opts) {
+        if (this.jobQueue !== undefined) {
+            throw new JobConfigError("invalid_option", "app.useJobs() was called twice; jobs are already configured on this app.");
+        }
+        if (opts.store instanceof MemoryJobStore && this.isProduction()) {
+            const message = "app.useJobs(): MemoryJobStore is not durable — jobs are lost on process restart " +
+                "and invisible to other replicas. Supply a shared JobStore (Redis/Postgres/SQS adapter) " +
+                "in production, or pass strictProduction: false to keep this warning-only posture.";
+            if (opts.strictProduction === true) {
+                throw new JobConfigError("invalid_option", message);
+            }
+            this.log.warn({ event: "jobs.memory_store_production", component: "jobs" }, message);
+        }
+        const logger = this.log.child({ component: "jobs" });
+        const queue = createJobQueue({ store: opts.store, logger, ...opts.queue });
+        let worker;
+        if (opts.startWorker === true) {
+            const handlers = opts.handlers;
+            if (handlers === undefined || Object.keys(handlers).length === 0) {
+                throw new JobConfigError("invalid_option", "app.useJobs(): startWorker: true requires a non-empty handlers map.");
+            }
+            worker = createJobWorker({
+                ...opts.worker,
+                queue,
+                handlers,
+                logger: opts.worker?.logger ?? logger,
+            });
+            worker.start();
+            // Drain the worker during the post-drain close phase so an in-flight
+            // job settles (or fails back to the queue) alongside other resources.
+            const startedWorker = worker;
+            this.onClose(() => startedWorker.stop());
+        }
+        this.jobQueue = queue;
+        this.jobWorkerRef = worker;
+        return this;
+    }
+    /**
+     * The {@link JobQueue} attached by {@link App.useJobs}, or `undefined`
+     * when jobs are not configured. Route handlers enqueue through this;
+     * delivery is at-least-once, so handlers must be idempotent.
+     *
+     * @since 1.3.0
+     */
+    get jobs() {
+        return this.jobQueue;
+    }
+    /**
+     * The {@link JobWorker} created by {@link App.useJobs} with
+     * `startWorker: true`, or `undefined`. Exposed for inspection
+     * (`getState()`) and tests (`runOnce()`); the lifecycle is owned by the app.
+     *
+     * @since 1.3.0
+     */
+    get jobWorker() {
+        return this.jobWorkerRef;
+    }
+    /**
+     * Register a cron task whose tick enqueues a job instead of running the
+     * side effect in-process. This is the production posture for scheduled
+     * work with global side effects (nightly reconciliation, invoice runs):
+     * every replica may tick, but the deterministic idempotency key
+     * `cron:{taskName}:{floor(scheduledFor / tickGranularity)}` collapses the
+     * duplicate enqueues into one job, and exactly one worker claims it.
+     *
+     * `tickGranularity` is the task's `intervalMs` for interval schedules and
+     * one minute for cron expressions (the finest cadence a cron expression
+     * can fire), so two replicas ticking the same slot always derive the same
+     * key. Use plain {@link App.cron} for process-local maintenance (cache
+     * sweeps that must happen in *this* process); use `cronEnqueue` for work
+     * that must happen once, cluster-wide, and survive a restart.
+     *
+     * @example
+     * ```ts
+     * app.cronEnqueue(
+     *   { name: "nightly-reconcile", cron: "0 2 * * *" },
+     *   { name: "ops.reconcile", payload: {} },
+     * );
+     * ```
+     *
+     * @param def - The task definition (schedule), same shape as {@link App.cron}.
+     * @param job - The job to enqueue on each tick. `payload` defaults to
+     *   `{ scheduledFor: <ISO time of the tick slot> }`, floored to the same
+     *   slot the idempotency key uses so replicas ticking milliseconds apart
+     *   enqueue byte-identical payloads and dedupe instead of conflicting.
+     * @returns This `App` instance for chaining.
+     * @throws {@link JobConfigError} (`store_required`) when called before
+     *   {@link App.useJobs} — fail fast at registration, not at the first tick.
+     * @since 1.3.0
+     */
+    cronEnqueue(def, job) {
+        const queue = this.jobQueue;
+        if (queue === undefined) {
+            throw new JobConfigError("store_required", "app.cronEnqueue() requires app.useJobs() first: attach a JobStore before scheduling job-producing ticks.");
+        }
+        const granularityMs = def.intervalMs !== undefined && def.intervalMs > 0 ? def.intervalMs : 60_000;
+        return this.cron(def, async ({ name, scheduledFor }) => {
+            const slot = Math.floor(scheduledFor.getTime() / granularityMs);
+            await queue.enqueue({
+                name: job.name,
+                // Derive the default payload from the slot, not the raw tick time:
+                // replicas tick a few milliseconds apart, and an identical key with
+                // a different payload is a JobIdempotencyConflictError, not a dedup.
+                payload: job.payload ?? { scheduledFor: new Date(slot * granularityMs).toISOString() },
+                ...(job.queue !== undefined ? { queue: job.queue } : {}),
+                ...(job.priority !== undefined ? { priority: job.priority } : {}),
+                idempotencyKey: `cron:${encodeURIComponent(name)}:${slot}`,
+            });
+        });
+    }
     registerHealthRoute(kind, opts, handler) {
         const isHealth = kind === "healthcheck";
         const defaultPath = (isHealth ? "/healthz" : "/readyz");

package/dist/index.d.ts CHANGED Viewed

@@ -48,6 +48,8 @@ export { createWebhookSender, MemoryWebhookDeadLetterSink } from "./webhook-deli
 export type { WebhookEvent, WebhookSenderOptions, WebhookDeliveryResult, WebhookDeadLetter, WebhookDeadLetterSink, WebhookAttempt, } from "./webhook-delivery.js";
 export { Scheduler, CronParseError, parseCron, nextCronRun } from "./scheduler.js";
 export type { SchedulerOptions, SchedulerLogger, TimerFns, TaskDefinition, TaskHandler, TaskRunContext, TaskErrorInfo, TaskState, CronFields, } from "./scheduler.js";
+export { createJobQueue, createJobWorker, computeBackoffMs, jobIdempotencyKey, MemoryJobStore, JobConfigError, JobIdempotencyConflictError, JobFatalError, JobTimeoutError, } from "./jobs.js";
+export type { Job, JobStatus, JobStore, JobQueue, JobQueueOptions, JobWorker, JobWorkerOptions, JobContext, JobHandler, JobHandlerMap, JobBackoffOptions, EnqueueOptions, EnqueueResult, MemoryJobStoreOptions, JobConfigErrorCode, } from "./jobs.js";
 export { clientCertAuth, setClientCertificate, getClientCertificate, normalizePeerCertificate, parseForwardedClientCert, } from "./mtls.js";
 export type { ClientCertificate, ClientCertificateSource, ClientCertAuthOptions, ClientCertHeaderConfig, PeerCertificateLike, } from "./mtls.js";
 export { signMessage, signRequest, verifyMessage, verifyRequest, httpSignatureAuth, contentDigest, verifyContentDigest, DEFAULT_SIGNATURE_LABEL, DEFAULT_MAX_SIGNATURE_AGE_SECONDS, DEFAULT_SIGNATURE_CLOCK_SKEW_SECONDS, } from "./http-signatures.js";

package/dist/index.js CHANGED Viewed

@@ -26,6 +26,7 @@ export { fetchGuard, SsrfBlockedError } from "./fetch-guard.js";
 export { resilientFetch, CircuitBreaker, CircuitOpenError, FetchTimeoutError, } from "./fetch-resilience.js";
 export { createWebhookSender, MemoryWebhookDeadLetterSink } from "./webhook-delivery.js";
 export { Scheduler, CronParseError, parseCron, nextCronRun } from "./scheduler.js";
+export { createJobQueue, createJobWorker, computeBackoffMs, jobIdempotencyKey, MemoryJobStore, JobConfigError, JobIdempotencyConflictError, JobFatalError, JobTimeoutError, } from "./jobs.js";
 export { clientCertAuth, setClientCertificate, getClientCertificate, normalizePeerCertificate, parseForwardedClientCert, } from "./mtls.js";
 export { signMessage, signRequest, verifyMessage, verifyRequest, httpSignatureAuth, contentDigest, verifyContentDigest, DEFAULT_SIGNATURE_LABEL, DEFAULT_MAX_SIGNATURE_AGE_SECONDS, DEFAULT_SIGNATURE_CLOCK_SKEW_SECONDS, } from "./http-signatures.js";
 export { autoBan, MemoryAutoBanStore, _resetAutoBanStoresForTests } from "./auto-ban.js";