@evanion/nestjs-correlation-id 1.0.4 → 2.0.0

package/dist/index.js

@@ -1,21 +1,6 @@
-"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 __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("./correlation-id.middleware"), exports);
-__exportStar(require("./correlation.service"), exports);
-__exportStar(require("./correlation.module"), exports);
-__exportStar(require("./withCorrelation.function"), exports);
-__exportStar(require("./constants"), exports);
+export * from './correlation-id.middleware.js';
+export * from './correlation.service.js';
+export * from './correlation.module.js';
+export * from './withCorrelation.function.js';
+export * from './constants.js';
+export * from './interfaces/correlation-config.interface.js';

package/dist/interfaces/correlation-config.interface.d.ts

@@ -1,4 +1,6 @@
 export interface CorrelationConfig {
     header: string;
     generator: () => string;
+    validate?: (value: string) => boolean;
 }
+//# sourceMappingURL=correlation-config.interface.d.ts.map

package/dist/interfaces/correlation-config.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correlation-config.interface.d.ts","sourceRoot":"","sources":["../../src/interfaces/correlation-config.interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;CACvC"}

package/dist/interfaces/correlation-config.interface.js

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

package/dist/withCorrelation.function.d.ts

@@ -1,74 +1,16 @@
-import { HttpModuleOptions } from '@nestjs/axios';
-import { CorrelationModule } from './correlation.module';
-import { CorrelationService } from './correlation.service';
-export declare const withCorrelation: (config?: HttpModuleOptions) => {
-    imports: (typeof CorrelationModule)[];
-    useFactory: (correlationService: CorrelationService) => Promise<{
-        headers: {
-            "X-Correlation-Id": string;
-        } | {
-            "X-Correlation-Id": string;
-            Accept?: import("axios").AxiosHeaderValue;
-            "Content-Length"?: import("axios").AxiosHeaderValue;
-            "User-Agent"?: import("axios").AxiosHeaderValue;
-            "Content-Encoding"?: import("axios").AxiosHeaderValue;
-            Authorization?: import("axios").AxiosHeaderValue;
-            'Content-Type'?: import("axios").AxiosHeaderValue;
-            link?: import("axios").AxiosHeaders;
-            head?: import("axios").AxiosHeaders;
-            options?: import("axios").AxiosHeaders;
-            get?: import("axios").AxiosHeaders;
-            post?: import("axios").AxiosHeaders;
-            put?: import("axios").AxiosHeaders;
-            delete?: import("axios").AxiosHeaders;
-            patch?: import("axios").AxiosHeaders;
-            purge?: import("axios").AxiosHeaders;
-            unlink?: import("axios").AxiosHeaders;
-            common?: import("axios").AxiosHeaders;
-        };
-        url?: string;
-        method?: string;
-        baseURL?: string;
-        transformRequest?: import("axios").AxiosRequestTransformer | import("axios").AxiosRequestTransformer[];
-        transformResponse?: import("axios").AxiosResponseTransformer | import("axios").AxiosResponseTransformer[];
-        params?: any;
-        paramsSerializer?: import("axios").CustomParamsSerializer | import("axios").ParamsSerializerOptions;
-        data?: any;
-        timeout?: number;
-        timeoutErrorMessage?: string;
-        withCredentials?: boolean;
-        adapter?: (string | import("axios").AxiosAdapter) | (string | import("axios").AxiosAdapter)[];
-        auth?: import("axios").AxiosBasicCredentials;
-        responseType?: import("axios").ResponseType;
-        responseEncoding?: string;
-        xsrfCookieName?: string;
-        xsrfHeaderName?: string;
-        onUploadProgress?: (progressEvent: import("axios").AxiosProgressEvent) => void;
-        onDownloadProgress?: (progressEvent: import("axios").AxiosProgressEvent) => void;
-        maxContentLength?: number;
-        validateStatus?: (status: number) => boolean;
-        maxBodyLength?: number;
-        maxRedirects?: number;
-        maxRate?: number | [number, number];
-        beforeRedirect?: (options: Record<string, any>, responseDetails: {
-            headers: Record<string, string>;
-        }) => void;
-        socketPath?: string;
-        transport?: any;
-        httpAgent?: any;
-        httpsAgent?: any;
-        proxy?: false | import("axios").AxiosProxyConfig;
-        cancelToken?: import("axios").CancelToken;
-        decompress?: boolean;
-        transitional?: import("axios").TransitionalOptions;
-        signal?: import("axios").GenericAbortSignal;
-        insecureHTTPParser?: boolean;
-        env?: {
-            FormData?: new (...args: any[]) => object;
-        };
-        formSerializer?: import("axios").FormSerializerOptions;
-        family?: 4 | 6;
-        lookup?: ((hostname: string, options: object, cb: (err: Error, address: string, family: number) => void) => void) | ((hostname: string, options: object) => Promise<string | [address: string, family: number]>);
-    }>;
-    inject: (typeof CorrelationService)[];
-};
+import type { HttpModuleAsyncOptions, HttpModuleOptions } from '@nestjs/axios';
+/**
+ * Options for `HttpModule.registerAsync` that forward the current correlation
+ * id on every outgoing request.
+ *
+ * Requires `CorrelationModule.forRoot()` somewhere in the application. It is a
+ * global module, so importing it once in the root module is enough; without it
+ * Nest fails with `Nest can't resolve dependencies of the HTTP_MODULE_OPTIONS`.
+ *
+ * The id is read by an axios request interceptor, at the moment the request is
+ * made. It used to be baked into the options object by a factory injecting the
+ * then request-scoped `CorrelationService`, which made `HttpService` -- and
+ * every provider holding it -- request-scoped too.
+ */
+export declare const withCorrelation: (config?: HttpModuleOptions) => HttpModuleAsyncOptions;
+//# sourceMappingURL=withCorrelation.function.d.ts.map

package/dist/withCorrelation.function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withCorrelation.function.d.ts","sourceRoot":"","sources":["../src/withCorrelation.function.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,iBAAiB,EAClB,MAAM,eAAe,CAAC;AAiBvB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,GAC1B,SAAS,iBAAiB,KACzB,sBAwBD,CAAC"}

package/dist/withCorrelation.function.js

@@ -1,23 +1,42 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withCorrelation = void 0;
-const constants_1 = require("./constants");
-const correlation_module_1 = require("./correlation.module");
-const correlation_service_1 = require("./correlation.service");
-const withCorrelation = (config) => ({
-    imports: [correlation_module_1.CorrelationModule],
-    useFactory: (correlationService) => __awaiter(void 0, void 0, void 0, function* () {
-        return (Object.assign(Object.assign({}, config), { headers: Object.assign(Object.assign({}, ((config === null || config === void 0 ? void 0 : config.headers) && config.headers)), { [constants_1.CORRELATION_ID_HEADER]: correlationService.getCorrelationId() }) }));
-    }),
-    inject: [correlation_service_1.CorrelationService],
+import { CORRELATION_AXIOS_INTERCEPTOR, CORRELATION_CONFIG_TOKEN, } from './constants.js';
+import { CorrelationService } from './correlation.service.js';
+/**
+ * @nestjs/axios' own token for the axios instance HttpModule creates. It is a
+ * plain string and is not re-exported from the package root, so it is inlined
+ * here -- which also keeps @nestjs/axios a type-only import, and therefore
+ * genuinely optional at runtime.
+ */
+const AXIOS_INSTANCE_TOKEN = 'AXIOS_INSTANCE_TOKEN';
+/**
+ * Options for `HttpModule.registerAsync` that forward the current correlation
+ * id on every outgoing request.
+ *
+ * Requires `CorrelationModule.forRoot()` somewhere in the application. It is a
+ * global module, so importing it once in the root module is enough; without it
+ * Nest fails with `Nest can't resolve dependencies of the HTTP_MODULE_OPTIONS`.
+ *
+ * The id is read by an axios request interceptor, at the moment the request is
+ * made. It used to be baked into the options object by a factory injecting the
+ * then request-scoped `CorrelationService`, which made `HttpService` -- and
+ * every provider holding it -- request-scoped too.
+ */
+export const withCorrelation = (config) => ({
+    useFactory: () => ({ ...config }),
+    extraProviders: [
+        {
+            provide: CORRELATION_AXIOS_INTERCEPTOR,
+            useFactory: (axiosInstance, correlationService, correlationConfig) => axiosInstance.interceptors.request.use((request) => {
+                const correlationId = correlationService.getCorrelationId();
+                if (correlationId !== undefined) {
+                    request.headers.set(correlationConfig.header, correlationId);
+                }
+                return request;
+            }),
+            inject: [
+                AXIOS_INSTANCE_TOKEN,
+                CorrelationService,
+                CORRELATION_CONFIG_TOKEN,
+            ],
+        },
+    ],
 });
-exports.withCorrelation = withCorrelation;

package/package.json

@@ -1,78 +1,92 @@
 {
   "name": "@evanion/nestjs-correlation-id",
-  "version": "1.0.4",
-  "description": "Transparently forward or add correlation id to all requests",
-  "author": "Mikael Pettersson <evanion@icloud.com>",
-  "license": "MIT",
-  "readmeFilename": "README.md",
-  "main": "dist/index.js",
-  "files": [
-    "dist/**/*",
-    "*.md"
-  ],
-  "scripts": {
-    "start:dev": "tsc -w",
-    "build": "tsc",
-    "prepare": "npm run build",
-    "format": "prettier --write \"src/**/*.ts\"",
-    "lint": "eslint \"src/**/*.ts\"",
-    "lint:fix": "eslint --fix \"src/**/*.ts\"",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:cov": "jest --coverage",
-    "test:e2e": "jest --config ./test/jest-e2e.json",
-    "release": "release-it"
-  },
+  "version": "2.0.0",
+  "description": "Correlation ID middleware for NestJS. Propagates a request-scoped correlation id across incoming requests, outgoing HTTP calls and logs.",
   "keywords": [
     "nestjs",
-    "nestjs-middleware",
-    "middleware",
-    "correlation",
     "correlation-id",
-    "request",
-    "request-id"
+    "request-id",
+    "tracing",
+    "middleware",
+    "observability",
+    "typescript"
   ],
-  "publishConfig": {
-    "access": "public"
+  "homepage": "https://github.com/Evanion/libraries/tree/main/nest/correlation-id#readme",
+  "bugs": {
+    "url": "https://github.com/Evanion/libraries/issues"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/evanion/nestjs-correlation-id"
+    "url": "git+https://github.com/Evanion/libraries.git",
+    "directory": "nest/correlation-id"
+  },
+  "license": "MIT",
+  "author": "Mikael Pettersson",
+  "sideEffects": false,
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@evanion/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.tsbuildinfo",
+    "src",
+    "!src/**/*.test.*",
+    "!src/**/*.spec.*",
+    "!src/**/*.test-d.*",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
   },
-  "bugs": "https://github.com/evanion/nestjs-correlation-id/issues",
   "peerDependencies": {
-    "@nestjs/axios": "^0.1.0 || ^1.0.0 || ^2.0.0",
-    "@nestjs/common": "^6.0.0 || ^7.0.0 || ^8.0.0 || ^9.0.0"
+    "@nestjs/axios": "^12.0.0",
+    "@nestjs/common": "^12.0.0"
   },
-  "dependencies": {
-    "uuid": "^9.0.0"
+  "peerDependenciesMeta": {
+    "@nestjs/axios": {
+      "optional": true
+    }
+  },
+  "nx": {
+    "targets": {
+      "build": {
+        "executor": "nx:run-commands",
+        "outputs": [
+          "{projectRoot}/dist"
+        ],
+        "options": {
+          "cwd": "nest/correlation-id",
+          "command": "tsc --build tsconfig.lib.json"
+        }
+      }
+    }
   },
   "devDependencies": {
-    "@nestjs/axios": "^2.0.0",
-    "@nestjs/common": "^9.4.1",
-    "@nestjs/core": "^9.4.1",
-    "@nestjs/platform-express": "^9.4.1",
-    "@nestjs/testing": "9.4.1",
-    "@types/express": "4.17.17",
-    "@types/jest": "29.5.1",
-    "@types/supertest": "2.0.12",
-    "@typescript-eslint/eslint-plugin": "^5.59.6",
-    "@typescript-eslint/parser": "^5.59.6",
-    "axios": "^1.4.0",
-    "eslint": "^8.41.0",
-    "eslint-config-prettier": "^8.8.0",
-    "eslint-plugin-prettier": "^4.2.1",
-    "jest": "29.5.0",
-    "prettier": "^2.8.8",
-    "reflect-metadata": "^0.1.13",
-    "release-it": "^15.10.3",
-    "rxjs": "^7.8.1",
-    "supertest": "6.3.3",
-    "ts-jest": "29.1.0",
-    "ts-node": "10.9.1",
-    "tsc-watch": "6.0.4",
-    "tsconfig-paths": "4.2.0",
-    "typescript": "5.0.4",
-    "uuid": "^9.0.0"
+    "@nestjs/axios": "^12.0.0",
+    "@nestjs/common": "^12.0.1",
+    "@nestjs/core": "^12.0.1",
+    "@nestjs/platform-express": "^12.0.1",
+    "@nestjs/testing": "^12.0.1",
+    "@types/express": "^5.0.0",
+    "express": "^5.0.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.2"
+  },
+  "dependencies": {
+    "tslib": "^2.8.1"
   }
 }

package/src/constants.ts

@@ -0,0 +1,19 @@
+export const CORRELATION_ID_HEADER = 'X-Correlation-Id';
+/**
+ * Namespaced because the provider is registered in a `global: true` module: a
+ * bare 'CORRELATION_CONFIG' would collide silently with any other package that
+ * happened to pick the same string. Deliberately a string and not a Symbol --
+ * a bare `Symbol()` is not stable across duplicate copies of a module, which
+ * would reintroduce exactly the hazard the single ESM build removes.
+ */
+export const CORRELATION_CONFIG_TOKEN =
+  '@evanion/nestjs-correlation-id:CORRELATION_CONFIG';
+/**
+ * Token of the provider that attaches the outgoing-request interceptor to the
+ * axios instance `withCorrelation` configures. Nothing injects it; it exists so
+ * Nest instantiates the factory that registers the interceptor.
+ */
+export const CORRELATION_AXIOS_INTERCEPTOR =
+  '@evanion/nestjs-correlation-id:AXIOS_INTERCEPTOR';
+export const DEFAULT_CORRELATION_ID_VALIDATOR = (value: string): boolean =>
+  /^[\w.:-]{1,128}$/.test(value);

package/src/correlation-id.middleware.ts

@@ -0,0 +1,55 @@
+import { Inject, Injectable, NestMiddleware } from '@nestjs/common';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { CORRELATION_CONFIG_TOKEN, DEFAULT_CORRELATION_ID_VALIDATOR } from './constants.js';
+import { CorrelationService } from './correlation.service.js';
+// Must be `import type`: with isolatedModules and emitDecoratorMetadata,
+// a type referenced in a decorated signature cannot be a value import.
+import type { CorrelationConfig } from './interfaces/correlation-config.interface.js';
+
+/**
+ * Node normalises repeated request headers into a single comma-joined string
+ * for everything except set-cookie, which stays an array. Joining an array the
+ * same way keeps both shapes on one code path -- and the default validator
+ * rejects the result, which is the wanted behaviour for a duplicated
+ * correlation id.
+ */
+const singleValue = (
+  value: string | string[] | undefined,
+): string | undefined => (Array.isArray(value) ? value.join(', ') : value);
+
+@Injectable()
+export class CorrelationIdMiddleware implements NestMiddleware {
+  constructor(
+    private correlationService: CorrelationService,
+    @Inject(CORRELATION_CONFIG_TOKEN)
+    private correlationConfig: CorrelationConfig,
+  ) {}
+
+  use(
+    req: IncomingMessage,
+    res: ServerResponse,
+    next: (error?: unknown) => void,
+  ) {
+    const {
+      header,
+      validate = DEFAULT_CORRELATION_ID_VALIDATOR,
+    } = this.correlationConfig;
+    const key = header.toLowerCase();
+    const incoming = singleValue(req.headers[key]);
+    // The generator runs only when nothing usable arrived, so a counter- or
+    // sequence-backed generator is not advanced for an id that gets discarded.
+    const correlationId =
+      incoming && validate(incoming)
+        ? incoming
+        : this.correlationService.generate();
+
+    if (!req.headers[key]) req.headers[key] = correlationId;
+    // setHeader preserves the casing it is given, so the configured casing is
+    // what goes out on the wire.
+    if (res.getHeader(header) === undefined) res.setHeader(header, correlationId);
+
+    // Everything downstream of next() -- guards, interceptors, the controller,
+    // and anything they await -- runs inside this context.
+    this.correlationService.run(correlationId, next);
+  }
+}

package/src/correlation.module.ts

@@ -0,0 +1,32 @@
+import { DynamicModule, Module, Provider } from '@nestjs/common';
+import { randomUUID } from 'node:crypto';
+import {
+  CORRELATION_CONFIG_TOKEN,
+  CORRELATION_ID_HEADER,
+  DEFAULT_CORRELATION_ID_VALIDATOR,
+} from './constants.js';
+import { CorrelationService } from './correlation.service.js';
+// Must be `import type`: with isolatedModules and emitDecoratorMetadata,
+// a type referenced in a decorated signature cannot be a value import.
+import type { CorrelationConfig } from './interfaces/correlation-config.interface.js';
+
+@Module({})
+export class CorrelationModule {
+  static forRoot(config?: Partial<CorrelationConfig>): DynamicModule {
+    const correlationConfigProvider: Provider = {
+      provide: CORRELATION_CONFIG_TOKEN,
+      useValue: {
+        ...config,
+        header: config?.header || CORRELATION_ID_HEADER,
+        generator: config?.generator || randomUUID,
+        validate: config?.validate || DEFAULT_CORRELATION_ID_VALIDATOR,
+      },
+    };
+    return {
+      global: true,
+      module: CorrelationModule,
+      providers: [correlationConfigProvider, CorrelationService],
+      exports: [correlationConfigProvider, CorrelationService],
+    };
+  }
+}

package/src/correlation.service.ts

@@ -0,0 +1,69 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { CORRELATION_CONFIG_TOKEN } from './constants.js';
+// Must be `import type`: with isolatedModules and emitDecoratorMetadata,
+// a type referenced in a decorated signature cannot be a value import.
+import type { CorrelationConfig } from './interfaces/correlation-config.interface.js';
+
+interface CorrelationStore {
+  correlationId: string;
+}
+
+/**
+ * A plain singleton over AsyncLocalStorage.
+ *
+ * It used to be `@Injectable({ scope: Scope.REQUEST })`. Nest propagates scope
+ * upward through the injection graph, so every provider that reached this one
+ * -- including `HttpService`, via `withCorrelation` -- silently became
+ * request-scoped: re-instantiated per request, and never given `onModuleInit`.
+ * AsyncLocalStorage gives the same per-request isolation with none of that.
+ */
+@Injectable()
+export class CorrelationService {
+  private readonly storage = new AsyncLocalStorage<CorrelationStore>();
+
+  constructor(
+    @Inject(CORRELATION_CONFIG_TOKEN)
+    private readonly correlationConfig: CorrelationConfig,
+  ) {}
+
+  /**
+   * Runs `callback` in a correlation context. Everything it awaits, schedules
+   * or calls sees `correlationId`, and overlapping contexts stay isolated.
+   *
+   * The middleware does this per request. Call it directly for work that has no
+   * request behind it -- queue consumers, cron jobs, scripts.
+   */
+  run<T>(correlationId: string, callback: () => T): T {
+    return this.storage.run({ correlationId }, callback);
+  }
+
+  /**
+   * The id of the surrounding correlation context, or `undefined` when there is
+   * none. Outside a context there is genuinely no correlation id, so this does
+   * not invent one.
+   */
+  getCorrelationId(): string | undefined {
+    return this.storage.getStore()?.correlationId;
+  }
+
+  /** Replaces the id of the surrounding correlation context. */
+  setCorrelationId(correlationId: string): void {
+    const store = this.storage.getStore();
+    if (!store) {
+      throw new Error(
+        'setCorrelationId() was called outside a correlation context. Apply CorrelationIdMiddleware, or wrap the work in CorrelationService.run().',
+      );
+    }
+    store.correlationId = correlationId;
+  }
+
+  /**
+   * A fresh id from the configured generator. Called only when no usable id
+   * arrived with the request, so a counter- or sequence-backed generator is not
+   * advanced for ids that get discarded.
+   */
+  generate(): string {
+    return this.correlationConfig.generator();
+  }
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './correlation-id.middleware.js';
+export * from './correlation.service.js';
+export * from './correlation.module.js';
+export * from './withCorrelation.function.js';
+export * from './constants.js';
+export * from './interfaces/correlation-config.interface.js';

package/src/interfaces/correlation-config.interface.ts

@@ -0,0 +1,5 @@
+export interface CorrelationConfig {
+  header: string;
+  generator: () => string;
+  validate?: (value: string) => boolean;
+}

package/src/withCorrelation.function.ts

@@ -0,0 +1,60 @@
+import type {
+  HttpModuleAsyncOptions,
+  HttpModuleOptions,
+} from '@nestjs/axios';
+import type { AxiosInstance } from 'axios';
+import {
+  CORRELATION_AXIOS_INTERCEPTOR,
+  CORRELATION_CONFIG_TOKEN,
+} from './constants.js';
+import { CorrelationService } from './correlation.service.js';
+import type { CorrelationConfig } from './interfaces/correlation-config.interface.js';
+
+/**
+ * @nestjs/axios' own token for the axios instance HttpModule creates. It is a
+ * plain string and is not re-exported from the package root, so it is inlined
+ * here -- which also keeps @nestjs/axios a type-only import, and therefore
+ * genuinely optional at runtime.
+ */
+const AXIOS_INSTANCE_TOKEN = 'AXIOS_INSTANCE_TOKEN';
+
+/**
+ * Options for `HttpModule.registerAsync` that forward the current correlation
+ * id on every outgoing request.
+ *
+ * Requires `CorrelationModule.forRoot()` somewhere in the application. It is a
+ * global module, so importing it once in the root module is enough; without it
+ * Nest fails with `Nest can't resolve dependencies of the HTTP_MODULE_OPTIONS`.
+ *
+ * The id is read by an axios request interceptor, at the moment the request is
+ * made. It used to be baked into the options object by a factory injecting the
+ * then request-scoped `CorrelationService`, which made `HttpService` -- and
+ * every provider holding it -- request-scoped too.
+ */
+export const withCorrelation = (
+  config?: HttpModuleOptions,
+): HttpModuleAsyncOptions => ({
+  useFactory: () => ({ ...config }),
+  extraProviders: [
+    {
+      provide: CORRELATION_AXIOS_INTERCEPTOR,
+      useFactory: (
+        axiosInstance: AxiosInstance,
+        correlationService: CorrelationService,
+        correlationConfig: CorrelationConfig,
+      ) =>
+        axiosInstance.interceptors.request.use((request) => {
+          const correlationId = correlationService.getCorrelationId();
+          if (correlationId !== undefined) {
+            request.headers.set(correlationConfig.header, correlationId);
+          }
+          return request;
+        }),
+      inject: [
+        AXIOS_INSTANCE_TOKEN,
+        CorrelationService,
+        CORRELATION_CONFIG_TOKEN,
+      ],
+    },
+  ],
+});

package/CONTRIBUTING.md

@@ -1,31 +0,0 @@
-# Contributing
-
-1. [Fork it](https://help.github.com/articles/fork-a-repo/)
-2. Install dependencies (`npm install`)
-3. Create your feature branch (`git checkout -b my-new-feature`)
-4. Commit your changes (`git commit -am 'Added some feature'`)
-5. Test your changes (`npm test`)
-6. Push to the branch (`git push origin my-new-feature`)
-7. [Create new Pull Request](https://help.github.com/articles/creating-a-pull-request/)
-
-## Testing
-
-We use [Jest](https://github.com/facebook/jest) to write tests. Run our test suite with this command:
-
-```
-npm test
-```
-
-## Code Style
-
-We use [Prettier](https://prettier.io/) and tslint to maintain code style and best practices.
-Please make sure your PR adheres to the guides by running:
-
-```
-npm run format
-```
-
-and
-```
-npm run lint
-```

package/dist/correlation-id.middleware.spec.d.ts

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