@adobe/aio-commerce-lib-app 0.2.0 → 0.3.0

package/dist/cjs/actions/index.d.cts

@@ -1,5 +1,5 @@
-import { r as CommerceAppConfigOutputModel } from "../app-C4HhkXbP.cjs";
-import { P as InstallationContext } from "../index-DS3IlISO.cjs";
+import { n as CommerceAppConfigOutputModel } from "../app-Dx0ca6oL.cjs";
+import { P as InstallationContext } from "../index-C5SutkJQ.cjs";
 import * as _adobe_aio_commerce_lib_core_responses0 from "@adobe/aio-commerce-lib-core/responses";
 import { RuntimeActionParams } from "@adobe/aio-commerce-lib-core/params";
 

package/dist/cjs/app-Dx0ca6oL.d.cts

@@ -0,0 +1,181 @@
+import * as v from "valibot";
+
+//#region source/config/schema/app.d.ts
+/** The schema used to validate the commerce app config file. */
+declare const CommerceAppConfigSchema: v.LooseObjectSchema<{
+  readonly metadata: v.ObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.RegexAction<string, `Only alphanumeric characters and hyphens are allowed in string value of "${string}"${string}`>]>;
+    readonly displayName: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string for the ${string}`>, v.NonEmptyAction<string, `The ${string} must not be empty`>]>, v.MaxLengthAction<string, 50, "The application display name must not be longer than 50 characters">]>;
+    readonly description: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string for the ${string}`>, v.NonEmptyAction<string, `The ${string} must not be empty`>]>, v.MaxLengthAction<string, 255, "The metadata description must not be longer than 255 characters">]>;
+    readonly version: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string for the ${string}`>, v.NonEmptyAction<string, `The ${string} must not be empty`>]>, v.RegexAction<string, "The version must follow semantic versioning (semver) format">]>;
+  }, undefined>;
+  readonly businessConfig: v.OptionalSchema<v.ObjectSchema<{
+    readonly schema: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.VariantSchema<"type", [v.VariantSchema<"selectionMode", [v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"list", "Expected the type to be 'list'">;
+      readonly selectionMode: v.LiteralSchema<"single", "Expected the selectionMode to be 'single'">;
+      readonly options: v.ArraySchema<v.ObjectSchema<{
+        readonly label: v.StringSchema<"Expected a string for the option label">;
+        readonly value: v.StringSchema<"Expected a string for the option value">;
+      }, undefined>, "Expected an array of list options">;
+      readonly default: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the default value">, v.NonEmptyAction<string, "The default value must not be empty">]>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"list", "Expected the type to be 'list'">;
+      readonly selectionMode: v.LiteralSchema<"multiple", "Expected the selectionMode to be 'multiple'">;
+      readonly options: v.ArraySchema<v.ObjectSchema<{
+        readonly label: v.StringSchema<"Expected a string for the option label">;
+        readonly value: v.StringSchema<"Expected a string for the option value">;
+      }, undefined>, "Expected an array of list options">;
+      readonly default: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for each default value">, v.NonEmptyAction<string, "Each default value must not be empty">]>, "Expected an array of default values">, readonly []>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>], undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"text", "Expected the type to be 'text'">;
+      readonly default: v.OptionalSchema<v.StringSchema<"Expected a string for the default value">, undefined>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"password", "Expected the type to be 'password'">;
+      readonly default: v.OptionalSchema<v.StringSchema<"Expected a string for the default value">, undefined>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"email", "Expected the type to be 'email'">;
+      readonly default: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the default email value">, v.EmailAction<string, "The email must be a valid email address">]>, undefined>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"url", "Expected the type to be 'url'">;
+      readonly default: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the default URL value">, v.UrlAction<string, "The URL must be a valid URL">]>, undefined>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"tel", "Expected the type to be 'tel'">;
+      readonly default: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the default phone number value">, v.RegexAction<string, "The phone number must contain only numbers and/or country codes">]>, undefined>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>], undefined>, "Expected an array of configuration fields">, v.MinLengthAction<({
+      type: "list";
+      selectionMode: "single";
+      options: {
+        label: string;
+        value: string;
+      }[];
+      default: string;
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    } | {
+      type: "list";
+      selectionMode: "multiple";
+      options: {
+        label: string;
+        value: string;
+      }[];
+      default: string[];
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    } | {
+      type: "text";
+      default?: string | undefined;
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    } | {
+      type: "password";
+      default?: string | undefined;
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    } | {
+      type: "email";
+      default?: string | undefined;
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    } | {
+      type: "url";
+      default?: string | undefined;
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    } | {
+      type: "tel";
+      default?: string | undefined;
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    })[], 1, "At least one configuration parameter is required">]>, readonly []>;
+  }, undefined>, undefined>;
+  readonly eventing: v.OptionalSchema<v.ObjectSchema<{
+    readonly commerce: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly provider: v.ObjectSchema<{
+        readonly label: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 100, "The provider label must not be longer than 100 characters">]>;
+        readonly description: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 255, "The provider description must not be longer than 255 characters">]>;
+        readonly key: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.RegexAction<string, `Only alphanumeric characters and hyphens are allowed in string value of "${string}"${string}`>]>, v.MaxLengthAction<string, 50, "The provider key must not be longer than 50 characters">]>, undefined>;
+      }, undefined>;
+      readonly events: v.ArraySchema<v.ObjectSchema<{
+        readonly name: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, "Event name must start with \"plugin.\" or \"observer.\" followed by lowercase letters and underscores only (e.g., \"plugin.order_placed\")">]>;
+        readonly fields: v.ArraySchema<v.ObjectSchema<{
+          readonly name: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, "Field name must contain only letters (a-z, A-Z), numbers (0-9), underscores (_), dashes (-), dots (.), and square brackets ([, ]), or be exactly \"*\"">]>;
+          readonly source: v.OptionalSchema<v.StringSchema<`Expected a string value for '${string}'`>, undefined>;
+        }, undefined>, "Expected an array of event field objects with a 'name' property">;
+        readonly rules: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+          readonly field: v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>;
+          readonly operator: v.UnionSchema<v.LiteralSchema<"regex" | "greaterThan" | "lessThan" | "equal" | "in" | "onChange", undefined>[], `Operator must be one of: ${string}`>;
+          readonly value: v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>;
+        }, undefined>, "Expected an array of event rules with field, operator, and value">, undefined>;
+        readonly destination: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, undefined>;
+        readonly hipaaAuditRequired: v.OptionalSchema<v.BooleanSchema<`Expected a boolean value for '${string}'`>, undefined>;
+        readonly prioritary: v.OptionalSchema<v.BooleanSchema<`Expected a boolean value for '${string}'`>, undefined>;
+        readonly force: v.OptionalSchema<v.BooleanSchema<`Expected a boolean value for '${string}'`>, undefined>;
+        readonly label: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 100, "The event label must not be longer than 100 characters">]>;
+        readonly description: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 255, "The event description must not be longer than 255 characters">]>;
+        readonly runtimeActions: v.ArraySchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, "Runtime action must be in the format \"<package>/<action>\" (e.g., \"my-package/my-action\")">]>, "Expected an array of runtime actions in the format <package>/<action>">;
+      }, undefined>, "Expected an array of Commerce events">;
+    }, undefined>, "Expected an array of Commerce event sources">, undefined>;
+    readonly external: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly provider: v.ObjectSchema<{
+        readonly label: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 100, "The provider label must not be longer than 100 characters">]>;
+        readonly description: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 255, "The provider description must not be longer than 255 characters">]>;
+        readonly key: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.RegexAction<string, `Only alphanumeric characters and hyphens are allowed in string value of "${string}"${string}`>]>, v.MaxLengthAction<string, 50, "The provider key must not be longer than 50 characters">]>, undefined>;
+      }, undefined>;
+      readonly events: v.ArraySchema<v.ObjectSchema<{
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.RegexAction<string, `Only alphanumeric characters and underscores are allowed in string value of "${string}"${string}`>]>;
+        readonly label: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 100, "The event label must not be longer than 100 characters">]>;
+        readonly description: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 255, "The event description must not be longer than 255 characters">]>;
+        readonly runtimeActions: v.ArraySchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, "Runtime action must be in the format \"<package>/<action>\" (e.g., \"my-package/my-action\")">]>, "Expected an array of runtime actions in the format <package>/<action>">;
+      }, undefined>, "Expected an array of external events">;
+    }, undefined>, "Expected an array of external event sources">, undefined>;
+  }, undefined>, undefined>;
+  readonly installation: v.OptionalSchema<v.ObjectSchema<{
+    readonly messages: v.OptionalSchema<v.ObjectSchema<{
+      readonly preInstallation: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 1000, "The preInstallation message must not be longer than 1000 characters">]>, undefined>;
+      readonly postInstallation: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 1000, "The postInstallation message must not be longer than 1000 characters">]>, undefined>;
+    }, undefined>, undefined>;
+    readonly customInstallationSteps: v.SchemaWithPipe<readonly [v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly script: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, "Script path must end with .js (e.g., \"./setup.js\", \"./scripts/setup.js\", or \"../../scripts/setup.js\")">]>;
+      readonly name: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 255, "The step name must not be longer than 255 characters">]>;
+      readonly description: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 255, "The step description must not be longer than 255 characters">]>;
+    }, undefined>, "Expected an array of custom installation steps">, undefined>, v.CheckAction<{
+      script: string;
+      name: string;
+      description: string;
+    }[] | undefined, "Duplicate step names detected in custom installation steps. Each step must have a unique name.">]>;
+  }, undefined>, undefined>;
+}, undefined>;
+/** The input shape of the commerce app config schema. */
+type CommerceAppConfig = v.InferInput<typeof CommerceAppConfigSchema>;
+/** The output shape of the commerce app config schema. */
+type CommerceAppConfigOutputModel = v.InferOutput<typeof CommerceAppConfigSchema>;
+//#endregion
+export { CommerceAppConfigOutputModel as n, CommerceAppConfig as t };

package/dist/cjs/commands/generate/actions/templates/business-configuration/get-config-schema.js.template

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2025 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// This file has been auto-generated by `@adobe/aio-commerce-lib-config`
+// Do not modify this file directly
+
+import util from "node:util";
+
+import { getConfigSchema } from "@adobe/aio-commerce-lib-config";
+import {
+  internalServerError,
+  ok,
+} from "@adobe/aio-commerce-sdk/core/responses";
+import AioLogger from "@adobe/aio-lib-core-logging";
+
+// Shorthand to inspect an object.
+const inspect = (obj) => util.inspect(obj, { depth: null });
+
+/**
+ * Get the configuration schema.
+ * @returns The response object containing the configuration schema.
+ */
+export async function main(params) {
+  const logger = AioLogger("get-config-schema", {
+    level: params.LOG_LEVEL || "info",
+  });
+
+  try {
+    logger.debug("Retrieving configuration schema...");
+    const configSchema = await getConfigSchema();
+
+    logger.debug(
+      `Successfully retrieved configSchema: ${inspect(configSchema)}`,
+    );
+
+    return ok({
+      body: {
+        configSchema,
+      },
+    });
+  } catch (error) {
+    logger.error(
+      `Something wen't wrong while retrieving config schema: ${inspect(error)}`,
+    );
+
+    return internalServerError({
+      body: {
+        code: "INTERNAL_ERROR",
+        details: error instanceof Error ? error.message : "Unknown error",
+        message: "An internal server error occurred",
+      },
+    });
+  }
+}

package/dist/cjs/commands/generate/actions/templates/business-configuration/get-configuration.js.template

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2025 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// This file has been auto-generated by `@adobe/aio-commerce-lib-config`
+// Do not modify this file directly
+
+import util from "node:util";
+
+import {
+  byCode,
+  byCodeAndLevel,
+  byScopeId,
+  getConfiguration,
+  setGlobalLibConfigOptions,
+} from "@adobe/aio-commerce-lib-config";
+import {
+  badRequest,
+  internalServerError,
+  ok,
+} from "@adobe/aio-commerce-sdk/core/responses";
+import AioLogger from "@adobe/aio-lib-core-logging";
+
+// Shorthand to inspect an object.
+const inspect = (obj) => util.inspect(obj, { depth: null });
+
+/**
+ * Get the configuration.
+ * @param params - The input parameters.
+ * @returns The response object containing the configuration data.
+ */
+export async function main(params) {
+  const logger = AioLogger("get-configuration", {
+    level: params.LOG_LEVEL || "info",
+  });
+
+  try {
+   if (params.AIO_COMMERCE_CONFIG_ENCRYPTION_KEY) {
+      setGlobalLibConfigOptions({
+        encryptionKey: params.AIO_COMMERCE_CONFIG_ENCRYPTION_KEY,
+     });
+    }
+
+    const id = params.id;
+    const code = params.code;
+    const level = params.level;
+
+    logger.debug(
+      `Retrieving configuration with params: ${inspect({ id, code, level })}`,
+    );
+
+    if (!(id || code)) {
+      logger.warn("Invalid params: Either id or code query param is required");
+      return badRequest({
+        body: {
+          code: "INVALID_PARAMS",
+          message: "Either id or code query param is required",
+        },
+      });
+    }
+
+    let appConfiguration;
+    if (id) {
+      logger.debug(`Retrieving configuration by id: ${id}`);
+      appConfiguration = await getConfiguration(byScopeId(id));
+    } else if (level) {
+      logger.debug(
+        `Retrieving configuration by code: ${code}, level: ${level}`,
+      );
+
+      appConfiguration = await getConfiguration(byCodeAndLevel(code, level));
+    } else {
+      logger.debug(`Retrieving configuration by code: ${code}`);
+      appConfiguration = await getConfiguration(byCode(code));
+    }
+
+    logger.debug(
+      `Successfully retrieved configuration: ${inspect(appConfiguration)}`,
+    );
+
+    return ok({ body: appConfiguration });
+  } catch (error) {
+    logger.error(
+      `Something went wrong while retrieving configuration: ${inspect(error)}`,
+    );
+
+    return internalServerError({
+      body: {
+        code: "INTERNAL_ERROR",
+        details: error instanceof Error ? error.message : "Unknown error",
+
+        message: "An internal server error occurred",
+      },
+    });
+  }
+}

package/dist/cjs/commands/generate/actions/templates/business-configuration/get-scope-tree.js.template

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2025 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// This file has been auto-generated by `@adobe/aio-commerce-lib-config`
+// Do not modify this file directly
+
+import util from "node:util";
+
+import { getScopeTree } from "@adobe/aio-commerce-lib-config";
+import {
+  internalServerError,
+  nonAuthoritativeInformation,
+  ok,
+} from "@adobe/aio-commerce-sdk/core/responses";
+import AioLogger from "@adobe/aio-lib-core-logging";
+
+// Shorthand to inspect an object.
+const inspect = (obj) => util.inspect(obj, { depth: null });
+
+/**
+ * Get scope tree.
+ * @returns The response object containing persisted scope tree configuration from cache/storage.
+ */
+export async function main(params) {
+  const logger = AioLogger("get-scope-tree", {
+    level: params.LOG_LEVEL || "info",
+  });
+
+  try {
+    logger.debug("Retrieving scope tree...");
+
+    const result = await getScopeTree();
+    logger.debug(
+      `Successfully retrieved scope tree (cached: ${result.isCachedData}): ${inspect(result.scopeTree)}`,
+    );
+
+    if (result.isCachedData) {
+      return nonAuthoritativeInformation({
+        headers: { "x-cache": "hit" },
+        body: { scopes: result.scopeTree },
+      });
+    }
+
+    return ok({
+      body: { scopes: result.scopeTree },
+    });
+  } catch (error) {
+    logger.error(
+      `Something went wrong while retrieving scope tree: ${inspect(error)}`,
+    );
+
+    return internalServerError({
+      body: {
+        code: "INTERNAL_ERROR",
+        message: "An internal server error occurred",
+        details: error instanceof Error ? error.message : "Unknown error",
+      },
+    });
+  }
+}

package/dist/cjs/commands/generate/actions/templates/business-configuration/set-configuration.js.template

@@ -0,0 +1,125 @@
+// @ts-check
+
+/*
+ * Copyright 2025 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// This file has been auto-generated by `@adobe/aio-commerce-lib-config`
+// Do not modify this file directly
+
+import util from "node:util";
+
+import {
+  byCodeAndLevel,
+  byScopeId,
+  setConfiguration,
+  setGlobalLibConfigOptions,
+} from "@adobe/aio-commerce-lib-config";
+import {
+  badRequest,
+  internalServerError,
+  ok,
+} from "@adobe/aio-commerce-sdk/core/responses";
+import AioLogger from "@adobe/aio-lib-core-logging";
+
+// Shorthand to inspect an object.
+const inspect = (obj) => util.inspect(obj, { depth: null });
+
+/**
+ * Get the configuration.
+ * @param params - The input parameters.
+ * @returns The response object containing the updated configuration values.
+ */
+export async function main(params) {
+  const logger = AioLogger("set-configuration", {
+    level: params.LOG_LEVEL || "info",
+  });
+
+  try {
+    if (params.AIO_COMMERCE_CONFIG_ENCRYPTION_KEY) {
+      setGlobalLibConfigOptions({
+        encryptionKey: params.AIO_COMMERCE_CONFIG_ENCRYPTION_KEY,
+      });
+    }
+    let body;
+
+    if (
+      params &&
+      typeof params === "object" &&
+      Object.keys(params).length === 0
+    ) {
+      body = {};
+    }
+
+    const id = params.id;
+    const code = params.code;
+    const level = params.level;
+
+    logger.debug(
+      `Setting configuration with params: ${inspect({ id, code, level })}`,
+    );
+
+    if (!(id || (code && level))) {
+      logger.warn(
+        "Invalid params: Either id or both code and level query params are required",
+      );
+
+      return badRequest({
+        body: {
+          code: "INVALID_PARAMS",
+          message: "Either id or both code and level query params are required",
+        },
+      });
+    }
+
+    const candidateConfig = params.config ?? body?.config;
+    if (!(candidateConfig && Array.isArray(candidateConfig))) {
+      logger.warn(
+        "Invalid body: request must include a config array in params.config or body.config",
+      );
+
+      return badRequest({
+        body: {
+          code: "INVALID_BODY",
+          message:
+            "request must include a config array in params.config or body.config",
+        },
+      });
+    }
+
+    const payload = { config: candidateConfig };
+    logger.debug(`Setting configuration with payload: ${inspect(payload)}`);
+
+    const result = id
+      ? await setConfiguration(payload, byScopeId(id))
+      : await setConfiguration(payload, byCodeAndLevel(code, level));
+
+    logger.debug(`Successfully set configuration: ${inspect(result)}`);
+    return ok({
+      body: { result },
+      headers: {
+        "Cache-Control": "no-store",
+      },
+    });
+  } catch (error) {
+    logger.error(
+      `Something went wrong while setting configuration: ${inspect(error)}`,
+    );
+
+    return internalServerError({
+      body: {
+        code: "INTERNAL_ERROR",
+        message: "An internal server error occurred",
+        details: error instanceof Error ? error.message : "Unknown error",
+      },
+    });
+  }
+}

package/dist/cjs/commands/generate/actions/templates/business-configuration/set-custom-scope-tree.js.template

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2025 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// This file has been auto-generated by `@adobe/aio-commerce-lib-config`
+// Do not modify this file directly
+
+import util from "node:util";
+
+import { setCustomScopeTree } from "@adobe/aio-commerce-lib-config";
+import {
+  badRequest,
+  internalServerError,
+  ok,
+} from "@adobe/aio-commerce-sdk/core/responses";
+import AioLogger from "@adobe/aio-lib-core-logging";
+
+// Shorthand to inspect an object.
+const inspect = (obj) => util.inspect(obj, { depth: null });
+
+/**
+ * Set custom scope tree - replace all custom scopes with provided ones
+ * @param params - The input parameters containing scopes array
+ * @returns The response object containing updated custom scopes
+ */
+export async function main(params) {
+  const logger = AioLogger("set-custom-scope-tree", {
+    level: params.LOG_LEVEL || "info",
+  });
+
+  try {
+    const scopes = params.scopes;
+    logger.debug(
+      `Setting custom scope tree with ${scopes?.length || 0} scopes`,
+    );
+
+    if (!scopes) {
+      logger.warn("Invalid request: Request must include scopes parameter");
+      return badRequest({
+        body: {
+          code: "INVALID_REQUEST",
+          message: "Request must include scopes parameter",
+          details: "Expected: { scopes: [array of scope objects] }",
+        },
+      });
+    }
+
+    const request = { scopes };
+    logger.debug(`Setting custom scope tree: ${inspect(request)}`);
+
+    const result = await setCustomScopeTree(request);
+    logger.debug(`Successfully set custom scope tree: ${inspect(result)}`);
+
+    return ok({
+      body: { result },
+      headers: {
+        "Cache-Control": "no-store",
+      },
+    });
+  } catch (error) {
+    logger.error(
+      `Something went wrong while updating custom scope tree: ${inspect(error)}`,
+    );
+
+    return internalServerError({
+      body: {
+        code: "INTERNAL_ERROR",
+        details: error instanceof Error ? error.message : "Unknown error",
+
+        message:
+          "An internal server error occurred while updating custom scope tree",
+      },
+    });
+  }
+}