refactor: MethodDecoratorManager

Author: Fifciu

packages/middleware/src/apiClientFactory/applyContextToApi.ts

@@ -1,14 +1,19 @@
 // @ts-check
-import { isExtensionEndpointHandler } from "../helpers";
-import { createExtendQuery } from "./createExtendQuery";
 import {
   AfterCallParams,
   ApiMethods,
   ApplyingContextHooks,
   BeforeCallParams,
   MiddlewareContext,
 } from "../types";
-import { getLogger } from "../logger";
+import {
+  ExtensionEndpointMethodDecorator,
+  PurgeHookNameMethodDecorator,
+  MethodDecoratorManager,
+  MissingScopeMethodDecorator,
+  OrchiestratedMethodDecorator,
+  ScopeTypeMethodDecorator,
+} from "./methodDecorator";
 
 const nopBefore = <ARGS>({ args }: BeforeCallParams<any, ARGS>): ARGS => args;
 const nopAfter = <RESPONSE>({
@@ -39,87 +44,27 @@ const applyContextToApi = <
     (prev, [callName, fn]) => ({
       ...prev,
       [callName]: async (...args: Parameters<typeof fn>) => {
-        const hasMetadataScope = checkMetadataScope(context);
-        if (!hasMetadataScope) {
-          const logger = getLogger(context.res);
-          logger.warning(
-            `Alokai's metadata object is missing in the context under 'res.locals.alokai'. 
-            This could indicate that the extension's scope or metadata has not been properly initialized. 
-            Without this metadata, certain custom API client functionalities may not work as expected, 
-            including tracking of extension-specific actions or data. 
-            Please ensure that the Alokai metadata object is correctly set up in 'res.locals.alokai' before proceeding with the request.
-            
-            Steps to troubleshoot:
-            1. Verify if content of res.locals hasn't been overwritten, instead of extended.
-            2. If you're unsure, please consult Alokai's team for further assistance or review the source code implementation.
-
-            Call Name: ${callName}
-            Function Name: ${fn.name || "Unnamed function"}`
-          );
-        }
-        const extendQuery = createExtendQuery(context);
-        let tmpIntegrationName = "";
-        let tmpFnName = "";
-        if (hasMetadataScope) {
-          context.res.locals.alokai.metadata.scope.type = "requestHook";
-          tmpIntegrationName =
-            context.res.locals.alokai.metadata.scope.integrationName;
-          context.res.locals.alokai.metadata.scope.integrationName =
-            context.integrationKey;
-
-          tmpFnName = context.res.locals.alokai.metadata.scope.functionName;
-          context.res.locals.alokai.metadata.scope.functionName = callName;
-        }
-        const transformedArgs = await hooks.before({ callName, args });
-        const apiClientContext = { ...context, extendQuery };
-        if (isExtensionEndpointHandler(fn)) {
-          context.res.locals.alokai.metadata.scope.extensionName =
-            fn._extensionName;
-        }
-        let tmp = {
-          extensionName: null,
-          functionName: null,
-        };
-        const isTmpSet = (tmp) => !!tmp.functionName; // as we never set fn name to nullish
-        if (hasMetadataScope) {
-          context.res.locals.alokai.metadata.scope.type = "endpoint";
-          context.res.locals.alokai.metadata.scope.hookName = undefined;
-          if (!(fn as any)._extensionName) {
-            tmp = {
-              extensionName:
-                context.res.locals.alokai.metadata.scope.extensionName,
-              functionName:
-                context.res.locals.alokai.metadata.scope.functionName,
-            };
-            context.res.locals.alokai.metadata.scope.extensionName = undefined;
-            context.res.locals.alokai.metadata.scope.functionName = callName;
-            // console.log(`wywolam ${fn.name} lub ${callName}`, { ...tmp });
-          }
-        }
-        const response = await fn(apiClientContext, ...transformedArgs);
-        if (hasMetadataScope) {
-          if (isTmpSet(tmp)) {
-            context.res.locals.alokai.metadata.scope.extensionName =
-              tmp.extensionName;
-            context.res.locals.alokai.metadata.scope.functionName =
-              tmp.functionName;
-          }
-          // console.log("co ustawiam?: ", { ...tmp });
-          context.res.locals.alokai.metadata.scope.type = "requestHook";
-        }
-        const transformedResponse = await hooks.after({
+        const methodDecoratorManager = new MethodDecoratorManager(
+          context,
+          hooks,
           callName,
-          args,
-          response,
-        });
+          fn
+        );
+
+        const hasMetadataScope = checkMetadataScope(context);
+        const decoratorsToAdd = hasMetadataScope
+          ? [
+              new ScopeTypeMethodDecorator(context),
+              new PurgeHookNameMethodDecorator(context),
+              new ExtensionEndpointMethodDecorator(context, fn),
+              new OrchiestratedMethodDecorator(context, callName, fn),
+            ]
+          : [new MissingScopeMethodDecorator(context, callName, fn.name)];
+        methodDecoratorManager.addDecorator(...decoratorsToAdd);
 
-        if (hasMetadataScope) {
-          context.res.locals.alokai.metadata.scope.integrationName =
-            tmpIntegrationName;
-          context.res.locals.alokai.metadata.scope.functionName = tmpFnName;
-        }
+        const method = methodDecoratorManager.prepare<typeof args>();
 
-        return transformedResponse;
+        return await method(args);
       },
     }),
     {} as any

packages/middleware/src/apiClientFactory/index.ts

@@ -11,21 +11,9 @@ import {
   CreateApiClientFn,
   ExtensionHookWith,
   ExtensionWith,
-  ExtensionEndpointHandler,
 } from "../types";
 import { applyContextToApi } from "./applyContextToApi";
-
-/**
- * Function marking endpoint added or overwritten by extension's extendApiMethod hook
- * with information about source extension's name
- */
-function markWithExtensionName(
-  apiMethod: ExtensionEndpointHandler,
-  extensionName: string
-) {
-  apiMethod._extensionName = extensionName;
-  return apiMethod;
-}
+import { markExtensionNameHelpers } from "./markExtensionNameHelpers";
 
 const apiClientFactory = <
   ALL_SETTINGS extends ApiClientConfig,
@@ -92,7 +80,7 @@ const apiClientFactory = <
 
       const loggerWithMetadata = injectMetadata(logger, () => ({
         scope: {
-          integrationName: this.middleware?.integrationKey,
+          integrationName: this.middleware?.integrationTag,
           type: "requestHook",
           hookName: "onCreate",
         },
@@ -150,10 +138,7 @@ const apiClientFactory = <
         },
       };
 
-      const context = {
-        ...settings,
-        ...(this?.middleware || {}),
-      };
+      const context = { ...settings, ...(this?.middleware || {}) };
 
       const api = await resolveApi(factoryParams.api, settings);
 
@@ -166,28 +151,20 @@ const apiClientFactory = <
           settings
         );
         if (extension.isNamespaced) {
-          const markedExtendedApiMethods = Object.entries(
-            extendedApiMethods
-          ).reduce((total, [name, fn]: [string, ExtensionEndpointHandler]) => {
-            return {
-              ...total,
-              [name]: markWithExtensionName(fn, extension.name),
-            };
-          }, {});
+          const markedExtendedApiMethods = markExtensionNameHelpers.markApi(
+            extendedApiMethods,
+            extension.name
+          );
 
           namespacedExtensions[extension.name] = {
             ...(namespacedExtensions?.[extension.name] ?? {}),
             ...markedExtendedApiMethods,
           };
         } else {
-          const markedExtendedApiMethods = Object.entries(
-            extendedApiMethods
-          ).reduce((total, [name, fn]: [string, ExtensionEndpointHandler]) => {
-            return {
-              ...total,
-              [name]: markWithExtensionName(fn, extension.name),
-            };
-          }, {});
+          const markedExtendedApiMethods = markExtensionNameHelpers.markApi(
+            extendedApiMethods,
+            extension.name
+          );
           sharedExtensions = {
             ...sharedExtensions,
             ...markedExtendedApiMethods,

packages/middleware/src/apiClientFactory/markExtensionNameHelpers.ts

@@ -0,0 +1,39 @@
+import { ExtensionEndpointHandler } from "../types";
+
+/**
+ * Set of helpers to faciliate working with _extensionName property
+ * added on handlers added by extension's extendApiMethod hook.
+ */
+export const markExtensionNameHelpers = {
+  /**
+   * Function marking endpoint added or overwritten by extension's extendApiMethod hook
+   * with information about source extension's name
+   */
+  mark(apiMethod: ExtensionEndpointHandler, extensionName: string) {
+    apiMethod._extensionName = extensionName;
+    return apiMethod;
+  },
+
+  markApi(
+    api: Record<string, ExtensionEndpointHandler>,
+    extensionName: string
+  ) {
+    return Object.entries(api).reduce(
+      (total, [name, fn]: [string, ExtensionEndpointHandler]) => {
+        return {
+          ...total,
+          [name]: markExtensionNameHelpers.mark(fn, extensionName),
+        };
+      },
+      {}
+    );
+  },
+
+  has(obj: object): obj is ExtensionEndpointHandler {
+    return "_extensionName" in obj;
+  },
+
+  get(obj: object) {
+    return (obj as ExtensionEndpointHandler)?._extensionName;
+  },
+};