@adobe-commerce/aio-toolkit 1.2.0 → 1.2.1

package/dist/index.js

@@ -34,6 +34,7 @@ __export(index_exports, {
   AbdbCollection: () => collection_default,
   AbdbColumn: () => column_default,
   AbdbColumnType: () => AbdbColumnType,
+  AbdbRepository: () => abdb_repository_default,
   AdminUiSdk: () => AdminUiSdk,
   AdobeAuth: () => adobe_auth_default,
   AdobeCommerceClient: () => adobe_commerce_client_default,
@@ -2394,1780 +2395,2014 @@ __name(_FileRepository, "FileRepository");
 var FileRepository = _FileRepository;
 var file_repository_default = FileRepository;
 
-// src/framework/publish-event/index.ts
-var import_aio_sdk3 = require("@adobe/aio-sdk");
-var import_cloudevents = require("cloudevents");
-var import_uuid = require("uuid");
+// src/framework/abdb/collection/index.ts
+var import_aio_lib_db = require("@adobe/aio-lib-db");
 
-// src/framework/custom-logger/index.ts
-var _CustomLogger = class _CustomLogger {
+// src/framework/abdb/column/types.ts
+var AbdbColumnType = /* @__PURE__ */ ((AbdbColumnType2) => {
+  AbdbColumnType2["STRING"] = "STRING";
+  AbdbColumnType2["NUMBER"] = "NUMBER";
+  AbdbColumnType2["BOOLEAN"] = "BOOLEAN";
+  AbdbColumnType2["DATETIME"] = "DATETIME";
+  return AbdbColumnType2;
+})(AbdbColumnType || {});
+
+// src/framework/abdb/column/index.ts
+var ISO_8601_DATETIME = /^\d{4}-\d{2}-\d{2}([Tt ]\d{2}:\d{2}(:\d{2}(\.\d{1,9})?)?(Z|[+-]\d{2}(:?\d{2})?)?)?$/;
+var _AbdbColumn = class _AbdbColumn {
   /**
-   * @param logger - External logger instance (can be null)
+   * @param options - Field definition
+   * @throws {Error} When `name` is missing or blank, or `type` is missing / not a member of {@link AbdbColumnType}
    */
-  constructor(logger = null) {
-    this.logger = logger;
+  constructor(options) {
+    if (!options?.name?.trim()) {
+      throw new Error('AbdbColumn: "name" is required and cannot be empty');
+    }
+    if (!options.type || !Object.values(AbdbColumnType).includes(options.type)) {
+      throw new Error('AbdbColumn: "type" is required');
+    }
+    this._name = options.name.trim();
+    this._type = options.type;
+    this._description = void 0;
+    this._isRequired = options.isRequired ?? false;
+    if (options.description !== void 0) {
+      const trimmed = options.description.trim();
+      if (trimmed.length > 0) {
+        this._description = trimmed;
+      }
+    }
+    Object.freeze(this);
   }
   /**
-   * Log debug message if logger is available
-   * @param message - Debug message to log
-   * @param args - Additional arguments to pass to logger
+   * Returns the trimmed field name.
    */
-  debug(message, ...args) {
-    if (this.logger && typeof this.logger.debug === "function") {
-      this.logger.debug(message, ...args);
-    }
+  getName() {
+    return this._name;
   }
   /**
-   * Log info message if logger is available
-   * @param message - Info message to log
-   * @param args - Additional arguments to pass to logger
+   * Returns the expected value type for this column.
    */
-  info(message, ...args) {
-    if (this.logger && typeof this.logger.info === "function") {
-      this.logger.info(message, ...args);
-    }
+  getType() {
+    return this._type;
   }
   /**
-   * Log error message if logger is available
-   * @param message - Error message to log
-   * @param args - Additional arguments to pass to logger
+   * Returns the optional description, if one was provided and non-whitespace.
+   *
+   * @returns Description string, or `undefined` when not set
    */
-  error(message, ...args) {
-    if (this.logger && typeof this.logger.error === "function") {
-      this.logger.error(message, ...args);
-    }
+  getDescription() {
+    return this._description;
   }
   /**
-   * Get the underlying logger instance
-   * @returns the logger instance or null
+   * Returns whether a value is mandatory for {@link AbdbColumn#validate}.
+   *
+   * @returns `true` if constructed with `isRequired: true`; otherwise `false`
    */
-  getLogger() {
-    return this.logger;
+  getIsRequired() {
+    return this._isRequired;
   }
-};
-__name(_CustomLogger, "CustomLogger");
-var CustomLogger = _CustomLogger;
-var custom_logger_default = CustomLogger;
-
-// src/framework/publish-event/index.ts
-var _PublishEvent = class _PublishEvent {
   /**
-   * Creates a new PublishEvent instance
-   *
-   * @param imsOrgId - Adobe IMS Organization ID
-   * @param apiKey - Adobe API Key (Client ID)
-   * @param accessToken - Adobe Access Token
-   * @param logger - Optional logger instance
+   * Serializes this column to a plain object for JSON (config files, APIs, persistence).
    */
-  constructor(imsOrgId, apiKey, accessToken, logger = null) {
-    if (!imsOrgId?.trim()) {
-      throw new Error("imsOrgId is required and cannot be empty");
-    }
-    if (!apiKey?.trim()) {
-      throw new Error("apiKey is required and cannot be empty");
+  toJSON() {
+    const json = {
+      name: this._name,
+      type: this._type
+    };
+    if (this._description !== void 0) {
+      json.description = this._description;
     }
-    if (!accessToken?.trim()) {
-      throw new Error("accessToken is required and cannot be empty");
+    if (this._isRequired) {
+      json.isRequired = true;
     }
-    this.imsOrgId = imsOrgId;
-    this.apiKey = apiKey;
-    this.accessToken = accessToken;
-    this.customLogger = new custom_logger_default(logger);
-    this.customLogger.debug("PublishEvent initialized with valid configuration");
+    return json;
   }
   /**
-   * Publishes a CloudEvent to Adobe I/O Events
+   * Creates a new column with the same or overridden options. Does not mutate this instance.
    *
-   * @param providerId - The Adobe I/O Events provider ID
-   * @param eventCode - The event type identifier (e.g., 'commerce.order.created')
-   * @param payload - The event payload data
-   * @param eventId - Optional custom event ID; if not provided, a UUID will be generated
-   * @param subject - Optional subject for the event
-   * @returns Promise<PublishEventResult> - The publish result
+   * Passing `description: '   '` (blank / whitespace) clears the description on the new column.
    *
-   * @throws Error when providerId or eventCode is invalid or publishing fails
+   * @param overrides - Partial options; omitted keys keep current values
+   * @returns A new {@link AbdbColumn} instance
    */
-  async execute(providerId, eventCode, payload, eventId, subject) {
-    try {
-      if (!providerId?.trim()) {
-        throw new Error("providerId is required and cannot be empty");
-      }
-      if (!eventCode?.trim()) {
-        throw new Error("eventCode is required and cannot be empty");
-      }
-      if (payload === null || payload === void 0) {
-        throw new Error("payload is required");
-      }
-      this.customLogger.info(`Publishing event to provider: ${providerId}`);
-      eventId = eventId ?? (0, import_uuid.v4)();
-      const cloudEvent = new import_cloudevents.CloudEvent({
-        id: eventId,
-        source: `urn:uuid:${providerId}`,
-        datacontenttype: "application/json",
-        type: eventCode,
-        data: payload,
-        ...subject && { subject }
-      });
-      this.customLogger.debug(`Constructed CloudEvent with ID: ${eventId}`);
-      const eventsClient = await import_aio_sdk3.Events.init(this.imsOrgId, this.apiKey, this.accessToken);
-      this.customLogger.debug("Adobe I/O Events client initialized successfully");
-      await eventsClient.publishEvent(cloudEvent);
-      const publishedAt = (/* @__PURE__ */ new Date()).toISOString();
-      this.customLogger.info(`Event published successfully with ID: ${eventId}`);
-      return {
-        eventId,
-        status: "published",
-        publishedAt
-      };
-    } catch (error) {
-      this.customLogger.error(`Failed to publish event: ${error.message}`);
-      return {
-        eventId: (0, import_uuid.v4)(),
-        // Generate ID for tracking even failed events
-        status: "failed",
-        publishedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        error: error.message
-      };
+  clone(overrides = {}) {
+    const name = overrides.name ?? this._name;
+    const type = overrides.type ?? this._type;
+    const isRequired = overrides.isRequired ?? this._isRequired;
+    if (overrides.description !== void 0) {
+      return new _AbdbColumn({ name, type, description: overrides.description, isRequired });
     }
+    if (this._description !== void 0) {
+      return new _AbdbColumn({ name, type, description: this._description, isRequired });
+    }
+    return new _AbdbColumn({ name, type, isRequired });
   }
-};
-__name(_PublishEvent, "PublishEvent");
-var PublishEvent = _PublishEvent;
-var publish_event_default = PublishEvent;
-
-// src/framework/webhook-action/response/types.ts
-var WebhookActionOperation = /* @__PURE__ */ ((WebhookActionOperation2) => {
-  WebhookActionOperation2["SUCCESS"] = "success";
-  WebhookActionOperation2["EXCEPTION"] = "exception";
-  WebhookActionOperation2["ADD"] = "add";
-  WebhookActionOperation2["REPLACE"] = "replace";
-  WebhookActionOperation2["REMOVE"] = "remove";
-  return WebhookActionOperation2;
-})(WebhookActionOperation || {});
-
-// src/framework/webhook-action/response/index.ts
-var _WebhookActionResponse = class _WebhookActionResponse {
   /**
-   * Creates a success response indicating the webhook was processed successfully.
-   *
-   * Use this method when the webhook has been processed without errors and
-   * no modifications to the payload are needed.
+   * Validates a payload value against this column's requiredness and {@link AbdbColumnType}.
    *
-   * @returns A success response object
+   * **Missing values** (`undefined`, `null`, or empty / whitespace-only strings) are handled first:
+   * if `isRequired` is `false`, validation succeeds; if `true`, throws.
    *
-   * @example
-   * ```typescript
-   * const handler = WebhookAction.execute('process-order', [], [], async (params) => {
-   *   // Process the order...
-   *   await processOrder(params.order);
+   * **Type rules** (when a non-missing value is present):
+   * - `STRING`: primitive string
+   * - `NUMBER`: finite number, or a non-empty string whose trim parses to a finite number via `Number`
+   * - `BOOLEAN`: primitive boolean, or non-empty trimmed string `"true"` / `"false"` (case-insensitive)
+   * - `DATETIME`: valid `Date`, finite numeric timestamp (ms), or non-empty trimmed ISO 8601 date/datetime string
    *
-   *   // Return success
-   *   return {
-   *     statusCode: 200,
-   *     body: WebhookActionResponse.success()
-   *   };
-   * });
-   * ```
+   * @param value - Document field or API payload value
+   * @throws {Error} When required and missing, or when the value does not match the column type
    */
-  static success() {
-    return {
-      op: "success" /* SUCCESS */
-    };
-  }
-  /**
-   * Creates an exception response to report an error during webhook processing.
-   *
-   * Use this method to notify Adobe Commerce that an error occurred while
-   * processing the webhook. This helps with debugging and error tracking.
-   *
-   * @param message - Optional error message describing what went wrong
-   * @param exceptionClass - Optional exception class name for categorization (e.g., 'Magento\\Framework\\Exception\\LocalizedException')
-   * @returns An exception response object
-   *
-   * @example
-   * ```typescript
-   * const handler = WebhookAction.execute('validate-product', [], [], async (params) => {
-   *   const product = await findProduct(params.sku);
-   *
-   *   if (!product) {
-   *     return {
-   *       statusCode: 404,
-   *       body: WebhookActionResponse.exception(
-   *         `Product with SKU ${params.sku} not found`,
-   *         'Magento\\Framework\\Exception\\NoSuchEntityException'
-   *       )
-   *     };
-   *   }
-   *
-   *   return { statusCode: 200, body: WebhookActionResponse.success() };
-   * });
-   * ```
-   */
-  static exception(message, exceptionClass) {
-    const response = {
-      op: "exception" /* EXCEPTION */
-    };
-    if (message !== void 0) {
-      response.message = message;
+  validate(value) {
+    if (this._isMissingValue(value)) {
+      if (this._isRequired) {
+        throw new Error(`AbdbColumn: "${this._name}" is required`);
+      }
+      return;
     }
-    if (exceptionClass !== void 0) {
-      response.class = exceptionClass;
+    switch (this._type) {
+      case "STRING" /* STRING */:
+        this._validateStringValue(value);
+        return;
+      case "NUMBER" /* NUMBER */:
+        this._validateNumberValue(value);
+        return;
+      case "BOOLEAN" /* BOOLEAN */:
+        this._validateBooleanValue(value);
+        return;
+      case "DATETIME" /* DATETIME */:
+        this._validateDateTimeValue(value);
+        return;
+      default: {
+        const _unreachable = this._type;
+        throw new Error(`AbdbColumn: unhandled type "${_unreachable}"`);
+      }
     }
-    return response;
   }
   /**
-   * Creates a response to add new data to the webhook payload.
-   *
-   * Use this method to inject additional data into the webhook payload that
-   * will be processed by Adobe Commerce. The data is added at the specified
-   * path using dot notation.
-   *
-   * @param path - Dot-notation path where the value should be added (e.g., 'order.items', 'customer.addresses')
-   * @param value - The value to add at the specified path
-   * @param instance - Optional instance identifier for tracking or reference purposes
-   * @returns An add response object
+   * Whether `value` counts as absent for requiredness checks (before type validation).
    *
-   * @example
-   * ```typescript
-   * const handler = WebhookAction.execute('enrich-order', [], [], async (params) => {
-   *   // Add loyalty points to the order
-   *   return {
-   *     statusCode: 200,
-   *     body: WebhookActionResponse.add(
-   *       'order.loyalty',
-   *       { points: 150, tier: 'gold' },
-   *       params.order.id
-   *     )
-   *   };
-   * });
-   * ```
+   * @returns `true` for `undefined`, `null`, or a string that is empty after trim
    */
-  static add(path, value, instance) {
-    const response = {
-      op: "add" /* ADD */,
-      path,
-      value
-    };
-    if (instance !== void 0) {
-      response.instance = instance;
+  _isMissingValue(value) {
+    if (value === void 0 || value === null) {
+      return true;
     }
-    return response;
+    return typeof value === "string" && value.trim() === "";
   }
   /**
-   * Creates a response to replace existing data in the webhook payload.
-   *
-   * Use this method to modify existing fields in the webhook payload.
-   * The existing value at the specified path will be replaced with the new value.
-   *
-   * @param path - Dot-notation path to the field that should be replaced (e.g., 'product.price', 'order.status')
-   * @param value - The new value to replace the existing value
-   * @param instance - Optional instance identifier for tracking or reference purposes
-   * @returns A replace response object
-   *
-   * @example
-   * ```typescript
-   * const handler = WebhookAction.execute('adjust-price', [], [], async (params) => {
-   *   // Apply dynamic pricing
-   *   const newPrice = await calculateDiscountedPrice(params.product.price);
-   *
-   *   return {
-   *     statusCode: 200,
-   *     body: WebhookActionResponse.replace(
-   *       'product.price',
-   *       newPrice,
-   *       params.product.id
-   *     )
-   *   };
-   * });
-   * ```
+   * @throws {Error} When `value` is not a primitive string
    */
-  static replace(path, value, instance) {
-    const response = {
-      op: "replace" /* REPLACE */,
-      path,
-      value
-    };
-    if (instance !== void 0) {
-      response.instance = instance;
+  _validateStringValue(value) {
+    if (typeof value !== "string") {
+      throw new Error(`AbdbColumn: "${this._name}" expects string, got ${typeof value}`);
     }
-    return response;
   }
   /**
-   * Creates a response to remove data from the webhook payload.
-   *
-   * Use this method to remove fields from the webhook payload before it's
-   * processed by Adobe Commerce. This is useful for filtering sensitive data
-   * or removing unnecessary information.
-   *
-   * @param path - Dot-notation path to the field that should be removed (e.g., 'items.0', 'customer.internal_notes')
-   * @returns A remove response object
-   *
-   * @example
-   * ```typescript
-   * const handler = WebhookAction.execute('sanitize-customer', [], [], async (params) => {
-   *   // Remove internal notes before processing
-   *   return {
-   *     statusCode: 200,
-   *     body: WebhookActionResponse.remove('customer.internal_notes')
-   *   };
-   * });
-   * ```
-   *
-   * @example
-   * ```typescript
-   * // Remove an item from an array
-   * return {
-   *   statusCode: 200,
-   *   body: WebhookActionResponse.remove('order.items.2')
-   * };
-   * ```
+   * @throws {Error} When not a finite number or numeric string
    */
-  static remove(path) {
-    return {
-      op: "remove" /* REMOVE */,
-      path
-    };
+  _validateNumberValue(value) {
+    if (typeof value === "number") {
+      if (Number.isFinite(value)) {
+        return;
+      }
+      throw new Error(`AbdbColumn: "${this._name}" expects a finite number, got ${String(value)}`);
+    }
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      const n = Number(trimmed);
+      if (Number.isFinite(n)) {
+        return;
+      }
+      throw new Error(
+        `AbdbColumn: "${this._name}" expects a finite number or numeric string, got ${JSON.stringify(value)}`
+      );
+    }
+    throw new Error(
+      `AbdbColumn: "${this._name}" expects a finite number or numeric string, got ${typeof value}`
+    );
   }
-};
-__name(_WebhookActionResponse, "WebhookActionResponse");
-var WebhookActionResponse = _WebhookActionResponse;
-var response_default2 = WebhookActionResponse;
-
-// src/framework/webhook-action/types.ts
-var SignatureVerification = /* @__PURE__ */ ((SignatureVerification2) => {
-  SignatureVerification2["ENABLED"] = "enabled";
-  SignatureVerification2["DISABLED"] = "disabled";
-  return SignatureVerification2;
-})(SignatureVerification || {});
-
-// src/framework/webhook-action/index.ts
-var import_crypto = __toESM(require("crypto"));
-var _WebhookAction = class _WebhookAction {
   /**
-   * Execute a webhook action with validation and response handling.
-   *
-   * @param name - Name of the webhook action
-   * @param requiredParams - Required parameters in the webhook payload
-   * @param requiredHeaders - Required headers (e.g., signature headers)
-   * @param signatureVerification - Enable/disable signature verification
-   * @param action - Webhook action function returning WebhookActionResponse
-   * @returns Function that handles the webhook HTTP request
+   * @throws {Error} When not a boolean or `"true"` / `"false"` string
    */
-  static execute(name = "webhook", requiredParams = [], requiredHeaders = [], signatureVerification = "disabled" /* DISABLED */, action = async () => response_default2.success()) {
-    const httpMethods = ["POST" /* POST */];
-    const callback = /* @__PURE__ */ __name(async (params, ctx) => {
-      const { logger, telemetry } = ctx;
-      if (signatureVerification === "enabled" /* ENABLED */) {
-        const verificationErrorMessage = await _WebhookAction.verifySignatureWithInstrumentation(
-          name,
-          params,
-          telemetry
-        );
-        if (verificationErrorMessage) {
-          logger.error({
-            message: "Webhook action signature verification failed",
-            error: verificationErrorMessage
-          });
-          const verificationErrorResponse = response_default2.exception(verificationErrorMessage);
-          return response_default.success(JSON.stringify(verificationErrorResponse));
-        }
-        params = {
-          ...params,
-          ...JSON.parse(atob(params.__ow_body))
-        };
-      }
-      const errorMessage = _WebhookAction.validateWithInstrumentation(
-        name,
-        params,
-        requiredParams,
-        requiredHeaders,
-        telemetry
-      );
-      if (errorMessage) {
-        logger.error({
-          message: "Webhook action validation failed",
-          error: errorMessage
-        });
-        const errorMessageResponse = response_default2.exception(errorMessage);
-        return response_default.success(JSON.stringify(errorMessageResponse));
+  _validateBooleanValue(value) {
+    if (typeof value === "boolean") {
+      return;
+    }
+    if (typeof value === "string") {
+      const t = value.trim().toLowerCase();
+      if (t === "true" || t === "false") {
+        return;
       }
-      const response = await _WebhookAction.executeActionWithInstrumentation(
-        name,
-        action,
-        params,
-        ctx
+      throw new Error(
+        `AbdbColumn: "${this._name}" expects boolean or "true"/"false" string, got ${JSON.stringify(value)}`
       );
-      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);
+    }
+    throw new Error(
+      `AbdbColumn: "${this._name}" expects boolean or "true"/"false" string, got ${typeof value}`
+    );
   }
   /**
-   * Executes webhook action with OpenTelemetry instrumentation
-   *
-   * This method wraps the webhook action execution with distributed tracing instrumentation,
-   * creating a span that tracks execution metrics and results in New Relic.
-   *
-   * @param name - Webhook action name used for span naming
-   * @param action - The webhook action function to execute
-   * @param params - Request parameters
-   * @param ctx - Context object with logger, headers, and telemetry
-   * @returns Promise resolving to the webhook action response(s)
-   *
-   * @private
+   * @throws {Error} When not a valid `Date`, finite timestamp, or ISO 8601 string
    */
-  static async executeActionWithInstrumentation(name, action, params, ctx) {
-    const instrumentedWebhookAction = ctx.telemetry.instrument(
-      `webhook.action.${name}.execute`,
-      async (actionName, actionFn, actionParams, context2) => {
-        const span = context2.telemetry.getCurrentSpan();
-        if (span) {
-          span.setAttribute("webhook.action.name", actionName);
-          span.setAttribute("webhook.action.has_headers", !!context2.headers);
-          span.addEvent("webhook-execution-started");
-        }
-        const response = await actionFn(actionParams, context2);
-        if (span) {
-          span.setAttribute("webhook.action.response_is_array", Array.isArray(response));
-          if (Array.isArray(response)) {
-            span.setAttribute("webhook.action.response_count", response.length);
-          }
-          span.addEvent("webhook-execution-completed", {
-            isArray: Array.isArray(response),
-            count: Array.isArray(response) ? response.length : 1
-          });
-        }
-        return response;
+  _validateDateTimeValue(value) {
+    if (value instanceof Date) {
+      if (!Number.isNaN(value.getTime())) {
+        return;
+      }
+      throw new Error(`AbdbColumn: "${this._name}" expects a valid Date`);
+    }
+    if (typeof value === "number") {
+      if (Number.isFinite(value)) {
+        return;
+      }
+      throw new Error(
+        `AbdbColumn: "${this._name}" expects a finite numeric timestamp, got ${value}`
+      );
+    }
+    if (typeof value === "string") {
+      const s = value.trim();
+      if (!ISO_8601_DATETIME.test(s)) {
+        throw new Error(
+          `AbdbColumn: "${this._name}" expects ISO 8601 datetime string, got ${JSON.stringify(value)}`
+        );
+      }
+      const t = Date.parse(s);
+      if (Number.isNaN(t)) {
+        throw new Error(
+          `AbdbColumn: "${this._name}" expects ISO 8601 datetime string, got ${JSON.stringify(value)}`
+        );
       }
+      return;
+    }
+    throw new Error(
+      `AbdbColumn: "${this._name}" expects Date, finite numeric timestamp, or ISO 8601 datetime string, got ${typeof value}`
     );
-    return instrumentedWebhookAction(name, action, params, ctx);
   }
+};
+__name(_AbdbColumn, "AbdbColumn");
+var AbdbColumn = _AbdbColumn;
+var column_default = AbdbColumn;
+
+// src/framework/abdb/collection/index.ts
+var _AbdbCollection = class _AbdbCollection {
   /**
-   * Verifies webhook signature with OpenTelemetry instrumentation
-   *
-   * This method wraps the signature verification logic with distributed tracing instrumentation,
-   * creating a span that tracks verification metrics and results in New Relic.
-   *
-   * @param name - Webhook action name used for span naming
-   * @param params - Request parameters including headers, body, and public key
-   * @param telemetry - Telemetry instance for instrumentation
-   * @returns Error message if verification fails, null if successful
+   * Creates a collection and optionally configures it in a callback (e.g. chained {@link addColumn} calls).
    *
-   * @private
+   * @param name - Raw collection name; trimmed and validated
+   * @param callback - Optional function invoked with `this` for fluent setup
+   * @throws {Error} When `name` is empty, whitespace-only, or contains invalid characters
    */
-  static async verifySignatureWithInstrumentation(name, params, telemetry) {
-    const instrumentedVerifySignature = telemetry.instrument(
-      `webhook.action.${name}.verify-signature`,
-      async (actionName, actionParams, actionTelemetry) => {
-        const span = actionTelemetry.getCurrentSpan();
-        if (span) {
-          span.setAttribute("webhook.signature.enabled", true);
-          span.setAttribute(
-            "webhook.signature.header_present",
-            !!actionParams.__ow_headers?.["x-adobe-commerce-webhook-signature"]
-          );
-          span.setAttribute("webhook.signature.has_body", !!actionParams.__ow_body);
-          span.setAttribute(
-            "webhook.signature.has_public_key",
-            !!(actionParams.PUBLIC_KEY || actionParams.PUBLIC_KEY_BASE64)
-          );
-          span.addEvent("signature-verification-started");
-        }
-        const verificationError = await _WebhookAction.verifySignature(actionParams);
-        if (span) {
-          span.setAttribute("webhook.signature.valid", verificationError === null);
-          if (verificationError) {
-            span.setAttribute("webhook.signature.error", verificationError);
-          }
-          span.addEvent("signature-verification-completed", {
-            valid: verificationError === null
-          });
-        }
-        return verificationError;
+  constructor(name, callback) {
+    this._name = this._validateCollectionName(name);
+    this._columns = /* @__PURE__ */ new Map();
+    if (callback) {
+      callback(this);
+    }
+  }
+  /**
+   * Returns this collection's name.
+   */
+  getName() {
+    return this._name;
+  }
+  addColumn(name, type, descriptionOrOptions, isRequired) {
+    const trimmed = this._validateColumnName(name);
+    if (this._columns.has(trimmed)) {
+      throw new Error(`AbdbCollection: duplicate column name "${trimmed}"`);
+    }
+    const columnOptions = { name: trimmed, type };
+    if (typeof descriptionOrOptions === "string") {
+      columnOptions.description = descriptionOrOptions;
+      if (isRequired !== void 0) {
+        columnOptions.isRequired = isRequired;
       }
-    );
-    return instrumentedVerifySignature(name, params, telemetry);
+    } else if (descriptionOrOptions !== void 0) {
+      if (descriptionOrOptions.description !== void 0) {
+        columnOptions.description = descriptionOrOptions.description;
+      }
+      if (descriptionOrOptions.isRequired !== void 0) {
+        columnOptions.isRequired = descriptionOrOptions.isRequired;
+      }
+    }
+    this._columns.set(trimmed, new column_default(columnOptions));
+    return this;
   }
   /**
-   * Validates webhook parameters and headers with OpenTelemetry instrumentation
+   * Returns a defensive copy of columns in insertion order.
+   */
+  getColumns() {
+    return Array.from(this._columns.values());
+  }
+  /**
+   * Returns the column registered under `name`, or `undefined` if no such column exists.
    *
-   * This method wraps the validation logic with distributed tracing instrumentation,
-   * creating a span that tracks validation metrics and results in New Relic.
+   * @param name - Column name to look up (exact match after trimming)
+   * @returns The {@link AbdbColumn} instance, or `undefined`
+   */
+  getColumn(name) {
+    return this._columns.get(name.trim());
+  }
+  /**
+   * Returns `true` when a column with the given name has been registered.
    *
-   * @param name - Webhook action name used for span naming
-   * @param params - Request parameters
-   * @param requiredParams - List of required parameter names to validate
-   * @param requiredHeaders - List of required header names to validate
-   * @param telemetry - Telemetry instance for instrumentation
-   * @returns Error message if validation fails, empty string if successful
+   * @param name - Column name to check (exact match after trimming)
+   */
+  hasColumn(name) {
+    return this._columns.has(name.trim());
+  }
+  /**
+   * Validates a document-style object against this collection's columns. Throws on the **first** failing
+   * column. Use {@link validateAll} when you need all errors reported at once.
    *
-   * @private
+   * Missing keys are read as `undefined`, so a **required** column whose key is absent fails validation.
+   * Extra keys not matching any column name are ignored.
+   *
+   * @param record - Key/value payload whose keys are column names
+   * @throws {Error} When any column validation fails (requiredness or type)
    */
-  static validateWithInstrumentation(name, params, requiredParams, requiredHeaders, telemetry) {
-    const instrumentedValidate = telemetry.instrument(
-      `webhook.action.${name}.validate`,
-      (actionName, actionParams, actionRequiredParams, actionRequiredHeaders, actionTelemetry) => {
-        const span = actionTelemetry.getCurrentSpan();
-        if (span) {
-          span.setAttribute("webhook.validation.required_params", actionRequiredParams.join(","));
-          span.setAttribute("webhook.validation.required_headers", actionRequiredHeaders.join(","));
-        }
-        const errorMessage = validator_default.checkMissingRequestInputs(
-          actionParams,
-          actionRequiredParams,
-          actionRequiredHeaders
-        ) ?? "";
-        if (span) {
-          span.setAttribute("webhook.validation.passed", errorMessage === "");
-          if (errorMessage) {
-            span.setAttribute("webhook.validation.error", errorMessage);
-          }
-        }
-        return errorMessage;
-      }
-    );
-    return instrumentedValidate(name, params, requiredParams, requiredHeaders, telemetry);
+  validate(record) {
+    for (const col of this._columns.values()) {
+      col.validate(record[col.getName()]);
+    }
   }
   /**
-   * Verify webhook signature using a public key and SHA256
+   * Validates a document-style object against **all** columns and collects every error instead of
+   * stopping at the first failure. Useful at API boundaries where reporting all problems at once
+   * gives a better developer or end-user experience.
    *
-   * This method validates the authenticity of webhook requests by verifying
-   * the signature against the request body using the provided public key.
+   * Returns an empty array when the record is fully valid.
    *
-   * @param params - Request parameters including headers, body, and public key
-   * @returns Error message if verification fails, null if successful
+   * @param record - Key/value payload whose keys are column names
+   * @returns Array of validation error messages, one per failing column (insertion order)
    *
-   * @private
+   * @example
+   * ```typescript
+   * const errors = orders.validateAll(payload);
+   * if (errors.length > 0) {
+   *   return { status: 400, body: { errors } };
+   * }
+   * ```
    */
-  static async verifySignature(params) {
-    const signature = params.__ow_headers["x-adobe-commerce-webhook-signature"] || "";
-    if (!signature) {
-      return "Header `x-adobe-commerce-webhook-signature` not found. Make sure Webhooks signature is enabled in the Commerce instance.";
-    }
-    const body = params.__ow_body;
-    if (!body) {
-      return "Request body not found. Make sure the action is configured with `raw-http: true`.";
-    }
-    let publicKey = params.PUBLIC_KEY;
-    if (!publicKey && params.PUBLIC_KEY_BASE64) {
-      publicKey = atob(params.PUBLIC_KEY_BASE64);
-    }
-    if (!publicKey) {
-      return "Public key not found. Make sure the action is configured with the input `PUBLIC_KEY` or `PUBLIC_KEY_BASE64` and it is defined in .env file.";
+  validateAll(record) {
+    const errors = [];
+    for (const col of this._columns.values()) {
+      try {
+        col.validate(record[col.getName()]);
+      } catch (e) {
+        errors.push(e instanceof Error ? e.message : String(e));
+      }
     }
+    return errors;
+  }
+  /**
+   * Connects to the database (via `@adobe/aio-lib-db`), runs `callback` with the selected DB **collection**
+   * handle and the **client**, then closes the client in a `finally` block.
+   *
+   * **Errors:** `DbError` instances are rethrown as `AbdbCollection: database error: …`;
+   * any other value is wrapped as `AbdbCollection: unexpected error: …`.
+   *
+   * @param callback - Receives `(collection, client)` after connect
+   * @param token - IMS access token for `initDb`
+   * @param region - Data region (default: `'amer'`)
+   * @returns Promise resolving to the callback's return value
+   * @throws {Error} On init, connect, `DbError`, or callback failure
+   */
+  async run(callback, token, region = "amer") {
+    let client;
     try {
-      const verifier = import_crypto.default.createVerify("SHA256");
-      verifier.update(body);
-      const isSignatureValid = verifier.verify(publicKey, signature, "base64");
-      if (!isSignatureValid) {
-        return "The signature is invalid.";
-      }
+      const db = await (0, import_aio_lib_db.init)({ token, region });
+      client = await db.connect();
+      const collection = await client.collection(this._name);
+      return await callback(collection, client);
     } catch (error) {
-      return "The signature is invalid.";
+      if (error instanceof import_aio_lib_db.DbError) {
+        throw new Error(`AbdbCollection: database error: ${error.message}`);
+      }
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new Error(`AbdbCollection: unexpected error: ${detail}`);
+    } finally {
+      await client?.close();
     }
-    return null;
   }
-};
-__name(_WebhookAction, "WebhookAction");
-var WebhookAction = _WebhookAction;
-var webhook_action_default = WebhookAction;
-
-// src/framework/ims-token/index.ts
-var import_aio_sdk4 = 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
+   * Validates and normalizes the collection identifier used at construction.
    *
-   * @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
+   * @throws {Error} If the name is empty or not `[a-zA-Z0-9_]`
+   */
+  _validateCollectionName(name) {
+    return this._validateIdentifier(
+      name,
+      'AbdbCollection: "name" is required and cannot be empty',
+      "AbdbCollection: name must contain only alphanumeric characters and underscores"
+    );
+  }
+  /**
+   * Validates and normalizes a column name before {@link addColumn} stores it.
    *
-   * @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']
-   * );
+   * @throws {Error} If the name is empty or not `[a-zA-Z0-9_]`
    */
-  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)();
+  _validateColumnName(name) {
+    return this._validateIdentifier(
+      name,
+      'AbdbCollection: column "name" is required and cannot be empty',
+      "AbdbCollection: column name must contain only alphanumeric characters and underscores"
+    );
+  }
+  /**
+   * Shared validation for collection and column identifiers.
+   *
+   * @param raw - Unvalidated string
+   * @param emptyMessage - Thrown when `raw` is missing or whitespace-only
+   * @param invalidMessage - Thrown when the trimmed value is not alphanumeric with underscores
+   * @returns The trimmed identifier
+   */
+  _validateIdentifier(raw, emptyMessage, invalidMessage) {
+    if (!raw || raw.trim() === "") {
+      throw new Error(emptyMessage);
+    }
+    const trimmed = raw.trim();
+    if (!/^[a-zA-Z0-9_]+$/.test(trimmed)) {
+      throw new Error(invalidMessage);
+    }
+    return trimmed;
   }
 };
-__name(_AdobeAuth, "AdobeAuth");
-var AdobeAuth = _AdobeAuth;
-var adobe_auth_default = AdobeAuth;
+__name(_AbdbCollection, "AbdbCollection");
+var AbdbCollection = _AbdbCollection;
+var collection_default = AbdbCollection;
 
-// src/integration/bearer-token/index.ts
-var _BearerToken = class _BearerToken {
+// src/framework/repository/abdb-repository/index.ts
+var _AbdbRepository = class _AbdbRepository {
   /**
-   * Extracts the Bearer token from HTTP request headers and returns detailed token information.
-   * Supports both standard HTTP headers and OpenWhisk action parameter formats.
+   * @param collection - Schema and DB-connection wrapper for the target collection
+   * @param token - IMS access token forwarded to every `collection.run()` call
+   * @param region - Data region forwarded to every `collection.run()` call (default: `'amer'`)
+   * @throws {Error} When `collection` is not an {@link AbdbCollection} instance, or `token` is missing
+   */
+  constructor(collection, token, region = "amer") {
+    if (!(collection instanceof collection_default)) {
+      throw new Error('AbdbRepository: "collection" must be an AbdbCollection instance');
+    }
+    if (!token || typeof token !== "string" || !token.trim()) {
+      throw new Error('AbdbRepository: "token" is required');
+    }
+    if (!collection.hasColumn("_created_at")) {
+      collection.addColumn("_created_at", "DATETIME" /* DATETIME */, "Record creation timestamp");
+    }
+    if (!collection.hasColumn("_updated_at")) {
+      collection.addColumn("_updated_at", "DATETIME" /* DATETIME */, "Record last-updated timestamp");
+    }
+    this._collection = collection;
+    this._token = token;
+    this._region = region;
+  }
+  /**
+   * Returns the name of the underlying collection.
+   */
+  getName() {
+    return this._collection.getName();
+  }
+  /**
+   * Returns the underlying {@link AbdbCollection} instance.
+   */
+  getCollection() {
+    return this._collection;
+  }
+  /**
+   * Returns all documents matching `filter` as an array.
+   * Passing no filter (or an empty object) returns every document in the collection.
    *
-   * @param headersOrParams - Either a standard headers object or OpenWhisk action parameters
-   * @returns Detailed token information object
+   * @param filter - Optional query filter (default: `{}`)
+   * @returns Array of matched documents (may be empty)
+   */
+  async find(filter = {}) {
+    return this._collection.run(
+      async (collection) => {
+        return collection.find(filter).toArray();
+      },
+      this._token,
+      this._region
+    );
+  }
+  /**
+   * Returns the first document matching `filter`, or `null` if none found.
    *
-   * @example
-   * // Standard HTTP headers approach
-   * const headers = {
-   *   authorization: 'Bearer abc123token'
-   * };
-   * const tokenInfo = BearerToken.extract(headers);
+   * @param filter - Query filter (e.g. `{ _id: 'abc' }` or `{ email: 'a@b.com' }`)
+   * @returns The matched document, or `null`
+   */
+  async findOne(filter) {
+    return this._collection.run(
+      async (collection) => {
+        return collection.findOne(filter);
+      },
+      this._token,
+      this._region
+    );
+  }
+  /**
+   * Returns `true` when a document with the given `_id` exists in the collection.
+   * Uses `countDocuments` rather than fetching the full document for efficiency.
    *
-   * @example
-   * // OpenWhisk action parameters (backward compatibility)
-   * const params = {
-   *   __ow_headers: {
-   *     authorization: 'Bearer abc123token'
-   *   }
-   * };
-   * const tokenInfo = BearerToken.extract(params);
+   * @param id - The `_id` to check
+   * @returns `true` if the document exists, `false` otherwise
+   */
+  async exists(id) {
+    if (!id) return false;
+    const n = await this._collection.run(
+      (collection) => {
+        return collection.countDocuments({ _id: id });
+      },
+      this._token,
+      this._region
+    );
+    return n > 0;
+  }
+  /**
+   * Returns the number of documents in the collection matching `filter`.
+   * Passing no filter (or an empty object) counts every document.
    *
-   * @example
-   * // Both return the same result:
-   * // {
-   * //   token: 'abc123token',
-   * //   tokenLength: 11,
-   * //   isValid: true,
-   * //   expiry: '2024-01-01T12:00:00.000Z',
-   * //   timeUntilExpiry: 3600000
-   * // }
+   * @param filter - Optional query filter (default: `{}`)
+   * @returns Total number of matching documents
    */
-  static extract(headersOrParams) {
-    let token = null;
-    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);
+  async count(filter = {}) {
+    return this._collection.run(
+      (collection) => {
+        return collection.countDocuments(filter);
+      },
+      this._token,
+      this._region
+    );
+  }
+  /**
+   * Inserts or updates a document.
+   *
+   * - **Insert** (no `id`): stamps both `_created_at` and `_updated_at`, runs full schema
+   *   validation, then calls `insertOne`. Returns the new document's `_id`.
+   * - **Update** (with `id`): stamps `_updated_at`, runs **partial** validation (only columns
+   *   present in the payload are checked — required fields that are absent are not enforced
+   *   because they already exist in the stored document), then calls `updateOne` with
+   *   `upsert: true`. Returns the same `id` that was passed in.
+   *
+   * @param payload - Document fields to write
+   * @param id - When provided, updates the document with this `_id`; otherwise inserts
+   * @returns The `_id` of the inserted or updated document
+   */
+  async save(payload = {}, id = "") {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (id) {
+      const updatePayload = { ...payload, _updated_at: now };
+      this._validatePartial(updatePayload);
+      await this._collection.run(
+        async (collection) => {
+          await collection.updateOne({ _id: id }, updatePayload, { upsert: true });
+        },
+        this._token,
+        this._region
+      );
+      return id;
     }
-    return _BearerToken.info(token);
+    const insertPayload = { ...payload, _created_at: now, _updated_at: now };
+    this._collection.validate(insertPayload);
+    return this._collection.run(
+      async (collection) => {
+        return collection.insertOne(insertPayload);
+      },
+      this._token,
+      this._region
+    );
   }
   /**
-   * 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).
+   * Deletes the document with the given `_id`. No-ops silently when `id` is empty.
    *
-   * @param token - The Bearer token string (or null). Can be JWT or plain token.
-   * @returns Detailed token information object
+   * @param id - The `_id` of the document to delete
+   */
+  async delete(id = "") {
+    if (!id) return;
+    await this._collection.run(
+      async (collection) => {
+        await collection.deleteOne({ _id: id });
+      },
+      this._token,
+      this._region
+    );
+  }
+  /**
+   * Inserts multiple documents in a single `insertMany` call.
+   * Each payload is stamped with `_created_at` / `_updated_at` and validated
+   * against the full collection schema before the bulk write is sent to the DB.
    *
-   * @example
-   * // Plain token (gets 24h default expiry)
-   * const plainTokenInfo = BearerToken.info('abc123token');
-   * // returns: {
-   * //   token: 'abc123token',
-   * //   tokenLength: 11,
-   * //   isValid: true,
-   * //   expiry: '2024-01-02T12:00:00.000Z', // 24h from now
-   * //   timeUntilExpiry: 86400000 // milliseconds until expiry
-   * // }
+   * @param payloads - Array of document payloads to insert
+   * @returns Array of inserted `_id` values in insertion order
+   */
+  async insertAll(payloads) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const insertPayloads = payloads.map((payload) => {
+      const doc = { ...payload, _created_at: now, _updated_at: now };
+      this._collection.validate(doc);
+      return doc;
+    });
+    return this._collection.run(
+      async (collection) => {
+        return collection.insertMany(insertPayloads);
+      },
+      this._token,
+      this._region
+    );
+  }
+  /**
+   * Applies a partial update to all documents matching `filter` using a single `updateMany` call.
+   * Stamps `_updated_at` on every matched document and runs partial validation on the payload
+   * (only the columns present in the payload are checked).
    *
-   * @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
-   * // }
+   * @param payload - Fields to update on every matched document
+   * @param filter - Query condition selecting which documents to update (default: `{}` — all documents)
+   */
+  async updateAll(payload, filter = {}) {
+    const updatePayload = { ...payload, _updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+    this._validatePartial(updatePayload);
+    await this._collection.run(
+      async (collection) => {
+        await collection.updateMany(filter, updatePayload);
+      },
+      this._token,
+      this._region
+    );
+  }
+  /**
+   * Deletes all documents matching `filter` using a single `deleteMany` call.
+   * Passing no filter (or an empty object) deletes every document in the collection.
    *
-   * @example
-   * // Null or invalid token
-   * const nullTokenInfo = BearerToken.info(null);
-   * // returns: {
-   * //   token: null,
-   * //   tokenLength: 0,
-   * //   isValid: false,
-   * //   expiry: null,
-   * //   timeUntilExpiry: null
-   * // }
+   * @param filter - Optional query filter (default: `{}`)
    */
-  static info(token) {
-    const tokenExpiry = _BearerToken._calculateExpiry(token);
-    return {
-      token,
-      tokenLength: token ? token.length : 0,
-      isValid: _BearerToken._isTokenValid(token, tokenExpiry),
-      expiry: tokenExpiry ? tokenExpiry.toISOString() : null,
-      timeUntilExpiry: tokenExpiry ? Math.max(0, tokenExpiry.getTime() - Date.now()) : null
-    };
+  async deleteAll(filter = {}) {
+    await this._collection.run(
+      async (collection) => {
+        await collection.deleteMany(filter);
+      },
+      this._token,
+      this._region
+    );
   }
   /**
-   * Checks if the given token is valid and not expired
-   * @private
-   * @param token - The bearer token string
-   * @param tokenExpiry - The token expiry date
-   * @returns {boolean} True if token is valid
+   * Validates only the columns whose keys are present in `record`.
+   * Required columns that are absent from the payload are intentionally skipped —
+   * they already exist in the stored document and are not being changed.
+   *
+   * Used by the update path of {@link save} and {@link updateAll}.
    */
-  static _isTokenValid(token, tokenExpiry) {
-    if (!token) {
-      return false;
+  _validatePartial(record) {
+    for (const col of this._collection.getColumns()) {
+      const key = col.getName();
+      if (key in record) {
+        col.validate(record[key]);
+      }
     }
-    if (tokenExpiry && Date.now() >= tokenExpiry.getTime()) {
-      console.log("\u23F0 Token has expired");
-      return false;
+  }
+};
+__name(_AbdbRepository, "AbdbRepository");
+var AbdbRepository = _AbdbRepository;
+var abdb_repository_default = AbdbRepository;
+
+// src/framework/publish-event/index.ts
+var import_aio_sdk3 = require("@adobe/aio-sdk");
+var import_cloudevents = require("cloudevents");
+var import_uuid = require("uuid");
+
+// src/framework/custom-logger/index.ts
+var _CustomLogger = class _CustomLogger {
+  /**
+   * @param logger - External logger instance (can be null)
+   */
+  constructor(logger = null) {
+    this.logger = logger;
+  }
+  /**
+   * Log debug message if logger is available
+   * @param message - Debug message to log
+   * @param args - Additional arguments to pass to logger
+   */
+  debug(message, ...args) {
+    if (this.logger && typeof this.logger.debug === "function") {
+      this.logger.debug(message, ...args);
     }
-    return true;
   }
   /**
-   * Calculates token expiry from JWT token or uses default for non-JWT tokens
-   * @private
-   * @param token - The token string (JWT or plain token)
-   * @returns Date object representing token expiry
+   * Log info message if logger is available
+   * @param message - Info message to log
+   * @param args - Additional arguments to pass to logger
+   */
+  info(message, ...args) {
+    if (this.logger && typeof this.logger.info === "function") {
+      this.logger.info(message, ...args);
+    }
+  }
+  /**
+   * Log error message if logger is available
+   * @param message - Error message to log
+   * @param args - Additional arguments to pass to logger
+   */
+  error(message, ...args) {
+    if (this.logger && typeof this.logger.error === "function") {
+      this.logger.error(message, ...args);
+    }
+  }
+  /**
+   * Get the underlying logger instance
+   * @returns the logger instance or null
+   */
+  getLogger() {
+    return this.logger;
+  }
+};
+__name(_CustomLogger, "CustomLogger");
+var CustomLogger = _CustomLogger;
+var custom_logger_default = CustomLogger;
+
+// src/framework/publish-event/index.ts
+var _PublishEvent = class _PublishEvent {
+  /**
+   * Creates a new PublishEvent instance
+   *
+   * @param imsOrgId - Adobe IMS Organization ID
+   * @param apiKey - Adobe API Key (Client ID)
+   * @param accessToken - Adobe Access Token
+   * @param logger - Optional logger instance
+   */
+  constructor(imsOrgId, apiKey, accessToken, logger = null) {
+    if (!imsOrgId?.trim()) {
+      throw new Error("imsOrgId is required and cannot be empty");
+    }
+    if (!apiKey?.trim()) {
+      throw new Error("apiKey is required and cannot be empty");
+    }
+    if (!accessToken?.trim()) {
+      throw new Error("accessToken is required and cannot be empty");
+    }
+    this.imsOrgId = imsOrgId;
+    this.apiKey = apiKey;
+    this.accessToken = accessToken;
+    this.customLogger = new custom_logger_default(logger);
+    this.customLogger.debug("PublishEvent initialized with valid configuration");
+  }
+  /**
+   * Publishes a CloudEvent to Adobe I/O Events
+   *
+   * @param providerId - The Adobe I/O Events provider ID
+   * @param eventCode - The event type identifier (e.g., 'commerce.order.created')
+   * @param payload - The event payload data
+   * @param eventId - Optional custom event ID; if not provided, a UUID will be generated
+   * @param subject - Optional subject for the event
+   * @returns Promise<PublishEventResult> - The publish result
+   *
+   * @throws Error when providerId or eventCode is invalid or publishing fails
+   */
+  async execute(providerId, eventCode, payload, eventId, subject) {
+    try {
+      if (!providerId?.trim()) {
+        throw new Error("providerId is required and cannot be empty");
+      }
+      if (!eventCode?.trim()) {
+        throw new Error("eventCode is required and cannot be empty");
+      }
+      if (payload === null || payload === void 0) {
+        throw new Error("payload is required");
+      }
+      this.customLogger.info(`Publishing event to provider: ${providerId}`);
+      eventId = eventId ?? (0, import_uuid.v4)();
+      const cloudEvent = new import_cloudevents.CloudEvent({
+        id: eventId,
+        source: `urn:uuid:${providerId}`,
+        datacontenttype: "application/json",
+        type: eventCode,
+        data: payload,
+        ...subject && { subject }
+      });
+      this.customLogger.debug(`Constructed CloudEvent with ID: ${eventId}`);
+      const eventsClient = await import_aio_sdk3.Events.init(this.imsOrgId, this.apiKey, this.accessToken);
+      this.customLogger.debug("Adobe I/O Events client initialized successfully");
+      await eventsClient.publishEvent(cloudEvent);
+      const publishedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.customLogger.info(`Event published successfully with ID: ${eventId}`);
+      return {
+        eventId,
+        status: "published",
+        publishedAt
+      };
+    } catch (error) {
+      this.customLogger.error(`Failed to publish event: ${error.message}`);
+      return {
+        eventId: (0, import_uuid.v4)(),
+        // Generate ID for tracking even failed events
+        status: "failed",
+        publishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        error: error.message
+      };
+    }
+  }
+};
+__name(_PublishEvent, "PublishEvent");
+var PublishEvent = _PublishEvent;
+var publish_event_default = PublishEvent;
+
+// src/framework/webhook-action/response/types.ts
+var WebhookActionOperation = /* @__PURE__ */ ((WebhookActionOperation2) => {
+  WebhookActionOperation2["SUCCESS"] = "success";
+  WebhookActionOperation2["EXCEPTION"] = "exception";
+  WebhookActionOperation2["ADD"] = "add";
+  WebhookActionOperation2["REPLACE"] = "replace";
+  WebhookActionOperation2["REMOVE"] = "remove";
+  return WebhookActionOperation2;
+})(WebhookActionOperation || {});
+
+// src/framework/webhook-action/response/index.ts
+var _WebhookActionResponse = class _WebhookActionResponse {
+  /**
+   * Creates a success response indicating the webhook was processed successfully.
+   *
+   * Use this method when the webhook has been processed without errors and
+   * no modifications to the payload are needed.
+   *
+   * @returns A success response object
+   *
+   * @example
+   * ```typescript
+   * const handler = WebhookAction.execute('process-order', [], [], async (params) => {
+   *   // Process the order...
+   *   await processOrder(params.order);
+   *
+   *   // Return success
+   *   return {
+   *     statusCode: 200,
+   *     body: WebhookActionResponse.success()
+   *   };
+   * });
+   * ```
+   */
+  static success() {
+    return {
+      op: "success" /* SUCCESS */
+    };
+  }
+  /**
+   * Creates an exception response to report an error during webhook processing.
+   *
+   * Use this method to notify Adobe Commerce that an error occurred while
+   * processing the webhook. This helps with debugging and error tracking.
+   *
+   * @param message - Optional error message describing what went wrong
+   * @param exceptionClass - Optional exception class name for categorization (e.g., 'Magento\\Framework\\Exception\\LocalizedException')
+   * @returns An exception response object
+   *
+   * @example
+   * ```typescript
+   * const handler = WebhookAction.execute('validate-product', [], [], async (params) => {
+   *   const product = await findProduct(params.sku);
+   *
+   *   if (!product) {
+   *     return {
+   *       statusCode: 404,
+   *       body: WebhookActionResponse.exception(
+   *         `Product with SKU ${params.sku} not found`,
+   *         'Magento\\Framework\\Exception\\NoSuchEntityException'
+   *       )
+   *     };
+   *   }
+   *
+   *   return { statusCode: 200, body: WebhookActionResponse.success() };
+   * });
+   * ```
    */
-  static _calculateExpiry(token) {
-    if (!token) {
-      return null;
+  static exception(message, exceptionClass) {
+    const response = {
+      op: "exception" /* EXCEPTION */
+    };
+    if (message !== void 0) {
+      response.message = message;
     }
-    try {
-      const parts = token.split(".");
-      if (parts.length === 3) {
-        const payload = JSON.parse(Buffer.from(parts[1] || "", "base64").toString());
-        if (payload.expires_in) {
-          return new Date(Date.now() + parseInt(payload.expires_in));
-        }
-        if (payload.exp) {
-          return new Date(payload.exp * 1e3);
-        }
-      }
-      return new Date(Date.now() + 24 * 60 * 60 * 1e3);
-    } catch (error) {
-      console.warn("[WARN] Could not parse token expiry, using default 24h");
-      return new Date(Date.now() + 24 * 60 * 60 * 1e3);
+    if (exceptionClass !== void 0) {
+      response.class = exceptionClass;
     }
+    return response;
   }
-};
-__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
+   * Creates a response to add new data to the webhook payload.
    *
-   * @deprecated Use `AdobeAuth.getToken()` directly and implement caching in your application.
-   * See class documentation for migration examples.
+   * Use this method to inject additional data into the webhook payload that
+   * will be processed by Adobe Commerce. The data is added at the specified
+   * path using dot notation.
    *
-   * @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')
+   * @param path - Dot-notation path where the value should be added (e.g., 'order.items', 'customer.addresses')
+   * @param value - The value to add at the specified path
+   * @param instance - Optional instance identifier for tracking or reference purposes
+   * @returns An add response object
+   *
+   * @example
+   * ```typescript
+   * const handler = WebhookAction.execute('enrich-order', [], [], async (params) => {
+   *   // Add loyalty points to the order
+   *   return {
+   *     statusCode: 200,
+   *     body: WebhookActionResponse.add(
+   *       'order.loyalty',
+   *       { points: 150, tier: 'gold' },
+   *       params.order.id
+   *     )
+   *   };
+   * });
+   * ```
    */
-  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";
+  static add(path, value, instance) {
+    const response = {
+      op: "add" /* ADD */,
+      path,
+      value
+    };
+    if (instance !== void 0) {
+      response.instance = instance;
+    }
+    return response;
   }
   /**
-   * Executes IMS token generation or retrieves a cached token
+   * Creates a response to replace existing data in the webhook payload.
    *
-   * @deprecated Use `AdobeAuth.getToken()` directly and implement caching in your application.
-   * The built-in caching mechanism has reliability issues with the State API.
-   * See class documentation for migration examples.
+   * Use this method to modify existing fields in the webhook payload.
+   * The existing value at the specified path will be replaced with the new value.
    *
-   * 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.
+   * @param path - Dot-notation path to the field that should be replaced (e.g., 'product.price', 'order.status')
+   * @param value - The new value to replace the existing value
+   * @param instance - Optional instance identifier for tracking or reference purposes
+   * @returns A replace response object
    *
-   * @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);
-   * }
+   * const handler = WebhookAction.execute('adjust-price', [], [], async (params) => {
+   *   // Apply dynamic pricing
+   *   const newPrice = await calculateDiscountedPrice(params.product.price);
+   *
+   *   return {
+   *     statusCode: 200,
+   *     body: WebhookActionResponse.replace(
+   *       'product.price',
+   *       newPrice,
+   *       params.product.id
+   *     )
+   *   };
+   * });
    * ```
    */
-  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;
+  static replace(path, value, instance) {
+    const response = {
+      op: "replace" /* REPLACE */,
+      path,
+      value
+    };
+    if (instance !== void 0) {
+      response.instance = instance;
     }
+    return response;
   }
   /**
-   * Generates a new IMS token from Adobe IMS service
+   * Creates a response to remove data from the webhook payload.
    *
-   * @returns A promise that resolves to ImsTokenResult or null if generation fails
-   * @private
+   * Use this method to remove fields from the webhook payload before it's
+   * processed by Adobe Commerce. This is useful for filtering sensitive data
+   * or removing unnecessary information.
+   *
+   * @param path - Dot-notation path to the field that should be removed (e.g., 'items.0', 'customer.internal_notes')
+   * @returns A remove response object
+   *
+   * @example
+   * ```typescript
+   * const handler = WebhookAction.execute('sanitize-customer', [], [], async (params) => {
+   *   // Remove internal notes before processing
+   *   return {
+   *     statusCode: 200,
+   *     body: WebhookActionResponse.remove('customer.internal_notes')
+   *   };
+   * });
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Remove an item from an array
+   * return {
+   *   statusCode: 200,
+   *   body: WebhookActionResponse.remove('order.items.2')
+   * };
+   * ```
    */
-  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;
-    }
+  static remove(path) {
+    return {
+      op: "remove" /* REMOVE */,
+      path
+    };
   }
+};
+__name(_WebhookActionResponse, "WebhookActionResponse");
+var WebhookActionResponse = _WebhookActionResponse;
+var response_default2 = WebhookActionResponse;
+
+// src/framework/webhook-action/types.ts
+var SignatureVerification = /* @__PURE__ */ ((SignatureVerification2) => {
+  SignatureVerification2["ENABLED"] = "enabled";
+  SignatureVerification2["DISABLED"] = "disabled";
+  return SignatureVerification2;
+})(SignatureVerification || {});
+
+// src/framework/webhook-action/index.ts
+var import_crypto = __toESM(require("crypto"));
+var _WebhookAction = class _WebhookAction {
   /**
-   * Caches the IMS token in the state store with TTL
-   *
-   * @deprecated This method has issues with State API reliability. Use application-level caching instead.
-   *
-   * **Known Issues:**
-   * - State API may not be available in all runtime environments
-   * - Hard-coded 10-minute buffer may not suit all use cases
-   * - Minimum 60-minute TTL is opinionated and inflexible
-   * - No retry mechanism for State API failures
+   * Execute a webhook action with validation and response handling.
    *
-   * @param result - The token result containing the token and expiration time
-   * @returns A promise that resolves to true if caching succeeded, false otherwise
-   * @private
+   * @param name - Name of the webhook action
+   * @param requiredParams - Required parameters in the webhook payload
+   * @param requiredHeaders - Required headers (e.g., signature headers)
+   * @param signatureVerification - Enable/disable signature verification
+   * @param action - Webhook action function returning WebhookActionResponse
+   * @returns Function that handles the webhook HTTP request
    */
-  async setValue(result) {
-    try {
-      const state = await this.getState();
-      if (state === null) {
-        this.customLogger.info("State API not available, skipping token caching");
-        return true;
+  static execute(name = "webhook", requiredParams = [], requiredHeaders = [], signatureVerification = "disabled" /* DISABLED */, action = async () => response_default2.success()) {
+    const httpMethods = ["POST" /* POST */];
+    const callback = /* @__PURE__ */ __name(async (params, ctx) => {
+      const { logger, telemetry } = ctx;
+      if (signatureVerification === "enabled" /* ENABLED */) {
+        const verificationErrorMessage = await _WebhookAction.verifySignatureWithInstrumentation(
+          name,
+          params,
+          telemetry
+        );
+        if (verificationErrorMessage) {
+          logger.error({
+            message: "Webhook action signature verification failed",
+            error: verificationErrorMessage
+          });
+          const verificationErrorResponse = response_default2.exception(verificationErrorMessage);
+          return response_default.success(JSON.stringify(verificationErrorResponse));
+        }
+        params = {
+          ...params,
+          ...JSON.parse(atob(params.__ow_body))
+        };
       }
-      const ttlWithBuffer = Math.max(result.expire_in - 600, 3600);
-      this.customLogger.debug(
-        `Caching IMS token with TTL: ${ttlWithBuffer} seconds (original: ${result.expire_in})`
+      const errorMessage = _WebhookAction.validateWithInstrumentation(
+        name,
+        params,
+        requiredParams,
+        requiredHeaders,
+        telemetry
       );
-      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;
-    }
+      if (errorMessage) {
+        logger.error({
+          message: "Webhook action validation failed",
+          error: errorMessage
+        });
+        const errorMessageResponse = response_default2.exception(errorMessage);
+        return response_default.success(JSON.stringify(errorMessageResponse));
+      }
+      const response = await _WebhookAction.executeActionWithInstrumentation(
+        name,
+        action,
+        params,
+        ctx
+      );
+      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);
   }
   /**
-   * Retrieves a cached IMS token from the state store
+   * Executes webhook action with OpenTelemetry instrumentation
    *
-   * @deprecated This method has issues with State API reliability. Use application-level caching instead.
+   * This method wraps the webhook action execution with distributed tracing instrumentation,
+   * creating a span that tracks execution metrics and results in New Relic.
    *
-   * **Known Issues:**
-   * - State API may not be available in all runtime environments
-   * - No validation of cached token expiry
-   * - Silent failures may return null without proper error context
+   * @param name - Webhook action name used for span naming
+   * @param action - The webhook action function to execute
+   * @param params - Request parameters
+   * @param ctx - Context object with logger, headers, and telemetry
+   * @returns Promise resolving to the webhook action response(s)
    *
-   * @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;
+  static async executeActionWithInstrumentation(name, action, params, ctx) {
+    const instrumentedWebhookAction = ctx.telemetry.instrument(
+      `webhook.action.${name}.execute`,
+      async (actionName, actionFn, actionParams, context2) => {
+        const span = context2.telemetry.getCurrentSpan();
+        if (span) {
+          span.setAttribute("webhook.action.name", actionName);
+          span.setAttribute("webhook.action.has_headers", !!context2.headers);
+          span.addEvent("webhook-execution-started");
+        }
+        const response = await actionFn(actionParams, context2);
+        if (span) {
+          span.setAttribute("webhook.action.response_is_array", Array.isArray(response));
+          if (Array.isArray(response)) {
+            span.setAttribute("webhook.action.response_count", response.length);
+          }
+          span.addEvent("webhook-execution-completed", {
+            isArray: Array.isArray(response),
+            count: Array.isArray(response) ? response.length : 1
+          });
+        }
+        return response;
       }
-      this.customLogger.debug("No cached IMS token found");
-    } catch (error) {
-      this.customLogger.error(`Failed to retrieve cached IMS token: ${error.message}`);
-    }
-    return null;
+    );
+    return instrumentedWebhookAction(name, action, params, ctx);
   }
   /**
-   * Initializes and returns the state store instance
+   * Verifies webhook signature with OpenTelemetry instrumentation
    *
-   * @deprecated This method relies on State API which has reliability issues.
-   * Use application-level caching instead.
+   * This method wraps the signature verification logic with distributed tracing instrumentation,
+   * creating a span that tracks verification metrics and results in New Relic.
    *
-   * **Known Issues:**
-   * - State API initialization may fail silently
-   * - Not available outside Adobe I/O Runtime environments
-   * - Caches the state instance which may become stale
+   * @param name - Webhook action name used for span naming
+   * @param params - Request parameters including headers, body, and public key
+   * @param telemetry - Telemetry instance for instrumentation
+   * @returns Error message if verification fails, null if successful
    *
-   * @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_sdk4.State.init();
-      } catch (error) {
-        this.customLogger.error(`Failed to initialize State API: ${error.message}`);
-        this.state = null;
+  static async verifySignatureWithInstrumentation(name, params, telemetry) {
+    const instrumentedVerifySignature = telemetry.instrument(
+      `webhook.action.${name}.verify-signature`,
+      async (actionName, actionParams, actionTelemetry) => {
+        const span = actionTelemetry.getCurrentSpan();
+        if (span) {
+          span.setAttribute("webhook.signature.enabled", true);
+          span.setAttribute(
+            "webhook.signature.header_present",
+            !!actionParams.__ow_headers?.["x-adobe-commerce-webhook-signature"]
+          );
+          span.setAttribute("webhook.signature.has_body", !!actionParams.__ow_body);
+          span.setAttribute(
+            "webhook.signature.has_public_key",
+            !!(actionParams.PUBLIC_KEY || actionParams.PUBLIC_KEY_BASE64)
+          );
+          span.addEvent("signature-verification-started");
+        }
+        const verificationError = await _WebhookAction.verifySignature(actionParams);
+        if (span) {
+          span.setAttribute("webhook.signature.valid", verificationError === null);
+          if (verificationError) {
+            span.setAttribute("webhook.signature.error", verificationError);
+          }
+          span.addEvent("signature-verification-completed", {
+            valid: verificationError === null
+          });
+        }
+        return verificationError;
       }
-    }
-    return this.state;
+    );
+    return instrumentedVerifySignature(name, params, telemetry);
   }
-};
-__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 {
   /**
-   * 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;
+   * Validates webhook parameters and headers with OpenTelemetry instrumentation
+   *
+   * This method wraps the validation logic with distributed tracing instrumentation,
+   * creating a span that tracks validation metrics and results in New Relic.
+   *
+   * @param name - Webhook action name used for span naming
+   * @param params - Request parameters
+   * @param requiredParams - List of required parameter names to validate
+   * @param requiredHeaders - List of required header names to validate
+   * @param telemetry - Telemetry instance for instrumentation
+   * @returns Error message if validation fails, empty string if successful
+   *
+   * @private
+   */
+  static validateWithInstrumentation(name, params, requiredParams, requiredHeaders, telemetry) {
+    const instrumentedValidate = telemetry.instrument(
+      `webhook.action.${name}.validate`,
+      (actionName, actionParams, actionRequiredParams, actionRequiredHeaders, actionTelemetry) => {
+        const span = actionTelemetry.getCurrentSpan();
+        if (span) {
+          span.setAttribute("webhook.validation.required_params", actionRequiredParams.join(","));
+          span.setAttribute("webhook.validation.required_headers", actionRequiredHeaders.join(","));
+        }
+        const errorMessage = validator_default.checkMissingRequestInputs(
+          actionParams,
+          actionRequiredParams,
+          actionRequiredHeaders
+        ) ?? "";
+        if (span) {
+          span.setAttribute("webhook.validation.passed", errorMessage === "");
+          if (errorMessage) {
+            span.setAttribute("webhook.validation.error", errorMessage);
+          }
+        }
+        return errorMessage;
       }
-      options = {
-        ...options,
-        body,
-        headers: requestHeaders
-      };
-    }
-    return await (0, import_node_fetch.default)(endpoint, options);
+    );
+    return instrumentedValidate(name, params, requiredParams, requiredHeaders, telemetry);
   }
   /**
-   * A method to parse HTTP response
+   * Verify webhook signature using a public key and SHA256
    *
-   * @param response
-   * @returns {Promise<any>}
+   * This method validates the authenticity of webhook requests by verifying
+   * the signature against the request body using the provided public key.
+   *
+   * @param params - Request parameters including headers, body, and public key
+   * @returns Error message if verification fails, null if successful
+   *
+   * @private
    */
-  async parseResponse(response) {
-    if (!response.ok) {
-      throw new Error(`HTTP error! status: ${response.status}`);
+  static async verifySignature(params) {
+    const signature = params.__ow_headers["x-adobe-commerce-webhook-signature"] || "";
+    if (!signature) {
+      return "Header `x-adobe-commerce-webhook-signature` not found. Make sure Webhooks signature is enabled in the Commerce instance.";
     }
-    if (response.status === 204 || response.headers?.get("content-length") === "0") {
-      return null;
+    const body = params.__ow_body;
+    if (!body) {
+      return "Request body not found. Make sure the action is configured with `raw-http: true`.";
     }
-    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();
-      }
+    let publicKey = params.PUBLIC_KEY;
+    if (!publicKey && params.PUBLIC_KEY_BASE64) {
+      publicKey = atob(params.PUBLIC_KEY_BASE64);
     }
-    if (typeof response.text === "function") {
-      const text = await response.text();
-      return text;
+    if (!publicKey) {
+      return "Public key not found. Make sure the action is configured with the input `PUBLIC_KEY` or `PUBLIC_KEY_BASE64` and it is defined in .env file.";
+    }
+    try {
+      const verifier = import_crypto.default.createVerify("SHA256");
+      verifier.update(body);
+      const isSignatureValid = verifier.verify(publicKey, signature, "base64");
+      if (!isSignatureValid) {
+        return "The signature is invalid.";
+      }
+    } catch (error) {
+      return "The signature is invalid.";
     }
     return null;
   }
+};
+__name(_WebhookAction, "WebhookAction");
+var WebhookAction = _WebhookAction;
+var webhook_action_default = WebhookAction;
+
+// src/framework/ims-token/index.ts
+var import_aio_sdk4 = require("@adobe/aio-sdk");
+
+// src/commerce/adobe-auth/index.ts
+var import_aio_lib_ims = require("@adobe/aio-lib-ims");
+var _AdobeAuth = class _AdobeAuth {
   /**
-   * A generic method to make GET rest call
+   * Retrieves an authentication token from Adobe IMS
    *
-   * @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
+   * @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
    *
-   * @param endpoint
-   * @param headers
-   * @param payload
-   * @param parsed
-   * @returns {Promise<Response | any>}
+   * @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']
+   * );
    */
-  async post(endpoint, headers = {}, payload = null, parsed = true) {
-    const response = await this.makeRequest(endpoint, "POST", headers, payload);
-    return parsed ? await this.parseResponse(response) : response;
+  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 {
   /**
-   * A generic method to make PUT rest call
+   * Extracts the Bearer token from HTTP request headers and returns detailed token information.
+   * Supports both standard HTTP headers and OpenWhisk action parameter formats.
    *
-   * @param endpoint
-   * @param headers
-   * @param payload
-   * @param parsed
-   * @returns {Promise<Response | any>}
+   * @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);
+   *
+   * @example
+   * // Both return the same result:
+   * // {
+   * //   token: 'abc123token',
+   * //   tokenLength: 11,
+   * //   isValid: true,
+   * //   expiry: '2024-01-01T12:00:00.000Z',
+   * //   timeUntilExpiry: 3600000
+   * // }
    */
-  async put(endpoint, headers = {}, payload = null, parsed = true) {
-    const response = await this.makeRequest(endpoint, "PUT", headers, payload);
-    return parsed ? await this.parseResponse(response) : response;
+  static extract(headersOrParams) {
+    let token = null;
+    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);
   }
   /**
-   * A generic method to make DELETE rest call
+   * 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 endpoint
-   * @param headers
-   * @param parsed
-   * @returns {Promise<Response | any>}
+   * @param token - The Bearer token string (or null). Can be JWT or plain token.
+   * @returns Detailed token information object
+   *
+   * @example
+   * // Plain token (gets 24h default expiry)
+   * const plainTokenInfo = BearerToken.info('abc123token');
+   * // returns: {
+   * //   token: 'abc123token',
+   * //   tokenLength: 11,
+   * //   isValid: true,
+   * //   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
+   * // }
    */
-  async delete(endpoint, headers = {}, parsed = true) {
-    const response = await this.makeRequest(endpoint, "DELETE", headers);
-    return parsed ? await this.parseResponse(response) : response;
+  static info(token) {
+    const tokenExpiry = _BearerToken._calculateExpiry(token);
+    return {
+      token,
+      tokenLength: token ? token.length : 0,
+      isValid: _BearerToken._isTokenValid(token, tokenExpiry),
+      expiry: tokenExpiry ? tokenExpiry.toISOString() : null,
+      timeUntilExpiry: tokenExpiry ? Math.max(0, tokenExpiry.getTime() - Date.now()) : null
+    };
   }
   /**
-   * A generic method to make rest call
-   *
-   * @param endpoint
-   * @param method
-   * @param headers
-   * @param payload
-   * @returns {Promise<any>}
-   * @deprecated Use makeRequest() and parseResponse() methods instead
+   * Checks if the given token is valid and not expired
+   * @private
+   * @param token - The bearer token string
+   * @param tokenExpiry - The token expiry date
+   * @returns {boolean} True if token is valid
    */
-  async apiCall(endpoint, method = "POST", headers = {}, payload = null) {
-    let options = {
-      method,
-      headers
-    };
-    if (payload !== null) {
-      options = {
-        ...options,
-        body: JSON.stringify(payload),
-        headers: {
-          ...headers,
-          "Content-Type": "application/json"
-        }
-      };
+  static _isTokenValid(token, tokenExpiry) {
+    if (!token) {
+      return false;
     }
-    const response = await (0, import_node_fetch.default)(endpoint, options);
-    if (!response.ok) {
-      throw new Error(`HTTP error! status: ${response.status}`);
+    if (tokenExpiry && Date.now() >= tokenExpiry.getTime()) {
+      console.log("\u23F0 Token has expired");
+      return false;
     }
-    if (response.status === 204 || response.headers?.get("content-length") === "0") {
+    return true;
+  }
+  /**
+   * Calculates token expiry from JWT token or uses default for non-JWT tokens
+   * @private
+   * @param token - The token string (JWT or plain token)
+   * @returns Date object representing token expiry
+   */
+  static _calculateExpiry(token) {
+    if (!token) {
       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();
+    try {
+      const parts = token.split(".");
+      if (parts.length === 3) {
+        const payload = JSON.parse(Buffer.from(parts[1] || "", "base64").toString());
+        if (payload.expires_in) {
+          return new Date(Date.now() + parseInt(payload.expires_in));
+        }
+        if (payload.exp) {
+          return new Date(payload.exp * 1e3);
+        }
       }
+      return new Date(Date.now() + 24 * 60 * 60 * 1e3);
+    } catch (error) {
+      console.warn("[WARN] Could not parse token expiry, using default 24h");
+      return new Date(Date.now() + 24 * 60 * 60 * 1e3);
     }
-    if (typeof response.text === "function") {
-      const text = await response.text();
-      return text;
-    }
-    return null;
   }
 };
-__name(_RestClient, "RestClient");
-var RestClient = _RestClient;
-var rest_client_default = RestClient;
+__name(_BearerToken, "BearerToken");
+var BearerToken = _BearerToken;
+var bearer_token_default = BearerToken;
 
-// src/framework/runtime-api-gateway-service/index.ts
-var _RuntimeApiGatewayService = class _RuntimeApiGatewayService {
+// src/framework/ims-token/index.ts
+var _ImsToken = class _ImsToken {
   /**
-   * Creates an instance of RuntimeApiGatewayService
+   * Creates an instance of ImsToken
    *
-   * @param namespace - The Adobe I/O Runtime namespace identifier
+   * @deprecated Use `AdobeAuth.getToken()` directly and implement caching in your application.
+   * See class documentation for migration examples.
+   *
+   * @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 imsToken - Bearer token string for authentication
+   * @param scopes - Array of scopes required for the token
    * @param logger - Optional logger instance for logging operations
-   * @example
-   * ```typescript
-   * const service = new RuntimeApiGatewayService(
-   *   'test-namespace',
-   *   'org-id@AdobeOrg',
-   *   'bearer-token-string',
-   *   logger
-   * );
-   * ```
+   * @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(namespace, imsOrgId, imsToken, logger = null) {
-    this.namespace = namespace;
+  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.imsToken = imsToken;
-    this.restClient = new rest_client_default();
+    this.scopes = scopes;
     this.customLogger = new custom_logger_default(logger);
+    this.key = cacheKey || "ims_token";
+    this.tokenContext = tokenContext || "ims-context";
   }
   /**
-   * Builds the complete API endpoint URL
+   * Executes IMS token generation or retrieves a cached token
    *
-   * @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
+   * @deprecated Use `AdobeAuth.getToken()` directly and implement caching in your application.
+   * The built-in caching mechanism has reliability issues with the State API.
+   * See class documentation for migration examples.
    *
-   * @returns Headers object including authentication
-   * @private
-   */
-  getAuthenticatedHeaders() {
-    return {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${this.imsToken}`,
-      "x-gw-ims-org-id": this.imsOrgId
-    };
-  }
-  /**
-   * Performs a GET request to the Runtime API Gateway
+   * 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.
    *
-   * @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
+   * @returns A promise that resolves to the IMS token string or null if generation 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' });
+   * const token = await imsToken.execute();
+   * if (token) {
+   *   console.log('Token obtained:', token);
+   * }
    * ```
    */
-  async get(endpoint, additionalHeaders = {}) {
+  async execute() {
     try {
-      const url = this.buildEndpoint(endpoint);
-      this.customLogger.info(`Performing GET request to: ${url}`);
-      const headers = { ...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;
+      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) {
-      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}`);
+      this.customLogger.error(`Failed to execute IMS token generation: ${error.message}`);
+      return null;
     }
   }
   /**
-   * 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' });
+   * Generates a new IMS token from Adobe IMS service
    *
-   * // With additional headers
-   * const result = await service.post('v1/my-endpoint', { key: 'value' }, { 'Custom-Header': 'value' });
-   * ```
+   * @returns A promise that resolves to ImsTokenResult or null if generation fails
+   * @private
    */
-  async post(endpoint, payload, additionalHeaders = {}) {
+  async getImsToken() {
     try {
-      const url = this.buildEndpoint(endpoint);
-      this.customLogger.info(`Performing POST request to: ${url}`);
-      this.customLogger.debug(`POST payload: ${JSON.stringify(payload)}`);
-      const headers = { ...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;
+      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) {
-      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}`);
+      this.customLogger.error(`Failed to get IMS token: ${error.message}`);
+      return null;
     }
   }
   /**
-   * Performs a PUT request to the Runtime API Gateway
+   * Caches the IMS token in the state store with TTL
    *
-   * @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' });
+   * @deprecated This method has issues with State API reliability. Use application-level caching instead.
    *
-   * // With additional headers
-   * const updated = await service.put('v1/my-endpoint', { id: 1 }, { 'Custom-Header': 'value' });
-   * ```
+   * **Known Issues:**
+   * - State API may not be available in all runtime environments
+   * - Hard-coded 10-minute buffer may not suit all use cases
+   * - Minimum 60-minute TTL is opinionated and inflexible
+   * - No retry mechanism for State API failures
+   *
+   * @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 put(endpoint, payload, additionalHeaders = {}) {
+  async setValue(result) {
     try {
-      const url = this.buildEndpoint(endpoint);
-      this.customLogger.info(`Performing PUT request to: ${url}`);
-      this.customLogger.debug(`PUT payload: ${JSON.stringify(payload)}`);
-      const headers = { ...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;
+      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) {
-      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}`);
+      this.customLogger.error(`Failed to cache IMS token: ${error.message}`);
+      return true;
     }
   }
   /**
-   * Performs a DELETE request to the Runtime API Gateway
+   * Retrieves a cached IMS token from the state store
    *
-   * @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');
+   * @deprecated This method has issues with State API reliability. Use application-level caching instead.
    *
-   * // With additional headers
-   * const deleted = await service.delete('v1/my-endpoint', { 'Custom-Header': 'value' });
-   * ```
+   * **Known Issues:**
+   * - State API may not be available in all runtime environments
+   * - No validation of cached token expiry
+   * - Silent failures may return null without proper error context
+   *
+   * @returns A promise that resolves to the cached token string or null if not found
+   * @private
    */
-  async delete(endpoint, additionalHeaders = {}) {
+  async getValue() {
     try {
-      const url = this.buildEndpoint(endpoint);
-      this.customLogger.info(`Performing DELETE request to: ${url}`);
-      const headers = { ...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/framework/abdb/column/types.ts
-var AbdbColumnType = /* @__PURE__ */ ((AbdbColumnType2) => {
-  AbdbColumnType2["STRING"] = "STRING";
-  AbdbColumnType2["NUMBER"] = "NUMBER";
-  AbdbColumnType2["BOOLEAN"] = "BOOLEAN";
-  AbdbColumnType2["DATETIME"] = "DATETIME";
-  return AbdbColumnType2;
-})(AbdbColumnType || {});
-
-// src/framework/abdb/column/index.ts
-var ISO_8601_DATETIME = /^\d{4}-\d{2}-\d{2}([Tt ]\d{2}:\d{2}(:\d{2}(\.\d{1,9})?)?(Z|[+-]\d{2}(:?\d{2})?)?)?$/;
-var _AbdbColumn = class _AbdbColumn {
-  /**
-   * @param options - Field definition
-   * @throws {Error} When `name` is missing or blank, or `type` is missing / not a member of {@link AbdbColumnType}
-   */
-  constructor(options) {
-    if (!options?.name?.trim()) {
-      throw new Error('AbdbColumn: "name" is required and cannot be empty');
-    }
-    if (!options.type || !Object.values(AbdbColumnType).includes(options.type)) {
-      throw new Error('AbdbColumn: "type" is required');
-    }
-    this._name = options.name.trim();
-    this._type = options.type;
-    this._description = void 0;
-    this._isRequired = options.isRequired ?? false;
-    if (options.description !== void 0) {
-      const trimmed = options.description.trim();
-      if (trimmed.length > 0) {
-        this._description = trimmed;
+      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}`);
     }
-    Object.freeze(this);
-  }
-  /**
-   * Returns the trimmed field name.
-   */
-  getName() {
-    return this._name;
-  }
-  /**
-   * Returns the expected value type for this column.
-   */
-  getType() {
-    return this._type;
-  }
-  /**
-   * Returns the optional description, if one was provided and non-whitespace.
-   *
-   * @returns Description string, or `undefined` when not set
-   */
-  getDescription() {
-    return this._description;
+    return null;
   }
   /**
-   * Returns whether a value is mandatory for {@link AbdbColumn#validate}.
+   * Initializes and returns the state store instance
    *
-   * @returns `true` if constructed with `isRequired: true`; otherwise `false`
-   */
-  getIsRequired() {
-    return this._isRequired;
-  }
-  /**
-   * Serializes this column to a plain object for JSON (config files, APIs, persistence).
-   */
-  toJSON() {
-    const json = {
-      name: this._name,
-      type: this._type
-    };
-    if (this._description !== void 0) {
-      json.description = this._description;
-    }
-    if (this._isRequired) {
-      json.isRequired = true;
-    }
-    return json;
-  }
-  /**
-   * Creates a new column with the same or overridden options. Does not mutate this instance.
+   * @deprecated This method relies on State API which has reliability issues.
+   * Use application-level caching instead.
    *
-   * Passing `description: '   '` (blank / whitespace) clears the description on the new column.
+   * **Known Issues:**
+   * - State API initialization may fail silently
+   * - Not available outside Adobe I/O Runtime environments
+   * - Caches the state instance which may become stale
    *
-   * @param overrides - Partial options; omitted keys keep current values
-   * @returns A new {@link AbdbColumn} instance
+   * @returns A promise that resolves to the state instance or null if initialization fails
+   * @private
    */
-  clone(overrides = {}) {
-    const name = overrides.name ?? this._name;
-    const type = overrides.type ?? this._type;
-    const isRequired = overrides.isRequired ?? this._isRequired;
-    if (overrides.description !== void 0) {
-      return new _AbdbColumn({ name, type, description: overrides.description, isRequired });
-    }
-    if (this._description !== void 0) {
-      return new _AbdbColumn({ name, type, description: this._description, isRequired });
+  async getState() {
+    if (this.state === void 0) {
+      try {
+        this.customLogger.debug("Initializing State API for token caching");
+        this.state = await import_aio_sdk4.State.init();
+      } catch (error) {
+        this.customLogger.error(`Failed to initialize State API: ${error.message}`);
+        this.state = null;
+      }
     }
-    return new _AbdbColumn({ name, type, isRequired });
+    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 {
   /**
-   * Validates a payload value against this column's requiredness and {@link AbdbColumnType}.
-   *
-   * **Missing values** (`undefined`, `null`, or empty / whitespace-only strings) are handled first:
-   * if `isRequired` is `false`, validation succeeds; if `true`, throws.
-   *
-   * **Type rules** (when a non-missing value is present):
-   * - `STRING`: primitive string
-   * - `NUMBER`: finite number, or a non-empty string whose trim parses to a finite number via `Number`
-   * - `BOOLEAN`: primitive boolean, or non-empty trimmed string `"true"` / `"false"` (case-insensitive)
-   * - `DATETIME`: valid `Date`, finite numeric timestamp (ms), or non-empty trimmed ISO 8601 date/datetime string
+   * A completely raw method to make HTTP requests
    *
-   * @param value - Document field or API payload value
-   * @throws {Error} When required and missing, or when the value does not match the column type
+   * @param endpoint
+   * @param method
+   * @param headers
+   * @param payload
+   * @returns {Promise<Response>}
    */
-  validate(value) {
-    if (this._isMissingValue(value)) {
-      if (this._isRequired) {
-        throw new Error(`AbdbColumn: "${this._name}" is required`);
+  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";
       }
-      return;
-    }
-    switch (this._type) {
-      case "STRING" /* STRING */:
-        this._validateStringValue(value);
-        return;
-      case "NUMBER" /* NUMBER */:
-        this._validateNumberValue(value);
-        return;
-      case "BOOLEAN" /* BOOLEAN */:
-        this._validateBooleanValue(value);
-        return;
-      case "DATETIME" /* DATETIME */:
-        this._validateDateTimeValue(value);
-        return;
-      default: {
-        const _unreachable = this._type;
-        throw new Error(`AbdbColumn: unhandled type "${_unreachable}"`);
+      const requestHeaders = { ...headers };
+      if (contentType) {
+        requestHeaders["Content-Type"] = contentType;
       }
+      options = {
+        ...options,
+        body,
+        headers: requestHeaders
+      };
     }
+    return await (0, import_node_fetch.default)(endpoint, options);
   }
   /**
-   * Whether `value` counts as absent for requiredness checks (before type validation).
+   * A method to parse HTTP response
    *
-   * @returns `true` for `undefined`, `null`, or a string that is empty after trim
+   * @param response
+   * @returns {Promise<any>}
    */
-  _isMissingValue(value) {
-    if (value === void 0 || value === null) {
-      return true;
+  async parseResponse(response) {
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
     }
-    return typeof value === "string" && value.trim() === "";
-  }
-  /**
-   * @throws {Error} When `value` is not a primitive string
-   */
-  _validateStringValue(value) {
-    if (typeof value !== "string") {
-      throw new Error(`AbdbColumn: "${this._name}" expects string, got ${typeof value}`);
+    if (response.status === 204 || response.headers?.get("content-length") === "0") {
+      return null;
     }
-  }
-  /**
-   * @throws {Error} When not a finite number or numeric string
-   */
-  _validateNumberValue(value) {
-    if (typeof value === "number") {
-      if (Number.isFinite(value)) {
-        return;
+    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();
       }
-      throw new Error(`AbdbColumn: "${this._name}" expects a finite number, got ${String(value)}`);
     }
-    if (typeof value === "string") {
-      const trimmed = value.trim();
-      const n = Number(trimmed);
-      if (Number.isFinite(n)) {
-        return;
-      }
-      throw new Error(
-        `AbdbColumn: "${this._name}" expects a finite number or numeric string, got ${JSON.stringify(value)}`
-      );
+    if (typeof response.text === "function") {
+      const text = await response.text();
+      return text;
     }
-    throw new Error(
-      `AbdbColumn: "${this._name}" expects a finite number or numeric string, got ${typeof value}`
-    );
+    return null;
   }
   /**
-   * @throws {Error} When not a boolean or `"true"` / `"false"` string
+   * A generic method to make GET rest call
+   *
+   * @param endpoint
+   * @param headers
+   * @param parsed
+   * @returns {Promise<Response | any>}
    */
-  _validateBooleanValue(value) {
-    if (typeof value === "boolean") {
-      return;
-    }
-    if (typeof value === "string") {
-      const t = value.trim().toLowerCase();
-      if (t === "true" || t === "false") {
-        return;
-      }
-      throw new Error(
-        `AbdbColumn: "${this._name}" expects boolean or "true"/"false" string, got ${JSON.stringify(value)}`
-      );
-    }
-    throw new Error(
-      `AbdbColumn: "${this._name}" expects boolean or "true"/"false" string, got ${typeof value}`
-    );
+  async get(endpoint, headers = {}, parsed = true) {
+    const response = await this.makeRequest(endpoint, "GET", headers);
+    return parsed ? await this.parseResponse(response) : response;
   }
   /**
-   * @throws {Error} When not a valid `Date`, finite timestamp, or ISO 8601 string
+   * A generic method to make POST rest call
+   *
+   * @param endpoint
+   * @param headers
+   * @param payload
+   * @param parsed
+   * @returns {Promise<Response | any>}
    */
-  _validateDateTimeValue(value) {
-    if (value instanceof Date) {
-      if (!Number.isNaN(value.getTime())) {
-        return;
-      }
-      throw new Error(`AbdbColumn: "${this._name}" expects a valid Date`);
-    }
-    if (typeof value === "number") {
-      if (Number.isFinite(value)) {
-        return;
-      }
-      throw new Error(
-        `AbdbColumn: "${this._name}" expects a finite numeric timestamp, got ${value}`
-      );
-    }
-    if (typeof value === "string") {
-      const s = value.trim();
-      if (!ISO_8601_DATETIME.test(s)) {
-        throw new Error(
-          `AbdbColumn: "${this._name}" expects ISO 8601 datetime string, got ${JSON.stringify(value)}`
-        );
-      }
-      const t = Date.parse(s);
-      if (Number.isNaN(t)) {
-        throw new Error(
-          `AbdbColumn: "${this._name}" expects ISO 8601 datetime string, got ${JSON.stringify(value)}`
-        );
-      }
-      return;
-    }
-    throw new Error(
-      `AbdbColumn: "${this._name}" expects Date, finite numeric timestamp, or ISO 8601 datetime string, got ${typeof value}`
-    );
+  async post(endpoint, headers = {}, payload = null, parsed = true) {
+    const response = await this.makeRequest(endpoint, "POST", headers, payload);
+    return parsed ? await this.parseResponse(response) : response;
   }
-};
-__name(_AbdbColumn, "AbdbColumn");
-var AbdbColumn = _AbdbColumn;
-var column_default = AbdbColumn;
-
-// src/framework/abdb/collection/index.ts
-var import_aio_lib_db = require("@adobe/aio-lib-db");
-var _AbdbCollection = class _AbdbCollection {
   /**
-   * Creates a collection and optionally configures it in a callback (e.g. chained {@link addColumn} calls).
+   * A generic method to make PUT rest call
    *
-   * @param name - Raw collection name; trimmed and validated
-   * @param callback - Optional function invoked with `this` for fluent setup
-   * @throws {Error} When `name` is empty, whitespace-only, or contains invalid characters
+   * @param endpoint
+   * @param headers
+   * @param payload
+   * @param parsed
+   * @returns {Promise<Response | any>}
    */
-  constructor(name, callback) {
-    this._name = this._validateCollectionName(name);
-    this._columns = /* @__PURE__ */ new Map();
-    if (callback) {
-      callback(this);
-    }
+  async put(endpoint, headers = {}, payload = null, parsed = true) {
+    const response = await this.makeRequest(endpoint, "PUT", headers, payload);
+    return parsed ? await this.parseResponse(response) : response;
   }
   /**
-   * Returns this collection's name.
+   * A generic method to make DELETE rest call
+   *
+   * @param endpoint
+   * @param headers
+   * @param parsed
+   * @returns {Promise<Response | any>}
    */
-  getName() {
-    return this._name;
+  async delete(endpoint, headers = {}, parsed = true) {
+    const response = await this.makeRequest(endpoint, "DELETE", headers);
+    return parsed ? await this.parseResponse(response) : response;
   }
-  addColumn(name, type, descriptionOrOptions, isRequired) {
-    const trimmed = this._validateColumnName(name);
-    if (this._columns.has(trimmed)) {
-      throw new Error(`AbdbCollection: duplicate column name "${trimmed}"`);
+  /**
+   * A generic method to make rest call
+   *
+   * @param endpoint
+   * @param method
+   * @param headers
+   * @param payload
+   * @returns {Promise<any>}
+   * @deprecated Use makeRequest() and parseResponse() methods instead
+   */
+  async apiCall(endpoint, method = "POST", headers = {}, payload = null) {
+    let options = {
+      method,
+      headers
+    };
+    if (payload !== null) {
+      options = {
+        ...options,
+        body: JSON.stringify(payload),
+        headers: {
+          ...headers,
+          "Content-Type": "application/json"
+        }
+      };
     }
-    const columnOptions = { name: trimmed, type };
-    if (typeof descriptionOrOptions === "string") {
-      columnOptions.description = descriptionOrOptions;
-      if (isRequired !== void 0) {
-        columnOptions.isRequired = isRequired;
-      }
-    } else if (descriptionOrOptions !== void 0) {
-      if (descriptionOrOptions.description !== void 0) {
-        columnOptions.description = descriptionOrOptions.description;
-      }
-      if (descriptionOrOptions.isRequired !== void 0) {
-        columnOptions.isRequired = descriptionOrOptions.isRequired;
+    const response = await (0, import_node_fetch.default)(endpoint, options);
+    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();
       }
     }
-    this._columns.set(trimmed, new column_default(columnOptions));
-    return this;
+    if (typeof response.text === "function") {
+      const text = await response.text();
+      return text;
+    }
+    return null;
   }
+};
+__name(_RestClient, "RestClient");
+var RestClient = _RestClient;
+var rest_client_default = RestClient;
+
+// src/framework/runtime-api-gateway-service/index.ts
+var _RuntimeApiGatewayService = class _RuntimeApiGatewayService {
   /**
-   * Returns a defensive copy of columns in insertion order.
+   * Creates an instance of RuntimeApiGatewayService
+   *
+   * @param namespace - The Adobe I/O Runtime namespace identifier
+   * @param imsOrgId - IMS organization ID
+   * @param imsToken - Bearer token string for authentication
+   * @param logger - Optional logger instance for logging operations
+   * @example
+   * ```typescript
+   * const service = new RuntimeApiGatewayService(
+   *   'test-namespace',
+   *   'org-id@AdobeOrg',
+   *   'bearer-token-string',
+   *   logger
+   * );
+   * ```
    */
-  getColumns() {
-    return Array.from(this._columns.values());
+  constructor(namespace, imsOrgId, imsToken, logger = null) {
+    this.namespace = namespace;
+    this.imsOrgId = imsOrgId;
+    this.imsToken = imsToken;
+    this.restClient = new rest_client_default();
+    this.customLogger = new custom_logger_default(logger);
   }
   /**
-   * Returns the column registered under `name`, or `undefined` if no such column exists.
+   * Builds the complete API endpoint URL
    *
-   * @param name - Column name to look up (exact match after trimming)
-   * @returns The {@link AbdbColumn} instance, or `undefined`
+   * @param endpoint - API endpoint path (e.g., 'v1/my-endpoint')
+   * @returns The fully constructed endpoint URL
+   * @private
    */
-  getColumn(name) {
-    return this._columns.get(name.trim());
+  buildEndpoint(endpoint) {
+    return `${_RuntimeApiGatewayService.BASE_URL}/${this.namespace}/${endpoint}`;
   }
   /**
-   * Returns `true` when a column with the given name has been registered.
+   * Gets the authenticated headers for API requests
    *
-   * @param name - Column name to check (exact match after trimming)
+   * @returns Headers object including authentication
+   * @private
    */
-  hasColumn(name) {
-    return this._columns.has(name.trim());
+  getAuthenticatedHeaders() {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.imsToken}`,
+      "x-gw-ims-org-id": this.imsOrgId
+    };
   }
   /**
-   * Validates a document-style object against this collection's columns. Throws on the **first** failing
-   * column. Use {@link validateAll} when you need all errors reported at once.
+   * Performs a GET request to the Runtime API Gateway
    *
-   * Missing keys are read as `undefined`, so a **required** column whose key is absent fails validation.
-   * Extra keys not matching any column name are ignored.
+   * @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');
    *
-   * @param record - Key/value payload whose keys are column names
-   * @throws {Error} When any column validation fails (requiredness or type)
+   * // With additional headers
+   * const data = await service.get('v1/my-endpoint', { 'Custom-Header': 'value' });
+   * ```
    */
-  validate(record) {
-    for (const col of this._columns.values()) {
-      col.validate(record[col.getName()]);
+  async get(endpoint, additionalHeaders = {}) {
+    try {
+      const url = this.buildEndpoint(endpoint);
+      this.customLogger.info(`Performing GET request to: ${url}`);
+      const headers = { ...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}`);
     }
   }
   /**
-   * Validates a document-style object against **all** columns and collects every error instead of
-   * stopping at the first failure. Useful at API boundaries where reporting all problems at once
-   * gives a better developer or end-user experience.
-   *
-   * Returns an empty array when the record is fully valid.
-   *
-   * @param record - Key/value payload whose keys are column names
-   * @returns Array of validation error messages, one per failing column (insertion order)
+   * 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 errors = orders.validateAll(payload);
-   * if (errors.length > 0) {
-   *   return { status: 400, body: { errors } };
-   * }
+   * 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' });
    * ```
    */
-  validateAll(record) {
-    const errors = [];
-    for (const col of this._columns.values()) {
-      try {
-        col.validate(record[col.getName()]);
-      } catch (e) {
-        errors.push(e instanceof Error ? e.message : String(e));
-      }
+  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 = { ...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}`);
     }
-    return errors;
   }
   /**
-   * Connects to the database (via `@adobe/aio-lib-db`), runs `callback` with the selected DB **collection**
-   * handle and the **client**, then closes the client in a `finally` block.
+   * Performs a PUT request to the Runtime API Gateway
    *
-   * **Errors:** `DbError` instances are rethrown as `AbdbCollection: database error: …`;
-   * any other value is wrapped as `AbdbCollection: unexpected error: …`.
+   * @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' });
    *
-   * @param callback - Receives `(collection, client)` after connect
-   * @param token - IMS access token for `initDb`
-   * @param region - Data region (default: `'amer'`)
-   * @returns Promise resolving to the callback's return value
-   * @throws {Error} On init, connect, `DbError`, or callback failure
+   * // With additional headers
+   * const updated = await service.put('v1/my-endpoint', { id: 1 }, { 'Custom-Header': 'value' });
+   * ```
    */
-  async run(callback, token, region = "amer") {
-    let client;
+  async put(endpoint, payload, additionalHeaders = {}) {
     try {
-      const db = await (0, import_aio_lib_db.init)({ token, region });
-      client = await db.connect();
-      const collection = await client.collection(this._name);
-      return await callback(collection, client);
+      const url = this.buildEndpoint(endpoint);
+      this.customLogger.info(`Performing PUT request to: ${url}`);
+      this.customLogger.debug(`PUT payload: ${JSON.stringify(payload)}`);
+      const headers = { ...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) {
-      if (error instanceof import_aio_lib_db.DbError) {
-        throw new Error(`AbdbCollection: database error: ${error.message}`);
-      }
-      const detail = error instanceof Error ? error.message : String(error);
-      throw new Error(`AbdbCollection: unexpected error: ${detail}`);
-    } finally {
-      await client?.close();
+      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}`);
     }
   }
   /**
-   * Validates and normalizes the collection identifier used at construction.
-   *
-   * @throws {Error} If the name is empty or not `[a-zA-Z0-9_]`
-   */
-  _validateCollectionName(name) {
-    return this._validateIdentifier(
-      name,
-      'AbdbCollection: "name" is required and cannot be empty',
-      "AbdbCollection: name must contain only alphanumeric characters and underscores"
-    );
-  }
-  /**
-   * Validates and normalizes a column name before {@link addColumn} stores it.
+   * Performs a DELETE request to the Runtime API Gateway
    *
-   * @throws {Error} If the name is empty or not `[a-zA-Z0-9_]`
-   */
-  _validateColumnName(name) {
-    return this._validateIdentifier(
-      name,
-      'AbdbCollection: column "name" is required and cannot be empty',
-      "AbdbCollection: column name must contain only alphanumeric characters and underscores"
-    );
-  }
-  /**
-   * Shared validation for collection and column identifiers.
+   * @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');
    *
-   * @param raw - Unvalidated string
-   * @param emptyMessage - Thrown when `raw` is missing or whitespace-only
-   * @param invalidMessage - Thrown when the trimmed value is not alphanumeric with underscores
-   * @returns The trimmed identifier
+   * // With additional headers
+   * const deleted = await service.delete('v1/my-endpoint', { 'Custom-Header': 'value' });
+   * ```
    */
-  _validateIdentifier(raw, emptyMessage, invalidMessage) {
-    if (!raw || raw.trim() === "") {
-      throw new Error(emptyMessage);
-    }
-    const trimmed = raw.trim();
-    if (!/^[a-zA-Z0-9_]+$/.test(trimmed)) {
-      throw new Error(invalidMessage);
+  async delete(endpoint, additionalHeaders = {}) {
+    try {
+      const url = this.buildEndpoint(endpoint);
+      this.customLogger.info(`Performing DELETE request to: ${url}`);
+      const headers = { ...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}`);
     }
-    return trimmed;
   }
 };
-__name(_AbdbCollection, "AbdbCollection");
-var AbdbCollection = _AbdbCollection;
-var collection_default = AbdbCollection;
+__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_sdk5 = require("@adobe/aio-sdk");
@@ -9292,6 +9527,7 @@ var AdminUiSdk = _AdminUiSdk;
   AbdbCollection,
   AbdbColumn,
   AbdbColumnType,
+  AbdbRepository,
   AdminUiSdk,
   AdobeAuth,
   AdobeCommerceClient,