@pipeline-builder/api-core 4.1.6 → 4.1.8

package/lib/services/token-revocation.js

@@ -3,6 +3,7 @@
 import { createEnvRedisClient, createRedisReadyGate } from './env-redis.js';
 import { createLogger } from '../utils/logger.js';
 import { emitCounter } from '../utils/metric-emitter.js';
+import { errorMessage } from '../utils/response.js';
 const logger = createLogger('token-revocation');
 /**
  * Redis key namespace for the per-user current `tokenVersion`. The platform
@@ -59,7 +60,7 @@ export function createRedisTokenRevocationStore(redis) {
                 // which is a deliberate opt-out, not a degradation.
                 emitCounter('token_revocation_fail_open_total', { reason: 'read-error' });
                 logger.debug('Token-revocation read failed (fail-open)', {
-                    userId, error: err instanceof Error ? err.message : String(err),
+                    userId, error: errorMessage(err),
                 });
                 return null;
             }
@@ -75,7 +76,7 @@ export function createRedisTokenRevocationStore(redis) {
                 // support impersonation everywhere — is visible and alertable.
                 emitCounter('session_revocation_unavailable_total', { reason: 'read-error' });
                 logger.debug('Session-revocation read failed (rejecting impersonation token)', {
-                    error: err instanceof Error ? err.message : String(err),
+                    error: errorMessage(err),
                 });
                 return 'unavailable';
             }
@@ -163,7 +164,7 @@ export async function publishTokenRevocation(redis, userId, tokenVersion, ttlSec
     }
     catch (err) {
         logger.warn('Token-revocation publish failed (services fall back to token expiry)', {
-            userId, error: err instanceof Error ? err.message : String(err),
+            userId, error: errorMessage(err),
         });
     }
 }
@@ -188,9 +189,9 @@ export async function publishSessionRevocation(redis, jti, ttlMs) {
     }
     catch (err) {
         logger.warn('Session-revocation publish failed (other services will honour the token until it expires)', {
-            error: err instanceof Error ? err.message : String(err),
+            error: errorMessage(err),
         });
         return false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token-revocation.js","sourceRoot":"","sources":["../../src/services/token-revocation.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { RedisCacheClient } from './cache-service.js';\nimport { createEnvRedisClient, createRedisReadyGate, type ReadyAwareRedis } from './env-redis.js';\nimport type { SessionRevocationState, TokenRevocationStore } from '../middleware/auth.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('token-revocation');\n\n/**\n * Redis key namespace for the per-user current `tokenVersion`. The platform\n * PUBLISHES to this key on every privilege change; the stateless services READ\n * it in `requireAuth` (via {@link createRedisTokenRevocationStore}) to reject\n * tokens minted before that change. Publisher and readers MUST share this exact\n * prefix — hence both helpers live here, in one place.\n */\nexport const TOKEN_REVOCATION_KEY_PREFIX = 'authrev:tv:';\n\n/** The revocation key for a user id. */\nexport function tokenRevocationKey(userId: string): string {\n  return `${TOKEN_REVOCATION_KEY_PREFIX}${userId}`;\n}\n\n/**\n * Redis key namespace for ended IMPERSONATION sessions, by token `jti`. Same\n * publish/read split as the tokenVersion keys above, and kept beside them for the\n * same reason: publisher and readers must agree on this exact prefix.\n */\nexport const SESSION_REVOCATION_KEY_PREFIX = 'authrev:jti:';\n\n/** The revocation key for one session's token id. */\nexport function sessionRevocationKey(jti: string): string {\n  return `${SESSION_REVOCATION_KEY_PREFIX}${jti}`;\n}\n\n/**\n * Build a {@link TokenRevocationStore} backed by a Redis client, for a stateless\n * service to register via `setTokenRevocationStore`. Reads the current\n * `tokenVersion` the platform published for the user.\n *\n * Fail-open by contract: a miss, a parse failure, or a Redis error all yield\n * `null` (— `requireAuth` treats that as \"no known revocation\"), so a Redis\n * outage degrades to the pre-existing behaviour rather than locking users out.\n */\nexport function createRedisTokenRevocationStore(redis: RedisCacheClient): TokenRevocationStore {\n  return {\n    async getCurrentVersion(userId: string): Promise<number | null> {\n      try {\n        const raw = await redis.get(tokenRevocationKey(userId));\n        if (raw === null || raw === undefined || raw.trim() === '') return null;\n        // Strict integer parse: `Number` (unlike `parseInt`) rejects trailing\n        // garbage (\"5abc\" → NaN), so a corrupted entry fails open (null → \"not\n        // revoked\") rather than being read as a bogus version. The empty-string\n        // guard above matters because `Number('')` is 0, not NaN.\n        const n = Number(raw);\n        return Number.isInteger(n) ? n : null;\n      } catch (err) {\n        // Redis was reachable enough to try but the read errored — this is a\n        // DEGRADATION: while it persists, forced logouts / privilege revocations\n        // silently stop taking effect until natural token expiry. Emit a counter\n        // so `TokenRevocationFailingOpen` can alert on a SUSTAINED rate (mirrors\n        // the quota_fail_open_total pattern). Not emitted for the \"Redis not\n        // configured\" path (createEnvRedisTokenRevocationStore → null client),\n        // which is a deliberate opt-out, not a degradation.\n        emitCounter('token_revocation_fail_open_total', { reason: 'read-error' });\n        logger.debug('Token-revocation read failed (fail-open)', {\n          userId, error: err instanceof Error ? err.message : String(err),\n        });\n        return null;\n      }\n    },\n    async getSessionRevocation(jti: string): Promise<SessionRevocationState> {\n      try {\n        const raw = await redis.get(sessionRevocationKey(jti));\n        return raw === null || raw === undefined ? 'live' : 'revoked';\n      } catch (err) {\n        // NOT fail-open, unlike getCurrentVersion above: `unavailable` rejects\n        // the impersonation token. Counted so a sustained outage — which stops\n        // support impersonation everywhere — is visible and alertable.\n        emitCounter('session_revocation_unavailable_total', { reason: 'read-error' });\n        logger.debug('Session-revocation read failed (rejecting impersonation token)', {\n          error: err instanceof Error ? err.message : String(err),\n        });\n        return 'unavailable';\n      }\n    },\n  };\n}\n\n/**\n * Build a {@link TokenRevocationStore} backed by a Redis client that is lazily\n * constructed from the standard `REDIS_URL` or `REDIS_SENTINELS` env —\n * for a stateless service that keeps NO Redis client of its own. The client is\n * built on first `getCurrentVersion` call and memoized; `ioredis` is loaded via\n * a guarded dynamic require so merely importing this never breaks a build/test\n * where Redis isn't present.\n *\n * FULLY FAIL-OPEN: no env configured, an ioredis load failure, a connect error,\n * or any read failure all resolve to `null` (\"no known revocation\"), so a\n * service degrades to natural token expiry rather than locking users out. A\n * service opts in with a single boot line:\n *   `setTokenRevocationStore(createEnvRedisTokenRevocationStore());`\n */\nexport function createEnvRedisTokenRevocationStore(): TokenRevocationStore {\n  type ReaderRedis = RedisCacheClient & ReadyAwareRedis;\n  // undefined = not yet attempted; null = attempted and unavailable (stay off).\n  let cached: ReaderRedis | null | undefined;\n  let ready: (() => Promise<void>) | undefined;\n\n  /**\n   * The reader client, built on first use. The env client has no offline queue,\n   * so a GET before the first connection completes is rejected — which made the\n   * FIRST impersonation check on every pod read 'unavailable' (401). Wait\n   * (bounded, never rejecting) for readiness; a genuinely down Redis then keeps\n   * the existing fail-open / 'unavailable' semantics.\n   */\n  async function client(): Promise<ReaderRedis | null> {\n    if (cached === undefined) {\n      // Shared env-configured ioredis construction (error listener attached, null\n      // when Redis isn't configured); the reader stays fail-open — a null client\n      // just falls back to natural token expiry.\n      cached = createEnvRedisClient<ReaderRedis>('revocation-reader');\n      if (cached) {\n        logger.info('Redis token-revocation reader initialized');\n        ready = createRedisReadyGate(cached);\n      }\n    }\n    if (ready) await ready();\n    return cached;\n  }\n\n  return {\n    async getCurrentVersion(userId: string): Promise<number | null> {\n      const redis = await client();\n      if (!redis) return null;\n      return createRedisTokenRevocationStore(redis).getCurrentVersion(userId);\n    },\n    async getSessionRevocation(jti: string): Promise<SessionRevocationState> {\n      const redis = await client();\n      // No Redis configured ⇒ there is no way to learn a session was ended, so\n      // an impersonation token can't be trusted. Every real deployment runs Redis\n      // (the build queue needs it), so this only bites a misconfigured service.\n      if (!redis) {\n        emitCounter('session_revocation_unavailable_total', { reason: 'not-configured' });\n        return 'unavailable';\n      }\n      return createRedisTokenRevocationStore(redis).getSessionRevocation!(jti);\n    },\n  };\n}\n\n/**\n * Publish a user's current `tokenVersion` so the stateless services see the\n * revocation immediately (platform side). Best-effort — never throws; a failure\n * just means the services fall back to natural token expiry for this change.\n *\n * The key is written with a TTL equal to the access-token lifetime: any token\n * that could still carry an older version has expired by the time the entry\n * lapses, so an expired entry can never cause a false \"revoked\" nor a missed one.\n *\n * @param redis - the platform's Redis client\n * @param userId - the user whose sessions changed\n * @param tokenVersion - the user's NEW (post-increment) tokenVersion\n * @param ttlSeconds - access-token lifetime in seconds\n */\nexport async function publishTokenRevocation(\n  redis: RedisCacheClient,\n  userId: string,\n  tokenVersion: number,\n  ttlSeconds: number,\n): Promise<void> {\n  try {\n    // ioredis-style variadic SET with expiry: SET key val EX ttl.\n    await redis.set(tokenRevocationKey(userId), String(tokenVersion), 'EX', Math.max(1, Math.floor(ttlSeconds)));\n  } catch (err) {\n    logger.warn('Token-revocation publish failed (services fall back to token expiry)', {\n      userId, error: err instanceof Error ? err.message : String(err),\n    });\n  }\n}\n\n/**\n * Publish that one IMPERSONATION session has ended, so every stateless service\n * rejects its token on the next request (platform side).\n *\n * Returns whether the publish landed — unlike `publishTokenRevocation`, which is\n * fire-and-forget. The caller must be able to tell the person who ended the\n * session that it did NOT end everywhere, rather than reporting success while\n * the token still works against other services.\n *\n * The entry expires with the session: once the token itself can no longer be\n * used, there is nothing left to revoke, so the key cleans itself up.\n *\n * @param ttlMs - time remaining on the session's token\n */\nexport async function publishSessionRevocation(\n  redis: RedisCacheClient,\n  jti: string,\n  ttlMs: number,\n): Promise<boolean> {\n  try {\n    await redis.set(sessionRevocationKey(jti), '1', 'PX', Math.max(1000, Math.ceil(ttlMs)));\n    return true;\n  } catch (err) {\n    logger.warn('Session-revocation publish failed (other services will honour the token until it expires)', {\n      error: err instanceof Error ? err.message : String(err),\n    });\n    return false;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token-revocation.js","sourceRoot":"","sources":["../../src/services/token-revocation.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { RedisCacheClient } from './cache-service.js';\nimport { createEnvRedisClient, createRedisReadyGate, type ReadyAwareRedis } from './env-redis.js';\nimport type { SessionRevocationState, TokenRevocationStore } from '../middleware/auth.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\nimport { errorMessage } from '../utils/response.js';\n\nconst logger = createLogger('token-revocation');\n\n/**\n * Redis key namespace for the per-user current `tokenVersion`. The platform\n * PUBLISHES to this key on every privilege change; the stateless services READ\n * it in `requireAuth` (via {@link createRedisTokenRevocationStore}) to reject\n * tokens minted before that change. Publisher and readers MUST share this exact\n * prefix — hence both helpers live here, in one place.\n */\nexport const TOKEN_REVOCATION_KEY_PREFIX = 'authrev:tv:';\n\n/** The revocation key for a user id. */\nexport function tokenRevocationKey(userId: string): string {\n  return `${TOKEN_REVOCATION_KEY_PREFIX}${userId}`;\n}\n\n/**\n * Redis key namespace for ended IMPERSONATION sessions, by token `jti`. Same\n * publish/read split as the tokenVersion keys above, and kept beside them for the\n * same reason: publisher and readers must agree on this exact prefix.\n */\nexport const SESSION_REVOCATION_KEY_PREFIX = 'authrev:jti:';\n\n/** The revocation key for one session's token id. */\nexport function sessionRevocationKey(jti: string): string {\n  return `${SESSION_REVOCATION_KEY_PREFIX}${jti}`;\n}\n\n/**\n * Build a {@link TokenRevocationStore} backed by a Redis client, for a stateless\n * service to register via `setTokenRevocationStore`. Reads the current\n * `tokenVersion` the platform published for the user.\n *\n * Fail-open by contract: a miss, a parse failure, or a Redis error all yield\n * `null` (— `requireAuth` treats that as \"no known revocation\"), so a Redis\n * outage degrades to the pre-existing behaviour rather than locking users out.\n */\nexport function createRedisTokenRevocationStore(redis: RedisCacheClient): TokenRevocationStore {\n  return {\n    async getCurrentVersion(userId: string): Promise<number | null> {\n      try {\n        const raw = await redis.get(tokenRevocationKey(userId));\n        if (raw === null || raw === undefined || raw.trim() === '') return null;\n        // Strict integer parse: `Number` (unlike `parseInt`) rejects trailing\n        // garbage (\"5abc\" → NaN), so a corrupted entry fails open (null → \"not\n        // revoked\") rather than being read as a bogus version. The empty-string\n        // guard above matters because `Number('')` is 0, not NaN.\n        const n = Number(raw);\n        return Number.isInteger(n) ? n : null;\n      } catch (err) {\n        // Redis was reachable enough to try but the read errored — this is a\n        // DEGRADATION: while it persists, forced logouts / privilege revocations\n        // silently stop taking effect until natural token expiry. Emit a counter\n        // so `TokenRevocationFailingOpen` can alert on a SUSTAINED rate (mirrors\n        // the quota_fail_open_total pattern). Not emitted for the \"Redis not\n        // configured\" path (createEnvRedisTokenRevocationStore → null client),\n        // which is a deliberate opt-out, not a degradation.\n        emitCounter('token_revocation_fail_open_total', { reason: 'read-error' });\n        logger.debug('Token-revocation read failed (fail-open)', {\n          userId, error: errorMessage(err),\n        });\n        return null;\n      }\n    },\n    async getSessionRevocation(jti: string): Promise<SessionRevocationState> {\n      try {\n        const raw = await redis.get(sessionRevocationKey(jti));\n        return raw === null || raw === undefined ? 'live' : 'revoked';\n      } catch (err) {\n        // NOT fail-open, unlike getCurrentVersion above: `unavailable` rejects\n        // the impersonation token. Counted so a sustained outage — which stops\n        // support impersonation everywhere — is visible and alertable.\n        emitCounter('session_revocation_unavailable_total', { reason: 'read-error' });\n        logger.debug('Session-revocation read failed (rejecting impersonation token)', {\n          error: errorMessage(err),\n        });\n        return 'unavailable';\n      }\n    },\n  };\n}\n\n/**\n * Build a {@link TokenRevocationStore} backed by a Redis client that is lazily\n * constructed from the standard `REDIS_URL` or `REDIS_SENTINELS` env —\n * for a stateless service that keeps NO Redis client of its own. The client is\n * built on first `getCurrentVersion` call and memoized; `ioredis` is loaded via\n * a guarded dynamic require so merely importing this never breaks a build/test\n * where Redis isn't present.\n *\n * FULLY FAIL-OPEN: no env configured, an ioredis load failure, a connect error,\n * or any read failure all resolve to `null` (\"no known revocation\"), so a\n * service degrades to natural token expiry rather than locking users out. A\n * service opts in with a single boot line:\n *   `setTokenRevocationStore(createEnvRedisTokenRevocationStore());`\n */\nexport function createEnvRedisTokenRevocationStore(): TokenRevocationStore {\n  type ReaderRedis = RedisCacheClient & ReadyAwareRedis;\n  // undefined = not yet attempted; null = attempted and unavailable (stay off).\n  let cached: ReaderRedis | null | undefined;\n  let ready: (() => Promise<void>) | undefined;\n\n  /**\n   * The reader client, built on first use. The env client has no offline queue,\n   * so a GET before the first connection completes is rejected — which made the\n   * FIRST impersonation check on every pod read 'unavailable' (401). Wait\n   * (bounded, never rejecting) for readiness; a genuinely down Redis then keeps\n   * the existing fail-open / 'unavailable' semantics.\n   */\n  async function client(): Promise<ReaderRedis | null> {\n    if (cached === undefined) {\n      // Shared env-configured ioredis construction (error listener attached, null\n      // when Redis isn't configured); the reader stays fail-open — a null client\n      // just falls back to natural token expiry.\n      cached = createEnvRedisClient<ReaderRedis>('revocation-reader');\n      if (cached) {\n        logger.info('Redis token-revocation reader initialized');\n        ready = createRedisReadyGate(cached);\n      }\n    }\n    if (ready) await ready();\n    return cached;\n  }\n\n  return {\n    async getCurrentVersion(userId: string): Promise<number | null> {\n      const redis = await client();\n      if (!redis) return null;\n      return createRedisTokenRevocationStore(redis).getCurrentVersion(userId);\n    },\n    async getSessionRevocation(jti: string): Promise<SessionRevocationState> {\n      const redis = await client();\n      // No Redis configured ⇒ there is no way to learn a session was ended, so\n      // an impersonation token can't be trusted. Every real deployment runs Redis\n      // (the build queue needs it), so this only bites a misconfigured service.\n      if (!redis) {\n        emitCounter('session_revocation_unavailable_total', { reason: 'not-configured' });\n        return 'unavailable';\n      }\n      return createRedisTokenRevocationStore(redis).getSessionRevocation!(jti);\n    },\n  };\n}\n\n/**\n * Publish a user's current `tokenVersion` so the stateless services see the\n * revocation immediately (platform side). Best-effort — never throws; a failure\n * just means the services fall back to natural token expiry for this change.\n *\n * The key is written with a TTL equal to the access-token lifetime: any token\n * that could still carry an older version has expired by the time the entry\n * lapses, so an expired entry can never cause a false \"revoked\" nor a missed one.\n *\n * @param redis - the platform's Redis client\n * @param userId - the user whose sessions changed\n * @param tokenVersion - the user's NEW (post-increment) tokenVersion\n * @param ttlSeconds - access-token lifetime in seconds\n */\nexport async function publishTokenRevocation(\n  redis: RedisCacheClient,\n  userId: string,\n  tokenVersion: number,\n  ttlSeconds: number,\n): Promise<void> {\n  try {\n    // ioredis-style variadic SET with expiry: SET key val EX ttl.\n    await redis.set(tokenRevocationKey(userId), String(tokenVersion), 'EX', Math.max(1, Math.floor(ttlSeconds)));\n  } catch (err) {\n    logger.warn('Token-revocation publish failed (services fall back to token expiry)', {\n      userId, error: errorMessage(err),\n    });\n  }\n}\n\n/**\n * Publish that one IMPERSONATION session has ended, so every stateless service\n * rejects its token on the next request (platform side).\n *\n * Returns whether the publish landed — unlike `publishTokenRevocation`, which is\n * fire-and-forget. The caller must be able to tell the person who ended the\n * session that it did NOT end everywhere, rather than reporting success while\n * the token still works against other services.\n *\n * The entry expires with the session: once the token itself can no longer be\n * used, there is nothing left to revoke, so the key cleans itself up.\n *\n * @param ttlMs - time remaining on the session's token\n */\nexport async function publishSessionRevocation(\n  redis: RedisCacheClient,\n  jti: string,\n  ttlMs: number,\n): Promise<boolean> {\n  try {\n    await redis.set(sessionRevocationKey(jti), '1', 'PX', Math.max(1000, Math.ceil(ttlMs)));\n    return true;\n  } catch (err) {\n    logger.warn('Session-revocation publish failed (other services will honour the token until it expires)', {\n      error: errorMessage(err),\n    });\n    return false;\n  }\n}\n"]}

package/lib/testing/mock-api-core.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Shared `@pipeline-builder/api-core` mock factory for ESM suites.
+ *
+ * WHY: every project kept its own `test/helpers/mock-api-core.ts` — twelve forks
+ * of the same ~150-line file, ranging from 23 to 61 overridden keys against an
+ * api-core barrel exporting ~357 symbols. Each fork re-declared the same logger
+ * stub, the same `ErrorCode` proxy, the same error classes and the same
+ * service-gate re-implementations, and each drifted independently.
+ *
+ * THE FIX: the shared parts live here, once. A project's helper keeps ONLY the
+ * defaults that are genuinely project-specific (its tier fixtures, its compliance
+ * client, its response helpers) and layers them on top:
+ *
+ *   const actualApiCore = jest.requireActual('@pipeline-builder/api-core') as Record<string, unknown>;
+ *   export function apiCoreMock(overrides: Record<string, unknown> = {}) {
+ *     return baseApiCoreMock(actualApiCore, { ...projectDefaults, ...overrides });
+ *   }
+ *
+ * Both this module and the per-project helpers start from `requireActual`, so an
+ * export ADDED to api-core is inherited automatically and can never again break a
+ * suite with "does not provide an export named X".
+ *
+ * WHY IT LIVES IN api-core: the deep path
+ * `@pipeline-builder/api-core/lib/testing/mock-api-core.js` is a different
+ * specifier from the `@pipeline-builder/api-core` barrel, so a suite's module
+ * mock does NOT intercept it — the factory can therefore read the real module
+ * without recursing into its own mock. Same trick as `tier-mock.ts`.
+ */
+import { jest } from '@jest/globals';
+/** Minimal Express-ish shapes the gate/response stubs below touch. */
+type MockRes = {
+    status: (n: number) => {
+        json: (b: unknown) => unknown;
+    };
+};
+type Next = () => void;
+/** A bare `jest.fn()`, named so the emitted `.d.ts` stays portable (TS2883). */
+type MockFn = ReturnType<typeof jest.fn>;
+/** The winston double every suite asserts on: four spies, nothing else. */
+export interface MockLogger {
+    info: MockFn;
+    warn: MockFn;
+    error: MockFn;
+    debug: MockFn;
+}
+/** The 4-method winston stub every suite repeats; a fresh set of spies per call. */
+export declare const loggerMock: () => MockLogger;
+/** Mirrors api-core: `ErrorCode.ANY_CODE` resolves to the string `'ANY_CODE'`. */
+export declare const mockErrorCode: Record<string, string>;
+/** No-op guard: the default mock covers route wiring, not the permission gate. */
+export declare const passThroughMiddleware: (_req: unknown, _res: unknown, next: Next) => void;
+/** Mirrors api-core's `AppError` base (typed HTTP error: statusCode + code). */
+export declare class MockAppError extends Error {
+    readonly statusCode: number;
+    readonly code: string;
+    constructor(statusCode: number, code: string, message?: string);
+}
+/** Mirrors api-core's NotFoundError (404 / NOT_FOUND). */
+export declare class MockNotFoundError extends MockAppError {
+    constructor(message?: string);
+}
+/** Mirrors api-core's ConflictError (409 / CONFLICT). */
+export declare class MockConflictError extends MockAppError {
+    constructor(message?: string);
+}
+/** Mirrors api-core's ForbiddenError (403 / INSUFFICIENT_PERMISSIONS). */
+export declare class MockForbiddenError extends MockAppError {
+    constructor(message?: string);
+}
+/** Mirrors api-core's ValidationError (400 / VALIDATION_ERROR). */
+export declare class MockValidationError extends MockAppError {
+    constructor(message?: string);
+}
+/**
+ * Capability-aware stand-in for api-core's `requirePermission` /
+ * `requireAllPermissions` gate factories. Mirrors the real gate's decision (minus
+ * the denial-audit side effect): superadmin passes, otherwise the caller must
+ * hold the permission(s); a miss is a 403 with the real message shape.
+ *
+ * `onAnonymous` picks what happens when there is no `req.user` at all: `'pass'`
+ * (suites with no auth layer mounted) or `'401'` (suites that drive the gate).
+ * `shape` picks the denial envelope the project's suites assert on.
+ */
+export declare function mockPermissionGate(options?: {
+    mode?: 'some' | 'every';
+    allowService?: boolean;
+    onAnonymous?: 'pass' | '401';
+    shape?: 'error' | 'message';
+}): (...permissions: string[]) => (req: {
+    user?: {
+        isSuperAdmin?: boolean;
+        permissions?: string[];
+        sub?: string;
+    };
+}, res: MockRes, next: Next) => unknown;
+/**
+ * The defaults shared by every service / package mock: the logger stub, the
+ * pagination constants, the inert scheduler / leader-lock / redis-audit wiring a
+ * boot module links at load, and the error + cache shapes. A project layers its
+ * own defaults on top by passing them in `overrides`.
+ */
+export declare function serviceApiCoreDefaults(): Record<string, unknown>;
+/**
+ * The audit / security wiring a service's boot module (`src/index.ts`,
+ * `src/services/audit.ts`) links at load time. Inert by default: nothing asserts
+ * on the registration, and pulling the real graph in would drag Redis + HTTP
+ * clients into every route suite.
+ */
+export declare function serviceAuditDefaults(): Record<string, unknown>;
+/**
+ * Build an api-core mock namespace: REAL api-core, then the shared service
+ * defaults, then `overrides` (a project's own defaults merged with the suite's).
+ *
+ * `actualApiCore` is supplied by the CALLER (`jest.requireActual(...)` at the top
+ * of the project's `test/helpers/mock-api-core.ts`) rather than resolved here.
+ * That is deliberate: `requireActual` on an ESM barrel only succeeds at a moment
+ * when nothing else is mid-`import()` of it, and the project helper — a static
+ * import of the test file, evaluated before any `await import(SUT)` — is the one
+ * point where that always holds. Resolving it from inside this module (which
+ * lives in the api-core package itself) races that import in some suites.
+ */
+export declare function baseApiCoreMock(actualApiCore: Record<string, unknown>, overrides?: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Build an api-core mock namespace with NO service defaults — REAL api-core plus
+ * the logger stub and `ErrorCode` proxy only. Platform uses this: it deliberately
+ * keeps api-core's real pagination/report constants and supplies its own
+ * (large) identity/tier/permission default set.
+ */
+export declare function primitiveApiCoreMock(actualApiCore: Record<string, unknown>, overrides?: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Mirror api-core's `requireInternalService({ callers })`: refuse any user token,
+ * then refuse a service whose name is not in the route's caller list. Resolved
+ * from the MERGED mock (rather than inherited from `requireActual`) so it uses
+ * the suite's `isServicePrincipal` / `serviceNameOf` / `sendError`, which the real
+ * one closes over and would write past.
+ */
+export declare function withInternalServiceGate(mock: Record<string, unknown>, overrides: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Mirror api-core's `requireServicePrincipal`: reject a non-service caller with a
+ * 403 INSUFFICIENT_PERMISSIONS (an authorization refusal, not a 400), resolving
+ * `isServicePrincipal` / `sendError` from the merged mock.
+ */
+export declare function withServicePrincipalGate(mock: Record<string, unknown>, overrides: Record<string, unknown>): Record<string, unknown>;
+/**
+ * `sendBadRequest` delegating to the (possibly-overridden) `sendError`, mirroring
+ * the real implementation — so a suite spying on `sendError` also observes the
+ * 400s routed through `sendBadRequest`.
+ */
+export declare function withDelegatingSendBadRequest(mock: Record<string, unknown>, overrides: Record<string, unknown>): Record<string, unknown>;
+export {};

package/lib/testing/mock-api-core.js

@@ -0,0 +1,246 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Shared `@pipeline-builder/api-core` mock factory for ESM suites.
+ *
+ * WHY: every project kept its own `test/helpers/mock-api-core.ts` — twelve forks
+ * of the same ~150-line file, ranging from 23 to 61 overridden keys against an
+ * api-core barrel exporting ~357 symbols. Each fork re-declared the same logger
+ * stub, the same `ErrorCode` proxy, the same error classes and the same
+ * service-gate re-implementations, and each drifted independently.
+ *
+ * THE FIX: the shared parts live here, once. A project's helper keeps ONLY the
+ * defaults that are genuinely project-specific (its tier fixtures, its compliance
+ * client, its response helpers) and layers them on top:
+ *
+ *   const actualApiCore = jest.requireActual('@pipeline-builder/api-core') as Record<string, unknown>;
+ *   export function apiCoreMock(overrides: Record<string, unknown> = {}) {
+ *     return baseApiCoreMock(actualApiCore, { ...projectDefaults, ...overrides });
+ *   }
+ *
+ * Both this module and the per-project helpers start from `requireActual`, so an
+ * export ADDED to api-core is inherited automatically and can never again break a
+ * suite with "does not provide an export named X".
+ *
+ * WHY IT LIVES IN api-core: the deep path
+ * `@pipeline-builder/api-core/lib/testing/mock-api-core.js` is a different
+ * specifier from the `@pipeline-builder/api-core` barrel, so a suite's module
+ * mock does NOT intercept it — the factory can therefore read the real module
+ * without recursing into its own mock. Same trick as `tier-mock.ts`.
+ */
+import { jest } from '@jest/globals';
+/** The 4-method winston stub every suite repeats; a fresh set of spies per call. */
+export const loggerMock = () => ({
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    debug: jest.fn(),
+});
+/** Mirrors api-core: `ErrorCode.ANY_CODE` resolves to the string `'ANY_CODE'`. */
+export const mockErrorCode = new Proxy({}, { get: (_t, key) => key });
+/** No-op guard: the default mock covers route wiring, not the permission gate. */
+export const passThroughMiddleware = (_req, _res, next) => next();
+/** Mirrors api-core's `AppError` base (typed HTTP error: statusCode + code). */
+export class MockAppError extends Error {
+    statusCode;
+    code;
+    constructor(statusCode, code, message) {
+        super(message);
+        this.statusCode = statusCode;
+        this.code = code;
+        this.name = 'AppError';
+    }
+}
+/** Mirrors api-core's NotFoundError (404 / NOT_FOUND). */
+export class MockNotFoundError extends MockAppError {
+    constructor(message) {
+        super(404, 'NOT_FOUND', message);
+        this.name = 'NotFoundError';
+    }
+}
+/** Mirrors api-core's ConflictError (409 / CONFLICT). */
+export class MockConflictError extends MockAppError {
+    constructor(message) {
+        super(409, 'CONFLICT', message);
+        this.name = 'ConflictError';
+    }
+}
+/** Mirrors api-core's ForbiddenError (403 / INSUFFICIENT_PERMISSIONS). */
+export class MockForbiddenError extends MockAppError {
+    constructor(message) {
+        super(403, 'INSUFFICIENT_PERMISSIONS', message);
+        this.name = 'ForbiddenError';
+    }
+}
+/** Mirrors api-core's ValidationError (400 / VALIDATION_ERROR). */
+export class MockValidationError extends MockAppError {
+    constructor(message) {
+        super(400, 'VALIDATION_ERROR', message);
+        this.name = 'ValidationError';
+    }
+}
+/**
+ * Capability-aware stand-in for api-core's `requirePermission` /
+ * `requireAllPermissions` gate factories. Mirrors the real gate's decision (minus
+ * the denial-audit side effect): superadmin passes, otherwise the caller must
+ * hold the permission(s); a miss is a 403 with the real message shape.
+ *
+ * `onAnonymous` picks what happens when there is no `req.user` at all: `'pass'`
+ * (suites with no auth layer mounted) or `'401'` (suites that drive the gate).
+ * `shape` picks the denial envelope the project's suites assert on.
+ */
+export function mockPermissionGate(options = {}) {
+    const { mode = 'some', allowService = false, onAnonymous = 'pass', shape = 'message' } = options;
+    const joiner = mode === 'some' ? ' or ' : ' and ';
+    const deny = (msg) => (shape === 'error' ? { error: msg } : { success: false, message: msg });
+    return (...permissions) => {
+        const gate = (req, res, next) => {
+            const user = req?.user;
+            if (!user)
+                return onAnonymous === 'pass' ? next() : res.status(401).json({ error: 'Authentication required' });
+            if (allowService && typeof user.sub === 'string' && user.sub.startsWith('service:'))
+                return next();
+            if (user.isSuperAdmin === true)
+                return next();
+            const held = Array.isArray(user.permissions) ? user.permissions : [];
+            const ok = mode === 'some' ? permissions.some((p) => held.includes(p)) : permissions.every((p) => held.includes(p));
+            if (ok)
+                return next();
+            return res.status(403).json(deny(`Missing required permission: ${permissions.join(joiner)}`));
+        };
+        // Tags let a wiring suite locate the gate layer in a router stack and assert
+        // which flavour was mounted.
+        gate.__permission = permissions.join(joiner);
+        gate.__allowService = allowService;
+        return gate;
+    };
+}
+/**
+ * The defaults shared by every service / package mock: the logger stub, the
+ * pagination constants, the inert scheduler / leader-lock / redis-audit wiring a
+ * boot module links at load, and the error + cache shapes. A project layers its
+ * own defaults on top by passing them in `overrides`.
+ */
+export function serviceApiCoreDefaults() {
+    return {
+        createLogger: loggerMock,
+        MAX_PAGE_LIMIT: 1000,
+        DEFAULT_PAGE_LIMIT: 100,
+        closeLeaderLock: async () => undefined,
+        loadAndRestore: async () => null,
+        REPORT_INTERVALS: ['day', 'week', 'month'],
+        scrubAwsIdentifiersFromString: (s) => s,
+        scrubAwsIdentifiers: (v) => v,
+        createScheduler: () => ({ start: () => undefined, stop: () => undefined }),
+        createEnvRedisLock: () => null,
+        requireStepUp: (_req, _res, next) => next(),
+        SYSTEM_ORG_ID: '000000000000000000000001',
+        ComputeType: { SMALL: 'SMALL', MEDIUM: 'MEDIUM', LARGE: 'LARGE', X2_LARGE: 'X2_LARGE' },
+        PluginType: { CODE_BUILD_STEP: 'CodeBuildStep', SHELL_STEP: 'ShellStep', MANUAL_APPROVAL_STEP: 'ManualApprovalStep' },
+        ErrorCode: mockErrorCode,
+        errorMessage: (e) => (e instanceof Error ? e.message : String(e)),
+        NotFoundError: MockNotFoundError,
+        createCacheService: () => ({
+            getOrSet: (_key, factory) => factory(),
+            invalidatePattern: () => Promise.resolve(0),
+        }),
+    };
+}
+/**
+ * The audit / security wiring a service's boot module (`src/index.ts`,
+ * `src/services/audit.ts`) links at load time. Inert by default: nothing asserts
+ * on the registration, and pulling the real graph in would drag Redis + HTTP
+ * clients into every route suite.
+ */
+export function serviceAuditDefaults() {
+    return {
+        createRemoteAuditClient: () => ({ record: jest.fn() }),
+        createEnvRedisAuditSpool: () => null,
+        createServiceAuditClient: () => ({ emit: jest.fn(), client: { record: jest.fn() } }),
+        createRemoteAuditAccessor: () => ({ getAuditClient: () => ({ record: jest.fn() }), emit: jest.fn() }),
+        setAuthzDenialAuditor: () => { },
+        wireAuthzDenialAuditor: () => { },
+        wireServiceSecurity: () => { },
+        setTokenRevocationStore: () => { },
+        createRedisTokenRevocationStore: () => ({ getCurrentVersion: async () => null }),
+        createEnvRedisTokenRevocationStore: () => ({ getCurrentVersion: async () => null }),
+    };
+}
+/**
+ * Build an api-core mock namespace: REAL api-core, then the shared service
+ * defaults, then `overrides` (a project's own defaults merged with the suite's).
+ *
+ * `actualApiCore` is supplied by the CALLER (`jest.requireActual(...)` at the top
+ * of the project's `test/helpers/mock-api-core.ts`) rather than resolved here.
+ * That is deliberate: `requireActual` on an ESM barrel only succeeds at a moment
+ * when nothing else is mid-`import()` of it, and the project helper — a static
+ * import of the test file, evaluated before any `await import(SUT)` — is the one
+ * point where that always holds. Resolving it from inside this module (which
+ * lives in the api-core package itself) races that import in some suites.
+ */
+export function baseApiCoreMock(actualApiCore, overrides = {}) {
+    return { ...actualApiCore, ...serviceApiCoreDefaults(), ...overrides };
+}
+/**
+ * Build an api-core mock namespace with NO service defaults — REAL api-core plus
+ * the logger stub and `ErrorCode` proxy only. Platform uses this: it deliberately
+ * keeps api-core's real pagination/report constants and supplies its own
+ * (large) identity/tier/permission default set.
+ */
+export function primitiveApiCoreMock(actualApiCore, overrides = {}) {
+    return { ...actualApiCore, createLogger: loggerMock, ErrorCode: mockErrorCode, ...overrides };
+}
+/**
+ * Mirror api-core's `requireInternalService({ callers })`: refuse any user token,
+ * then refuse a service whose name is not in the route's caller list. Resolved
+ * from the MERGED mock (rather than inherited from `requireActual`) so it uses
+ * the suite's `isServicePrincipal` / `serviceNameOf` / `sendError`, which the real
+ * one closes over and would write past.
+ */
+export function withInternalServiceGate(mock, overrides) {
+    if (overrides.requireInternalService !== undefined)
+        return mock;
+    mock.requireInternalService = ({ callers }) => (req, res, next) => {
+        const isSvc = mock.isServicePrincipal;
+        const nameOf = mock.serviceNameOf;
+        const caller = nameOf?.(req.user);
+        if (isSvc?.(req) && caller && callers.includes(caller)) {
+            next();
+            return;
+        }
+        const sendError = mock.sendError;
+        sendError(res, 403, 'Internal service calls only', 'INSUFFICIENT_PERMISSIONS');
+    };
+    return mock;
+}
+/**
+ * Mirror api-core's `requireServicePrincipal`: reject a non-service caller with a
+ * 403 INSUFFICIENT_PERMISSIONS (an authorization refusal, not a 400), resolving
+ * `isServicePrincipal` / `sendError` from the merged mock.
+ */
+export function withServicePrincipalGate(mock, overrides) {
+    if (overrides.requireServicePrincipal !== undefined)
+        return mock;
+    mock.requireServicePrincipal = (req, res, next) => {
+        const isSvc = mock.isServicePrincipal;
+        if (isSvc?.(req)) {
+            next();
+            return;
+        }
+        const sendError = mock.sendError;
+        sendError(res, 403, 'Internal service calls only', 'INSUFFICIENT_PERMISSIONS');
+    };
+    return mock;
+}
+/**
+ * `sendBadRequest` delegating to the (possibly-overridden) `sendError`, mirroring
+ * the real implementation — so a suite spying on `sendError` also observes the
+ * 400s routed through `sendBadRequest`.
+ */
+export function withDelegatingSendBadRequest(mock, overrides) {
+    if ('sendBadRequest' in overrides)
+        return mock;
+    mock.sendBadRequest = (res, message, code) => mock.sendError(res, 400, message, code ?? mockErrorCode.VALIDATION_ERROR);
+    return mock;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mock-api-core.js","sourceRoot":"","sources":["../../src/testing/mock-api-core.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared `@pipeline-builder/api-core` mock factory for ESM suites.\n *\n * WHY: every project kept its own `test/helpers/mock-api-core.ts` — twelve forks\n * of the same ~150-line file, ranging from 23 to 61 overridden keys against an\n * api-core barrel exporting ~357 symbols. Each fork re-declared the same logger\n * stub, the same `ErrorCode` proxy, the same error classes and the same\n * service-gate re-implementations, and each drifted independently.\n *\n * THE FIX: the shared parts live here, once. A project's helper keeps ONLY the\n * defaults that are genuinely project-specific (its tier fixtures, its compliance\n * client, its response helpers) and layers them on top:\n *\n *   const actualApiCore = jest.requireActual('@pipeline-builder/api-core') as Record<string, unknown>;\n *   export function apiCoreMock(overrides: Record<string, unknown> = {}) {\n *     return baseApiCoreMock(actualApiCore, { ...projectDefaults, ...overrides });\n *   }\n *\n * Both this module and the per-project helpers start from `requireActual`, so an\n * export ADDED to api-core is inherited automatically and can never again break a\n * suite with \"does not provide an export named X\".\n *\n * WHY IT LIVES IN api-core: the deep path\n * `@pipeline-builder/api-core/lib/testing/mock-api-core.js` is a different\n * specifier from the `@pipeline-builder/api-core` barrel, so a suite's module\n * mock does NOT intercept it — the factory can therefore read the real module\n * without recursing into its own mock. Same trick as `tier-mock.ts`.\n */\n\nimport { jest } from '@jest/globals';\n\n/** Minimal Express-ish shapes the gate/response stubs below touch. */\ntype MockRes = { status: (n: number) => { json: (b: unknown) => unknown } };\ntype Next = () => void;\n\n/** A bare `jest.fn()`, named so the emitted `.d.ts` stays portable (TS2883). */\ntype MockFn = ReturnType<typeof jest.fn>;\n\n/** The winston double every suite asserts on: four spies, nothing else. */\nexport interface MockLogger {\n  info: MockFn;\n  warn: MockFn;\n  error: MockFn;\n  debug: MockFn;\n}\n\n/** The 4-method winston stub every suite repeats; a fresh set of spies per call. */\nexport const loggerMock = (): MockLogger => ({\n  info: jest.fn(),\n  warn: jest.fn(),\n  error: jest.fn(),\n  debug: jest.fn(),\n});\n\n/** Mirrors api-core: `ErrorCode.ANY_CODE` resolves to the string `'ANY_CODE'`. */\nexport const mockErrorCode = new Proxy({}, { get: (_t, key) => key }) as Record<string, string>;\n\n/** No-op guard: the default mock covers route wiring, not the permission gate. */\nexport const passThroughMiddleware = (_req: unknown, _res: unknown, next: Next): void => next();\n\n/** Mirrors api-core's `AppError` base (typed HTTP error: statusCode + code). */\nexport class MockAppError extends Error {\n  constructor(public readonly statusCode: number, public readonly code: string, message?: string) {\n    super(message);\n    this.name = 'AppError';\n  }\n}\n\n/** Mirrors api-core's NotFoundError (404 / NOT_FOUND). */\nexport class MockNotFoundError extends MockAppError {\n  constructor(message?: string) {\n    super(404, 'NOT_FOUND', message);\n    this.name = 'NotFoundError';\n  }\n}\n\n/** Mirrors api-core's ConflictError (409 / CONFLICT). */\nexport class MockConflictError extends MockAppError {\n  constructor(message?: string) {\n    super(409, 'CONFLICT', message);\n    this.name = 'ConflictError';\n  }\n}\n\n/** Mirrors api-core's ForbiddenError (403 / INSUFFICIENT_PERMISSIONS). */\nexport class MockForbiddenError extends MockAppError {\n  constructor(message?: string) {\n    super(403, 'INSUFFICIENT_PERMISSIONS', message);\n    this.name = 'ForbiddenError';\n  }\n}\n\n/** Mirrors api-core's ValidationError (400 / VALIDATION_ERROR). */\nexport class MockValidationError extends MockAppError {\n  constructor(message?: string) {\n    super(400, 'VALIDATION_ERROR', message);\n    this.name = 'ValidationError';\n  }\n}\n\n/**\n * Capability-aware stand-in for api-core's `requirePermission` /\n * `requireAllPermissions` gate factories. Mirrors the real gate's decision (minus\n * the denial-audit side effect): superadmin passes, otherwise the caller must\n * hold the permission(s); a miss is a 403 with the real message shape.\n *\n * `onAnonymous` picks what happens when there is no `req.user` at all: `'pass'`\n * (suites with no auth layer mounted) or `'401'` (suites that drive the gate).\n * `shape` picks the denial envelope the project's suites assert on.\n */\nexport function mockPermissionGate(options: {\n  mode?: 'some' | 'every';\n  allowService?: boolean;\n  onAnonymous?: 'pass' | '401';\n  shape?: 'error' | 'message';\n} = {}) {\n  const { mode = 'some', allowService = false, onAnonymous = 'pass', shape = 'message' } = options;\n  const joiner = mode === 'some' ? ' or ' : ' and ';\n  const deny = (msg: string) => (shape === 'error' ? { error: msg } : { success: false, message: msg });\n  return (...permissions: string[]) => {\n    const gate = (req: { user?: { isSuperAdmin?: boolean; permissions?: string[]; sub?: string } }, res: MockRes, next: Next): unknown => {\n      const user = req?.user;\n      if (!user) return onAnonymous === 'pass' ? next() : res.status(401).json({ error: 'Authentication required' });\n      if (allowService && typeof user.sub === 'string' && user.sub.startsWith('service:')) return next();\n      if (user.isSuperAdmin === true) return next();\n      const held = Array.isArray(user.permissions) ? user.permissions : [];\n      const ok = mode === 'some' ? permissions.some((p) => held.includes(p)) : permissions.every((p) => held.includes(p));\n      if (ok) return next();\n      return res.status(403).json(deny(`Missing required permission: ${permissions.join(joiner)}`));\n    };\n    // Tags let a wiring suite locate the gate layer in a router stack and assert\n    // which flavour was mounted.\n    (gate as unknown as Record<string, unknown>).__permission = permissions.join(joiner);\n    (gate as unknown as Record<string, unknown>).__allowService = allowService;\n    return gate;\n  };\n}\n\n/**\n * The defaults shared by every service / package mock: the logger stub, the\n * pagination constants, the inert scheduler / leader-lock / redis-audit wiring a\n * boot module links at load, and the error + cache shapes. A project layers its\n * own defaults on top by passing them in `overrides`.\n */\nexport function serviceApiCoreDefaults(): Record<string, unknown> {\n  return {\n    createLogger: loggerMock,\n    MAX_PAGE_LIMIT: 1000,\n    DEFAULT_PAGE_LIMIT: 100,\n    closeLeaderLock: async () => undefined,\n    loadAndRestore: async () => null,\n    REPORT_INTERVALS: ['day', 'week', 'month'],\n    scrubAwsIdentifiersFromString: (s: string) => s,\n    scrubAwsIdentifiers: <T>(v: T): T => v,\n    createScheduler: () => ({ start: () => undefined, stop: () => undefined }),\n    createEnvRedisLock: () => null,\n    requireStepUp: (_req: unknown, _res: unknown, next: Next) => next(),\n    SYSTEM_ORG_ID: '000000000000000000000001',\n    ComputeType: { SMALL: 'SMALL', MEDIUM: 'MEDIUM', LARGE: 'LARGE', X2_LARGE: 'X2_LARGE' },\n    PluginType: { CODE_BUILD_STEP: 'CodeBuildStep', SHELL_STEP: 'ShellStep', MANUAL_APPROVAL_STEP: 'ManualApprovalStep' },\n    ErrorCode: mockErrorCode,\n    errorMessage: (e: unknown) => (e instanceof Error ? e.message : String(e)),\n    NotFoundError: MockNotFoundError,\n    createCacheService: () => ({\n      getOrSet: (_key: string, factory: () => Promise<unknown>) => factory(),\n      invalidatePattern: () => Promise.resolve(0),\n    }),\n  };\n}\n\n/**\n * The audit / security wiring a service's boot module (`src/index.ts`,\n * `src/services/audit.ts`) links at load time. Inert by default: nothing asserts\n * on the registration, and pulling the real graph in would drag Redis + HTTP\n * clients into every route suite.\n */\nexport function serviceAuditDefaults(): Record<string, unknown> {\n  return {\n    createRemoteAuditClient: () => ({ record: jest.fn() }),\n    createEnvRedisAuditSpool: () => null,\n    createServiceAuditClient: () => ({ emit: jest.fn(), client: { record: jest.fn() } }),\n    createRemoteAuditAccessor: () => ({ getAuditClient: () => ({ record: jest.fn() }), emit: jest.fn() }),\n    setAuthzDenialAuditor: () => {},\n    wireAuthzDenialAuditor: () => {},\n    wireServiceSecurity: () => {},\n    setTokenRevocationStore: () => {},\n    createRedisTokenRevocationStore: () => ({ getCurrentVersion: async () => null }),\n    createEnvRedisTokenRevocationStore: () => ({ getCurrentVersion: async () => null }),\n  };\n}\n\n/**\n * Build an api-core mock namespace: REAL api-core, then the shared service\n * defaults, then `overrides` (a project's own defaults merged with the suite's).\n *\n * `actualApiCore` is supplied by the CALLER (`jest.requireActual(...)` at the top\n * of the project's `test/helpers/mock-api-core.ts`) rather than resolved here.\n * That is deliberate: `requireActual` on an ESM barrel only succeeds at a moment\n * when nothing else is mid-`import()` of it, and the project helper — a static\n * import of the test file, evaluated before any `await import(SUT)` — is the one\n * point where that always holds. Resolving it from inside this module (which\n * lives in the api-core package itself) races that import in some suites.\n */\nexport function baseApiCoreMock(\n  actualApiCore: Record<string, unknown>,\n  overrides: Record<string, unknown> = {},\n): Record<string, unknown> {\n  return { ...actualApiCore, ...serviceApiCoreDefaults(), ...overrides };\n}\n\n/**\n * Build an api-core mock namespace with NO service defaults — REAL api-core plus\n * the logger stub and `ErrorCode` proxy only. Platform uses this: it deliberately\n * keeps api-core's real pagination/report constants and supplies its own\n * (large) identity/tier/permission default set.\n */\nexport function primitiveApiCoreMock(\n  actualApiCore: Record<string, unknown>,\n  overrides: Record<string, unknown> = {},\n): Record<string, unknown> {\n  return { ...actualApiCore, createLogger: loggerMock, ErrorCode: mockErrorCode, ...overrides };\n}\n\n/**\n * Mirror api-core's `requireInternalService({ callers })`: refuse any user token,\n * then refuse a service whose name is not in the route's caller list. Resolved\n * from the MERGED mock (rather than inherited from `requireActual`) so it uses\n * the suite's `isServicePrincipal` / `serviceNameOf` / `sendError`, which the real\n * one closes over and would write past.\n */\nexport function withInternalServiceGate(mock: Record<string, unknown>, overrides: Record<string, unknown>): Record<string, unknown> {\n  if (overrides.requireInternalService !== undefined) return mock;\n  mock.requireInternalService = ({ callers }: { callers: readonly string[] }) =>\n    (req: unknown, res: unknown, next: Next) => {\n      const isSvc = mock.isServicePrincipal as ((r: unknown) => boolean) | undefined;\n      const nameOf = mock.serviceNameOf as ((c: unknown) => string | undefined) | undefined;\n      const caller = nameOf?.((req as { user?: unknown }).user);\n      if (isSvc?.(req) && caller && callers.includes(caller)) {\n        next();\n        return;\n      }\n      const sendError = mock.sendError as (r: unknown, s: number, m: string, c: string) => unknown;\n      sendError(res, 403, 'Internal service calls only', 'INSUFFICIENT_PERMISSIONS');\n    };\n  return mock;\n}\n\n/**\n * Mirror api-core's `requireServicePrincipal`: reject a non-service caller with a\n * 403 INSUFFICIENT_PERMISSIONS (an authorization refusal, not a 400), resolving\n * `isServicePrincipal` / `sendError` from the merged mock.\n */\nexport function withServicePrincipalGate(mock: Record<string, unknown>, overrides: Record<string, unknown>): Record<string, unknown> {\n  if (overrides.requireServicePrincipal !== undefined) return mock;\n  mock.requireServicePrincipal = (req: unknown, res: unknown, next: Next) => {\n    const isSvc = mock.isServicePrincipal as ((r: unknown) => boolean) | undefined;\n    if (isSvc?.(req)) {\n      next();\n      return;\n    }\n    const sendError = mock.sendError as (r: unknown, s: number, m: string, c: string) => unknown;\n    sendError(res, 403, 'Internal service calls only', 'INSUFFICIENT_PERMISSIONS');\n  };\n  return mock;\n}\n\n/**\n * `sendBadRequest` delegating to the (possibly-overridden) `sendError`, mirroring\n * the real implementation — so a suite spying on `sendError` also observes the\n * 400s routed through `sendBadRequest`.\n */\nexport function withDelegatingSendBadRequest(mock: Record<string, unknown>, overrides: Record<string, unknown>): Record<string, unknown> {\n  if ('sendBadRequest' in overrides) return mock;\n  mock.sendBadRequest = (res: unknown, message: string, code?: string) =>\n    (mock.sendError as (r: unknown, s: number, m: string, c?: string) => unknown)(\n      res, 400, message, code ?? mockErrorCode.VALIDATION_ERROR);\n  return mock;\n}\n"]}

package/lib/testing/mock-drizzle.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Build a `drizzle-orm` mock namespace: every real export, with `overrides`
+ * spread last so a suite can swap an operator for an inspectable stub (or a
+ * `jest.fn()` it asserts on) without having to enumerate the rest.
+ */
+export declare function drizzleMock(overrides?: Record<string, unknown>): Record<string, unknown>;