@pipeline-builder/api-server 0.0.1

package/lib/api/etag-middleware.js

@@ -0,0 +1,44 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createHash } from 'crypto';
+/**
+ * Middleware that adds ETag support for conditional GET requests.
+ * Generates a weak ETag from the response body hash.
+ * Returns 304 Not Modified when the client's If-None-Match header matches.
+ */
+export function etagMiddleware() {
+    return (req, res, next) => {
+        // Only apply to GET requests
+        if (req.method !== 'GET')
+            return next();
+        res.json = (body) => {
+            // Serialize once, hash, and send — avoids double JSON.stringify
+            const serialized = JSON.stringify(body);
+            // Only ETag/304 SUCCESSFUL responses. For non-2xx (errors), skip the
+            // conditional logic entirely — otherwise an error response whose body
+            // happens to hash-match the client's If-None-Match would be turned into a
+            // 304 Not Modified, making the client serve a stale (possibly successful)
+            // cached body in place of the error.
+            if (res.statusCode < 200 || res.statusCode >= 300) {
+                res.setHeader('Content-Type', 'application/json');
+                res.end(serialized);
+                return res;
+            }
+            const hash = createHash('md5').update(serialized).digest('hex').slice(0, 16);
+            const etag = `W/"${hash}"`;
+            res.setHeader('ETag', etag);
+            // Check If-None-Match header
+            const ifNoneMatch = req.headers['if-none-match'];
+            if (ifNoneMatch && ifNoneMatch === etag) {
+                res.status(304).end();
+                return res;
+            }
+            // Send pre-serialized body to avoid double JSON.stringify
+            res.setHeader('Content-Type', 'application/json');
+            res.end(serialized);
+            return res;
+        };
+        next();
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/get-context.d.ts

@@ -0,0 +1,22 @@
+import type { Request } from 'express';
+import type { RequestContext } from './request-types.js';
+/**
+ * Safely retrieve the RequestContext from an Express request.
+ *
+ * Throws a descriptive error if the context middleware has not been applied,
+ * instead of silently returning undefined or crashing with a cryptic error.
+ *
+ * @param req - Express request object
+ * @returns The attached RequestContext
+ * @throws Error if req.context is not initialized
+ *
+ * @example
+ * ```typescript
+ * app.get('/pipelines', requireAuth, async (req, res) => {
+ *   const ctx = getContext(req);
+ *   ctx.log('INFO', 'Fetching pipelines');
+ *   // ...
+ * });
+ * ```
+ */
+export declare function getContext(req: Request): RequestContext;

package/lib/api/get-context.js

@@ -0,0 +1,28 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Safely retrieve the RequestContext from an Express request.
+ *
+ * Throws a descriptive error if the context middleware has not been applied,
+ * instead of silently returning undefined or crashing with a cryptic error.
+ *
+ * @param req - Express request object
+ * @returns The attached RequestContext
+ * @throws Error if req.context is not initialized
+ *
+ * @example
+ * ```typescript
+ * app.get('/pipelines', requireAuth, async (req, res) => {
+ *   const ctx = getContext(req);
+ *   ctx.log('INFO', 'Fetching pipelines');
+ *   // ...
+ * });
+ * ```
+ */
+export function getContext(req) {
+    if (!req.context) {
+        throw new Error('Request context not initialized. Ensure attachRequestContext middleware is applied.');
+    }
+    return req.context;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWNvbnRleHQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXBpL2dldC1jb250ZXh0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7QUFLdEM7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQWtCRztBQUNILE1BQU0sVUFBVSxVQUFVLENBQUMsR0FBWTtJQUNyQyxJQUFJLENBQUMsR0FBRyxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ2pCLE1BQU0sSUFBSSxLQUFLLENBQ2IscUZBQXFGLENBQ3RGLENBQUM7SUFDSixDQUFDO0lBQ0QsT0FBTyxHQUFHLENBQUMsT0FBTyxDQUFDO0FBQ3JCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuaW1wb3J0IHR5cGUgeyBSZXF1ZXN0IH0gZnJvbSAnZXhwcmVzcyc7XG5pbXBvcnQgdHlwZSB7IFJlcXVlc3RDb250ZXh0IH0gZnJvbSAnLi9yZXF1ZXN0LXR5cGVzLmpzJztcblxuLyoqXG4gKiBTYWZlbHkgcmV0cmlldmUgdGhlIFJlcXVlc3RDb250ZXh0IGZyb20gYW4gRXhwcmVzcyByZXF1ZXN0LlxuICpcbiAqIFRocm93cyBhIGRlc2NyaXB0aXZlIGVycm9yIGlmIHRoZSBjb250ZXh0IG1pZGRsZXdhcmUgaGFzIG5vdCBiZWVuIGFwcGxpZWQsXG4gKiBpbnN0ZWFkIG9mIHNpbGVudGx5IHJldHVybmluZyB1bmRlZmluZWQgb3IgY3Jhc2hpbmcgd2l0aCBhIGNyeXB0aWMgZXJyb3IuXG4gKlxuICogQHBhcmFtIHJlcSAtIEV4cHJlc3MgcmVxdWVzdCBvYmplY3RcbiAqIEByZXR1cm5zIFRoZSBhdHRhY2hlZCBSZXF1ZXN0Q29udGV4dFxuICogQHRocm93cyBFcnJvciBpZiByZXEuY29udGV4dCBpcyBub3QgaW5pdGlhbGl6ZWRcbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHlwZXNjcmlwdFxuICogYXBwLmdldCgnL3BpcGVsaW5lcycsIHJlcXVpcmVBdXRoLCBhc3luYyAocmVxLCByZXMpID0+IHtcbiAqICAgY29uc3QgY3R4ID0gZ2V0Q29udGV4dChyZXEpO1xuICogICBjdHgubG9nKCdJTkZPJywgJ0ZldGNoaW5nIHBpcGVsaW5lcycpO1xuICogICAvLyAuLi5cbiAqIH0pO1xuICogYGBgXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRDb250ZXh0KHJlcTogUmVxdWVzdCk6IFJlcXVlc3RDb250ZXh0IHtcbiAgaWYgKCFyZXEuY29udGV4dCkge1xuICAgIHRocm93IG5ldyBFcnJvcihcbiAgICAgICdSZXF1ZXN0IGNvbnRleHQgbm90IGluaXRpYWxpemVkLiBFbnN1cmUgYXR0YWNoUmVxdWVzdENvbnRleHQgbWlkZGxld2FyZSBpcyBhcHBsaWVkLicsXG4gICAgKTtcbiAgfVxuICByZXR1cm4gcmVxLmNvbnRleHQ7XG59XG4iXX0=

package/lib/api/health-checks.d.ts

@@ -0,0 +1,62 @@
+type HealthStatus = 'connected' | 'disconnected' | 'unknown';
+type HealthResult = Record<string, HealthStatus>;
+/**
+ * Postgres health probe: returns `{ postgres: 'connected' }` when the pool's
+ * connection test succeeds, `{ postgres: 'disconnected' }` on any error or
+ * timeout (so `/ready` correctly reports 503). Use as (part of) the
+ * `checkDependencies` option of `createApp()` for any service backed by the
+ * shared pipeline-data Drizzle connection.
+ */
+export declare function postgresHealthCheck(timeoutMs?: number): Promise<HealthResult>;
+/** Minimal shape of an ioredis client needed for a health PING. */
+interface RedisLike {
+    ping(): Promise<string>;
+}
+/**
+ * Source of a redis client: either the client itself, or a (sync/async) getter.
+ * The getter form supports BullMQ's `queue.client` (a `Promise<RedisClient>`)
+ * so a service can probe the exact connection its queue uses without opening
+ * a second one.
+ */
+type RedisClientSource = RedisLike | (() => RedisLike | Promise<RedisLike>);
+/**
+ * Redis health probe factory: pass the service's EXISTING ioredis connection
+ * (or a getter for it — e.g. `() => queue.client`) and get back a
+ * `checkDependencies` callback that `PING`s it. Mirrors `mongoHealthCheck` —
+ * it probes the real connection rather than opening a throwaway one per call.
+ * The PING is time-boxed so a down redis (whose offline queue would otherwise
+ * buffer the command) reports `disconnected` quickly instead of hanging.
+ */
+export declare function redisHealthCheck(source: RedisClientSource, timeoutMs?: number): () => Promise<HealthResult>;
+/**
+ * Combine several dependency probes into one `checkDependencies` callback that
+ * runs them IN PARALLEL and merges their results. A slow/failed probe can't
+ * delay the others or time out the whole `/ready` response.
+ *
+ * CONTRACT: each probe must CATCH internally and RETURN its `{ name: status }`
+ * (as the built-in postgres/redis/mongo probes do). A probe that THROWS is
+ * merged as `{}` — its dependency then vanishes from the map and `/ready`
+ * reports 200 with the dep simply absent (a silent false-healthy), rather than
+ * surfacing it as `disconnected`. The `.catch(() => ({}))` below only exists so
+ * one misbehaving probe can't take down the others, NOT as a substitute for a
+ * probe returning its own disconnected status.
+ */
+export declare function combineHealthChecks(...checks: Array<() => Promise<HealthResult>>): () => Promise<HealthResult>;
+/**
+ * Minimal shape expected of a mongoose connection for the health probe.
+ * Accepts `mongoose.connection` directly without requiring mongoose as a
+ * dependency of api-server.
+ */
+interface MongooseConnectionLike {
+    readyState: number;
+}
+/**
+ * MongoDB health probe factory: pass `mongoose.connection` and get back a
+ * `checkDependencies` callback that reports based on mongoose's readyState.
+ *
+ * Mapping (per mongoose docs): 1=connected, 2=connecting, 3=disconnecting,
+ * any other value (0=disconnected, 99=uninitialized) is treated as
+ * 'disconnected' so `/health` returns 503.
+ */
+export declare function mongoHealthCheck(connection: MongooseConnectionLike): () => Promise<HealthResult>;
+export {};

package/lib/api/health-checks.js

@@ -0,0 +1,87 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { getConnection } from '@pipeline-builder/pipeline-data';
+/**
+ * Reject if `promise` hasn't settled within `ms`. A health/readiness probe
+ * must never hang the `/ready` response — a down datastore (or a BullMQ
+ * ioredis client with `maxRetriesPerRequest: null` + an offline queue) can
+ * leave a `ping()`/query pending indefinitely, so every probe is time-boxed.
+ */
+function withTimeout(promise, ms, label) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+        timer.unref?.();
+        promise.then((value) => { clearTimeout(timer); resolve(value); }, (err) => { clearTimeout(timer); reject(err); });
+    });
+}
+/**
+ * Postgres health probe: returns `{ postgres: 'connected' }` when the pool's
+ * connection test succeeds, `{ postgres: 'disconnected' }` on any error or
+ * timeout (so `/ready` correctly reports 503). Use as (part of) the
+ * `checkDependencies` option of `createApp()` for any service backed by the
+ * shared pipeline-data Drizzle connection.
+ */
+export async function postgresHealthCheck(timeoutMs = 3000) {
+    try {
+        await withTimeout(getConnection().testConnection(), timeoutMs, 'postgres testConnection');
+        return { postgres: 'connected' };
+    }
+    catch {
+        return { postgres: 'disconnected' };
+    }
+}
+/**
+ * Redis health probe factory: pass the service's EXISTING ioredis connection
+ * (or a getter for it — e.g. `() => queue.client`) and get back a
+ * `checkDependencies` callback that `PING`s it. Mirrors `mongoHealthCheck` —
+ * it probes the real connection rather than opening a throwaway one per call.
+ * The PING is time-boxed so a down redis (whose offline queue would otherwise
+ * buffer the command) reports `disconnected` quickly instead of hanging.
+ */
+export function redisHealthCheck(source, timeoutMs = 2000) {
+    return async () => {
+        try {
+            const client = typeof source === 'function' ? await source() : source;
+            await withTimeout(client.ping(), timeoutMs, 'redis ping');
+            return { redis: 'connected' };
+        }
+        catch {
+            return { redis: 'disconnected' };
+        }
+    };
+}
+/**
+ * Combine several dependency probes into one `checkDependencies` callback that
+ * runs them IN PARALLEL and merges their results. A slow/failed probe can't
+ * delay the others or time out the whole `/ready` response.
+ *
+ * CONTRACT: each probe must CATCH internally and RETURN its `{ name: status }`
+ * (as the built-in postgres/redis/mongo probes do). A probe that THROWS is
+ * merged as `{}` — its dependency then vanishes from the map and `/ready`
+ * reports 200 with the dep simply absent (a silent false-healthy), rather than
+ * surfacing it as `disconnected`. The `.catch(() => ({}))` below only exists so
+ * one misbehaving probe can't take down the others, NOT as a substitute for a
+ * probe returning its own disconnected status.
+ */
+export function combineHealthChecks(...checks) {
+    return async () => {
+        const results = await Promise.all(checks.map((check) => check().catch(() => ({}))));
+        return Object.assign({}, ...results);
+    };
+}
+/**
+ * MongoDB health probe factory: pass `mongoose.connection` and get back a
+ * `checkDependencies` callback that reports based on mongoose's readyState.
+ *
+ * Mapping (per mongoose docs): 1=connected, 2=connecting, 3=disconnecting,
+ * any other value (0=disconnected, 99=uninitialized) is treated as
+ * 'disconnected' so `/health` returns 503.
+ */
+export function mongoHealthCheck(connection) {
+    return async () => ({
+        mongodb: connection.readyState === 1 ? 'connected'
+            : connection.readyState === 2 ? 'unknown' // connecting; treat as transient
+                : 'disconnected',
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"health-checks.js","sourceRoot":"","sources":["../../src/api/health-checks.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAKhE;;;;;GAKG;AACH,SAAS,WAAW,CAAI,OAAmB,EAAE,EAAU,EAAE,KAAa;IACpE,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACxC,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,GAAG,KAAK,oBAAoB,EAAE,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAC1F,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC;QAChB,OAAO,CAAC,IAAI,CACV,CAAC,KAAK,EAAE,EAAE,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EACnD,CAAC,GAAG,EAAE,EAAE,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAC/C,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,SAAS,GAAG,IAAI;IACxD,IAAI,CAAC;QACH,MAAM,WAAW,CAAC,aAAa,EAAE,CAAC,cAAc,EAAE,EAAE,SAAS,EAAE,yBAAyB,CAAC,CAAC;QAC1F,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC;IACnC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC;IACtC,CAAC;AACH,CAAC;AAeD;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAyB,EAAE,SAAS,GAAG,IAAI;IAC1E,OAAO,KAAK,IAAI,EAAE;QAChB,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,OAAO,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,MAAM,MAAM,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;YACtE,MAAM,WAAW,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;YAC1D,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC;QAChC,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,CAAC;QACnC,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,mBAAmB,CACjC,GAAG,MAA0C;IAE7C,OAAO,KAAK,IAAI,EAAE;QAChB,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,EAAmB,CAAA,CAAC,CAAC,CAAC,CAAC;QACpG,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,GAAG,OAAO,CAAiB,CAAC;IACvD,CAAC,CAAC;AACJ,CAAC;AAWD;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,UAAkC;IACjE,OAAO,KAAK,IAAI,EAAE,CAAC,CAAC;QAClB,OAAO,EAAE,UAAU,CAAC,UAAU,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW;YAChD,CAAC,CAAC,UAAU,CAAC,UAAU,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,iCAAiC;gBACzE,CAAC,CAAC,cAAc;KACrB,CAAC,CAAC;AACL,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { getConnection } from '@pipeline-builder/pipeline-data';\n\ntype HealthStatus = 'connected' | 'disconnected' | 'unknown';\ntype HealthResult = Record<string, HealthStatus>;\n\n/**\n * Reject if `promise` hasn't settled within `ms`. A health/readiness probe\n * must never hang the `/ready` response — a down datastore (or a BullMQ\n * ioredis client with `maxRetriesPerRequest: null` + an offline queue) can\n * leave a `ping()`/query pending indefinitely, so every probe is time-boxed.\n */\nfunction withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise<T> {\n  return new Promise<T>((resolve, reject) => {\n    const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);\n    timer.unref?.();\n    promise.then(\n      (value) => { clearTimeout(timer); resolve(value); },\n      (err) => { clearTimeout(timer); reject(err); },\n    );\n  });\n}\n\n/**\n * Postgres health probe: returns `{ postgres: 'connected' }` when the pool's\n * connection test succeeds, `{ postgres: 'disconnected' }` on any error or\n * timeout (so `/ready` correctly reports 503). Use as (part of) the\n * `checkDependencies` option of `createApp()` for any service backed by the\n * shared pipeline-data Drizzle connection.\n */\nexport async function postgresHealthCheck(timeoutMs = 3000): Promise<HealthResult> {\n  try {\n    await withTimeout(getConnection().testConnection(), timeoutMs, 'postgres testConnection');\n    return { postgres: 'connected' };\n  } catch {\n    return { postgres: 'disconnected' };\n  }\n}\n\n/** Minimal shape of an ioredis client needed for a health PING. */\ninterface RedisLike {\n  ping(): Promise<string>;\n}\n\n/**\n * Source of a redis client: either the client itself, or a (sync/async) getter.\n * The getter form supports BullMQ's `queue.client` (a `Promise<RedisClient>`)\n * so a service can probe the exact connection its queue uses without opening\n * a second one.\n */\ntype RedisClientSource = RedisLike | (() => RedisLike | Promise<RedisLike>);\n\n/**\n * Redis health probe factory: pass the service's EXISTING ioredis connection\n * (or a getter for it — e.g. `() => queue.client`) and get back a\n * `checkDependencies` callback that `PING`s it. Mirrors `mongoHealthCheck` —\n * it probes the real connection rather than opening a throwaway one per call.\n * The PING is time-boxed so a down redis (whose offline queue would otherwise\n * buffer the command) reports `disconnected` quickly instead of hanging.\n */\nexport function redisHealthCheck(source: RedisClientSource, timeoutMs = 2000): () => Promise<HealthResult> {\n  return async () => {\n    try {\n      const client = typeof source === 'function' ? await source() : source;\n      await withTimeout(client.ping(), timeoutMs, 'redis ping');\n      return { redis: 'connected' };\n    } catch {\n      return { redis: 'disconnected' };\n    }\n  };\n}\n\n/**\n * Combine several dependency probes into one `checkDependencies` callback that\n * runs them IN PARALLEL and merges their results. A slow/failed probe can't\n * delay the others or time out the whole `/ready` response.\n *\n * CONTRACT: each probe must CATCH internally and RETURN its `{ name: status }`\n * (as the built-in postgres/redis/mongo probes do). A probe that THROWS is\n * merged as `{}` — its dependency then vanishes from the map and `/ready`\n * reports 200 with the dep simply absent (a silent false-healthy), rather than\n * surfacing it as `disconnected`. The `.catch(() => ({}))` below only exists so\n * one misbehaving probe can't take down the others, NOT as a substitute for a\n * probe returning its own disconnected status.\n */\nexport function combineHealthChecks(\n  ...checks: Array<() => Promise<HealthResult>>\n): () => Promise<HealthResult> {\n  return async () => {\n    const results = await Promise.all(checks.map((check) => check().catch(() => ({} as HealthResult))));\n    return Object.assign({}, ...results) as HealthResult;\n  };\n}\n\n/**\n * Minimal shape expected of a mongoose connection for the health probe.\n * Accepts `mongoose.connection` directly without requiring mongoose as a\n * dependency of api-server.\n */\ninterface MongooseConnectionLike {\n  readyState: number;\n}\n\n/**\n * MongoDB health probe factory: pass `mongoose.connection` and get back a\n * `checkDependencies` callback that reports based on mongoose's readyState.\n *\n * Mapping (per mongoose docs): 1=connected, 2=connecting, 3=disconnecting,\n * any other value (0=disconnected, 99=uninitialized) is treated as\n * 'disconnected' so `/health` returns 503.\n */\nexport function mongoHealthCheck(connection: MongooseConnectionLike): () => Promise<HealthResult> {\n  return async () => ({\n    mongodb: connection.readyState === 1 ? 'connected'\n      : connection.readyState === 2 ? 'unknown' // connecting; treat as transient\n        : 'disconnected',\n  });\n}\n"]}

package/lib/api/idempotency-middleware.d.ts

@@ -0,0 +1,80 @@
+import type { Request, Response, NextFunction } from 'express';
+interface CachedEntry {
+    statusCode: number;
+    body: unknown;
+    expiresAt: number;
+    /** Reservation placeholder: the request is in-flight, no real response yet.
+     *  A duplicate that sees a pending entry is rejected with 409, not replayed. */
+    pending?: boolean;
+}
+/**
+ * Pluggable backend for idempotency-key replay cache. The default in-memory
+ * implementation works fine single-replica; a Redis-backed implementation
+ * is required for correct deduplication across horizontally-scaled replicas
+ * (otherwise two replicas behind a load-balancer cache independently and a
+ * retry hitting a different pod won't replay).
+ */
+export interface IdempotencyStore {
+    get(key: string): Promise<CachedEntry | null>;
+    set(key: string, entry: CachedEntry, ttlSeconds: number): Promise<void>;
+    /**
+     * Atomically claim `key` IFF it is currently absent. Returns `true` when THIS
+     * caller set the entry (won the race), `false` when an entry already exists.
+     * This is what serializes concurrent first-time requests that share an
+     * Idempotency-Key — a plain get-then-set leaves a window where two requests
+     * both see "not cached" and both execute the mutation.
+     */
+    reserve(key: string, entry: CachedEntry, ttlSeconds: number): Promise<boolean>;
+    /** Remove a key — releases a reservation after a non-cacheable (non-2xx) response. */
+    delete(key: string): Promise<void>;
+}
+/** Default in-memory store. Single-replica only. Exported for testing. */
+export declare function createMemoryStore(): IdempotencyStore;
+/**
+ * Minimal Redis surface the idempotency store needs (an ioredis subset).
+ * `set` supports the variadic option tail: `SET key val EX <ttl> [NX]`, which
+ * returns `'OK'` on success and `null` when an `NX` set was refused.
+ */
+export interface RedisIdempotencyClient {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ...args: (string | number)[]): Promise<string | null>;
+    del(key: string): Promise<number>;
+}
+/**
+ * Redis-backed {@link IdempotencyStore} for correct deduplication across
+ * horizontally-scaled replicas. `reserve` maps to an atomic `SET … NX` so two
+ * pods behind a load-balancer can't both win a first-time request sharing an
+ * Idempotency-Key; a retry landing on ANY pod sees the same committed response.
+ * Redis TTL owns expiry (the `CachedEntry.expiresAt` field is carried only for
+ * API-shape parity with the memory store).
+ */
+export declare function createRedisIdempotencyStore(redis: RedisIdempotencyClient): IdempotencyStore;
+/**
+ * Build a Redis-backed idempotency store from the shared env Redis (the same
+ * `REDIS_URL` / `REDIS_HOST` wiring the rate-limiter and audit-spool use).
+ * Returns `null` when Redis isn't configured/available so the caller keeps the
+ * in-memory default (single-replica correctness). Never throws.
+ */
+export declare function createEnvRedisIdempotencyStore(): IdempotencyStore | null;
+/** Inject the process-wide idempotency store (e.g. a Redis-backed one). */
+export declare function setIdempotencyStore(store: IdempotencyStore): void;
+/** The current process-wide default store (in-memory unless overridden). */
+export declare function getIdempotencyStore(): IdempotencyStore;
+export interface IdempotencyMiddlewareOptions {
+    /** Custom store backend. Defaults to the process-wide store set via
+     *  {@link setIdempotencyStore} (in-memory until `createApp` wires Redis). */
+    store?: IdempotencyStore;
+}
+/**
+ * Middleware that supports idempotency keys for POST/PUT/DELETE mutations.
+ *
+ * When a request includes the `Idempotency-Key` header:
+ * - First call: processes normally, caches the response
+ * - Subsequent calls with same key: returns cached response (prevents duplicate mutations)
+ *
+ * Defaults to an in-memory store (single-replica). Pass a custom
+ * cross-replica `{ store }` implementing `IdempotencyStore` to dedupe across
+ * replicas.
+ */
+export declare function idempotencyMiddleware(options?: IdempotencyMiddlewareOptions): (req: Request, res: Response, next: NextFunction) => void;
+export {};