@adobe-commerce/aio-toolkit 1.0.0 → 1.0.2

package/dist/index.mjs

@@ -15,13 +15,13 @@ var HttpStatus = /* @__PURE__ */ ((HttpStatus2) => {
   return HttpStatus2;
 })(HttpStatus || {});
 var HttpMethod = /* @__PURE__ */ ((HttpMethod3) => {
-  HttpMethod3["GET"] = "get";
-  HttpMethod3["POST"] = "post";
-  HttpMethod3["PUT"] = "put";
-  HttpMethod3["DELETE"] = "delete";
-  HttpMethod3["PATCH"] = "patch";
-  HttpMethod3["HEAD"] = "head";
-  HttpMethod3["OPTIONS"] = "options";
+  HttpMethod3["GET"] = "GET";
+  HttpMethod3["POST"] = "POST";
+  HttpMethod3["PUT"] = "PUT";
+  HttpMethod3["DELETE"] = "DELETE";
+  HttpMethod3["PATCH"] = "PATCH";
+  HttpMethod3["HEAD"] = "HEAD";
+  HttpMethod3["OPTIONS"] = "OPTIONS";
   return HttpMethod3;
 })(HttpMethod || {});
 
@@ -195,9 +195,9 @@ var _RuntimeAction = class _RuntimeAction {
     if (errorMessage) {
       return response_default.error(400 /* BAD_REQUEST */, errorMessage);
     }
-    const requestMethod = params.__ow_method;
+    const requestMethod = params.__ow_method?.toUpperCase();
     if (httpMethods.length > 0 && !httpMethods.includes(requestMethod)) {
-      const errorMessage2 = `Invalid HTTP method: ${requestMethod}. Allowed methods are: ${httpMethods.join(", ")}`;
+      const errorMessage2 = `Invalid HTTP method: ${params.__ow_method}. Allowed methods are: ${httpMethods.join(", ")}`;
       logger.error(errorMessage2);
       return response_default.error(405 /* METHOD_NOT_ALLOWED */, errorMessage2);
     }
@@ -258,7 +258,7 @@ var _GraphQlAction = class _GraphQlAction {
   }, name = "main", disableIntrospection = false) {
     return runtime_action_default.execute(
       `graphql-${name}`,
-      ["get" /* GET */, "post" /* POST */],
+      ["GET" /* GET */, "POST" /* POST */],
       ["query"],
       [],
       async (params, ctx) => {
@@ -423,39 +423,44 @@ var _FileRepository = class _FileRepository {
   /**
    * Saves a file record to the repository
    * @param payload - The data to save
-   * @returns Promise<boolean> True if save was successful, false otherwise
+   * @param id - Optional ID for the file (sanitized to alphanumeric + underscore, takes precedence over payload.id)
+   * @returns Promise<string | null> The filename on success, null on failure
    */
-  async save(payload = {}) {
+  async save(payload = {}, id) {
     try {
       const filesLib = await this.getFiles();
-      let requestFileId = (/* @__PURE__ */ new Date()).getTime();
-      if ("id" in payload && payload.id !== void 0) {
-        requestFileId = Number(payload.id);
+      let fileId;
+      if (id) {
+        fileId = this.sanitizeFileId(id);
+      } else if ("id" in payload && payload.id !== void 0) {
+        fileId = String(payload.id);
+      } else {
+        fileId = String((/* @__PURE__ */ new Date()).getTime());
       }
-      const filepath = `${this.filepath}/${requestFileId}.json`;
+      const filepath = `${this.filepath}/${fileId}.json`;
       const existingFile = await filesLib.list(filepath);
       if (existingFile.length) {
         const buffer = await filesLib.read(filepath);
         const existingData = JSON.parse(buffer.toString());
         payload = {
           ...payload,
-          updated_at: (/* @__PURE__ */ new Date()).toDateString()
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
         payload = { ...existingData, ...payload };
         await filesLib.delete(filepath);
       } else {
         payload = {
           ...payload,
-          id: requestFileId,
-          created_at: (/* @__PURE__ */ new Date()).toDateString(),
-          updated_at: (/* @__PURE__ */ new Date()).toDateString()
+          id: fileId,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         };
       }
       await filesLib.write(filepath, JSON.stringify(payload));
-      return true;
+      return fileId;
     } catch (error) {
       console.error("Error saving file:", error);
-      return false;
+      return null;
     }
   }
   /**
@@ -470,6 +475,21 @@ var _FileRepository = class _FileRepository {
     }
     return await this.list();
   }
+  /**
+   * Sanitizes the file ID to contain only alphanumeric characters and underscores
+   * @param id - The ID to sanitize
+   * @returns Sanitized ID with invalid characters replaced by underscores
+   */
+  sanitizeFileId(id) {
+    if (!id || typeof id !== "string") {
+      return String((/* @__PURE__ */ new Date()).getTime());
+    }
+    const sanitized = id.replace(/[^a-zA-Z0-9_]/g, "_");
+    if (!sanitized || /^_+$/.test(sanitized)) {
+      return String((/* @__PURE__ */ new Date()).getTime());
+    }
+    return sanitized;
+  }
   /**
    * Initializes and returns the Files library instance
    * @returns Promise<any> Initialized Files library instance
@@ -488,21 +508,31 @@ var file_repository_default = FileRepository;
 // src/integration/bearer-token/index.ts
 var _BearerToken = class _BearerToken {
   /**
-   * Extracts the Bearer token from OpenWhisk action parameters and returns detailed token information.
-   * Looks for the authorization header in __ow_headers and extracts the token value
-   * after the "Bearer " prefix.
+   * Extracts the Bearer token from HTTP request headers and returns detailed token information.
+   * Supports both standard HTTP headers and OpenWhisk action parameter formats.
    *
-   * @param params - OpenWhisk action input parameters containing headers
+   * @param headersOrParams - Either a standard headers object or OpenWhisk action parameters
    * @returns Detailed token information object
    *
    * @example
+   * // Standard HTTP headers approach
+   * const headers = {
+   *   authorization: 'Bearer abc123token'
+   * };
+   * const tokenInfo = BearerToken.extract(headers);
+   *
+   * @example
+   * // OpenWhisk action parameters (backward compatibility)
    * const params = {
    *   __ow_headers: {
    *     authorization: 'Bearer abc123token'
    *   }
    * };
    * const tokenInfo = BearerToken.extract(params);
-   * // returns: {
+   *
+   * @example
+   * // Both return the same result:
+   * // {
    * //   token: 'abc123token',
    * //   tokenLength: 11,
    * //   isValid: true,
@@ -510,26 +540,54 @@ var _BearerToken = class _BearerToken {
    * //   timeUntilExpiry: 3600000
    * // }
    */
-  static extract(params) {
+  static extract(headersOrParams) {
     let token = null;
-    if (params.__ow_headers?.authorization?.startsWith("Bearer ")) {
-      token = params.__ow_headers.authorization.substring("Bearer ".length);
+    if (headersOrParams.authorization?.startsWith("Bearer ")) {
+      token = headersOrParams.authorization.substring("Bearer ".length);
+    } else if (headersOrParams.__ow_headers?.authorization?.startsWith("Bearer ")) {
+      token = headersOrParams.__ow_headers.authorization.substring("Bearer ".length);
     }
     return _BearerToken.info(token);
   }
   /**
-   * Gets detailed information about a Bearer token
-   * @param token - The Bearer token string (or null)
-   * @returns {BearerTokenInfo} Detailed token information including validity and expiry
+   * Analyzes a Bearer token and returns detailed information including validity and expiry.
+   * Supports both JWT tokens (with automatic expiry detection) and plain tokens (24h default expiry).
+   *
+   * @param token - The Bearer token string (or null). Can be JWT or plain token.
+   * @returns Detailed token information object
    *
    * @example
-   * const tokenInfo = BearerToken.info('abc123token');
+   * // Plain token (gets 24h default expiry)
+   * const plainTokenInfo = BearerToken.info('abc123token');
    * // returns: {
    * //   token: 'abc123token',
    * //   tokenLength: 11,
    * //   isValid: true,
-   * //   expiry: '2024-01-01T12:00:00.000Z',
-   * //   timeUntilExpiry: 3600000
+   * //   expiry: '2024-01-02T12:00:00.000Z', // 24h from now
+   * //   timeUntilExpiry: 86400000 // milliseconds until expiry
+   * // }
+   *
+   * @example
+   * // JWT token (automatic expiry detection from 'exp' or 'expires_in' claims)
+   * const jwtToken = 'eyJhbGciOiJIUzI1NiJ9.eyJleHAiOjE3MDQ0Njc2MDB9.signature';
+   * const jwtTokenInfo = BearerToken.info(jwtToken);
+   * // returns: {
+   * //   token: 'eyJhbGciOiJIUzI1NiJ9...',
+   * //   tokenLength: 45,
+   * //   isValid: true, // false if expired
+   * //   expiry: '2024-01-05T12:00:00.000Z', // from JWT exp claim
+   * //   timeUntilExpiry: 172800000 // actual time until expiry
+   * // }
+   *
+   * @example
+   * // Null or invalid token
+   * const nullTokenInfo = BearerToken.info(null);
+   * // returns: {
+   * //   token: null,
+   * //   tokenLength: 0,
+   * //   isValid: false,
+   * //   expiry: null,
+   * //   timeUntilExpiry: null
    * // }
    */
   static info(token) {
@@ -595,14 +653,86 @@ var bearer_token_default = BearerToken;
 import fetch from "node-fetch";
 var _RestClient = class _RestClient {
   /**
-   * A generic method to make GET rest call
+   * A completely raw method to make HTTP requests
    *
    * @param endpoint
+   * @param method
    * @param headers
+   * @param payload
+   * @returns {Promise<Response>}
+   */
+  async makeRequest(endpoint, method = "GET", headers = {}, payload = null) {
+    let options = {
+      method,
+      headers
+    };
+    if (payload !== null) {
+      let body;
+      let contentType;
+      if (payload instanceof URLSearchParams) {
+        body = payload.toString();
+        contentType = headers["Content-Type"] || "application/x-www-form-urlencoded";
+      } else if (typeof FormData !== "undefined" && payload instanceof FormData) {
+        body = payload;
+        contentType = headers["Content-Type"];
+      } else if (typeof payload === "string") {
+        body = payload;
+        contentType = headers["Content-Type"] || "text/plain";
+      } else if (payload instanceof Buffer || payload instanceof ArrayBuffer || typeof Uint8Array !== "undefined" && payload instanceof Uint8Array) {
+        body = payload;
+        contentType = headers["Content-Type"] || "application/octet-stream";
+      } else {
+        body = JSON.stringify(payload);
+        contentType = headers["Content-Type"] || "application/json";
+      }
+      const requestHeaders = { ...headers };
+      if (contentType) {
+        requestHeaders["Content-Type"] = contentType;
+      }
+      options = {
+        ...options,
+        body,
+        headers: requestHeaders
+      };
+    }
+    return await fetch(endpoint, options);
+  }
+  /**
+   * A method to parse HTTP response
+   *
+   * @param response
    * @returns {Promise<any>}
    */
-  async get(endpoint, headers = {}) {
-    return await this.apiCall(endpoint, "GET", headers);
+  async parseResponse(response) {
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    if (response.status === 204 || response.headers?.get("content-length") === "0") {
+      return null;
+    }
+    if (typeof response.json === "function") {
+      const contentType = response.headers?.get("content-type");
+      if (!contentType || contentType.includes("application/json") || contentType.includes("application/hal+json")) {
+        return await response.json();
+      }
+    }
+    if (typeof response.text === "function") {
+      const text = await response.text();
+      return text;
+    }
+    return null;
+  }
+  /**
+   * A generic method to make GET rest call
+   *
+   * @param endpoint
+   * @param headers
+   * @param parsed
+   * @returns {Promise<Response | any>}
+   */
+  async get(endpoint, headers = {}, parsed = true) {
+    const response = await this.makeRequest(endpoint, "GET", headers);
+    return parsed ? await this.parseResponse(response) : response;
   }
   /**
    * A generic method to make POST rest call
@@ -610,10 +740,12 @@ var _RestClient = class _RestClient {
    * @param endpoint
    * @param headers
    * @param payload
-   * @returns {Promise<any>}
+   * @param parsed
+   * @returns {Promise<Response | any>}
    */
-  async post(endpoint, headers = {}, payload = null) {
-    return await this.apiCall(endpoint, "POST", headers, payload);
+  async post(endpoint, headers = {}, payload = null, parsed = true) {
+    const response = await this.makeRequest(endpoint, "POST", headers, payload);
+    return parsed ? await this.parseResponse(response) : response;
   }
   /**
    * A generic method to make PUT rest call
@@ -621,20 +753,24 @@ var _RestClient = class _RestClient {
    * @param endpoint
    * @param headers
    * @param payload
-   * @returns {Promise<any>}
+   * @param parsed
+   * @returns {Promise<Response | any>}
    */
-  async put(endpoint, headers = {}, payload = null) {
-    return await this.apiCall(endpoint, "PUT", headers, payload);
+  async put(endpoint, headers = {}, payload = null, parsed = true) {
+    const response = await this.makeRequest(endpoint, "PUT", headers, payload);
+    return parsed ? await this.parseResponse(response) : response;
   }
   /**
    * A generic method to make DELETE rest call
    *
    * @param endpoint
    * @param headers
-   * @returns {Promise<any>}
+   * @param parsed
+   * @returns {Promise<Response | any>}
    */
-  async delete(endpoint, headers = {}) {
-    return await this.apiCall(endpoint, "DELETE", headers);
+  async delete(endpoint, headers = {}, parsed = true) {
+    const response = await this.makeRequest(endpoint, "DELETE", headers);
+    return parsed ? await this.parseResponse(response) : response;
   }
   /**
    * A generic method to make rest call
@@ -644,6 +780,7 @@ var _RestClient = class _RestClient {
    * @param headers
    * @param payload
    * @returns {Promise<any>}
+   * @deprecated Use makeRequest() and parseResponse() methods instead
    */
   async apiCall(endpoint, method = "POST", headers = {}, payload = null) {
     let options = {