@terreno/api 0.13.3 → 0.14.0

package/dist/realtime/registry.d.ts

@@ -0,0 +1,40 @@
+import type { ModelRouterOptions } from "../api";
+import type { RealtimeConfig } from "./types";
+/**
+ * A registered model with real-time sync configuration.
+ */
+export interface RealtimeRegistryEntry {
+    /** Mongoose model name (e.g. "Todo") */
+    modelName: string;
+    /** Route path (e.g. "/todos") */
+    routePath: string;
+    /** Collection name in MongoDB (e.g. "todos") */
+    collectionName: string;
+    /** Real-time configuration from modelRouter options */
+    config: RealtimeConfig;
+    /**
+     * Full modelRouter options (for responseHandler, permissions, etc.).
+     */
+    options: ModelRouterOptions<any>;
+}
+/**
+ * Register a model for real-time sync. Called automatically by modelRouter
+ * when the `realtime` option is provided.
+ */
+export declare const registerRealtime: (entry: RealtimeRegistryEntry) => void;
+/**
+ * Get all registered real-time models.
+ */
+export declare const getRealtimeRegistry: () => RealtimeRegistryEntry[];
+/**
+ * Find a registry entry by MongoDB collection name.
+ */
+export declare const findRegistryEntryByCollection: (collectionName: string) => RealtimeRegistryEntry | undefined;
+/**
+ * Find a registry entry by route path / collection tag (e.g. "todos").
+ */
+export declare const findRegistryEntryByRoutePath: (collection: string) => RealtimeRegistryEntry | undefined;
+/**
+ * Clear the registry (for testing).
+ */
+export declare const clearRealtimeRegistry: () => void;

package/dist/realtime/registry.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearRealtimeRegistry = exports.findRegistryEntryByRoutePath = exports.findRegistryEntryByCollection = exports.getRealtimeRegistry = exports.registerRealtime = void 0;
+var realtimeRegistry = [];
+/**
+ * Register a model for real-time sync. Called automatically by modelRouter
+ * when the `realtime` option is provided.
+ */
+var registerRealtime = function (entry) {
+    realtimeRegistry.push(entry);
+};
+exports.registerRealtime = registerRealtime;
+/**
+ * Get all registered real-time models.
+ */
+var getRealtimeRegistry = function () { return realtimeRegistry; };
+exports.getRealtimeRegistry = getRealtimeRegistry;
+/**
+ * Find a registry entry by MongoDB collection name.
+ */
+var findRegistryEntryByCollection = function (collectionName) {
+    return realtimeRegistry.find(function (entry) { return entry.collectionName === collectionName; });
+};
+exports.findRegistryEntryByCollection = findRegistryEntryByCollection;
+/**
+ * Find a registry entry by route path / collection tag (e.g. "todos").
+ */
+var findRegistryEntryByRoutePath = function (collection) {
+    return realtimeRegistry.find(function (entry) { return entry.routePath === "/".concat(collection) || entry.routePath === collection; });
+};
+exports.findRegistryEntryByRoutePath = findRegistryEntryByRoutePath;
+/**
+ * Clear the registry (for testing).
+ */
+var clearRealtimeRegistry = function () {
+    realtimeRegistry.length = 0;
+};
+exports.clearRealtimeRegistry = clearRealtimeRegistry;

package/dist/realtime/socketUser.d.ts

@@ -0,0 +1,10 @@
+import type { User } from "../auth";
+export interface DecodedRealtimeToken {
+    admin?: boolean;
+    id?: string;
+    isAnonymous?: boolean;
+}
+export interface SocketWithDecodedToken {
+    decodedToken?: DecodedRealtimeToken;
+}
+export declare const getSocketUser: (socket: SocketWithDecodedToken) => User | undefined;

package/dist/realtime/socketUser.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSocketUser = void 0;
+var getSocketUser = function (socket) {
+    var _a, _b, _c;
+    var userId = (_a = socket.decodedToken) === null || _a === void 0 ? void 0 : _a.id;
+    if (!userId) {
+        return undefined;
+    }
+    return {
+        _id: userId,
+        admin: ((_b = socket.decodedToken) === null || _b === void 0 ? void 0 : _b.admin) === true,
+        id: userId,
+        isAnonymous: (_c = socket.decodedToken) === null || _c === void 0 ? void 0 : _c.isAnonymous,
+    };
+};
+exports.getSocketUser = getSocketUser;

package/dist/realtime/types.d.ts

@@ -0,0 +1,100 @@
+import type express from "express";
+/**
+ * Configuration for real-time sync on a modelRouter.
+ * Determines which CRUD methods emit WebSocket events and how they are routed.
+ */
+export interface RealtimeConfig {
+    /** Which CRUD methods should emit real-time sync events */
+    methods: Array<"create" | "update" | "delete">;
+    /**
+     * Strategy for determining which Socket.io rooms receive events.
+     * - 'owner': emit to `user:{doc.ownerId}` room
+     * - 'model': emit to `model:{modelName}` room (clients must subscribe)
+     * - 'broadcast': emit to all authenticated sockets
+     * - function: custom room resolver returning room name(s)
+     */
+    roomStrategy: "owner" | "model" | "broadcast" | ((doc: any, method: string, req: express.Request) => string[]);
+    /** Custom serializer for real-time events. Falls back to the modelRouter responseHandler. */
+    realtimeResponseHandler?: (doc: any, method: string) => any;
+}
+/**
+ * A real-time sync event emitted to clients via WebSocket.
+ */
+export interface RealtimeEvent {
+    /** Mongoose model name (e.g. "Todo") */
+    model: string;
+    /** Route path used as tag type (e.g. "todos") */
+    collection: string;
+    /** The CRUD method that triggered this event */
+    method: "create" | "update" | "delete";
+    /** Document ID */
+    id: string;
+    /** Serialized document data (omitted for hard deletes) */
+    data?: any;
+    /** Fields that were updated (for update events from change streams) */
+    updatedFields?: string[];
+    /** Epoch milliseconds when the event was generated */
+    timestamp: number;
+}
+/**
+ * Configuration for the MongoDB change stream watcher.
+ */
+export interface ChangeStreamConfig {
+    /** Collections to never watch (e.g. "socketio", "sessions") */
+    ignoredCollections?: string[];
+    /** Operation types to ignore */
+    ignoredOperations?: string[];
+    /** Non-modelRouter collections to watch (emits raw events) */
+    additionalCollections?: string[];
+    /** Change stream batch size (default: 50) */
+    batchSize?: number;
+    /** Full document mode (default: "updateLookup") */
+    fullDocument?: "updateLookup" | "whenAvailable";
+}
+/**
+ * Options for the RealtimeApp plugin.
+ */
+export interface RealtimeAppOptions {
+    /** Change stream watcher configuration */
+    changeStream?: ChangeStreamConfig;
+    /** CORS configuration for Socket.io */
+    cors?: {
+        origin: string | string[];
+        methods?: string[];
+    };
+    /**
+     * Socket.io adapter for multi-instance deployments.
+     * - 'none': single-instance mode, no adapter (default)
+     * - 'redis': use Redis adapter (requires redisUrl or VALKEY_URL env var)
+     *
+     * For MongoDB adapter or custom adapters, configure the Socket.io instance
+     * directly via getIo() after server creation.
+     */
+    adapter?: "redis" | "none";
+    /** Redis URL for the Redis adapter */
+    redisUrl?: string;
+    /** JWT secret for socket authentication (default: process.env.TOKEN_SECRET) */
+    tokenSecret?: string;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Payload sent by the client to subscribe to a single document's changes.
+ */
+export interface DocumentSubscription {
+    /** Collection tag (e.g. "todos") */
+    collection: string;
+    /** Document ID */
+    id: string;
+}
+/**
+ * Payload sent by the client to subscribe to a query-filtered list.
+ */
+export interface QuerySubscription {
+    /** Collection tag (e.g. "todos") */
+    collection: string;
+    /** MongoDB-style query filter (e.g. {completed: false}) */
+    query: Record<string, any>;
+    /** Client-provided queryId (ignored — server computes a canonical ID) */
+    queryId?: string;
+}

package/dist/realtime/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/requestContext.d.ts

@@ -0,0 +1,37 @@
+import type express from "express";
+import type { JwtPayload } from "jsonwebtoken";
+export interface RequestContext {
+    jobId?: string;
+    requestId: string;
+    sessionId?: string;
+    spanId?: string;
+    traceId?: string;
+    traceSampled?: boolean;
+    userId?: string;
+}
+export type RequestContextAttributes = Record<string, string>;
+export declare const REQUEST_CONTEXT_ATTRIBUTE_NAMES: {
+    readonly jobId: "x-job-id";
+    readonly requestId: "x-request-id";
+    readonly sessionId: "x-session-id";
+    readonly spanId: "x-span-id";
+    readonly traceId: "x-trace-id";
+    readonly traceParent: "traceparent";
+    readonly traceSampled: "x-trace-sampled";
+    readonly userId: "x-user-id";
+};
+export interface JwtSessionPayload extends JwtPayload {
+    sid?: string;
+    sessionId?: string;
+}
+export declare const getSessionIdFromJwtPayload: (payload?: JwtSessionPayload | null) => string | undefined;
+export declare const getRequestContextFromAttributes: (attributes?: Record<string, string | undefined>) => RequestContext;
+export declare const getCurrentRequestContext: () => RequestContext | undefined;
+export declare const getCurrentLogContext: () => Partial<RequestContext>;
+export declare const applyRequestContextToSentry: (context?: Partial<RequestContext>) => void;
+export declare const setRequestContext: (updates: Partial<RequestContext>) => void;
+export declare const getCurrentRequestContextAttributes: (overrides?: Partial<RequestContext>) => RequestContextAttributes;
+export declare const runWithRequestContext: <T>(context: Partial<RequestContext>, callback: () => T) => T;
+export declare const runWithRequestContextAttributes: <T>(attributes: Record<string, string | undefined> | undefined, callback: () => T) => T;
+export declare const updateRequestContextFromRequest: (req: express.Request, res?: express.Response) => void;
+export declare const requestContextMiddleware: (req: express.Request, res: express.Response, next: express.NextFunction) => void;

package/dist/requestContext.js

@@ -0,0 +1,344 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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;
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestContextMiddleware = exports.updateRequestContextFromRequest = exports.runWithRequestContextAttributes = exports.runWithRequestContext = exports.getCurrentRequestContextAttributes = exports.setRequestContext = exports.applyRequestContextToSentry = exports.getCurrentLogContext = exports.getCurrentRequestContext = exports.getRequestContextFromAttributes = exports.getSessionIdFromJwtPayload = exports.REQUEST_CONTEXT_ATTRIBUTE_NAMES = void 0;
+var node_async_hooks_1 = require("node:async_hooks");
+var node_crypto_1 = require("node:crypto");
+var Sentry = __importStar(require("@sentry/bun"));
+var CLOUD_TRACE_CONTEXT_HEADER = "x-cloud-trace-context";
+var JOB_ID_HEADER = "x-job-id";
+var REQUEST_ID_HEADERS = ["x-request-id", "x-correlation-id", "x-transaction-id"];
+var SESSION_ID_HEADER = "x-session-id";
+var SPAN_ID_HEADER = "x-span-id";
+var TRACE_ID_HEADER = "x-trace-id";
+var TRACE_PARENT_HEADER = "traceparent";
+var TRACE_SAMPLED_HEADER = "x-trace-sampled";
+var USER_ID_HEADER = "x-user-id";
+exports.REQUEST_CONTEXT_ATTRIBUTE_NAMES = {
+    jobId: JOB_ID_HEADER,
+    requestId: "x-request-id",
+    sessionId: SESSION_ID_HEADER,
+    spanId: SPAN_ID_HEADER,
+    traceId: TRACE_ID_HEADER,
+    traceParent: TRACE_PARENT_HEADER,
+    traceSampled: TRACE_SAMPLED_HEADER,
+    userId: USER_ID_HEADER,
+};
+var requestContextStorage = new node_async_hooks_1.AsyncLocalStorage();
+var getHeader = function (req, headerName) {
+    var value = req.header(headerName);
+    if (!Array.isArray(value)) {
+        return value;
+    }
+    return value[0];
+};
+var parseGoogleCloudTraceContext = function (headerValue) {
+    if (!headerValue) {
+        return undefined;
+    }
+    var _a = __read(headerValue.split(";"), 2), traceAndSpan = _a[0], options = _a[1];
+    var _b = __read(traceAndSpan.split("/"), 2), traceId = _b[0], spanId = _b[1];
+    if (!traceId) {
+        return undefined;
+    }
+    return {
+        spanId: spanId,
+        traceId: traceId,
+        traceSampled: options === "o=1",
+    };
+};
+var parseTraceParent = function (headerValue) {
+    if (!headerValue) {
+        return undefined;
+    }
+    var _a = __read(headerValue.split("-"), 4), _version = _a[0], traceId = _a[1], spanId = _a[2], flags = _a[3];
+    if (!traceId) {
+        return undefined;
+    }
+    return {
+        spanId: spanId,
+        traceId: traceId,
+        traceSampled: flags === "01",
+    };
+};
+var parseTraceSampled = function (value) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (value === "true" || value === "1") {
+        return true;
+    }
+    if (value === "false" || value === "0") {
+        return false;
+    }
+    return undefined;
+};
+var getIncomingRequestId = function (req, traceContext) {
+    var e_1, _a;
+    try {
+        for (var REQUEST_ID_HEADERS_1 = __values(REQUEST_ID_HEADERS), REQUEST_ID_HEADERS_1_1 = REQUEST_ID_HEADERS_1.next(); !REQUEST_ID_HEADERS_1_1.done; REQUEST_ID_HEADERS_1_1 = REQUEST_ID_HEADERS_1.next()) {
+            var headerName = REQUEST_ID_HEADERS_1_1.value;
+            var headerValue = getHeader(req, headerName);
+            if (headerValue) {
+                return headerValue;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (REQUEST_ID_HEADERS_1_1 && !REQUEST_ID_HEADERS_1_1.done && (_a = REQUEST_ID_HEADERS_1.return)) _a.call(REQUEST_ID_HEADERS_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (traceContext === null || traceContext === void 0 ? void 0 : traceContext.traceId) {
+        return traceContext.traceId;
+    }
+    return (0, node_crypto_1.randomUUID)();
+};
+var getSessionIdFromJwtPayload = function (payload) {
+    if (!payload) {
+        return undefined;
+    }
+    if (payload.sid) {
+        return payload.sid;
+    }
+    return payload.sessionId;
+};
+exports.getSessionIdFromJwtPayload = getSessionIdFromJwtPayload;
+var getRequestContextFromAttributes = function (attributes) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (attributes === void 0) { attributes = {}; }
+    var cloudTraceContext = parseGoogleCloudTraceContext(attributes[CLOUD_TRACE_CONTEXT_HEADER]);
+    var traceParentContext = parseTraceParent(attributes[TRACE_PARENT_HEADER]);
+    var traceContext = cloudTraceContext !== null && cloudTraceContext !== void 0 ? cloudTraceContext : traceParentContext;
+    return {
+        jobId: attributes[JOB_ID_HEADER],
+        requestId: (_d = (_c = (_b = (_a = attributes[exports.REQUEST_CONTEXT_ATTRIBUTE_NAMES.requestId]) !== null && _a !== void 0 ? _a : attributes["x-correlation-id"]) !== null && _b !== void 0 ? _b : attributes["x-transaction-id"]) !== null && _c !== void 0 ? _c : traceContext === null || traceContext === void 0 ? void 0 : traceContext.traceId) !== null && _d !== void 0 ? _d : (0, node_crypto_1.randomUUID)(),
+        sessionId: attributes[SESSION_ID_HEADER],
+        spanId: (_e = attributes[SPAN_ID_HEADER]) !== null && _e !== void 0 ? _e : traceContext === null || traceContext === void 0 ? void 0 : traceContext.spanId,
+        traceId: (_f = attributes[TRACE_ID_HEADER]) !== null && _f !== void 0 ? _f : traceContext === null || traceContext === void 0 ? void 0 : traceContext.traceId,
+        traceSampled: (_g = parseTraceSampled(attributes[TRACE_SAMPLED_HEADER])) !== null && _g !== void 0 ? _g : traceContext === null || traceContext === void 0 ? void 0 : traceContext.traceSampled,
+        userId: attributes[USER_ID_HEADER],
+    };
+};
+exports.getRequestContextFromAttributes = getRequestContextFromAttributes;
+var getCurrentRequestContext = function () {
+    return requestContextStorage.getStore();
+};
+exports.getCurrentRequestContext = getCurrentRequestContext;
+var getCurrentLogContext = function () {
+    var context = (0, exports.getCurrentRequestContext)();
+    if (!context) {
+        return {};
+    }
+    return {
+        jobId: context.jobId,
+        requestId: context.requestId,
+        sessionId: context.sessionId,
+        spanId: context.spanId,
+        traceId: context.traceId,
+        traceSampled: context.traceSampled,
+        userId: context.userId,
+    };
+};
+exports.getCurrentLogContext = getCurrentLogContext;
+var setSentryTag = function (scope, name, value) {
+    if (typeof value === "undefined") {
+        return;
+    }
+    scope.setTag(name, String(value));
+};
+var setSentryContextValue = function (context, name, value) {
+    if (typeof value === "undefined") {
+        return;
+    }
+    context[name] = value;
+};
+var applyRequestContextToSentry = function (context) {
+    if (context === void 0) { context = (0, exports.getCurrentLogContext)(); }
+    var scope = Sentry.getCurrentScope();
+    setSentryTag(scope, "request_id", context.requestId);
+    setSentryTag(scope, "session_id", context.sessionId);
+    setSentryTag(scope, "job_id", context.jobId);
+    setSentryTag(scope, "user_id", context.userId);
+    setSentryTag(scope, "trace_id", context.traceId);
+    setSentryTag(scope, "span_id", context.spanId);
+    setSentryTag(scope, "trace_sampled", context.traceSampled);
+    if (context.userId) {
+        scope.setUser({ id: context.userId });
+    }
+    var sentryContext = {};
+    setSentryContextValue(sentryContext, "requestId", context.requestId);
+    setSentryContextValue(sentryContext, "sessionId", context.sessionId);
+    setSentryContextValue(sentryContext, "jobId", context.jobId);
+    setSentryContextValue(sentryContext, "userId", context.userId);
+    setSentryContextValue(sentryContext, "traceId", context.traceId);
+    setSentryContextValue(sentryContext, "spanId", context.spanId);
+    setSentryContextValue(sentryContext, "traceSampled", context.traceSampled);
+    if (Object.keys(sentryContext).length > 0) {
+        scope.setContext("request_context", sentryContext);
+    }
+};
+exports.applyRequestContextToSentry = applyRequestContextToSentry;
+var setRequestContext = function (updates) {
+    var context = (0, exports.getCurrentRequestContext)();
+    if (!context) {
+        return;
+    }
+    Object.assign(context, updates);
+    (0, exports.applyRequestContextToSentry)(context);
+};
+exports.setRequestContext = setRequestContext;
+var setAttribute = function (attributes, name, value) {
+    if (typeof value === "undefined") {
+        return;
+    }
+    attributes[name] = String(value);
+};
+var getCurrentRequestContextAttributes = function (overrides) {
+    if (overrides === void 0) { overrides = {}; }
+    var context = __assign(__assign({}, (0, exports.getCurrentLogContext)()), overrides);
+    var attributes = {};
+    setAttribute(attributes, exports.REQUEST_CONTEXT_ATTRIBUTE_NAMES.requestId, context.requestId);
+    setAttribute(attributes, exports.REQUEST_CONTEXT_ATTRIBUTE_NAMES.sessionId, context.sessionId);
+    setAttribute(attributes, exports.REQUEST_CONTEXT_ATTRIBUTE_NAMES.jobId, context.jobId);
+    setAttribute(attributes, exports.REQUEST_CONTEXT_ATTRIBUTE_NAMES.userId, context.userId);
+    setAttribute(attributes, exports.REQUEST_CONTEXT_ATTRIBUTE_NAMES.traceId, context.traceId);
+    setAttribute(attributes, exports.REQUEST_CONTEXT_ATTRIBUTE_NAMES.spanId, context.spanId);
+    setAttribute(attributes, exports.REQUEST_CONTEXT_ATTRIBUTE_NAMES.traceSampled, context.traceSampled);
+    return attributes;
+};
+exports.getCurrentRequestContextAttributes = getCurrentRequestContextAttributes;
+var runWithRequestContext = function (context, callback) {
+    var _a;
+    var nextContext = __assign(__assign({}, context), { requestId: (_a = context.requestId) !== null && _a !== void 0 ? _a : (0, node_crypto_1.randomUUID)() });
+    return requestContextStorage.run(nextContext, function () {
+        (0, exports.applyRequestContextToSentry)(nextContext);
+        return callback();
+    });
+};
+exports.runWithRequestContext = runWithRequestContext;
+var runWithRequestContextAttributes = function (attributes, callback) {
+    if (attributes === void 0) { attributes = {}; }
+    return (0, exports.runWithRequestContext)((0, exports.getRequestContextFromAttributes)(attributes), callback);
+};
+exports.runWithRequestContextAttributes = runWithRequestContextAttributes;
+var updateRequestContextFromRequest = function (req, res) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    var reqWithContext = req;
+    var jobId = (_a = reqWithContext.jobId) !== null && _a !== void 0 ? _a : getHeader(req, JOB_ID_HEADER);
+    var sessionId = (_f = (_e = (_b = (0, exports.getSessionIdFromJwtPayload)(reqWithContext.authTokenPayload)) !== null && _b !== void 0 ? _b : (_d = (_c = reqWithContext.betterAuthSession) === null || _c === void 0 ? void 0 : _c.session) === null || _d === void 0 ? void 0 : _d.id) !== null && _e !== void 0 ? _e : reqWithContext.sessionId) !== null && _f !== void 0 ? _f : getHeader(req, SESSION_ID_HEADER);
+    var user = req.user;
+    var userId = (_g = user === null || user === void 0 ? void 0 : user.id) !== null && _g !== void 0 ? _g : ((user === null || user === void 0 ? void 0 : user._id) ? String(user._id) : undefined);
+    (0, exports.setRequestContext)({ jobId: jobId, sessionId: sessionId, userId: userId });
+    if (jobId) {
+        reqWithContext.jobId = jobId;
+        res === null || res === void 0 ? void 0 : res.setHeader("X-Job-ID", jobId);
+    }
+    if (sessionId) {
+        reqWithContext.sessionId = sessionId;
+        res === null || res === void 0 ? void 0 : res.setHeader("X-Session-ID", sessionId);
+    }
+};
+exports.updateRequestContextFromRequest = updateRequestContextFromRequest;
+var requestContextMiddleware = function (req, res, next) {
+    var cloudTraceContext = parseGoogleCloudTraceContext(getHeader(req, CLOUD_TRACE_CONTEXT_HEADER));
+    var traceParentContext = parseTraceParent(getHeader(req, TRACE_PARENT_HEADER));
+    var traceContext = cloudTraceContext !== null && cloudTraceContext !== void 0 ? cloudTraceContext : traceParentContext;
+    var requestId = getIncomingRequestId(req, traceContext);
+    var jobId = getHeader(req, JOB_ID_HEADER);
+    var sessionId = getHeader(req, SESSION_ID_HEADER);
+    var context = {
+        jobId: jobId,
+        requestId: requestId,
+        sessionId: sessionId,
+        spanId: traceContext === null || traceContext === void 0 ? void 0 : traceContext.spanId,
+        traceId: traceContext === null || traceContext === void 0 ? void 0 : traceContext.traceId,
+        traceSampled: traceContext === null || traceContext === void 0 ? void 0 : traceContext.traceSampled,
+    };
+    var reqWithContext = req;
+    if (jobId) {
+        reqWithContext.jobId = jobId;
+    }
+    reqWithContext.requestId = requestId;
+    if (sessionId) {
+        reqWithContext.sessionId = sessionId;
+    }
+    res.setHeader("X-Request-ID", requestId);
+    requestContextStorage.run(context, function () {
+        (0, exports.updateRequestContextFromRequest)(req, res);
+        next();
+    });
+};
+exports.requestContextMiddleware = requestContextMiddleware;

package/dist/requestContext.test.d.ts

@@ -0,0 +1 @@
+export {};