@adobe-commerce/aio-toolkit 1.0.11 → 1.0.13

package/dist/index.mjs

@@ -1490,6 +1490,23 @@ var _RuntimeAction = class _RuntimeAction {
   static getActionType() {
     return _RuntimeAction.actionType;
   }
+  /**
+   * Sets the action type name for the next action execution
+   * This is used for logging to identify different action types
+   * (runtime-action, webhook-action, event-consumer-action, etc.)
+   *
+   * @param name - The action type name identifier
+   */
+  static setActionTypeName(name) {
+    _RuntimeAction.actionTypeName = name;
+  }
+  /**
+   * Gets the current action type name
+   * @returns The current action type name identifier
+   */
+  static getActionTypeName() {
+    return _RuntimeAction.actionTypeName;
+  }
   /**
    * Creates a runtime action handler with validation, logging, and telemetry
    *
@@ -1550,17 +1567,20 @@ var _RuntimeAction = class _RuntimeAction {
       const logger = telemetry_default.createLogger(name, params);
       try {
         logger.debug({
-          message: `${name}-started`,
-          action_name: name
-        });
-        logger.debug({
-          message: `${name}-headers`,
-          headers: params.__ow_headers || {}
-        });
-        logger.debug({
-          message: `${name}-body`,
-          body: params.__ow_body || {}
+          message: `${_RuntimeAction.getActionTypeName()} execution started`
         });
+        logger.debug(
+          JSON.stringify({
+            message: `${_RuntimeAction.getActionTypeName()} headers received`,
+            headers: params.__ow_headers || {}
+          })
+        );
+        logger.debug(
+          JSON.stringify({
+            message: `${_RuntimeAction.getActionTypeName()} body received`,
+            body: params.__ow_body || {}
+          })
+        );
         const validationError = _RuntimeAction.validateRequest(
           params,
           requiredParams,
@@ -1573,21 +1593,23 @@ var _RuntimeAction = class _RuntimeAction {
           return validationError;
         }
         const result = await action(params, { logger, headers: params.__ow_headers || {} });
-        logger.debug({
-          message: `${name}-completed`,
-          result
-        });
+        logger.debug(
+          JSON.stringify({
+            message: `${_RuntimeAction.getActionTypeName()} execution completed`,
+            result
+          })
+        );
         return result;
       } catch (error) {
         if (error instanceof Error) {
           logger.error({
-            message: `${name}-failed`,
+            message: `${_RuntimeAction.getActionTypeName()} execution failed`,
             error: error.message,
             stack: error.stack
           });
         } else {
           logger.error({
-            message: `${name}-failed`,
+            message: `${_RuntimeAction.getActionTypeName()} execution failed`,
             error
           });
         }
@@ -1629,11 +1651,11 @@ var _RuntimeAction = class _RuntimeAction {
    * }
    * ```
    */
-  static validateRequest(params, requiredParams, requiredHeaders, httpMethods, logger, name) {
+  static validateRequest(params, requiredParams, requiredHeaders, httpMethods, logger, _name) {
     const errorMessage = validator_default.checkMissingRequestInputs(params, requiredParams, requiredHeaders) ?? "";
     if (errorMessage) {
       logger.error({
-        message: `${name}-validation-failed`,
+        message: `${_RuntimeAction.getActionTypeName()} validation failed`,
         error: errorMessage
       });
       return response_default.error(400 /* BAD_REQUEST */, errorMessage);
@@ -1642,7 +1664,7 @@ var _RuntimeAction = class _RuntimeAction {
     if (httpMethods.length > 0 && !httpMethods.includes(requestMethod)) {
       const errorMessage2 = `Invalid HTTP method: ${params.__ow_method}. Allowed methods are: ${httpMethods.join(", ")}`;
       logger.error({
-        message: `${name}-validation-failed`,
+        message: `${_RuntimeAction.getActionTypeName()} validation failed`,
         error: errorMessage2
       });
       return response_default.error(405 /* METHOD_NOT_ALLOWED */, errorMessage2);
@@ -1656,6 +1678,11 @@ __name(_RuntimeAction, "RuntimeAction");
  * Can be set using setActionType() before calling execute()
  */
 _RuntimeAction.actionType = "runtime-action";
+/**
+ * Private static property to store the action type name for logging
+ * Can be set using setActionTypeName() before calling execute()
+ */
+_RuntimeAction.actionTypeName = "Runtime action";
 var RuntimeAction = _RuntimeAction;
 var runtime_action_default = RuntimeAction;
 
@@ -1723,28 +1750,27 @@ var _EventConsumerAction = class _EventConsumerAction {
       const logger = telemetry_default.createLogger(name, params);
       try {
         logger.debug({
-          message: `${name}-started`,
-          action_name: name
+          message: "Event consumer action execution started"
         });
         logger.debug({
-          message: `${name}-headers`,
+          message: "Event consumer action headers received",
           headers: params.__ow_headers || {}
         });
         logger.debug({
-          message: `${name}-parameters`,
+          message: "Event consumer action parameters received",
           parameters: params
         });
         const errorMessage = validator_default.checkMissingRequestInputs(params, requiredParams, requiredHeaders) || "";
         if (errorMessage) {
           logger.error({
-            message: `${name}-validation-failed`,
+            message: "Event consumer action validation failed",
             error: errorMessage
           });
           return response_default.error(400 /* BAD_REQUEST */, errorMessage);
         }
         const result = await action(params, { logger, headers: params.__ow_headers || {} });
         logger.debug({
-          message: `${name}-completed`,
+          message: "Event consumer action execution completed",
           result
         });
         return result;
@@ -1779,65 +1805,91 @@ var _GraphQlAction = class _GraphQlAction {
       hello: /* @__PURE__ */ __name(() => "Hello World!", "hello")
     };
   }, name = "main", disableIntrospection = false) {
-    return runtime_action_default.execute(
-      `graphql-${name}`,
-      ["GET" /* GET */, "POST" /* POST */],
-      ["query"],
-      [],
-      async (params, ctx) => {
-        let graphqlSchema;
-        try {
-          graphqlSchema = buildSchema(schema);
-        } catch (error) {
-          return response_default.error(400 /* BAD_REQUEST */, error.message);
+    runtime_action_default.setActionType("graphql-action");
+    runtime_action_default.setActionTypeName("GraphQL action");
+    const callback = /* @__PURE__ */ __name(async (params, ctx) => {
+      const { logger } = ctx;
+      let graphqlSchema;
+      try {
+        graphqlSchema = buildSchema(schema);
+      } catch (error) {
+        return response_default.error(400 /* BAD_REQUEST */, error.message);
+      }
+      const graphqlResolvers = await resolvers({
+        ...ctx,
+        ...{
+          params
         }
-        const graphqlResolvers = await resolvers({
-          ...ctx,
-          ...{
-            params
-          }
+      });
+      const context2 = {};
+      const query = params.query;
+      let parsedQuery;
+      try {
+        parsedQuery = parse(query);
+      } catch (error) {
+        return response_default.error(400 /* BAD_REQUEST */, error.message);
+      }
+      logger.debug(
+        JSON.stringify({
+          message: "GraphQL action query parsed",
+          query: parsedQuery
+        })
+      );
+      const validationErrors = validate(graphqlSchema, parsedQuery);
+      if (validationErrors.length) {
+        logger.error({
+          message: "GraphQL action query validation failed",
+          errors: validationErrors
         });
-        const context2 = {};
-        const query = params.query;
-        let parsedQuery;
-        try {
-          parsedQuery = parse(query);
-        } catch (error) {
-          return response_default.error(400 /* BAD_REQUEST */, error.message);
-        }
-        const validationErrors = validate(graphqlSchema, parsedQuery);
-        if (validationErrors.length) {
+        return response_default.error(
+          400 /* BAD_REQUEST */,
+          validationErrors.map((err) => err.message).join(", ")
+        );
+      }
+      if (disableIntrospection) {
+        logger.debug({
+          message: "GraphQL action introspection check disabled"
+        });
+        const isIntrospectionQuery = parsedQuery.definitions.some(
+          (definition) => definition.selectionSet.selections.some(
+            (selection) => selection.name.value.startsWith("__")
+          )
+        );
+        if (isIntrospectionQuery) {
+          logger.error({
+            message: "GraphQL action introspection query detected",
+            query: parsedQuery
+          });
           return response_default.error(
             400 /* BAD_REQUEST */,
-            validationErrors.map((err) => err.message).join(", ")
+            "Introspection is disabled for security reasons."
           );
         }
-        if (disableIntrospection) {
-          const isIntrospectionQuery = parsedQuery.definitions.some(
-            (definition) => definition.selectionSet.selections.some(
-              (selection) => selection.name.value.startsWith("__")
-            )
-          );
-          if (isIntrospectionQuery) {
-            return response_default.error(
-              400 /* BAD_REQUEST */,
-              "Introspection is disabled for security reasons."
-            );
-          }
-        }
-        const variables = typeof params.variables === "string" ? JSON.parse(params.variables) : params.variables;
-        return response_default.success(
-          await graphql({
-            schema: graphqlSchema,
-            source: query,
-            rootValue: graphqlResolvers,
-            contextValue: context2,
-            variableValues: variables,
-            operationName: params.operationName
-          })
-        );
       }
+      const variables = typeof params.variables === "string" ? JSON.parse(params.variables) : params.variables;
+      logger.debug({
+        message: "GraphQL action variables parsed",
+        variables
+      });
+      return response_default.success(
+        await graphql({
+          schema: graphqlSchema,
+          source: query,
+          rootValue: graphqlResolvers,
+          contextValue: context2,
+          variableValues: variables,
+          operationName: params.operationName
+        })
+      );
+    }, "callback");
+    const graphqlAction = runtime_action_default.execute(
+      `graphql-${name}`,
+      ["GET" /* GET */, "POST" /* POST */],
+      ["query"],
+      [],
+      callback
     );
+    return telemetry_default.initialize(graphqlAction);
   }
 };
 __name(_GraphQlAction, "GraphQlAction");
@@ -1855,14 +1907,19 @@ var _Openwhisk = class _Openwhisk {
     this.openwhiskClient = openwhisk({ apihost: host, api_key: apiKey });
   }
   /**
-   * @param action
-   * @param params
-   * @returns {Promise<Activation<Dict>>}
+   * Execute an OpenWhisk action
+   *
+   * @param action - Name of the action to execute
+   * @param params - Parameters to pass to the action
+   * @param config - Configuration options for execution
+   * @param config.blocking - Whether to wait for action completion (default: true)
+   * @returns {Promise<Activation<Dict>>} Action activation result
    */
-  async execute(action, params) {
+  async execute(action, params, config = {}) {
+    const { blocking = true } = config;
     return await this.openwhiskClient.actions.invoke({
       name: action,
-      blocking: true,
+      blocking,
       params
     });
   }
@@ -1919,29 +1976,28 @@ var _OpenwhiskAction = class _OpenwhiskAction {
       const logger = telemetry_default.createLogger(name, params);
       try {
         logger.debug({
-          message: `${name}-started`,
-          action_name: name
+          message: "OpenWhisk action execution started"
         });
         logger.debug({
-          message: `${name}-params`,
+          message: "OpenWhisk action parameters received",
           params
         });
         const result = await action(params, { logger, headers: params.__ow_headers || {} });
         logger.debug({
-          message: `${name}-completed`,
+          message: "OpenWhisk action execution completed",
           result
         });
         return result;
       } catch (error) {
         if (error instanceof Error) {
           logger.error({
-            message: `${name}-failed`,
+            message: "OpenWhisk action execution failed",
             error: error.message,
             stack: error.stack
           });
         } else {
           logger.error({
-            message: `${name}-failed`,
+            message: "OpenWhisk action execution failed",
             error
           });
         }
@@ -2506,7 +2562,7 @@ var _WebhookAction = class _WebhookAction {
         const verificationErrorMessage = await verifySignature(params);
         if (verificationErrorMessage) {
           logger.error({
-            message: `${name}-signature-verification-failed`,
+            message: "Webhook actionsignature verification failed",
             error: verificationErrorMessage
           });
           const verificationErrorResponse = response_default2.exception(verificationErrorMessage);
@@ -2520,7 +2576,7 @@ var _WebhookAction = class _WebhookAction {
       const errorMessage = validator_default.checkMissingRequestInputs(params, requiredParams, requiredHeaders) ?? "";
       if (errorMessage) {
         logger.error({
-          message: `${name}-validation-failed`,
+          message: "Webhook action validation failed",
           error: errorMessage
         });
         const errorMessageResponse = response_default2.exception(errorMessage);
@@ -2530,6 +2586,7 @@ var _WebhookAction = class _WebhookAction {
       return response_default.success(JSON.stringify(response));
     }, "callback");
     runtime_action_default.setActionType("webhook-action");
+    runtime_action_default.setActionTypeName("Webhook action");
     return runtime_action_default.execute(name, httpMethods, [], [], callback);
   }
 };