@adobe/aio-commerce-lib-app 0.3.2 → 1.0.1

package/dist/cjs/{management-Dm5h0E6l.cjs → runner-NHMvoMO2.cjs}

@@ -1,7 +1,9 @@
-const require_error = require('./error-Byj1DVHZ.cjs');
-const require_logging = require('./logging-DYwr5WQk.cjs');
+const require_schemas = require('./schemas-CZ6c8Id9.cjs');
+const require_installation = require('./installation-CLbceU9F.cjs');
+const require_error = require('./error-DJ2UAPH2.cjs');
+const require_logging = require('./logging-IDRQG0as.cjs');
 let camelcase = require("camelcase");
-camelcase = require_error.__toESM(camelcase);
+camelcase = require_schemas.__toESM(camelcase);
 let _adobe_aio_commerce_lib_auth = require("@adobe/aio-commerce-lib-auth");
 let _adobe_aio_commerce_lib_api = require("@adobe/aio-commerce-lib-api");
 let _adobe_aio_commerce_lib_events_commerce = require("@adobe/aio-commerce-lib-events/commerce");
@@ -330,7 +332,7 @@ function createCustomScriptStep(scriptConfig) {
 * defined in the configuration. Each script becomes a separate leaf step.
 */
 function createCustomScriptSteps(config) {
-	if (!require_error.hasCustomInstallationSteps(config)) return [];
+	if (!require_installation.hasCustomInstallationSteps(config)) return [];
 	const steps = config.installation.customInstallationSteps;
 	if (new Set(steps.map((step) => step.name)).size !== steps.length) throw new Error("Duplicate step names detected in custom installation steps. Each step must have a unique name.");
 	return steps.map((scriptConfig) => createCustomScriptStep(scriptConfig));
@@ -345,7 +347,7 @@ const customInstallationStepBase = defineBranchStep({
 		label: "Custom Installation Steps",
 		description: "Executes custom installation scripts defined in the application configuration"
 	},
-	when: require_error.hasCustomInstallationSteps,
+	when: require_installation.hasCustomInstallationSteps,
 	children: []
 });
 /**
@@ -559,9 +561,9 @@ async function getIoEventsExistingData(context) {
 	});
 	const providersWithMetadata = existingProviders.map((providerHal) => {
 		const { _embedded, _links, ...providerData } = providerHal;
-		const actualMetadata = (_embedded?.eventmetadata ?? []).map(({ _embedded: _embedded$1, _links: _links$1, ...meta }) => ({
+		const actualMetadata = (_embedded?.eventmetadata ?? []).map(({ _embedded, _links, ...meta }) => ({
 			...meta,
-			sample: _embedded$1?.sample_event ?? null
+			sample: _embedded?.sample_event ?? null
 		}));
 		return {
 			...providerData,
@@ -750,13 +752,13 @@ async function configureCommerceEventing(params, existingData) {
 		enabled: true
 	};
 	if (existingData.isDefaultWorkspaceConfigurationEmpty) {
-		if (!config.workspaceConfiguration) {
+		if (!config.workspace_configuration) {
 			const message = "Workspace configuration is required to enable Commerce Eventing when there is not an existing one.";
 			logger.error(message);
 			throw new Error(message);
 		}
 		logger.info("Default provider workspace configuration already present, it will not be overriden");
-		const { workspaceConfiguration, ...rest } = updateParams;
+		const { workspace_configuration, ...rest } = updateParams;
 		updateParams = rest;
 	}
 	logger.info("Updating Commerce Eventing configuration with provided workspace configuration.");
@@ -780,11 +782,8 @@ async function createCommerceProvider(params) {
 	const { commerceEventsClient, logger } = context;
 	logger.info(`Creating Commerce provider "${provider.label}" with instance ID "${provider.instance_id}"`);
 	return commerceEventsClient.createEventProvider({
-		providerId: provider.id,
-		instanceId: provider.instance_id,
-		label: provider.label,
-		description: provider.description,
-		associatedWorkspaceConfiguration: provider.workspaceConfiguration
+		...provider,
+		provider_id: provider.id
 	}).then((res) => {
 		logger.info(`Commerce provider "${provider.label}" created with ID '${res.provider_id}'`);
 		return res;
@@ -821,10 +820,10 @@ async function createCommerceEventSubscription(params) {
 		name: eventName,
 		parent: event.config.name,
 		fields: event.config.fields,
-		providerId: provider.id,
+		provider_id: provider.id,
 		destination: event.config.destination,
-		hipaaAuditRequired: event.config.hipaaAuditRequired,
-		prioritary: event.config.prioritary,
+		hipaa_audit_required: event.config.hipaa_audit_required,
+		priority: event.config.priority,
 		force: event.config.force
 	};
 	logger.debug(`Event subscription specification for event "${event.config.name}": ${require_logging.inspect(eventSpec)}`);
@@ -847,12 +846,7 @@ async function createOrGetCommerceEventSubscription(params, existingData) {
 	const existing = findExistingSubscription(existingData, getNamespacedEvent(metadata, event.config.name));
 	if (existing) {
 		logger.info(`Subscription for event "${event.config.name}" already exists, skipping creation.`);
-		return {
-			name: existing.name,
-			parent: existing.parent,
-			fields: existing.fields,
-			providerId: existing.provider_id
-		};
+		return existing;
 	}
 	return createCommerceEventSubscription(params);
 }
@@ -921,7 +915,7 @@ async function onboardCommerceEventing(params, existingData) {
 	const subscriptions = [];
 	await configureCommerceEventing({
 		context,
-		config: { workspaceConfiguration }
+		config: { workspace_configuration: workspaceConfiguration }
 	}, existingData);
 	const { workspace_configuration: _, ...commerceProviderData } = await createOrGetCommerceProvider({
 		context,
@@ -930,7 +924,7 @@ async function onboardCommerceEventing(params, existingData) {
 			instance_id: instanceId,
 			label: provider.label,
 			description: provider.description,
-			workspaceConfiguration
+			workspace_configuration: workspaceConfiguration
 		}
 	}, existingData.providers);
 	for (const event of events) subscriptions.push(await createOrGetCommerceEventSubscription({
@@ -954,7 +948,7 @@ const commerceEventsStep = defineLeafStep({
 		label: "Configure Commerce Events",
 		description: "Sets up I/O Events for Adobe Commerce event sources"
 	},
-	when: require_error.hasCommerceEvents,
+	when: require_installation.hasCommerceEvents,
 	run: async (config, context) => {
 		const { logger } = context;
 		logger.debug("Starting installation of Commerce Events with config:", config);
@@ -985,9 +979,9 @@ const commerceEventsStep = defineLeafStep({
 				data: {
 					ioEvents: providerData,
 					commerce: commerceProvider,
-					events: eventsData.map(({ config: config$1, data }, index) => {
+					events: eventsData.map(({ config, data }, index) => {
 						return {
-							config: config$1,
+							config,
 							data: {
 								...data,
 								subscription: subscriptions[index]
@@ -1062,7 +1056,7 @@ const externalEventsStep = defineLeafStep({
 		label: "Configure External Events",
 		description: "Sets up I/O Events for external event sources"
 	},
-	when: require_error.hasExternalEvents,
+	when: require_installation.hasExternalEvents,
 	run: async (config, context) => {
 		const { logger } = context;
 		logger.debug("Starting installation of External Events with config:", config);
@@ -1101,7 +1095,7 @@ const eventingStep = defineBranchStep({
 		label: "Eventing",
 		description: "Sets up the I/O Events and the Commerce events required by the application"
 	},
-	when: require_error.hasEventing,
+	when: require_installation.hasEventing,
 	context: createEventsStepContext,
 	children: [commerceEventsStep, externalEventsStep]
 });

package/dist/cjs/schemas-CZ6c8Id9.cjs

@@ -0,0 +1,98 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let valibot = require("valibot");
+valibot = __toESM(valibot);
+
+//#region ../../packages-private/common-utils/source/valibot/schemas.ts
+const ALPHANUMERIC_OR_HYPHEN_REGEX = {
+	any: /^[a-zA-Z0-9-]+$/,
+	lowercase: /^[a-z0-9-]+$/,
+	uppercase: /^[A-Z0-9-]+$/
+};
+/**
+* A schema for a string value.
+* @param name The name of the field this schema refers to.
+*/
+function stringValueSchema(name) {
+	return valibot.string(`Expected a string value for '${name}'`);
+}
+/**
+* A schema for a non-empty string value.
+* @param name The name of the field this schema refers to.
+*/
+function nonEmptyStringValueSchema(name) {
+	return valibot.pipe(stringValueSchema(name), valibot.nonEmpty(`The value of "${name}" must not be empty`));
+}
+/**
+* A schema for a boolean value.
+* @param name The name of the field this schema refers to.
+*/
+function booleanValueSchema(name) {
+	return valibot.boolean(`Expected a boolean value for '${name}'`);
+}
+/**
+* A schema for a string that only contains alphanumeric characters and hyphens.
+* @param name The name of the field this schema refers to.
+* @param casing The allowed casing for the string (default: "any").
+*/
+function alphaNumericOrHyphenSchema(name, casing = "any") {
+	const casingLabel = casing === "any" ? "" : ` (${casing} only)`;
+	return valibot.pipe(stringValueSchema(name), valibot.regex(ALPHANUMERIC_OR_HYPHEN_REGEX[casing], `Only alphanumeric characters and hyphens are allowed in string value of "${name}"${casingLabel}`));
+}
+
+//#endregion
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'alphaNumericOrHyphenSchema', {
+  enumerable: true,
+  get: function () {
+    return alphaNumericOrHyphenSchema;
+  }
+});
+Object.defineProperty(exports, 'booleanValueSchema', {
+  enumerable: true,
+  get: function () {
+    return booleanValueSchema;
+  }
+});
+Object.defineProperty(exports, 'nonEmptyStringValueSchema', {
+  enumerable: true,
+  get: function () {
+    return nonEmptyStringValueSchema;
+  }
+});
+Object.defineProperty(exports, 'stringValueSchema', {
+  enumerable: true,
+  get: function () {
+    return stringValueSchema;
+  }
+});

package/dist/cjs/validate-Btzn9ilZ.cjs

@@ -0,0 +1,235 @@
+const require_schemas = require('./schemas-CZ6c8Id9.cjs');
+const require_installation = require('./installation-CLbceU9F.cjs');
+let _adobe_aio_commerce_lib_core_error = require("@adobe/aio-commerce-lib-core/error");
+let valibot = require("valibot");
+valibot = require_schemas.__toESM(valibot);
+let _adobe_aio_commerce_lib_config = require("@adobe/aio-commerce-lib-config");
+
+//#region source/config/schema/business-configuration.ts
+/**
+* Check if config has business config.
+* @param config - The configuration to check.
+*/
+function hasBusinessConfig(config) {
+	return config.businessConfig !== void 0;
+}
+/**
+* Check if config has business config schema.
+* @param config - The configuration to check.
+*/
+function hasBusinessConfigSchema(config) {
+	return config.businessConfig?.schema !== void 0 && config.businessConfig.schema.length > 0;
+}
+
+//#endregion
+//#region source/config/schema/metadata.ts
+const MAX_DESCRIPTION_LENGTH = 255;
+const MAX_DISPLAY_NAME_LENGTH = 50;
+const NUMERIC_IDENTIFIER = "(0|[1-9]\\d*)";
+const SEMVER_REGEX = new RegExp(`^${NUMERIC_IDENTIFIER}\\.${NUMERIC_IDENTIFIER}\\.${NUMERIC_IDENTIFIER}$`);
+function nonEmptyString(fieldName) {
+	return valibot.pipe(valibot.string(`Expected a string for the ${fieldName}`), valibot.nonEmpty(`The ${fieldName} must not be empty`));
+}
+/** The schema for the metadata of the application. */
+const MetadataSchema = valibot.object({
+	id: require_schemas.alphaNumericOrHyphenSchema("application id (metadata.id)"),
+	displayName: valibot.pipe(nonEmptyString("application display name"), valibot.maxLength(MAX_DISPLAY_NAME_LENGTH, `The application display name must not be longer than ${MAX_DISPLAY_NAME_LENGTH} characters`)),
+	description: valibot.pipe(nonEmptyString("metadata description"), valibot.maxLength(MAX_DESCRIPTION_LENGTH, `The metadata description must not be longer than ${MAX_DESCRIPTION_LENGTH} characters`)),
+	version: valibot.pipe(nonEmptyString("version"), valibot.regex(SEMVER_REGEX, "The version must follow semantic versioning (semver) format"))
+});
+/**
+* Check if config has metadata.
+* @param config - The configuration to check.
+*/
+function hasMetadata(config) {
+	return config.metadata !== void 0;
+}
+
+//#endregion
+//#region source/config/schema/app.ts
+/** biome-ignore-all lint/performance/noBarrelFile: We want to have all the schema exports in one file. */
+/** The schema used to validate the commerce app config file. */
+const CommerceAppConfigSchema = valibot.looseObject({
+	metadata: MetadataSchema,
+	businessConfig: valibot.optional(_adobe_aio_commerce_lib_config.SchemaBusinessConfig),
+	eventing: valibot.optional(require_installation.EventingSchema),
+	installation: valibot.optional(require_installation.InstallationSchema)
+});
+
+//#endregion
+//#region source/config/schema/domains.ts
+/** The individual validatable domains of the app config. */
+const CommerceAppConfigSchemas = {
+	metadata: MetadataSchema,
+	businessConfig: _adobe_aio_commerce_lib_config.SchemaBusinessConfig,
+	eventing: require_installation.EventingSchema,
+	installation: require_installation.InstallationSchema,
+	"businessConfig.schema": valibot.unwrap(_adobe_aio_commerce_lib_config.SchemaBusinessConfig.entries.schema),
+	"eventing.commerce": valibot.unwrap(require_installation.EventingSchema.entries.commerce),
+	"eventing.external": valibot.unwrap(require_installation.EventingSchema.entries.external),
+	"installation.customInstallationSteps": valibot.unwrap(require_installation.InstallationSchema.entries.customInstallationSteps)
+};
+/**
+* Get the config domains that are present in the config.
+* @param config - The configuration to check.
+*/
+function getConfigDomains(config) {
+	const withCommerceEvents = require_installation.hasCommerceEvents(config);
+	const withExternalEvents = require_installation.hasExternalEvents(config);
+	const domains = {
+		metadata: hasMetadata(config),
+		businessConfig: hasBusinessConfig(config),
+		eventing: withCommerceEvents || withExternalEvents,
+		installation: require_installation.hasCustomInstallation(config),
+		"businessConfig.schema": hasBusinessConfigSchema(config),
+		"eventing.commerce": withCommerceEvents,
+		"eventing.external": withExternalEvents,
+		"installation.customInstallationSteps": require_installation.hasCustomInstallationSteps(config)
+	};
+	const domainsList = Object.entries(domains).filter(([_, value]) => value).map(([key]) => key);
+	return new Set(domainsList);
+}
+/**
+* Check if the config has a specific domain.
+* @param config - The configuration to check.
+* @param domain - The domain to check.
+*/
+function hasConfigDomain(config, domain) {
+	return getConfigDomains(config).has(domain);
+}
+
+//#endregion
+//#region source/config/lib/validate.ts
+const commerceAppConfigDomainsSchema = valibot.picklist(Object.keys(CommerceAppConfigSchemas));
+/**
+* Validates a complete commerce app configuration object against the schema.
+*
+* @param config - The configuration object to validate.
+* @returns The validated and typed configuration output model.
+*
+* @throws {CommerceSdkValidationError} If the configuration is invalid, with
+* detailed validation issues included.
+*
+* @example
+* ```typescript
+* const config = {
+*   businessConfiguration: {
+*     // ... configuration data
+*   }
+* };
+*
+* try {
+*   const validatedConfig = validateCommerceAppConfig(config);
+*   // Use validatedConfig safely
+* } catch (error) {
+*   if (error instanceof CommerceSdkValidationError) {
+*     console.error('Validation failed:', error.display());
+*   }
+* }
+* ```
+*/
+function validateCommerceAppConfig(config) {
+	const validatedConfig = valibot.safeParse(CommerceAppConfigSchema, config);
+	if (!validatedConfig.success) throw new _adobe_aio_commerce_lib_core_error.CommerceSdkValidationError("Invalid commerce app config", { issues: validatedConfig.issues });
+	return validatedConfig.output;
+}
+/**
+* Validates a specific domain configuration within the commerce app config.
+*
+* This function validates only a specific domain's configuration rather than
+* the entire commerce app configuration object. It first validates that the
+* domain name is valid, then validates the configuration data against the
+* schema for that specific domain.
+*
+* @template T - The type of the domain, constrained to valid domain names.
+*
+* @param config - The domain configuration object to validate.
+* @param domain - The name of the domain to validate (e.g., 'businessConfiguration').
+* @returns The validated and typed configuration for the specified domain.
+*
+* @throws {CommerceSdkValidationError} If the domain name is invalid or if the
+* configuration doesn't match the domain's schema.
+*
+* @example
+* ```typescript
+* const businessConfig = {
+*   fields: [
+*     {
+*       name: 'category',
+*       type: 'dropdown',
+*       // ... field configuration
+*     }
+*   ]
+* };
+*
+* try {
+*   const validatedConfig = validateCommerceAppConfigDomain(
+*     businessConfig,
+*     'businessConfig'
+*   );
+*   // Use validatedConfig safely
+* } catch (error) {
+*   if (error instanceof CommerceSdkValidationError) {
+*     console.error('Domain validation failed:', error.issues);
+*   }
+* }
+* ```
+*/
+function validateCommerceAppConfigDomain(config, domain) {
+	const domainSchema = valibot.safeParse(commerceAppConfigDomainsSchema, domain);
+	if (!domainSchema.success) throw new _adobe_aio_commerce_lib_core_error.CommerceSdkValidationError("Invalid commerce app config domain", { issues: domainSchema.issues });
+	const domainConfigSchema = CommerceAppConfigSchemas[domain];
+	const validatedConfig = valibot.safeParse(domainConfigSchema, config);
+	if (!validatedConfig.success) throw new _adobe_aio_commerce_lib_core_error.CommerceSdkValidationError(`Invalid commerce app config: ${domain}`, { issues: validatedConfig.issues });
+	return validatedConfig.output;
+}
+
+//#endregion
+Object.defineProperty(exports, 'CommerceAppConfigSchemas', {
+  enumerable: true,
+  get: function () {
+    return CommerceAppConfigSchemas;
+  }
+});
+Object.defineProperty(exports, 'getConfigDomains', {
+  enumerable: true,
+  get: function () {
+    return getConfigDomains;
+  }
+});
+Object.defineProperty(exports, 'hasBusinessConfig', {
+  enumerable: true,
+  get: function () {
+    return hasBusinessConfig;
+  }
+});
+Object.defineProperty(exports, 'hasBusinessConfigSchema', {
+  enumerable: true,
+  get: function () {
+    return hasBusinessConfigSchema;
+  }
+});
+Object.defineProperty(exports, 'hasConfigDomain', {
+  enumerable: true,
+  get: function () {
+    return hasConfigDomain;
+  }
+});
+Object.defineProperty(exports, 'hasMetadata', {
+  enumerable: true,
+  get: function () {
+    return hasMetadata;
+  }
+});
+Object.defineProperty(exports, 'validateCommerceAppConfig', {
+  enumerable: true,
+  get: function () {
+    return validateCommerceAppConfig;
+  }
+});
+Object.defineProperty(exports, 'validateCommerceAppConfigDomain', {
+  enumerable: true,
+  get: function () {
+    return validateCommerceAppConfigDomain;
+  }
+});

package/dist/es/actions/app-config.d.mts

@@ -0,0 +1,15 @@
+import { n as CommerceAppConfigOutputModel } from "../app-BAiyvNo2.mjs";
+import * as _adobe_aio_commerce_lib_core_responses0 from "@adobe/aio-commerce-lib-core/responses";
+import { RuntimeActionParams } from "@adobe/aio-commerce-lib-core/params";
+
+//#region source/actions/app-config.d.ts
+/** Arguments for the runtime action factory. */
+type RuntimeActionFactoryArgs = {
+  appConfig: CommerceAppConfigOutputModel;
+};
+/** Factory to create the route handler for the `app-config` action. */
+declare const appConfigRuntimeAction: ({
+  appConfig
+}: RuntimeActionFactoryArgs) => (params: RuntimeActionParams) => Promise<_adobe_aio_commerce_lib_core_responses0.ActionResponse>;
+//#endregion
+export { appConfigRuntimeAction };

package/dist/es/actions/app-config.mjs

@@ -0,0 +1,25 @@
+import { n as logger, t as HttpActionRouter } from "../router-CJ4VWoCt.mjs";
+import { t as validateCommerceAppConfig } from "../validate-DKnju9-R.mjs";
+import { ok } from "@adobe/aio-commerce-lib-core/responses";
+
+//#region source/actions/app-config.ts
+/** Router for the app config actions. */
+const router = new HttpActionRouter().use(logger({ name: () => "get-app-config" }));
+/** GET / - Get app config */
+router.get("/", { handler: async (_req, { logger, rawParams }) => {
+	logger.debug("Validating app config...");
+	const { appConfig } = rawParams;
+	const config = validateCommerceAppConfig(appConfig);
+	logger.debug("Successfully validated the app config");
+	return ok({ body: config });
+} });
+/** Factory to create the route handler for the `app-config` action. */
+const appConfigRuntimeAction = ({ appConfig }) => async (params) => {
+	return await router.handler()({
+		...params,
+		appConfig
+	});
+};
+
+//#endregion
+export { appConfigRuntimeAction };

package/dist/es/actions/config.d.mts

@@ -0,0 +1,15 @@
+import * as _adobe_aio_commerce_lib_core_responses0 from "@adobe/aio-commerce-lib-core/responses";
+import { BusinessConfigSchema } from "@adobe/aio-commerce-lib-config";
+import { RuntimeActionParams } from "@adobe/aio-commerce-lib-core/params";
+
+//#region source/actions/config.d.ts
+/** The arguments for the config action factory. */
+type ConfigActionFactoryArgs = {
+  configSchema: BusinessConfigSchema;
+};
+/** Factory to create the route handler for the `config` action. */
+declare const configRuntimeAction: ({
+  configSchema
+}: ConfigActionFactoryArgs) => (params: RuntimeActionParams) => Promise<_adobe_aio_commerce_lib_core_responses0.ActionResponse>;
+//#endregion
+export { configRuntimeAction };

package/dist/es/actions/config.mjs

@@ -0,0 +1,77 @@
+import { n as logger, t as HttpActionRouter } from "../router-CJ4VWoCt.mjs";
+import { n as validateCommerceAppConfigDomain } from "../validate-DKnju9-R.mjs";
+import { r as nonEmptyStringValueSchema } from "../schemas-B8yIv0_b.mjs";
+import { ok } from "@adobe/aio-commerce-lib-core/responses";
+import * as v from "valibot";
+import { byScopeId, getConfiguration, initialize, setConfiguration } from "@adobe/aio-commerce-lib-config";
+
+//#region source/actions/config.ts
+const MASKED_PASSWORD_VALUE = "*****";
+/**
+* Filters password fields from the configuration values.
+* @param schema - The schema to use to filter the values.
+* @param values - The values to filter.
+* @returns The filtered values.
+*/
+function filterPasswordFields(schema, values) {
+	return values.map((item) => {
+		if (schema.find((field) => field.name === item.name)?.type === "password") return {
+			...item,
+			value: MASKED_PASSWORD_VALUE
+		};
+		return item;
+	});
+}
+const router = new HttpActionRouter().use(logger());
+/** GET / - Retrieve configuration */
+router.get("/", {
+	query: v.object({ scopeId: nonEmptyStringValueSchema("scopeId") }),
+	handler: async (req, ctx) => {
+		const { logger, rawParams } = ctx;
+		const configSchema = rawParams.configSchema;
+		logger.debug("Validating configuration schema...");
+		const validatedSchema = validateCommerceAppConfigDomain(configSchema, "businessConfig.schema");
+		initialize({ schema: validatedSchema });
+		const { scopeId } = req.query;
+		logger.debug(`Retrieving configuration with scope id: ${scopeId}`);
+		const appConfiguration = await getConfiguration(byScopeId(scopeId), { encryptionKey: rawParams.AIO_COMMERCE_CONFIG_ENCRYPTION_KEY });
+		logger.debug("Masking password values...");
+		appConfiguration.config = filterPasswordFields(configSchema, appConfiguration.config);
+		return ok({ body: {
+			schema: validatedSchema,
+			values: appConfiguration
+		} });
+	}
+});
+/** POST / - Set configuration */
+router.put("/", {
+	body: v.object({
+		scopeId: nonEmptyStringValueSchema("scopeId"),
+		config: v.array(v.object({
+			name: nonEmptyStringValueSchema("config.name"),
+			value: v.union([v.string(), v.array(v.string())])
+		}))
+	}),
+	handler: async (req, ctx) => {
+		const { logger, rawParams } = ctx;
+		const { configSchema } = rawParams;
+		logger.debug(`Setting configuration with scope id: ${req.body.scopeId}`);
+		const { scopeId, config } = req.body;
+		const result = await setConfiguration({ config: config.filter((item) => item.value !== MASKED_PASSWORD_VALUE) }, byScopeId(scopeId), { encryptionKey: rawParams.AIO_COMMERCE_CONFIG_ENCRYPTION_KEY });
+		result.config = filterPasswordFields(configSchema, result.config);
+		return ok({
+			body: result,
+			headers: { "Cache-Control": "no-store" }
+		});
+	}
+});
+/** Factory to create the route handler for the `config` action. */
+const configRuntimeAction = ({ configSchema }) => async (params) => {
+	return await router.handler()({
+		...params,
+		configSchema
+	});
+};
+
+//#endregion
+export { configRuntimeAction };

package/dist/es/actions/{index.d.mts → installation.d.mts}

@@ -1,15 +1,16 @@
-import { n as CommerceAppConfigOutputModel } from "../app-Cx1-6dn0.mjs";
-import { P as InstallationContext } from "../index-Bxr3zvCT.mjs";
+import { n as CommerceAppConfigOutputModel } from "../app-BAiyvNo2.mjs";
+import { P as InstallationContext } from "../runner-BD-lItnK.mjs";
 import * as _adobe_aio_commerce_lib_core_responses0 from "@adobe/aio-commerce-lib-core/responses";
 import { RuntimeActionParams } from "@adobe/aio-commerce-lib-core/params";
 
 //#region source/actions/installation.d.ts
 type CustomScriptsLoader = (config: CommerceAppConfigOutputModel, logger: InstallationContext["logger"]) => Record<string, unknown>;
+/** Arguments for the runtime action factory. */
 type RuntimeActionFactoryArgs = {
   appConfig: CommerceAppConfigOutputModel;
   customScriptsLoader?: CustomScriptsLoader;
 };
-/** The route handler for the runtime action. */
+/** Factory to create the route handler for the `installation` action. */
 declare const installationRuntimeAction: ({
   appConfig,
   customScriptsLoader