@cryptexlabs/codex-nodejs-common 0.16.4 → 0.16.7

package/src/context/context.builder.spec.ts

@@ -0,0 +1,231 @@
+import {
+  ApiMetaHeadersInterface,
+  ClientInterface,
+  Locale,
+  LocaleI18nInterface,
+  MessageContextInterface,
+  MessageMetaInterface,
+} from "@cryptexlabs/codex-data-model";
+import { LoggerService } from "@nestjs/common";
+import { Context } from "./context";
+import { ContextBuilder } from "./context.builder";
+import { DefaultConfig } from "../config";
+import { instance, mock, when } from "ts-mockito";
+
+interface I18nApiStub {
+  getCatalog: () => Record<string, unknown>;
+}
+
+describe("ContextBuilder", () => {
+  let loggerMock: LoggerService;
+  let configMock: DefaultConfig;
+  let client: ClientInterface;
+  let messageContext: MessageContextInterface;
+  let i18nData: i18nAPI;
+
+  beforeEach(() => {
+    const logger = mock<LoggerService>();
+    loggerMock = instance(logger);
+
+    const config = mock(DefaultConfig);
+    when(config.appName).thenReturn("app");
+    when(config.appVersion).thenReturn("1.0.0");
+    when(config.environmentName).thenReturn("env");
+    when(config.clientId).thenReturn("client-id");
+    configMock = instance(config);
+
+    client = {
+      id: "id",
+      version: "0.0.1",
+      name: "client",
+      variant: "variant",
+    };
+    messageContext = { category: "default", id: "none" };
+    const i18nStub: I18nApiStub = {
+      getCatalog: () => ({ "en-US": {} }),
+    };
+    i18nData = (i18nStub as unknown) as i18nAPI;
+  });
+
+  const buildBuilder = () =>
+    new ContextBuilder(
+      loggerMock,
+      configMock,
+      client,
+      messageContext,
+      i18nData
+    );
+
+  it("returns now override when provided", () => {
+    const builder = buildBuilder();
+
+    const before = Date.now();
+    const initialNow = builder.now().getTime();
+    expect(initialNow).toBeGreaterThanOrEqual(before);
+
+    const override = new Date("2024-02-02T12:00:00Z");
+    builder.setNow(override);
+
+    expect(builder.now()).toBe(override);
+  });
+
+  it("clones state with build including agent", () => {
+    const builder = buildBuilder();
+    builder.client.agent = "ua/1.0";
+
+    const clone = builder.build();
+
+    expect(clone).not.toBe(builder);
+    expect(clone.client.agent).toBe("ua/1.0");
+    expect(clone.now()).toBeInstanceOf(Date);
+  });
+
+  it("sets client fields including agent from headers", () => {
+    const builder = buildBuilder();
+    const headers: ApiMetaHeadersInterface & {
+      "x-forwarded-uri": string;
+      "user-agent": string;
+      "x-timezone": string;
+    } = {
+      "x-correlation-id": "corr-1",
+      "accept-language": "en-US",
+      "x-started": "2025-01-01T10:00:00Z",
+      "x-created": "2025-01-01T10:00:00Z",
+      "x-context-category": "cat",
+      "x-context-id": "ctx-id",
+      "x-client-id": "client-1",
+      "x-client-name": "client-name",
+      "x-client-version": "1.2.3",
+      "x-client-variant": "variant-x",
+      "x-forwarded-uri": "/some/path",
+      "x-now": "2025-01-01T11:00:00Z",
+      "x-timezone": "UTC",
+      "user-agent": "UnitTestAgent/1.0",
+    };
+
+    const resultBuilder = builder.setMetaFromHeaders(headers);
+    const context = resultBuilder.getResult();
+
+    expect(context.client.agent).toBe("UnitTestAgent/1.0");
+    expect(context.client.id).toBe("client-1");
+    expect(context.client.name).toBe("client-name");
+    expect(context.client.version).toBe("1.2.3");
+    expect(context.client.variant).toBe("variant-x");
+    expect(context.path).toBe("/some/path");
+    expect(context.now().toISOString()).toBe("2025-01-01T11:00:00.000Z");
+    expect(context.timezone).toBe("UTC");
+    expect(resultBuilder).toBe(builder);
+  });
+
+  it("allows overriding i18n data", () => {
+    const builder = buildBuilder();
+    const customI18n: I18nApiStub = {
+      getCatalog: () => ({ "en-US": { greeting: "hi" } }),
+    };
+
+    const returned = builder.setI18nData((customI18n as unknown) as i18nAPI);
+
+    expect(returned).toBe(builder);
+    expect(() => builder.getResult()).not.toThrow();
+  });
+
+  it("leaves client fields unchanged when optional headers missing", () => {
+    const builder = buildBuilder();
+    const minimalHeaders: ApiMetaHeadersInterface = {
+      "x-correlation-id": "corr-2",
+      "accept-language": "en-US",
+      "x-started": "2024-03-01T10:00:00Z",
+      "x-created": "2024-03-01T10:00:00Z",
+      "x-context-category": "default",
+      "x-context-id": "none",
+      "x-client-id": "id",
+      "x-client-name": "client",
+      "x-client-version": "0.0.1",
+      "x-client-variant": "variant",
+    };
+
+    builder.setMetaFromHeaders(minimalHeaders);
+    const context = builder.getResult();
+
+    expect(context.client.agent).toBeUndefined();
+    expect(context.path).toBeUndefined();
+    expect(context.timezone).toBeUndefined();
+  });
+
+  it("sets values from headers for new messages", () => {
+    const builder = buildBuilder();
+    const headers: ApiMetaHeadersInterface & { "x-forwarded-uri": string } = {
+      "x-correlation-id": "corr-3",
+      "accept-language": "en-US",
+      "x-started": "2024-04-01T10:00:00Z",
+      "x-created": "2024-04-01T10:00:00Z",
+      "x-context-category": "custom",
+      "x-context-id": "ctx-3",
+      "x-client-id": "id",
+      "x-client-name": "client",
+      "x-client-version": "0.0.1",
+      "x-client-variant": "variant",
+      "x-forwarded-uri": "/another/path",
+    };
+
+    builder.setMetaFromHeadersForNewMessage(headers);
+    const context = builder.getResult();
+
+    expect(context.correlationId).toBe("corr-3");
+    expect(context.messageContext.category).toBe("custom");
+    expect(context.messageContext.id).toBe("ctx-3");
+    expect(context.path).toBe("/another/path");
+  });
+
+  it("copies values from existing context", () => {
+    const baseBuilder = buildBuilder();
+    baseBuilder
+      .setCorrelationId("corr-4")
+      .setStarted("2024-05-01T10:00:00Z")
+      .setLocale(new Locale("en", "US"));
+    baseBuilder.client.agent = "CopiedAgent";
+    const sourceContext = baseBuilder.getResult();
+
+    const targetBuilder = buildBuilder().setMetaFromContext(sourceContext);
+    const result = targetBuilder.getResult();
+
+    expect(result.correlationId).toBe("corr-4");
+    expect(result.messageContext.id).toBe(sourceContext.messageContext.id);
+    expect(result.client.agent).toBe("CopiedAgent");
+  });
+
+  it("sets values from message meta", () => {
+    const builder = buildBuilder();
+    const meta: MessageMetaInterface = {
+      correlationId: "corr-5",
+      time: {
+        started: "2024-06-01T10:00:00Z",
+        created: "2024-06-01T10:00:00Z",
+      },
+      context: { category: "meta", id: "meta-id" },
+      client,
+      type: "type",
+      schemaVersion: "0.1.0",
+      locale: new Locale("fr", "CA") as LocaleI18nInterface,
+    };
+
+    builder.setMeta(meta);
+    const context = builder.getResult();
+
+    expect(context.correlationId).toBe("corr-5");
+    expect(context.locale.language).toBe("fr");
+    expect(context.started.toISOString()).toBe("2024-06-01T10:00:00.000Z");
+  });
+
+  it("applies defaults when values are missing", () => {
+    const builder = buildBuilder();
+    builder.setNow(new Date("2024-07-01T11:00:00Z"));
+
+    const context = builder.getResult();
+
+    expect(context.correlationId).toHaveLength(36);
+    expect(context.locale.i18n).toBe("en-US");
+    expect(context.started).toBeInstanceOf(Date);
+    expect(context.now().toISOString()).toBe("2024-07-01T11:00:00.000Z");
+  });
+});

package/src/context/context.builder.ts

@@ -51,6 +51,7 @@ export class ContextBuilder {
         version: this.client.version,
         id: this.client.id,
         variant: this.client.variant,
+        agent: this.client.agent,
       },
       {
         category: this.messageContext.category,
@@ -81,6 +82,9 @@ export class ContextBuilder {
     if (headers["x-client-variant"]) {
       this.client.variant = headers["x-client-variant"];
     }
+    if (headers["user-agent"]) {
+      this.client.agent = headers["user-agent"];
+    }
     if (headers["x-forwarded-uri"]) {
       this._path = headers["x-forwarded-uri"];
     }
@@ -112,6 +116,15 @@ export class ContextBuilder {
     return this;
   }
 
+  public setMetaFromContext(context: Context) {
+    this.setCorrelationId(context.correlationId);
+    this.setLocale(context.locale);
+    this.setStarted(context.started);
+    this.messageContext.category = context.messageContext.category;
+    this.messageContext.id = context.messageContext.id;
+    return this;
+  }
+
   public setMeta(meta: MessageMetaInterface) {
     this.setCorrelationId(meta.correlationId);
     this.setLocale(new Locale(meta.locale.language, meta.locale.country));

package/src/filter/app-http-exception-filter.ts

@@ -23,6 +23,9 @@ import { LocaleUtil } from "../util";
 @Catch()
 @Injectable()
 export class AppHttpExceptionFilter extends BaseExceptionFilter {
+  private _lastErrorLogTime: number = 0;
+  private _suppressedErrorCount: number = 0;
+
   constructor(
     private readonly fallbackLocale: Locale,
     @Inject("LOGGER") private readonly fallbackLogger: LoggerService,
@@ -32,12 +35,29 @@ export class AppHttpExceptionFilter extends BaseExceptionFilter {
     super(applicationRef);
   }
 
-  private isDebugLevel(): boolean {
+  private _isDebugLevel(): boolean {
     return this.config.logLevels.some(
       (level) => level.toLowerCase() === "debug"
     );
   }
 
+  private _shouldLogError(): boolean {
+    if (this._isDebugLevel()) {
+      return true;
+    }
+
+    const now = Date.now();
+    const timeSinceLastLog = now - this._lastErrorLogTime;
+
+    if (timeSinceLastLog >= this.config.errorLogIntervalMs) {
+      this._lastErrorLogTime = now;
+      return true;
+    }
+
+    this._suppressedErrorCount++;
+    return false;
+  }
+
   catch(exception: any, host: ArgumentsHost) {
     const ctx = host.switchToHttp();
     const request = ctx.getRequest<Request>();
@@ -97,43 +117,54 @@ export class AppHttpExceptionFilter extends BaseExceptionFilter {
       logger.error(`No stack available for error of type ${typeof exception}`);
     }
 
-    if (developerText) {
-      if (this.config.loggerType === "pino") {
-        logger.error(developerText, { body: request.body, stack });
+    const shouldLogError = this._shouldLogError();
+
+    if (shouldLogError) {
+      if (developerText) {
+        if (this.config.loggerType === "pino") {
+          logger.error(developerText, { body: request.body, stack });
+        } else {
+          logger.error(developerText, {
+            request: {
+              headers: request.headers,
+              body: request.body,
+              url: request.url,
+              method: request.method,
+              stack,
+            },
+          });
+        }
       } else {
-        logger.error(developerText, {
-          request: {
-            headers: request.headers,
-            body: request.body,
-            url: request.url,
-            method: request.method,
+        logger.error(
+          [
+            "Error not explained",
+            "This probably means someone wrote code that throws an error without an error message",
+            "This should never happen!",
+          ].join(". "),
+          {
             stack,
-          },
-        });
+          }
+        );
       }
-    } else {
-      logger.error(
-        [
-          "Error not explained",
-          "This probably means someone wrote code that throws an error without an error message",
-          "This should never happen!",
-        ].join(". "),
-        {
-          stack,
-        }
-      );
-    }
 
-    // If this is a normal error it means something random occurred and we want the stacktrace
-    if (
-      !(
-        exception instanceof HttpException ||
-        exception instanceof FriendlyHttpException ||
-        exception instanceof ContextualHttpException
-      ) &&
-      exception.stack
-    ) {
-      logger.error(exception.stack);
+      // If this is a normal error it means something random occurred and we want the stacktrace
+      if (
+        !(
+          exception instanceof HttpException ||
+          exception instanceof FriendlyHttpException ||
+          exception instanceof ContextualHttpException
+        ) &&
+        exception.stack
+      ) {
+        logger.error(exception.stack);
+      }
+
+      if (this._suppressedErrorCount > 0) {
+        logger.error(
+          `Suppressed ${this._suppressedErrorCount} error(s) in the last minute due to rate limiting`
+        );
+        this._suppressedErrorCount = 0;
+      }
     }
 
     let status: number;
@@ -174,7 +205,7 @@ export class AppHttpExceptionFilter extends BaseExceptionFilter {
       request.url || (request.headers["x-forwarded-uri"] as string);
 
     const canShowDeveloperText =
-      this.isDebugLevel() || (status >= 400 && status < 500);
+      this._isDebugLevel() || (status >= 400 && status < 500);
 
     const errorHttpResponse = new ErrorHttpResponse(
       status,
@@ -189,7 +220,7 @@ export class AppHttpExceptionFilter extends BaseExceptionFilter {
           : "Error unavailable in this context",
         userMessage
       ),
-      this.isDebugLevel() ? exception.stack || null : null,
+      this._isDebugLevel() ? exception.stack || null : null,
       this.config,
       correlationId,
       started,