@discover-cloud/shared 1.2.9 → 1.4.0

package/dist/jwt/user-jwt-verifier.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * @file user-jwt-verifier.ts
+ * @description Verifies user RS256 access tokens issued by auth-service.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserJwtVerifier = void 0;
+const jose = __importStar(require("jose"));
+const env_util_1 = require("../utils/env.util");
+const CLOCK_TOLERANCE_SECONDS = Number((0, env_util_1.getEnv)('JWT_CLOCK_TOLERANCE_SECONDS'));
+const JWKS_CACHE_MAX_AGE_MS = Number((0, env_util_1.getEnv)('JWKS_CACHE_MAX_AGE_MS'));
+const JWKS_FETCH_TIMEOUT_MS = Number((0, env_util_1.getEnv)('JWKS_FETCH_TIMEOUT_MS'));
+/**
+ * Verifies auth-service issued user access tokens.
+ */
+class UserJwtVerifier {
+    constructor() {
+        const authJwksUri = (0, env_util_1.getEnv)('AUTH_JWKS_URI');
+        this.issuer = (0, env_util_1.getEnv)('EXTERNAL_JWT_ISSUER');
+        this.audience = (0, env_util_1.getEnv)('EXTERNAL_JWT_AUDIENCE');
+        this.jwks = jose.createRemoteJWKSet(new URL(authJwksUri), {
+            cacheMaxAge: JWKS_CACHE_MAX_AGE_MS,
+            timeoutDuration: JWKS_FETCH_TIMEOUT_MS,
+        });
+    }
+    /**
+     * Verify JWT signature and required user claims.
+     *
+     * @param {string} token - Raw bearer access token.
+     * @returns {Promise<AccessTokenPayload>} Verified access payload.
+     */
+    async verify(token) {
+        const { payload } = await jose.jwtVerify(token, this.jwks, {
+            issuer: this.issuer,
+            audience: this.audience,
+            algorithms: ['RS256'],
+            clockTolerance: CLOCK_TOLERANCE_SECONDS,
+        });
+        if (payload.typ !== 'access') {
+            throw new jose.errors.JWTClaimValidationFailed(`Token type mismatch: expected "access", got "${String(payload.typ)}"`, payload, 'typ', 'check_failed');
+        }
+        if (typeof payload.accountId !== 'string' ||
+            typeof payload.sessionId !== 'string' ||
+            typeof payload.jti !== 'string' ||
+            typeof payload.iat !== 'number' ||
+            typeof payload.exp !== 'number') {
+            throw new jose.errors.JWTClaimValidationFailed('Missing required access token claims', payload, 'payload', 'missing');
+        }
+        return payload;
+    }
+    /**
+     * Builds request authorization context.
+     *
+     * @param {string} token - Raw bearer access token.
+     * @returns {Promise<{ payload: AccessTokenPayload; context: UserContext }>} The auth context block.
+     */
+    async buildAccessContext(token) {
+        const payload = await this.verify(token);
+        return {
+            payload,
+            context: {
+                type: 'user',
+                accountId: payload.accountId,
+                sessionId: payload.sessionId,
+            },
+        };
+    }
+}
+exports.UserJwtVerifier = UserJwtVerifier;

package/dist/messaging/audit.publisher.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @file audit.publisher.ts
+ * @description Publishes audit events with automatic request context enrichment.
+ */
+import { RabbitMQClient } from '../messaging';
+import { RecordAuditActionInput } from '../dtos';
+import { ILogger } from '../utils/logger.util';
+export type PublishAuditInput = Omit<RecordAuditActionInput, 'actorId' | 'actorType' | 'requestId'> & Partial<Pick<RecordAuditActionInput, 'actorId' | 'actorType' | 'requestId'>>;
+export declare class AuditPublisher {
+    private readonly mq;
+    private readonly logger;
+    constructor(mq: RabbitMQClient, logger: ILogger);
+    publish(input: PublishAuditInput): Promise<void>;
+}

package/dist/messaging/audit.publisher.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * @file audit.publisher.ts
+ * @description Publishes audit events with automatic request context enrichment.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditPublisher = void 0;
+const dtos_1 = require("../dtos");
+const request_context_storage_1 = require("../context/request-context.storage");
+class AuditPublisher {
+    constructor(mq, logger) {
+        this.mq = mq;
+        this.logger = logger;
+    }
+    async publish(input) {
+        const ctx = request_context_storage_1.RequestContextProvider.get();
+        let actorType = dtos_1.AuditActorType.SYSTEM;
+        let actorId = null;
+        if (ctx?.actor) {
+            switch (ctx.actor.type) {
+                case 'user':
+                    actorType = dtos_1.AuditActorType.USER;
+                    actorId = ctx.actor.accountId;
+                    break;
+                case 'machine':
+                    actorType = dtos_1.AuditActorType.SERVICE;
+                    actorId = ctx.actor.serviceId;
+                    break;
+            }
+        }
+        const payload = {
+            severity: dtos_1.AuditSeverity.INFO,
+            timestamp: new Date().toISOString(),
+            actorType,
+            actorId,
+            requestId: ctx?.requestId ?? null,
+            ipAddress: ctx?.ipAddress ?? null,
+            userAgent: ctx?.userAgent ?? null,
+            ...input,
+        };
+        try {
+            await this.mq.publishEvent(`audit.${input.action}`, payload);
+        }
+        catch (err) {
+            this.logger.error({ err, action: input.action }, 'Failed to publish audit event');
+        }
+    }
+}
+exports.AuditPublisher = AuditPublisher;

package/dist/messaging/index.d.ts

@@ -0,0 +1,2 @@
+export * from './rabbitmq.client';
+export * from './audit.publisher';

package/dist/{dto → messaging}/index.js

@@ -14,6 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./user-service.dtos"), exports);
-__exportStar(require("./auth-service.dtos"), exports);
-__exportStar(require("./response.dtos"), exports);
+__exportStar(require("./rabbitmq.client"), exports);
+__exportStar(require("./audit.publisher"), exports);

package/dist/messaging/rabbitmq.client.d.ts

@@ -0,0 +1,15 @@
+import { ILogger } from '../utils/logger.util';
+export declare class RabbitMQClient {
+    private connection;
+    private channel;
+    private url;
+    private exchangeName;
+    private logger;
+    constructor(url: string, logger?: ILogger);
+    connect(): Promise<void>;
+    publishEvent(routingKey: string, payload: unknown): Promise<void>;
+    subscribe(queueName: string, routingKey: string, handler: (payload: unknown) => Promise<void>, options?: {
+        prefetch?: number;
+    }): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/messaging/rabbitmq.client.js

@@ -0,0 +1,133 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMQClient = void 0;
+const amqplib = __importStar(require("amqplib"));
+const logger_util_1 = require("../utils/logger.util");
+class RabbitMQClient {
+    constructor(url, logger = logger_util_1.consoleLogger) {
+        this.connection = null;
+        this.channel = null;
+        this.exchangeName = 'discovercloud.topic';
+        this.url = url;
+        this.logger = logger;
+    }
+    async connect() {
+        if (this.connection && this.channel) {
+            return;
+        }
+        try {
+            this.connection = await amqplib.connect(this.url);
+            this.connection.on('error', (err) => {
+                this.logger.error(err, 'RabbitMQ Connection Error');
+            });
+            this.connection.on('close', () => {
+                this.logger.warn('RabbitMQ Connection Closed. Reconnecting...');
+                this.connection = null;
+                this.channel = null;
+                setTimeout(() => this.connect(), 5000);
+            });
+            this.channel = await this.connection.createChannel();
+            // Ensure the main topic exchange exists
+            await this.channel.assertExchange(this.exchangeName, 'topic', {
+                durable: true,
+            });
+            this.logger.info('✅ Connected to RabbitMQ');
+        }
+        catch (error) {
+            this.logger.error(error, '❌ Failed to connect to RabbitMQ');
+            setTimeout(() => this.connect(), 5000);
+        }
+    }
+    async publishEvent(routingKey, payload) {
+        if (!this.channel) {
+            throw new Error('RabbitMQ Channel not initialized');
+        }
+        const buffer = Buffer.from(JSON.stringify(payload));
+        this.channel.publish(this.exchangeName, routingKey, buffer, {
+            persistent: true,
+            contentType: 'application/json',
+            timestamp: Date.now(),
+        });
+    }
+    async subscribe(queueName, routingKey, handler, options = {}) {
+        if (!this.channel) {
+            throw new Error('RabbitMQ Channel not initialized');
+        }
+        if (options.prefetch) {
+            await this.channel.prefetch(options.prefetch);
+        }
+        // Dead Letter configuration
+        const dlxName = `${this.exchangeName}.dlx`;
+        const dlqName = `${queueName}.dlq`;
+        await this.channel.assertExchange(dlxName, 'topic', { durable: true });
+        await this.channel.assertQueue(dlqName, { durable: true });
+        await this.channel.bindQueue(dlqName, dlxName, routingKey);
+        // Assert main queue with DLX bindings
+        await this.channel.assertQueue(queueName, {
+            durable: true,
+            deadLetterExchange: dlxName,
+            deadLetterRoutingKey: routingKey,
+        });
+        await this.channel.bindQueue(queueName, this.exchangeName, routingKey);
+        this.channel.consume(queueName, async (msg) => {
+            if (!msg)
+                return;
+            try {
+                const payload = JSON.parse(msg.content.toString());
+                await handler(payload);
+                // Fix: Use optional chaining instead of non-null assertion (!)
+                this.channel?.ack(msg);
+            }
+            catch (error) {
+                this.logger.error(error, `Error processing message from ${queueName}`);
+                // Fix: Use optional chaining instead of non-null assertion (!)
+                // Nack the message and don't requeue, so it goes to the DLX
+                this.channel?.nack(msg, false, false);
+            }
+        });
+        this.logger.info(`📡 Subscribed to queue [${queueName}] with routing key [${routingKey}]`);
+    }
+    async close() {
+        if (this.channel) {
+            await this.channel.close();
+        }
+        if (this.connection) {
+            await this.connection.close();
+        }
+        this.logger.info('RabbitMQ connection closed.');
+    }
+}
+exports.RabbitMQClient = RabbitMQClient;

package/dist/middleware/error-handler.middleware.d.ts

@@ -1,30 +1,10 @@
-import { Request, Response, NextFunction } from "express";
 /**
- * GLOBAL ERROR HANDLER  (@discover-cloud/shared)
- * ────────────────────────────────────────────────
- * Centralised Express error handler. Register as the last middleware in
- * every service's app.ts:
- *
- *   app.use(GlobalErrorHandler.handle);
- *
- * Handles in order:
- *   1. ZodError  → 400 VALIDATION_ERROR with flattened field errors
- *   2. AppError  → mapped statusCode + code (details forwarded to client)
- *   3. Unknown   → 500 INTERNAL_SERVER_ERROR (internals never leaked)
- *
- * Logging strategy:
- *   Development — full error object printed for stack traces during development.
- *   Production  — message only for AppError/Error (no stack, no details in logs).
- *                 Unknown errors log the raw value at warn level.
- *                 In production, a structured logger (Pino) replaces console.*
- *                 in each service — these console calls are captured by stdout.
- *
- * Security:
- *   Unknown (unexpected) errors never expose internals to the client.
- *   AppError.details IS forwarded — callers that set details on an AppError
- *   are intentionally choosing to surface that context (e.g. validation hints).
- *   Never put secrets, stack traces, or raw DB errors in AppError.details.
+ * @file error-handler.middleware.ts
+ * @description Central Express error handler. Register as the final middleware.
  */
-export declare class GlobalErrorHandler {
-    static handle(err: unknown, req: Request, res: Response, _next: NextFunction): void;
-}
+import { ErrorRequestHandler } from 'express';
+import { ILogger } from '../utils';
+/**
+ * Creates global Express error middleware.
+ */
+export declare function createGlobalErrorHandler(logger?: ILogger): ErrorRequestHandler;

package/dist/middleware/error-handler.middleware.js

@@ -1,70 +1,79 @@
 "use strict";
+/**
+ * @file error-handler.middleware.ts
+ * @description Central Express error handler. Register as the final middleware.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GlobalErrorHandler = void 0;
+exports.createGlobalErrorHandler = createGlobalErrorHandler;
 const zod_1 = require("zod");
 const errors_1 = require("../errors");
 const utils_1 = require("../utils");
 /**
- * GLOBAL ERROR HANDLER  (@discover-cloud/shared)
- * ────────────────────────────────────────────────
- * Centralised Express error handler. Register as the last middleware in
- * every service's app.ts:
- *
- *   app.use(GlobalErrorHandler.handle);
- *
- * Handles in order:
- *   1. ZodError  → 400 VALIDATION_ERROR with flattened field errors
- *   2. AppError  → mapped statusCode + code (details forwarded to client)
- *   3. Unknown   → 500 INTERNAL_SERVER_ERROR (internals never leaked)
- *
- * Logging strategy:
- *   Development — full error object printed for stack traces during development.
- *   Production  — message only for AppError/Error (no stack, no details in logs).
- *                 Unknown errors log the raw value at warn level.
- *                 In production, a structured logger (Pino) replaces console.*
- *                 in each service — these console calls are captured by stdout.
- *
- * Security:
- *   Unknown (unexpected) errors never expose internals to the client.
- *   AppError.details IS forwarded — callers that set details on an AppError
- *   are intentionally choosing to surface that context (e.g. validation hints).
- *   Never put secrets, stack traces, or raw DB errors in AppError.details.
+ * Detects malformed JSON thrown by express.json().
  */
-class GlobalErrorHandler {
-    static handle(err, req, res, _next) {
-        // ── Logging ──────────────────────────────────────────────────────────
-        if (process.env["NODE_ENV"] !== "production") {
-            // Full object in development — stack traces + details are useful locally.
-            console.error(`[req ${req.id}]`, err);
-        }
-        else if (err instanceof Error) {
-            // Production: message only — no stack, no details, no internal paths.
-            console.error(`[req ${req.id}] ${err.name}: ${err.message}`);
-        }
-        else {
-            // Non-Error throw (string, object, etc.) — log at warn; this should not happen.
-            console.warn(`[req ${req.id}] Non-Error thrown:`, typeof err);
+function isMalformedJsonError(err) {
+    return (err instanceof SyntaxError &&
+        'status' in err &&
+        typeof err.status === 'number' &&
+        'body' in err);
+}
+/**
+ * Converts any thrown value into Error.
+ */
+function normalizeError(err) {
+    if (err instanceof Error) {
+        return err;
+    }
+    if (typeof err === 'string') {
+        return new Error(err);
+    }
+    return new Error(JSON.stringify(err));
+}
+/**
+ * Creates global Express error middleware.
+ */
+function createGlobalErrorHandler(logger = utils_1.noopLogger) {
+    return (err, req, res, _next) => {
+        const error = normalizeError(err);
+        const requestId = req.requestContext?.requestId ?? req.id;
+        /**
+         * Malformed JSON
+         */
+        if (isMalformedJsonError(err) && err.status === 400) {
+            logger.warn({ requestId, err: error }, 'Malformed JSON payload');
+            (0, utils_1.failure)(res, req, 'Invalid JSON payload', 'BAD_REQUEST', 400);
+            return;
         }
-        // ── 1. Zod validation errors ─────────────────────────────────────────
+        /**
+         * Validation failures
+         */
         if (err instanceof zod_1.ZodError) {
-            // flatten() groups errors into fieldErrors (keyed by path) and formErrors
-            // (top-level). This shape is stable across Zod versions and is what
-            // clients should key on for field-level error display.
-            (0, utils_1.failure)(res, req, "Validation failed", "VALIDATION_ERROR", 400, err.flatten());
+            logger.warn({ requestId, err: error }, 'Request validation failed');
+            (0, utils_1.failure)(res, req, 'Validation failed', 'VALIDATION_ERROR', 400, err.flatten());
             return;
         }
-        // ── 2. Known AppError subclasses ─────────────────────────────────────
-        // instanceof check — no duck-typing, no accidental matches.
-        // AppError.details is caller-controlled context (e.g. validation hints)
-        // and is intentionally forwarded to the client.
+        /**
+         * Known application errors
+         */
         if (err instanceof errors_1.AppError) {
+            const payload = {
+                requestId,
+                code: err.code,
+                err: error,
+            };
+            if (err.statusCode >= 500) {
+                logger.error(payload, err.message);
+            }
+            else {
+                logger.warn(payload, err.message);
+            }
             (0, utils_1.failure)(res, req, err.message, err.code, err.statusCode, err.details);
             return;
         }
-        // ── 3. Unexpected errors — never leak internals ───────────────────────
-        // Generic 500 with no details. The actual error is logged above (production:
-        // message only; development: full object). Nothing internal reaches the client.
-        (0, utils_1.failure)(res, req, "Internal Server Error", "INTERNAL_SERVER_ERROR", 500);
-    }
+        /**
+         * Unknown crashes
+         */
+        logger.error({ requestId, err: error }, 'Unhandled exception');
+        (0, utils_1.failure)(res, req, 'Internal Server Error', 'INTERNAL_SERVER_ERROR', 500);
+    };
 }
-exports.GlobalErrorHandler = GlobalErrorHandler;

package/dist/middleware/index.d.ts

@@ -1,8 +1,10 @@
-export * from "./error-handler.middleware";
-export * from "./validate.middleware";
-export * from "./request-id.middleware";
-export * from "./authorize.middleware";
-export * from "./validated-merge.middleware";
-export * from "./require-internal.middleware";
-export * from "./require-auth.middleware";
-export * from "./require-human.middleware";
+export * from './error-handler.middleware';
+export * from './validate.middleware';
+export * from './request-context.middleware';
+export * from './require-machine.middleware';
+export * from './require-auth.middleware';
+export * from './require-user.middleware';
+export * from './require-org-permission.middleware';
+export * from './require-workspace-permission.middleware';
+export * from './require-platform-permission.middleware';
+export * from './require-org-permission-from-body.middleware';

package/dist/middleware/index.js

@@ -16,9 +16,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./error-handler.middleware"), exports);
 __exportStar(require("./validate.middleware"), exports);
-__exportStar(require("./request-id.middleware"), exports);
-__exportStar(require("./authorize.middleware"), exports);
-__exportStar(require("./validated-merge.middleware"), exports);
-__exportStar(require("./require-internal.middleware"), exports);
+__exportStar(require("./request-context.middleware"), exports);
+__exportStar(require("./require-machine.middleware"), exports);
 __exportStar(require("./require-auth.middleware"), exports);
-__exportStar(require("./require-human.middleware"), exports);
+__exportStar(require("./require-user.middleware"), exports);
+__exportStar(require("./require-org-permission.middleware"), exports);
+__exportStar(require("./require-workspace-permission.middleware"), exports);
+__exportStar(require("./require-platform-permission.middleware"), exports);
+__exportStar(require("./require-org-permission-from-body.middleware"), exports);

package/dist/middleware/request-context.middleware.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @file request-context.middleware.ts
+ * @description Express middleware to assign request tracing and audit metadata context.
+ */
+import { Request, Response, NextFunction } from 'express';
+export declare const requestContext: (req: Request, res: Response, next: NextFunction) => void;

package/dist/middleware/request-context.middleware.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * @file request-context.middleware.ts
+ * @description Express middleware to assign request tracing and audit metadata context.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestContext = void 0;
+const crypto_1 = require("crypto");
+const request_context_storage_1 = require("../context/request-context.storage");
+function normalizeIp(ip) {
+    if (!ip)
+        return null;
+    if (ip === '::1') {
+        return '127.0.0.1';
+    }
+    if (ip.startsWith('::ffff:')) {
+        return ip.substring(7);
+    }
+    return ip;
+}
+function resolveClientIp(req) {
+    const forwarded = req.headers['x-forwarded-for'];
+    if (forwarded) {
+        const value = Array.isArray(forwarded) ? forwarded[0] : forwarded;
+        return normalizeIp(value.split(',')[0].trim());
+    }
+    const realIp = req.headers['x-real-ip'];
+    if (realIp) {
+        return normalizeIp(Array.isArray(realIp) ? realIp[0] : realIp);
+    }
+    return normalizeIp(req.socket.remoteAddress ?? null);
+}
+const requestContext = (req, res, next) => {
+    const upstream = req.headers['x-request-id'];
+    const requestId = Array.isArray(upstream) ? upstream[0] : (upstream ?? (0, crypto_1.randomUUID)());
+    // Explicitly type this as AuditRequestContext so TS knows it's mutable
+    // and allows the `.actor` property to be assigned by the auth middlewares later.
+    const context = {
+        requestId,
+        ipAddress: resolveClientIp(req),
+        userAgent: req.headers['user-agent'] ?? null,
+    };
+    req.id = requestId;
+    req.requestContext = context;
+    res.setHeader('x-request-id', requestId);
+    request_context_storage_1.requestContextStorage.run(context, () => next());
+};
+exports.requestContext = requestContext;