@adobe-commerce/aio-toolkit 1.0.5 → 1.0.6

package/dist/index.js

@@ -47,10 +47,13 @@ __export(index_exports, {
   HttpStatus: () => HttpStatus,
   IOEventsApiError: () => IOEventsApiError,
   ImsConnection: () => ims_connection_default,
+  ImsToken: () => ims_token_default,
   InfiniteLoopBreaker: () => infinite_loop_breaker_default,
   IoEventsGlobals: () => IoEventsGlobals,
   Oauth1aConnection: () => oauth1a_connection_default,
+  OnboardCommerce: () => onboard_commerce_default,
   OnboardEvents: () => onboard_events_default,
+  OnboardIOEvents: () => onboard_events_default,
   Openwhisk: () => openwhisk_default,
   OpenwhiskAction: () => openwhisk_action_default,
   Parameters: () => parameters_default,
@@ -60,6 +63,7 @@ __export(index_exports, {
   RestClient: () => rest_client_default,
   RuntimeAction: () => runtime_action_default,
   RuntimeActionResponse: () => response_default,
+  RuntimeApiGatewayService: () => RuntimeApiGatewayService,
   ShippingCarrier: () => shipping_carrier_default,
   ShippingCarrierMethod: () => method_default,
   ShippingCarrierResponse: () => response_default3,
@@ -1021,6 +1025,52 @@ __name(_WebhookAction, "WebhookAction");
 var WebhookAction = _WebhookAction;
 var webhook_action_default = WebhookAction;
 
+// src/framework/ims-token/index.ts
+var import_aio_sdk6 = require("@adobe/aio-sdk");
+
+// src/commerce/adobe-auth/index.ts
+var import_aio_lib_ims = require("@adobe/aio-lib-ims");
+var _AdobeAuth = class _AdobeAuth {
+  /**
+   * Retrieves an authentication token from Adobe IMS
+   *
+   * @param clientId - The client ID for the Adobe IMS integration
+   * @param clientSecret - The client secret for the Adobe IMS integration
+   * @param technicalAccountId - The technical account ID for the Adobe IMS integration
+   * @param technicalAccountEmail - The technical account email for the Adobe IMS integration
+   * @param imsOrgId - The IMS organization ID
+   * @param scopes - Array of permission scopes to request for the token
+   * @param currentContext - The context name for storing the configuration (defaults to 'onboarding-config')
+   * @returns Promise<string> - A promise that resolves to the authentication token
+   *
+   * @example
+   * const token = await AdobeAuth.getToken(
+   *   'your-client-id',
+   *   'your-client-secret',
+   *   'your-technical-account-id',
+   *   'your-technical-account-email',
+   *   'your-ims-org-id',
+   *   ['AdobeID', 'openid', 'adobeio_api']
+   * );
+   */
+  static async getToken(clientId, clientSecret, technicalAccountId, technicalAccountEmail, imsOrgId, scopes, currentContext = "onboarding-config") {
+    const config = {
+      client_id: clientId,
+      client_secrets: [clientSecret],
+      technical_account_id: technicalAccountId,
+      technical_account_email: technicalAccountEmail,
+      ims_org_id: imsOrgId,
+      scopes
+    };
+    await import_aio_lib_ims.context.setCurrent(currentContext);
+    await import_aio_lib_ims.context.set(currentContext, config);
+    return await (0, import_aio_lib_ims.getToken)();
+  }
+};
+__name(_AdobeAuth, "AdobeAuth");
+var AdobeAuth = _AdobeAuth;
+var adobe_auth_default = AdobeAuth;
+
 // src/integration/bearer-token/index.ts
 var _BearerToken = class _BearerToken {
   /**
@@ -1165,6 +1215,189 @@ __name(_BearerToken, "BearerToken");
 var BearerToken = _BearerToken;
 var bearer_token_default = BearerToken;
 
+// src/framework/ims-token/index.ts
+var _ImsToken = class _ImsToken {
+  /**
+   * Creates an instance of ImsToken
+   *
+   * @param clientId - OAuth client ID for Adobe IMS authentication
+   * @param clientSecret - OAuth client secret for Adobe IMS authentication
+   * @param technicalAccountId - Technical account ID for service-to-service authentication
+   * @param technicalAccountEmail - Technical account email for service-to-service authentication
+   * @param imsOrgId - IMS organization ID
+   * @param scopes - Array of scopes required for the token
+   * @param logger - Optional logger instance for logging operations
+   * @param cacheKey - Optional custom cache key for token storage (defaults to 'runtime_api_gateway_token')
+   * @param tokenContext - Optional token context for authentication (defaults to 'runtime-api-gateway-context')
+   */
+  constructor(clientId, clientSecret, technicalAccountId, technicalAccountEmail, imsOrgId, scopes, logger = null, cacheKey, tokenContext) {
+    /** State property for managing token state */
+    this.state = void 0;
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    this.technicalAccountId = technicalAccountId;
+    this.technicalAccountEmail = technicalAccountEmail;
+    this.imsOrgId = imsOrgId;
+    this.scopes = scopes;
+    this.customLogger = new custom_logger_default(logger);
+    this.key = cacheKey || "ims_token";
+    this.tokenContext = tokenContext || "ims-context";
+  }
+  /**
+   * Executes IMS token generation or retrieves a cached token
+   *
+   * This method first checks for a cached token. If a valid cached token exists,
+   * it returns that. Otherwise, it generates a new token, caches it, and returns it.
+   *
+   * @returns A promise that resolves to the IMS token string or null if generation fails
+   * @example
+   * ```typescript
+   * const token = await imsToken.execute();
+   * if (token) {
+   *   console.log('Token obtained:', token);
+   * }
+   * ```
+   */
+  async execute() {
+    try {
+      this.customLogger.info("Starting IMS token generation/retrieval process");
+      const currentValue = await this.getValue();
+      if (currentValue !== null) {
+        this.customLogger.info("Found cached IMS token, returning cached value");
+        return currentValue;
+      }
+      this.customLogger.info("No cached token found, generating new IMS token");
+      let result = {
+        token: null,
+        expire_in: 86399
+        // Default fallback, will be overridden by actual token expiry
+      };
+      const response = await this.getImsToken();
+      if (response !== null) {
+        result = response;
+      }
+      if (result.token !== null) {
+        this.customLogger.info(`Generated new IMS token, caching for ${result.expire_in} seconds`);
+        await this.setValue(result);
+      }
+      return result.token;
+    } catch (error) {
+      this.customLogger.error(`Failed to execute IMS token generation: ${error.message}`);
+      return null;
+    }
+  }
+  /**
+   * Generates a new IMS token from Adobe IMS service
+   *
+   * @returns A promise that resolves to ImsTokenResult or null if generation fails
+   * @private
+   */
+  async getImsToken() {
+    try {
+      this.customLogger.debug(`Calling AdobeAuth.getToken with context: ${this.tokenContext}`);
+      const token = await adobe_auth_default.getToken(
+        this.clientId,
+        this.clientSecret,
+        this.technicalAccountId,
+        this.technicalAccountEmail,
+        this.imsOrgId,
+        this.scopes,
+        this.tokenContext
+      );
+      if (token !== null && token !== void 0) {
+        this.customLogger.debug("Received token from AdobeAuth, parsing with BearerToken.info");
+        const tokenInfo = bearer_token_default.info(token);
+        if (!tokenInfo.isValid) {
+          this.customLogger.error("Received invalid or expired token from IMS");
+          return null;
+        }
+        const expireInSeconds = tokenInfo.timeUntilExpiry ? Math.floor(tokenInfo.timeUntilExpiry / 1e3) : 86399;
+        this.customLogger.debug(`Token expires in ${expireInSeconds} seconds`);
+        return {
+          token,
+          expire_in: expireInSeconds
+        };
+      }
+      this.customLogger.error("Received null or undefined token from IMS");
+      return null;
+    } catch (error) {
+      this.customLogger.error(`Failed to get IMS token: ${error.message}`);
+      return null;
+    }
+  }
+  /**
+   * Caches the IMS token in the state store with TTL
+   *
+   * @param result - The token result containing the token and expiration time
+   * @returns A promise that resolves to true if caching succeeded, false otherwise
+   * @private
+   */
+  async setValue(result) {
+    try {
+      const state = await this.getState();
+      if (state === null) {
+        this.customLogger.info("State API not available, skipping token caching");
+        return true;
+      }
+      const ttlWithBuffer = Math.max(result.expire_in - 600, 3600);
+      this.customLogger.debug(
+        `Caching IMS token with TTL: ${ttlWithBuffer} seconds (original: ${result.expire_in})`
+      );
+      await state.put(this.key, result.token, { ttl: ttlWithBuffer });
+      return true;
+    } catch (error) {
+      this.customLogger.error(`Failed to cache IMS token: ${error.message}`);
+      return true;
+    }
+  }
+  /**
+   * Retrieves a cached IMS token from the state store
+   *
+   * @returns A promise that resolves to the cached token string or null if not found
+   * @private
+   */
+  async getValue() {
+    try {
+      this.customLogger.debug("Checking for cached IMS token");
+      const state = await this.getState();
+      if (state === null) {
+        this.customLogger.debug("State API not available, cannot retrieve cached token");
+        return null;
+      }
+      const value = await state.get(this.key);
+      if (value !== void 0 && value.value) {
+        this.customLogger.debug("Found cached IMS token");
+        return value.value;
+      }
+      this.customLogger.debug("No cached IMS token found");
+    } catch (error) {
+      this.customLogger.error(`Failed to retrieve cached IMS token: ${error.message}`);
+    }
+    return null;
+  }
+  /**
+   * Initializes and returns the state store instance
+   *
+   * @returns A promise that resolves to the state instance or null if initialization fails
+   * @private
+   */
+  async getState() {
+    if (this.state === void 0) {
+      try {
+        this.customLogger.debug("Initializing State API for token caching");
+        this.state = await import_aio_sdk6.State.init();
+      } catch (error) {
+        this.customLogger.error(`Failed to initialize State API: ${error.message}`);
+        this.state = null;
+      }
+    }
+    return this.state;
+  }
+};
+__name(_ImsToken, "ImsToken");
+var ImsToken = _ImsToken;
+var ims_token_default = ImsToken;
+
 // src/integration/rest-client/index.ts
 var import_node_fetch = __toESM(require("node-fetch"));
 var _RestClient = class _RestClient {
@@ -1337,8 +1570,221 @@ __name(_RestClient, "RestClient");
 var RestClient = _RestClient;
 var rest_client_default = RestClient;
 
+// src/framework/runtime-api-gateway-service/index.ts
+var _RuntimeApiGatewayService = class _RuntimeApiGatewayService {
+  /**
+   * Creates an instance of RuntimeApiGatewayService
+   *
+   * @param clientId - OAuth client ID for Adobe IMS authentication
+   * @param clientSecret - OAuth client secret for Adobe IMS authentication
+   * @param technicalAccountId - Technical account ID for service-to-service authentication
+   * @param technicalAccountEmail - Technical account email for service-to-service authentication
+   * @param imsOrgId - IMS organization ID
+   * @param scopes - Array of scopes required for the token
+   * @param namespace - The Adobe I/O Runtime namespace identifier
+   * @param logger - Optional logger instance for logging operations
+   * @example
+   * ```typescript
+   * const service = new RuntimeApiGatewayService(
+   *   'client-id',
+   *   'client-secret',
+   *   'tech-account-id',
+   *   'tech@example.com',
+   *   'org-id',
+   *   ['openid', 'AdobeID'],
+   *   'my-namespace-12345',
+   *   logger // optional
+   * );
+   * ```
+   */
+  constructor(clientId, clientSecret, technicalAccountId, technicalAccountEmail, imsOrgId, scopes, namespace, logger = null) {
+    this.namespace = namespace;
+    this.imsOrgId = imsOrgId;
+    this.customLogger = new custom_logger_default(logger);
+    this.imsToken = new ims_token_default(
+      clientId,
+      clientSecret,
+      technicalAccountId,
+      technicalAccountEmail,
+      imsOrgId,
+      scopes,
+      logger,
+      "runtime_api_gateway_token",
+      "runtime-api-gateway-context"
+    );
+    this.restClient = new rest_client_default();
+  }
+  /**
+   * Builds the complete API endpoint URL
+   *
+   * @param endpoint - API endpoint path (e.g., 'v1/my-endpoint')
+   * @returns The fully constructed endpoint URL
+   * @private
+   */
+  buildEndpoint(endpoint) {
+    return `${_RuntimeApiGatewayService.BASE_URL}/${this.namespace}/${endpoint}`;
+  }
+  /**
+   * Gets the authenticated headers for API requests
+   *
+   * @returns A promise that resolves with the headers object including authentication
+   * @throws {Error} If token generation fails
+   * @private
+   */
+  async getAuthenticatedHeaders() {
+    this.customLogger.debug("Generating authenticated headers for API request");
+    const token = await this.imsToken.execute();
+    if (!token) {
+      this.customLogger.error("Failed to generate IMS token for authenticated headers");
+      throw new Error("Failed to generate IMS token");
+    }
+    this.customLogger.debug("Successfully generated authenticated headers");
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`,
+      "x-gw-ims-org-id": this.imsOrgId
+    };
+  }
+  /**
+   * Performs a GET request to the Runtime API Gateway
+   *
+   * @param endpoint - API endpoint path (e.g., 'v1/my-endpoint')
+   * @param additionalHeaders - Optional additional headers to include in the request
+   * @returns A promise that resolves with the API response data
+   * @throws {Error} If the API request fails
+   * @example
+   * ```typescript
+   * const service = new RuntimeApiGatewayService(...);
+   * const data = await service.get('v1/my-endpoint');
+   *
+   * // With additional headers
+   * const data = await service.get('v1/my-endpoint', { 'Custom-Header': 'value' });
+   * ```
+   */
+  async get(endpoint, additionalHeaders = {}) {
+    try {
+      const url = this.buildEndpoint(endpoint);
+      this.customLogger.info(`Performing GET request to: ${url}`);
+      const headers = { ...await this.getAuthenticatedHeaders(), ...additionalHeaders };
+      this.customLogger.debug(`GET headers: ${JSON.stringify(headers)}`);
+      const response = await this.restClient.get(url, headers, false);
+      this.customLogger.debug(`GET response: ${JSON.stringify(response)}`);
+      this.customLogger.info("GET request completed successfully");
+      return response;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.customLogger.error(`GET request failed: ${errorMessage}`);
+      throw new Error(`Runtime API gateway GET request failed: ${errorMessage}`);
+    }
+  }
+  /**
+   * Performs a POST request to the Runtime API Gateway
+   *
+   * @param endpoint - API endpoint path (e.g., 'v1/my-endpoint')
+   * @param payload - The data to send in the request body
+   * @param additionalHeaders - Optional additional headers to include in the request
+   * @returns A promise that resolves with the API response data
+   * @throws {Error} If the API request fails
+   * @example
+   * ```typescript
+   * const service = new RuntimeApiGatewayService(...);
+   * const result = await service.post('v1/my-endpoint', { key: 'value' });
+   *
+   * // With additional headers
+   * const result = await service.post('v1/my-endpoint', { key: 'value' }, { 'Custom-Header': 'value' });
+   * ```
+   */
+  async post(endpoint, payload, additionalHeaders = {}) {
+    try {
+      const url = this.buildEndpoint(endpoint);
+      this.customLogger.info(`Performing POST request to: ${url}`);
+      this.customLogger.debug(`POST payload: ${JSON.stringify(payload)}`);
+      const headers = { ...await this.getAuthenticatedHeaders(), ...additionalHeaders };
+      this.customLogger.debug(`POST headers: ${JSON.stringify(headers)}`);
+      const response = await this.restClient.post(url, headers, payload, false);
+      this.customLogger.debug(`POST response: ${JSON.stringify(response)}`);
+      this.customLogger.info("POST request completed successfully");
+      return response;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.customLogger.error(`POST request failed: ${errorMessage}`);
+      throw new Error(`Runtime API gateway POST request failed: ${errorMessage}`);
+    }
+  }
+  /**
+   * Performs a PUT request to the Runtime API Gateway
+   *
+   * @param endpoint - API endpoint path (e.g., 'v1/my-endpoint')
+   * @param payload - The data to send in the request body
+   * @param additionalHeaders - Optional additional headers to include in the request
+   * @returns A promise that resolves with the API response data
+   * @throws {Error} If the API request fails
+   * @example
+   * ```typescript
+   * const service = new RuntimeApiGatewayService(...);
+   * const updated = await service.put('v1/my-endpoint', { id: 1, name: 'updated' });
+   *
+   * // With additional headers
+   * const updated = await service.put('v1/my-endpoint', { id: 1 }, { 'Custom-Header': 'value' });
+   * ```
+   */
+  async put(endpoint, payload, additionalHeaders = {}) {
+    try {
+      const url = this.buildEndpoint(endpoint);
+      this.customLogger.info(`Performing PUT request to: ${url}`);
+      this.customLogger.debug(`PUT payload: ${JSON.stringify(payload)}`);
+      const headers = { ...await this.getAuthenticatedHeaders(), ...additionalHeaders };
+      this.customLogger.debug(`PUT headers: ${JSON.stringify(headers)}`);
+      const response = await this.restClient.put(url, headers, payload, false);
+      this.customLogger.debug(`PUT response: ${JSON.stringify(response)}`);
+      this.customLogger.info("PUT request completed successfully");
+      return response;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.customLogger.error(`PUT request failed: ${errorMessage}`);
+      throw new Error(`Runtime API gateway PUT request failed: ${errorMessage}`);
+    }
+  }
+  /**
+   * Performs a DELETE request to the Runtime API Gateway
+   *
+   * @param endpoint - API endpoint path (e.g., 'v1/my-endpoint')
+   * @param additionalHeaders - Optional additional headers to include in the request
+   * @returns A promise that resolves with the API response data
+   * @throws {Error} If the API request fails
+   * @example
+   * ```typescript
+   * const service = new RuntimeApiGatewayService(...);
+   * const deleted = await service.delete('v1/my-endpoint');
+   *
+   * // With additional headers
+   * const deleted = await service.delete('v1/my-endpoint', { 'Custom-Header': 'value' });
+   * ```
+   */
+  async delete(endpoint, additionalHeaders = {}) {
+    try {
+      const url = this.buildEndpoint(endpoint);
+      this.customLogger.info(`Performing DELETE request to: ${url}`);
+      const headers = { ...await this.getAuthenticatedHeaders(), ...additionalHeaders };
+      this.customLogger.debug(`DELETE headers: ${JSON.stringify(headers)}`);
+      const response = await this.restClient.delete(url, headers, false);
+      this.customLogger.debug(`DELETE response: ${JSON.stringify(response)}`);
+      this.customLogger.info("DELETE request completed successfully");
+      return response;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.customLogger.error(`DELETE request failed: ${errorMessage}`);
+      throw new Error(`Runtime API gateway DELETE request failed: ${errorMessage}`);
+    }
+  }
+};
+__name(_RuntimeApiGatewayService, "RuntimeApiGatewayService");
+/** Base URL for the Adobe I/O Runtime APIs */
+_RuntimeApiGatewayService.BASE_URL = "https://adobeioruntime.net/apis";
+var RuntimeApiGatewayService = _RuntimeApiGatewayService;
+
 // src/integration/onboard-events/index.ts
-var import_aio_sdk6 = require("@adobe/aio-sdk");
+var import_aio_sdk7 = require("@adobe/aio-sdk");
 
 // src/io-events/types.ts
 var IoEventsGlobals = {
@@ -4653,7 +5099,7 @@ var _OnboardEvents = class _OnboardEvents {
       throw new Error("Access token is required");
     }
     const loggerName = projectName.toLowerCase().replace(/[^a-z0-9\s-_]/g, "").replace(/\s+/g, "-").replace(/_{2,}/g, "_").replace(/-{2,}/g, "-").trim().concat("-onboard-events");
-    this.logger = import_aio_sdk6.Core.Logger(loggerName, { level: "debug" });
+    this.logger = import_aio_sdk7.Core.Logger(loggerName, { level: "debug" });
     this.createProviders = new create_providers_default(
       consumerId,
       projectId,
@@ -4849,7 +5295,7 @@ var OnboardEvents = _OnboardEvents;
 var onboard_events_default = OnboardEvents;
 
 // src/integration/infinite-loop-breaker/index.ts
-var import_aio_sdk7 = require("@adobe/aio-sdk");
+var import_aio_sdk8 = require("@adobe/aio-sdk");
 var import_crypto3 = __toESM(require("crypto"));
 var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
   // seconds
@@ -4867,7 +5313,7 @@ var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
     event
   }) {
     const logLevel = process.env.LOG_LEVEL || "info";
-    const logger = import_aio_sdk7.Core.Logger("infiniteLoopBreaker", { level: logLevel });
+    const logger = import_aio_sdk8.Core.Logger("infiniteLoopBreaker", { level: logLevel });
     logger.debug(`Checking for potential infinite loop for event: ${event}`);
     if (!eventTypes.includes(event)) {
       logger.debug(`Event type ${event} is not in the infinite loop event types list`);
@@ -4875,7 +5321,7 @@ var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
     }
     const key = typeof keyFn === "function" ? keyFn() : keyFn;
     const data = typeof fingerprintFn === "function" ? fingerprintFn() : fingerprintFn;
-    const state = await import_aio_sdk7.State.init();
+    const state = await import_aio_sdk8.State.init();
     const persistedFingerPrint = await state.get(key);
     if (!persistedFingerPrint) {
       logger.debug(`No persisted fingerprint found for key ${key}`);
@@ -4896,7 +5342,7 @@ var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
   static async storeFingerPrint(keyFn, fingerprintFn, ttl) {
     const key = typeof keyFn === "function" ? keyFn() : keyFn;
     const data = typeof fingerprintFn === "function" ? fingerprintFn() : fingerprintFn;
-    const state = await import_aio_sdk7.State.init();
+    const state = await import_aio_sdk8.State.init();
     await state.put(key, _InfiniteLoopBreaker.fingerPrint(data), {
       ttl: ttl !== void 0 ? ttl : _InfiniteLoopBreaker.DEFAULT_INFINITE_LOOP_BREAKER_TTL
     });
@@ -4913,80 +5359,544 @@ var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
     };
   }
   /**
-   * This function generates a function to create a key for the infinite loop detection based on params.
+   * This function generates a function to create a key for the infinite loop detection based on params.
+   *
+   * @param key - Data received from the event
+   * @returns The function that generates the key
+   */
+  static fnInfiniteLoopKey(key) {
+    return () => {
+      return key;
+    };
+  }
+  /**
+   * This function generates a fingerprint for the data
+   *
+   * @param data - The data to generate the fingerprint
+   * @returns The fingerprint
+   */
+  static fingerPrint(data) {
+    const hash = import_crypto3.default.createHash(_InfiniteLoopBreaker.FINGERPRINT_ALGORITHM);
+    hash.update(JSON.stringify(data));
+    return hash.digest(_InfiniteLoopBreaker.FINGERPRINT_ENCODING);
+  }
+};
+__name(_InfiniteLoopBreaker, "InfiniteLoopBreaker");
+/** The algorithm used to generate the fingerprint */
+_InfiniteLoopBreaker.FINGERPRINT_ALGORITHM = "sha256";
+/** The encoding used to generate the fingerprint */
+_InfiniteLoopBreaker.FINGERPRINT_ENCODING = "hex";
+/** The default time to live for the fingerprint in the lib state */
+_InfiniteLoopBreaker.DEFAULT_INFINITE_LOOP_BREAKER_TTL = 60;
+var InfiniteLoopBreaker = _InfiniteLoopBreaker;
+var infinite_loop_breaker_default = InfiniteLoopBreaker;
+
+// src/integration/onboard-commerce/configure-provider/index.ts
+var import_aio_services_kit = require("@adobe-commerce/aio-services-kit");
+var _ConfigureProvider = class _ConfigureProvider {
+  /**
+   * Constructor for ConfigureProvider
+   *
+   * @param adobeCommerceClient - Adobe Commerce client instance
+   * @param merchantId - Merchant ID for Adobe Commerce
+   * @param environmentId - Environment ID for Adobe Commerce
+   * @param logger - Optional logger instance for logging operations
+   * @throws {Error} When required parameters are missing or invalid
+   * @example
+   * ```typescript
+   * const configureProvider = new ConfigureProvider(
+   *   adobeCommerceClient,
+   *   'merchant-id-123',
+   *   'environment-id-456',
+   *   logger
+   * );
+   * ```
+   */
+  constructor(adobeCommerceClient, merchantId, environmentId, logger = null) {
+    if (!adobeCommerceClient) {
+      throw new Error("Adobe Commerce client is required");
+    }
+    if (!merchantId || typeof merchantId !== "string") {
+      throw new Error("Valid merchant ID is required");
+    }
+    if (!environmentId || typeof environmentId !== "string") {
+      throw new Error("Valid environment ID is required");
+    }
+    this.adobeCommerceClient = adobeCommerceClient;
+    this.merchantId = merchantId;
+    this.environmentId = environmentId;
+    this.customLogger = new custom_logger_default(logger);
+    this.eventProviderService = new import_aio_services_kit.EventProviderService(this.adobeCommerceClient);
+    this.eventConfigurationService = new import_aio_services_kit.EventConfigurationService(this.adobeCommerceClient);
+  }
+  /**
+   * Execute provider configuration
+   *
+   * This method handles the provider configuration process for Adobe I/O Events.
+   *
+   * @param provider - Provider configuration for Adobe I/O Events
+   * @param workspaceConfig - Workspace configuration settings
+   * @returns A promise that resolves with the configuration result
+   * @throws {Error} If provider configuration fails
+   * @example
+   * ```typescript
+   * const result = await configureProvider.execute(provider, workspaceConfig);
+   * if (result.success) {
+   *   console.log('Provider configured successfully');
+   * }
+   * ```
+   */
+  async execute(provider, workspaceConfig) {
+    this.customLogger.debug("[DEBUG] Starting provider configuration");
+    try {
+      this.validateConfigureParams(provider, workspaceConfig);
+      this.customLogger.debug("[FETCH] Fetching current event providers");
+      const eventProviderResult = await this.eventProviderService.list();
+      if (!eventProviderResult.success) {
+        const errorMsg = `Failed to fetch event providers: ${eventProviderResult.error}`;
+        this.customLogger.error(`[ERROR] ${errorMsg}`);
+        return {
+          success: false,
+          error: errorMsg,
+          details: eventProviderResult
+        };
+      }
+      const workspaceUpdateResult = await this.updateWorkspaceIfEmpty(
+        eventProviderResult.data,
+        workspaceConfig
+      );
+      if (!workspaceUpdateResult.success) {
+        return workspaceUpdateResult;
+      }
+      const providerList = Array.isArray(eventProviderResult.data) ? eventProviderResult.data : [];
+      const existingProvider = providerList.find(
+        (existingProvider2) => existingProvider2.provider_id === provider.id
+      );
+      if (existingProvider) {
+        this.customLogger.info(`[SKIP] Provider ${provider.id} is already configured`);
+        return {
+          success: true,
+          provider: existingProvider
+        };
+      } else {
+        this.customLogger.debug(
+          `[DEBUG] Provider ${provider.id} is not yet configured - creating new provider...`
+        );
+        const createResult = await this.createNewProvider(provider, workspaceConfig);
+        if (!createResult.success) {
+          return createResult;
+        }
+        this.customLogger.info(`[CREATE] Event provider ${provider.id} created successfully`);
+        return {
+          success: true,
+          provider: createResult.provider
+        };
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.customLogger.error(`[ERROR] Provider configuration failed: ${errorMessage}`);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * Creates a new event provider
+   *
+   * @param provider - Provider configuration object
+   * @param workspaceConfig - Workspace configuration object
+   * @returns Creation result with success status and provider data
+   * @private
+   */
+  async createNewProvider(provider, workspaceConfig) {
+    const providerData = {
+      provider_id: provider.id,
+      instance_id: provider.instance_id,
+      // Already validated in validateConfigureParams
+      label: provider.label,
+      description: provider.description,
+      workspace_configuration: JSON.stringify(workspaceConfig)
+    };
+    this.customLogger.debug(
+      `[DEBUG] Creating event provider:
+${JSON.stringify(providerData, null, 2)}`
+    );
+    const createResult = await this.eventProviderService.create(providerData);
+    if (!createResult.success) {
+      const errorMsg = `Failed to create event provider: ${createResult.error}`;
+      this.customLogger.error(`[ERROR] ${errorMsg}`);
+      return {
+        success: false,
+        error: errorMsg,
+        details: createResult
+      };
+    }
+    return {
+      success: true,
+      provider: createResult.data
+    };
+  }
+  /**
+   * Updates workspace configuration if the default workspace is empty
+   *
+   * @param existingProviders - Array of existing providers
+   * @param workspaceConfig - Workspace configuration object
+   * @returns Update result with success status
+   * @private
+   */
+  async updateWorkspaceIfEmpty(existingProviders, workspaceConfig) {
+    const providerArray = Array.isArray(existingProviders) ? existingProviders : [];
+    const isDefaultWorkspaceEmpty = providerArray.length === 0 || providerArray.every(
+      (item) => !item.workspace_configuration || item.workspace_configuration === ""
+    );
+    if (isDefaultWorkspaceEmpty) {
+      this.customLogger.debug("[DEBUG] Default workspace is empty, updating configuration...");
+      const updateConfigPayload = {
+        enabled: true,
+        merchant_id: this.merchantId,
+        environment_id: this.environmentId,
+        workspace_configuration: JSON.stringify(workspaceConfig)
+      };
+      this.customLogger.debug(
+        `[DEBUG] Updating configuration with payload:
+${JSON.stringify(updateConfigPayload, null, 2)}`
+      );
+      const updateResult = await this.eventConfigurationService.update(updateConfigPayload);
+      if (!updateResult.success) {
+        const errorMsg = `Failed to update configuration: ${updateResult.error}`;
+        this.customLogger.error(`[ERROR] ${errorMsg}`);
+        return {
+          success: false,
+          error: errorMsg,
+          details: updateResult
+        };
+      }
+      this.customLogger.info("[UPDATE] Configuration updated successfully");
+    }
+    return { success: true };
+  }
+  /**
+   * Validate input parameters for configure method
+   *
+   * @param provider - Provider configuration for Adobe I/O Events
+   * @param workspaceConfig - Workspace configuration settings
+   * @throws {Error} If validation fails
+   * @private
+   */
+  validateConfigureParams(provider, workspaceConfig) {
+    if (!provider || typeof provider !== "object") {
+      throw new Error("Provider configuration object is required");
+    }
+    const requiredProviderFields = [
+      "id",
+      "instance_id",
+      "label",
+      "description"
+    ];
+    for (const field of requiredProviderFields) {
+      if (!provider[field] || typeof provider[field] !== "string") {
+        throw new Error(`Provider ${field} is required and must be a string`);
+      }
+    }
+    if (!workspaceConfig || typeof workspaceConfig !== "object") {
+      throw new Error("Workspace configuration object is required");
+    }
+    this.customLogger.debug(`[DEBUG] Validated provider: ${provider.label} (${provider.id})`);
+  }
+};
+__name(_ConfigureProvider, "ConfigureProvider");
+var ConfigureProvider = _ConfigureProvider;
+var configure_provider_default = ConfigureProvider;
+
+// src/integration/onboard-commerce/index.ts
+var import_aio_services_kit2 = require("@adobe-commerce/aio-services-kit");
+var _OnboardCommerce = class _OnboardCommerce {
+  /**
+   * Constructor for OnboardCommerce
+   *
+   * @param adobeCommerceClient - Adobe Commerce client instance
+   * @param merchantId - Merchant ID for Adobe Commerce
+   * @param environmentId - Environment ID for Adobe Commerce
+   * @param logger - Optional logger instance for logging operations
+   * @throws {Error} When required parameters are missing or invalid
+   * @example
+   * ```typescript
+   * const adobeCommerceClient = new AdobeCommerceClient(...);
+   * const onboardCommerce = new OnboardCommerce(
+   *   adobeCommerceClient,
+   *   'merchant-id-123',
+   *   'environment-id-456',
+   *   logger
+   * );
+   * ```
+   */
+  constructor(adobeCommerceClient, merchantId, environmentId, logger = null) {
+    if (!adobeCommerceClient) {
+      throw new Error("Adobe Commerce client is required");
+    }
+    if (!merchantId || typeof merchantId !== "string") {
+      throw new Error("Valid merchant ID is required");
+    }
+    if (!environmentId || typeof environmentId !== "string") {
+      throw new Error("Valid environment ID is required");
+    }
+    this.adobeCommerceClient = adobeCommerceClient;
+    this.merchantId = merchantId;
+    this.environmentId = environmentId;
+    this.customLogger = new custom_logger_default(logger);
+    this.configureProvider = new configure_provider_default(
+      adobeCommerceClient,
+      merchantId,
+      environmentId,
+      logger
+    );
+    this.eventSubscriptionService = new import_aio_services_kit2.EventSubscriptionService(adobeCommerceClient);
+    this.eventService = new import_aio_services_kit2.EventService(adobeCommerceClient);
+  }
+  /**
+   * Process Adobe Commerce I/O Events Configuration
+   *
+   * This method automates the configuration of Adobe Commerce I/O Events by setting up
+   * the provider, workspace, and commerce-specific event configurations.
+   *
+   * @param provider - Provider configuration for Adobe I/O Events
+   * @param workspaceConfig - Workspace configuration settings
+   * @param commerceEventsConfig - Array of commerce event configurations (optional, defaults to empty array)
+   * @returns A promise that resolves with the configuration result
+   * @throws {Error} If configuration fails
+   * @example
+   * ```typescript
+   * const result = await onboardCommerce.process(
+   *   providerConfig,
+   *   workspaceConfig,
+   *   commerceEventsConfig
+   * );
+   * ```
+   */
+  async process(provider, workspaceConfig, commerceEventsConfig = []) {
+    this.customLogger.info(
+      `[START] Configuring Adobe Commerce I/O Events
+  Provider: ${provider.label} (${provider.id})
+  Workspace: ${workspaceConfig.project.name}
+  Events to process: ${commerceEventsConfig.length}`
+    );
+    try {
+      const providerResult = await this.configureProvider.execute(provider, workspaceConfig);
+      if (!providerResult.success) {
+        return providerResult;
+      }
+      if (commerceEventsConfig && commerceEventsConfig.length > 0) {
+        this.customLogger.debug("[FETCH] Fetching current event subscriptions...");
+        const eventSubscriptionsResult = await this.eventSubscriptionService.list();
+        let existingSubscriptions = [];
+        if (!eventSubscriptionsResult.success) {
+          this.customLogger.error(
+            `[ERROR] Failed to fetch event subscriptions: ${eventSubscriptionsResult.error}`
+          );
+        } else {
+          existingSubscriptions = Array.isArray(eventSubscriptionsResult.data) ? eventSubscriptionsResult.data : [];
+          this.customLogger.debug(
+            `[FETCH] Retrieved ${existingSubscriptions.length} existing event subscription(s)`
+          );
+        }
+        this.customLogger.debug("[FETCH] Fetching supported events list...");
+        const supportedEventsResult = await this.eventService.supportedList();
+        let supportedEvents = [];
+        if (!supportedEventsResult.success) {
+          this.customLogger.error(
+            `[ERROR] Failed to fetch supported events: ${supportedEventsResult.error}`
+          );
+        } else {
+          supportedEvents = Array.isArray(supportedEventsResult.data) ? supportedEventsResult.data : [];
+          this.customLogger.debug(`[FETCH] Retrieved ${supportedEvents.length} supported event(s)`);
+        }
+        const { alreadySubscribed, needsSubscription, unsupported } = this.filterEventsBySubscriptionStatus(
+          commerceEventsConfig,
+          existingSubscriptions,
+          provider.id,
+          supportedEvents
+        );
+        const result = {
+          successfulSubscriptions: [],
+          failedSubscriptions: [],
+          alreadySubscribed: alreadySubscribed.map((event) => event.event.name),
+          unsupported: unsupported.map((event) => event.event?.name || "Unknown"),
+          skipped: alreadySubscribed.length + unsupported.length
+        };
+        for (const commerceEvent of needsSubscription) {
+          try {
+            const preparedEvent = this.prepareEventPayload(commerceEvent, provider.id);
+            this.customLogger.debug(
+              `[DEBUG] Subscribing to event with payload:
+${JSON.stringify(preparedEvent.event, null, 2)}`
+            );
+            const eventSubscribeResult = await this.eventSubscriptionService.create(
+              preparedEvent.event
+            );
+            if (!eventSubscribeResult.success) {
+              result.failedSubscriptions.push(commerceEvent.event.name);
+              this.customLogger.error(
+                `[ERROR] Failed to subscribe to event: ${commerceEvent.event.name} - ${eventSubscribeResult.error}`
+              );
+              continue;
+            }
+            this.customLogger.info(`[CREATE] Successfully subscribed: ${commerceEvent.event.name}`);
+            result.successfulSubscriptions.push(commerceEvent.event.name);
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            result.failedSubscriptions.push(commerceEvent.event?.name || "Unknown");
+            this.customLogger.error(
+              `[ERROR] Error processing event subscription for ${commerceEvent.event?.name || "Unknown"}: ${errorMessage}`
+            );
+          }
+        }
+        this.logEventSubscriptionSummary(result, provider.label);
+      }
+      return {
+        success: true,
+        message: "Configuration completed successfully"
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      this.customLogger.error(`[ERROR] Configuration failed: ${errorMessage}`);
+      throw new Error(`Failed to configure Adobe Commerce I/O Events: ${errorMessage}`);
+    }
+  }
+  /**
+   * Filters commerce events configuration based on existing subscriptions and supported events
    *
-   * @param key - Data received from the event
-   * @returns The function that generates the key
+   * @param commerceEventsConfig - Array of commerce event configurations
+   * @param existingSubscriptions - Array of existing event subscriptions
+   * @param providerId - Provider ID to match against
+   * @param supportedEvents - Array of supported events from Adobe Commerce
+   * @returns Object containing alreadySubscribed, needsSubscription, and unsupported arrays
+   * @private
    */
-  static fnInfiniteLoopKey(key) {
-    return () => {
-      return key;
+  filterEventsBySubscriptionStatus(commerceEventsConfig, existingSubscriptions, providerId, supportedEvents = []) {
+    const alreadySubscribed = [];
+    const needsSubscription = [];
+    const unsupported = [];
+    const supportedEventNames = new Set(supportedEvents.map((event) => event.name));
+    commerceEventsConfig.forEach((commerceEvent) => {
+      const eventName = commerceEvent.event?.name;
+      if (!eventName) {
+        this.customLogger.error(
+          "Commerce event configuration missing event name, skipping:",
+          commerceEvent
+        );
+        return;
+      }
+      if (supportedEvents.length > 0 && !supportedEventNames.has(eventName)) {
+        unsupported.push(commerceEvent);
+        return;
+      }
+      const isAlreadySubscribed = existingSubscriptions.some(
+        (subscription) => subscription.name === eventName && subscription.provider_id === providerId
+      );
+      if (isAlreadySubscribed) {
+        alreadySubscribed.push(commerceEvent);
+      } else {
+        needsSubscription.push(commerceEvent);
+      }
+    });
+    return {
+      alreadySubscribed,
+      needsSubscription,
+      unsupported
     };
   }
   /**
-   * This function generates a fingerprint for the data
+   * Prepares event payload by transforming event names and adding provider information
    *
-   * @param data - The data to generate the fingerprint
-   * @returns The fingerprint
+   * @param eventSpec - Event specification object containing event details
+   * @param providerId - Provider ID to assign to the event
+   * @returns Modified event specification with updated event properties
+   * @private
    */
-  static fingerPrint(data) {
-    const hash = import_crypto3.default.createHash(_InfiniteLoopBreaker.FINGERPRINT_ALGORITHM);
-    hash.update(JSON.stringify(data));
-    return hash.digest(_InfiniteLoopBreaker.FINGERPRINT_ENCODING);
+  prepareEventPayload(eventSpec, providerId) {
+    if (!eventSpec || !eventSpec.event) {
+      throw new Error("Invalid event specification: event object is required");
+    }
+    if (!eventSpec.event.name) {
+      throw new Error("Invalid event specification: event name is required");
+    }
+    if (!providerId || typeof providerId !== "string") {
+      throw new Error("Valid provider ID is required");
+    }
+    const modifiedEventSpec = JSON.parse(JSON.stringify(eventSpec));
+    modifiedEventSpec.event.parent = modifiedEventSpec.event.name;
+    modifiedEventSpec.event.provider_id = providerId;
+    modifiedEventSpec.event.destination = "default";
+    modifiedEventSpec.event.provider_id = providerId;
+    modifiedEventSpec.event.priority = true;
+    modifiedEventSpec.event.hipaa_audit_required = false;
+    return modifiedEventSpec;
   }
-};
-__name(_InfiniteLoopBreaker, "InfiniteLoopBreaker");
-/** The algorithm used to generate the fingerprint */
-_InfiniteLoopBreaker.FINGERPRINT_ALGORITHM = "sha256";
-/** The encoding used to generate the fingerprint */
-_InfiniteLoopBreaker.FINGERPRINT_ENCODING = "hex";
-/** The default time to live for the fingerprint in the lib state */
-_InfiniteLoopBreaker.DEFAULT_INFINITE_LOOP_BREAKER_TTL = 60;
-var InfiniteLoopBreaker = _InfiniteLoopBreaker;
-var infinite_loop_breaker_default = InfiniteLoopBreaker;
-
-// src/commerce/adobe-auth/index.ts
-var import_aio_lib_ims = require("@adobe/aio-lib-ims");
-var _AdobeAuth = class _AdobeAuth {
   /**
-   * Retrieves an authentication token from Adobe IMS
-   *
-   * @param clientId - The client ID for the Adobe IMS integration
-   * @param clientSecret - The client secret for the Adobe IMS integration
-   * @param technicalAccountId - The technical account ID for the Adobe IMS integration
-   * @param technicalAccountEmail - The technical account email for the Adobe IMS integration
-   * @param imsOrgId - The IMS organization ID
-   * @param scopes - Array of permission scopes to request for the token
-   * @param currentContext - The context name for storing the configuration (defaults to 'onboarding-config')
-   * @returns Promise<string> - A promise that resolves to the authentication token
+   * Logs a comprehensive summary of event subscription results
    *
-   * @example
-   * const token = await AdobeAuth.getToken(
-   *   'your-client-id',
-   *   'your-client-secret',
-   *   'your-technical-account-id',
-   *   'your-technical-account-email',
-   *   'your-ims-org-id',
-   *   ['AdobeID', 'openid', 'adobeio_api']
-   * );
+   * @param result - Event subscription processing results
+   * @param providerLabel - Provider label for display
+   * @private
    */
-  static async getToken(clientId, clientSecret, technicalAccountId, technicalAccountEmail, imsOrgId, scopes, currentContext = "onboarding-config") {
-    const config = {
-      client_id: clientId,
-      client_secrets: [clientSecret],
-      technical_account_id: technicalAccountId,
-      technical_account_email: technicalAccountEmail,
-      ims_org_id: imsOrgId,
-      scopes
-    };
-    await import_aio_lib_ims.context.setCurrent(currentContext);
-    await import_aio_lib_ims.context.set(currentContext, config);
-    return await (0, import_aio_lib_ims.getToken)();
+  logEventSubscriptionSummary(result, providerLabel) {
+    if (result.alreadySubscribed.length > 0) {
+      result.alreadySubscribed.forEach((eventName) => {
+        this.customLogger.info(`[SKIP] Already subscribed: ${eventName}`);
+      });
+    }
+    if (result.unsupported.length > 0) {
+      result.unsupported.forEach((eventName) => {
+        this.customLogger.error(`[ERROR] Unsupported event: ${eventName}`);
+      });
+    }
+    this.customLogger.info("");
+    this.customLogger.info("=".repeat(60));
+    this.customLogger.info(`\u{1F4CA} COMMERCE EVENTS CONFIGURATION SUMMARY - ${providerLabel}`);
+    this.customLogger.info("=".repeat(60));
+    this.customLogger.info("");
+    const totalProcessed = result.successfulSubscriptions.length + result.failedSubscriptions.length + result.alreadySubscribed.length + result.unsupported.length;
+    this.customLogger.info(
+      `\u{1F4C8} OVERALL: ${totalProcessed} processed | ${result.successfulSubscriptions.length} created | ${result.alreadySubscribed.length} existing | ${result.unsupported.length} unsupported | ${result.failedSubscriptions.length} failed`
+    );
+    this.customLogger.info("");
+    if (result.successfulSubscriptions.length > 0) {
+      this.customLogger.info(
+        `\u2705 SUCCESSFUL SUBSCRIPTIONS (${result.successfulSubscriptions.length}):`
+      );
+      result.successfulSubscriptions.forEach((eventName) => {
+        this.customLogger.info(`   \u2713 ${eventName}`);
+      });
+      this.customLogger.info("");
+    }
+    if (result.alreadySubscribed.length > 0) {
+      this.customLogger.info(`\u2139\uFE0F  ALREADY SUBSCRIBED (${result.alreadySubscribed.length}):`);
+      result.alreadySubscribed.forEach((eventName) => {
+        this.customLogger.info(`   \u2192 ${eventName}`);
+      });
+      this.customLogger.info("");
+    }
+    if (result.unsupported.length > 0) {
+      this.customLogger.info(`\u26A0\uFE0F  UNSUPPORTED EVENTS (${result.unsupported.length}):`);
+      result.unsupported.forEach((eventName) => {
+        this.customLogger.info(`   \u26A0 ${eventName}`);
+      });
+      this.customLogger.info("");
+    }
+    if (result.failedSubscriptions.length > 0) {
+      this.customLogger.info(`\u274C FAILED SUBSCRIPTIONS (${result.failedSubscriptions.length}):`);
+      result.failedSubscriptions.forEach((eventName) => {
+        this.customLogger.info(`   \u2717 ${eventName}`);
+      });
+      this.customLogger.info("");
+    }
+    this.customLogger.info("=".repeat(60));
   }
 };
-__name(_AdobeAuth, "AdobeAuth");
-var AdobeAuth = _AdobeAuth;
-var adobe_auth_default = AdobeAuth;
+__name(_OnboardCommerce, "OnboardCommerce");
+var OnboardCommerce = _OnboardCommerce;
+var onboard_commerce_default = OnboardCommerce;
 
 // src/commerce/adobe-commerce-client/index.ts
 var import_got = __toESM(require("got"));
@@ -5128,7 +6038,7 @@ var AdobeCommerceClient = _AdobeCommerceClient;
 var adobe_commerce_client_default = AdobeCommerceClient;
 
 // src/commerce/adobe-commerce-client/basic-auth-connection/generate-basic-auth-token/index.ts
-var import_aio_sdk8 = require("@adobe/aio-sdk");
+var import_aio_sdk9 = require("@adobe/aio-sdk");
 var _GenerateBasicAuthToken = class _GenerateBasicAuthToken {
   /**
    * @param baseUrl
@@ -5278,7 +6188,7 @@ var _GenerateBasicAuthToken = class _GenerateBasicAuthToken {
   async getState() {
     if (this.state === void 0) {
       try {
-        this.state = await import_aio_sdk8.State.init();
+        this.state = await import_aio_sdk9.State.init();
       } catch (error) {
         this.logger.debug("State API initialization failed, running without caching");
         this.state = null;
@@ -5387,160 +6297,6 @@ __name(_Oauth1aConnection, "Oauth1aConnection");
 var Oauth1aConnection = _Oauth1aConnection;
 var oauth1a_connection_default = Oauth1aConnection;
 
-// src/commerce/adobe-commerce-client/ims-connection/generate-ims-token/index.ts
-var import_aio_sdk9 = require("@adobe/aio-sdk");
-var _GenerateImsToken = class _GenerateImsToken {
-  /**
-   * @param clientId
-   * @param clientSecret
-   * @param technicalAccountId
-   * @param technicalAccountEmail
-   * @param imsOrgId
-   * @param scopes
-   * @param logger
-   */
-  constructor(clientId, clientSecret, technicalAccountId, technicalAccountEmail, imsOrgId, scopes, logger = null) {
-    this.key = "adobe_ims_auth_token";
-    this.tokenContext = "adobe-commerce-client";
-    this.clientId = clientId;
-    this.clientSecret = clientSecret;
-    this.technicalAccountId = technicalAccountId;
-    this.technicalAccountEmail = technicalAccountEmail;
-    this.imsOrgId = imsOrgId;
-    this.scopes = scopes;
-    this.customLogger = new custom_logger_default(logger);
-  }
-  /**
-   * @return string | null
-   */
-  async execute() {
-    try {
-      this.customLogger.info("Starting IMS token generation/retrieval process");
-      const currentValue = await this.getValue();
-      if (currentValue !== null) {
-        this.customLogger.info("Found cached IMS token, returning cached value");
-        return currentValue;
-      }
-      this.customLogger.info("No cached token found, generating new IMS token");
-      let result = {
-        token: null,
-        expire_in: 86399
-        // Default fallback, will be overridden by actual token expiry
-      };
-      const response = await this.getImsToken();
-      if (response !== null) {
-        result = response;
-      }
-      if (result.token !== null) {
-        this.customLogger.info(`Generated new IMS token, caching for ${result.expire_in} seconds`);
-        await this.setValue(result);
-      }
-      return result.token;
-    } catch (error) {
-      this.customLogger.error(`Failed to execute IMS token generation: ${error.message}`);
-      return null;
-    }
-  }
-  /**
-   * @return ImsTokenResult | null
-   */
-  async getImsToken() {
-    try {
-      this.customLogger.debug(`Calling AdobeAuth.getToken with context: ${this.tokenContext}`);
-      const token = await adobe_auth_default.getToken(
-        this.clientId,
-        this.clientSecret,
-        this.technicalAccountId,
-        this.technicalAccountEmail,
-        this.imsOrgId,
-        this.scopes,
-        this.tokenContext
-      );
-      if (token !== null && token !== void 0) {
-        this.customLogger.debug("Received token from AdobeAuth, parsing with BearerToken.info");
-        const tokenInfo = bearer_token_default.info(token);
-        if (!tokenInfo.isValid) {
-          this.customLogger.error("Received invalid or expired token from IMS");
-          return null;
-        }
-        const expireInSeconds = tokenInfo.timeUntilExpiry ? Math.floor(tokenInfo.timeUntilExpiry / 1e3) : 86399;
-        this.customLogger.debug(`Token expires in ${expireInSeconds} seconds`);
-        return {
-          token,
-          expire_in: expireInSeconds
-        };
-      }
-      this.customLogger.error("Received null or undefined token from IMS");
-      return null;
-    } catch (error) {
-      this.customLogger.error(`Failed to get IMS token: ${error.message}`);
-      return null;
-    }
-  }
-  /**
-   * @param result
-   * @return boolean
-   */
-  async setValue(result) {
-    try {
-      const state = await this.getState();
-      if (state === null) {
-        this.customLogger.info("State API not available, skipping token caching");
-        return true;
-      }
-      const ttlWithBuffer = Math.max(result.expire_in - 300, 60);
-      this.customLogger.debug(
-        `Caching IMS token with TTL: ${ttlWithBuffer} seconds (original: ${result.expire_in})`
-      );
-      await state.put(this.key, result.token, { ttl: ttlWithBuffer });
-      return true;
-    } catch (error) {
-      this.customLogger.error(`Failed to cache IMS token: ${error.message}`);
-      return true;
-    }
-  }
-  /**
-   * @return string | null
-   */
-  async getValue() {
-    try {
-      this.customLogger.debug("Checking for cached IMS token");
-      const state = await this.getState();
-      if (state === null) {
-        this.customLogger.debug("State API not available, cannot retrieve cached token");
-        return null;
-      }
-      const value = await state.get(this.key);
-      if (value !== void 0 && value.value) {
-        this.customLogger.debug("Found cached IMS token");
-        return value.value;
-      }
-      this.customLogger.debug("No cached IMS token found");
-    } catch (error) {
-      this.customLogger.error(`Failed to retrieve cached IMS token: ${error.message}`);
-    }
-    return null;
-  }
-  /**
-   * @return any
-   */
-  async getState() {
-    if (this.state === void 0) {
-      try {
-        this.customLogger.debug("Initializing State API for token caching");
-        this.state = await import_aio_sdk9.State.init();
-      } catch (error) {
-        this.customLogger.error(`Failed to initialize State API: ${error.message}`);
-        this.state = null;
-      }
-    }
-    return this.state;
-  }
-};
-__name(_GenerateImsToken, "GenerateImsToken");
-var GenerateImsToken = _GenerateImsToken;
-var generate_ims_token_default = GenerateImsToken;
-
 // src/commerce/adobe-commerce-client/ims-connection/index.ts
 var _ImsConnection = class _ImsConnection {
   /**
@@ -5566,14 +6322,18 @@ var _ImsConnection = class _ImsConnection {
    */
   async extend(commerceGot) {
     this.customLogger.info("Using Commerce client with IMS authentication");
-    const tokenGenerator = new generate_ims_token_default(
+    const tokenGenerator = new ims_token_default(
       this.clientId,
       this.clientSecret,
       this.technicalAccountId,
       this.technicalAccountEmail,
       this.imsOrgId,
       this.scopes,
-      this.customLogger.getLogger()
+      this.customLogger.getLogger(),
+      "adobe_commerce_ims_token",
+      // Use specific cache key for commerce client
+      "adobe-commerce-client"
+      // Use adobe-commerce-client context for backward compatibility
     );
     const token = await tokenGenerator.execute();
     if (token === null) {
@@ -6152,10 +6912,13 @@ var AdminUiSdk = _AdminUiSdk;
   HttpStatus,
   IOEventsApiError,
   ImsConnection,
+  ImsToken,
   InfiniteLoopBreaker,
   IoEventsGlobals,
   Oauth1aConnection,
+  OnboardCommerce,
   OnboardEvents,
+  OnboardIOEvents,
   Openwhisk,
   OpenwhiskAction,
   Parameters,
@@ -6165,6 +6928,7 @@ var AdminUiSdk = _AdminUiSdk;
   RestClient,
   RuntimeAction,
   RuntimeActionResponse,
+  RuntimeApiGatewayService,
   ShippingCarrier,
   ShippingCarrierMethod,
   ShippingCarrierResponse,