refactor: reduced usage of singleton to support parallel calls of fns

Author: Fifciu

.changeset/forty-boats-tell.md

@@ -0,0 +1,5 @@
+---
+"@vue-storefront/middleware": patch
+---
+
+Fix scoping

packages/logger/__tests__/unit/structuredLog/gcpStructuredLog.spec.ts

@@ -1,3 +1,4 @@
+import { Metadata } from "../../../src/interfaces/LoggerInterface";
 import { LogLevel } from "../../../src/interfaces/LogLevel";
 import { GCPStructuredLog } from "../../../src/structuredLog/GCPStructuredLog";
 
@@ -157,7 +158,7 @@ describe("GCPStructuredLog", () => {
         logData,
         options,
         severity as LogLevel,
-        metadata
+        metadata as unknown as Metadata
       );
       expect(gcpStructuredLog).toEqual(expected);
     }

packages/middleware/__tests__/integration/bootstrap/api/index.ts

@@ -1,4 +1,5 @@
 export { success } from "./success";
+export { successParalell } from "./successParalell";
 export { setCookieHeader } from "./setCookieHeader";
 export { error } from "./error";
 export { throwAxiosError } from "./throwAxiosError";

packages/middleware/__tests__/integration/bootstrap/api/successParalell/index.ts

@@ -0,0 +1,11 @@
+import { getLogger } from "../../../../../src";
+
+export const successParalell = (context) => {
+  const logger = getLogger(context);
+  logger.info("successParalell");
+  return Promise.resolve({
+    status: 200,
+    message: "ok",
+    error: false,
+  });
+};

packages/middleware/__tests__/integration/loggerScopes.spec.ts

@@ -36,30 +36,47 @@ const testingExtension = {
     },
     async resueOtherIntegrationMethod(context) {
       const logger = getLogger(context);
-      logger.info("some log");
+      logger.info("resueOtherIntegrationMethod log");
       const int = await context.getApiClient("replicated_integration");
       return await int.api[
         "replicated-integration-extension"
       ].orchestrationTest();
     },
+    async paralellOrchestrationTest(context) {
+      const logger = getLogger(context);
+      logger.info("resueOtherIntegrationMethod log");
+      // paralell_replicated_integration
+      const int = await context.getApiClient("replicated_integration");
+      const int2 = await context.getApiClient(
+        "paralell_replicated_integration"
+      );
+      // await int.api["replicated-integration-extension"].orchestrationTest();
+      // await int2.api.successParalell();
+      return await Promise.all([
+        int.api["replicated-integration-extension"].orchestrationTest(),
+        int2.api.successParalell(),
+      ]);
+    },
   },
   hooks(req, res, alokai) {
     const logger = getLogger(alokai);
     logger.info("hooks");
     return {
-      beforeCall({ args }) {
+      beforeCall({ args, logger }) {
         logger.info("bc1");
         return args;
       },
       beforeCreate(a) {
+        const logger = getLogger(a);
         logger.info("bc2");
         return a;
       },
-      afterCall({ response }) {
+      afterCall({ response, logger }) {
         logger.info("after1");
         return response;
       },
       afterCreate(a) {
+        const logger = getLogger(a);
         logger.info("after2");
         return a;
       },
@@ -132,6 +149,19 @@ describe("[Integration] Logger scopes", () => {
             ];
           },
         },
+        paralell_replicated_integration: {
+          configuration: {},
+          location: "./__tests__/integration/bootstrap/server",
+          logger: {
+            handler: Logger,
+          },
+          extensions() {
+            return [
+              testingExtension as any,
+              replicatedIntegrationExtension as any,
+            ];
+          },
+        },
       },
     });
   });
@@ -339,6 +369,45 @@ describe("[Integration] Logger scopes", () => {
     });
   });
 
+  test("scope of log from: multiple different integrations called from extension", async () => {
+    await request(app).post("/test_integration/paralellOrchestrationTest");
+
+    expect(Logger.info).toBeCalledWith(expect.any(String), {
+      context: "middleware",
+      scope: {
+        extensionName: "testing-extension",
+        functionName: "paralellOrchestrationTest",
+        integrationName: "test_integration",
+        type: "endpoint",
+      },
+    });
+    expect(Logger.info).toBeCalledWith(expect.any(String), {
+      context: "middleware",
+      scope: {
+        extensionName: "replicated-integration-extension",
+        functionName: "orchestrationTest",
+        integrationName: "replicated_integration",
+        type: "endpoint",
+      },
+    });
+    expect(Logger.info).toBeCalledWith(expect.any(String), {
+      context: "middleware",
+      scope: {
+        functionName: "success",
+        integrationName: "replicated_integration",
+        type: "endpoint",
+      },
+    });
+    expect(Logger.info).toBeCalledWith(expect.any(String), {
+      context: "middleware",
+      scope: {
+        functionName: "successParalell",
+        integrationName: "paralell_replicated_integration",
+        type: "endpoint",
+      },
+    });
+  });
+
   test("scope of log extendApp", async () => {
     await createServer({
       logger: {

packages/middleware/__tests__/unit/apiClientFactory/apiClientFactory.spec.ts

@@ -75,24 +75,6 @@ describe("apiClientFactory", () => {
     expect(params.onCreate).toHaveBeenCalled();
   });
 
-  it("Should pass logger when calling onCreate", async () => {
-    const params = {
-      onCreate: jest.fn((config) => ({ config })),
-      defaultSettings: {},
-    };
-
-    const { createApiClient } = apiClientFactory<any, any>(params as any);
-
-    await createApiClient.call(
-      {
-        middleware: { req: null, res: null },
-      },
-      {}
-    );
-
-    expect(params.onCreate).toBeCalledWith(expect.anything(), { logger });
-  });
-
   it("Should run initial config when onCreate is not provided", async () => {
     const params = {
       defaultSettings: {},
@@ -206,7 +188,8 @@ describe("apiClientFactory", () => {
     expect(logger.info).toBeCalledWith("test", {
       scope: {
         extensionName: "extTest",
-        extensionNamePointsHookSource: true,
+        hookName: "hooks",
+        type: "requestHook",
       },
     });
   });

packages/middleware/__tests__/unit/handlers/callApiFunction.spec.ts

@@ -1,5 +1,6 @@
 import { Request, Response } from "express";
 import { callApiFunction } from "../../../src/handlers";
+import { logger } from "../../../__mocks__/logger";
 
 describe("[middleware-handlers] callApiFunction", () => {
   const apiResponse = {};
@@ -11,7 +12,14 @@ describe("[middleware-handlers] callApiFunction", () => {
   const req = {} as Request;
   const res = {
     send: jest.fn(),
-    locals: { apiFunction, errorHandler, args },
+    locals: {
+      apiFunction,
+      errorHandler,
+      args,
+      alokai: {
+        logger,
+      },
+    },
   } as unknown as Response;
 
   beforeEach(() => {

packages/middleware/__tests__/unit/handlers/prepareApiFunction.spec.ts

@@ -49,30 +49,6 @@ describe("[middleware-handlers] prepareApiFunction", () => {
       expect(res.locals).toEqual(expect.objectContaining({ apiFunction }));
     });
 
-    it("adds alokai metadata to res.locals", async () => {
-      const extensionName = "myExt";
-      const req = {
-        params: { integrationName, functionName, extensionName },
-      } as unknown as Request;
-      const res = {
-        status: jest.fn(),
-        send: jest.fn(),
-      } as unknown as Response;
-      res.locals = {
-        alokai: {
-          metadata: {},
-        },
-      };
-
-      await prepareApiFunction(integrations)(req, res, next);
-
-      expect(res.locals.alokai.metadata.scope).toEqual({
-        integrationName,
-        functionName,
-        extensionName,
-      });
-    });
-
     it("calls next middleware", async () => {
       await prepareApiFunction(integrations)(req, res, next);
 

packages/middleware/__tests__/unit/handlers/prepareLogger.spec.ts

@@ -8,6 +8,7 @@ describe("[middleware-handlers] prepareLogger", () => {
     query: {},
     params: {
       integrationName: "sapcc",
+      functionName: "getProduct",
     },
   } as unknown as Request;
   const res = { locals: {} } as unknown as Response;
@@ -33,13 +34,6 @@ describe("[middleware-handlers] prepareLogger", () => {
 
   it("appends metadata when logging", () => {
     prepareLogger(loggerManager)(req, res, next);
-    res.locals.alokai.metadata = {
-      context: "middleware",
-      scope: {
-        integrationName: "sapcc",
-        functionName: "getProduct",
-      },
-    };
     res.locals.alokai.logger.info("test", { d: 15 });
 
     expect(logger.info).toBeCalledWith("test", {