@adobe/aio-commerce-lib-app 1.0.2 → 1.1.0

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

@@ -1,13 +1,29 @@
-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');
+/**
+ * @license
+ *
+ * Copyright 2026 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.
+ */
+
+const require_schemas = require('./schemas-nkIxa8sL.cjs');
+const require_webhooks = require('./webhooks-CbZpv9y_.cjs');
+const require_error = require('./error-Dn7ool6k.cjs');
+const require_logging = require('./logging-4s36JTiN.cjs');
 let camelcase = require("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");
 let _adobe_aio_commerce_lib_events_io_events = require("@adobe/aio-commerce-lib-events/io-events");
+let _adobe_aio_commerce_lib_webhooks_api = require("@adobe/aio-commerce-lib-webhooks/api");
+let ky = require("ky");
 
 //#region source/management/installation/workflow/hooks.ts
 /** Helper to call a hook if it exists. */
@@ -47,7 +63,8 @@ function defineLeafStep(options) {
 		name: options.name,
 		meta: options.meta,
 		when: options.when,
-		run: options.run
+		run: options.run,
+		validate: options.validate
 	};
 }
 /**
@@ -71,7 +88,8 @@ function defineBranchStep(options) {
 		meta: options.meta,
 		when: options.when,
 		context: options.context,
-		children: options.children
+		children: options.children,
+		validate: options.validate
 	};
 }
 
@@ -295,6 +313,104 @@ function isCompletedState(state) {
 	return state.status === "succeeded" || state.status === "failed";
 }
 
+//#endregion
+//#region source/management/installation/workflow/validation.ts
+/**
+* Runs validation over the full step tree, returning a structured result.
+*
+* - Respects `when` conditions (skips steps that don't apply to the config)
+* - Calls each step's optional `validate` handler
+* - Sets up branch context factories before validating children
+* - Never throws; all errors from validate handlers are caught and reported as issues
+*/
+async function validateStepTree(options) {
+	const { rootStep, validationContext, config } = options;
+	const result = await validateStep(rootStep, config, validationContext, []);
+	const summary = aggregateSummary(result);
+	return {
+		valid: summary.errors === 0 && summary.warnings === 0,
+		result,
+		summary
+	};
+}
+/** Recursively validates a single step and its children. */
+async function validateStep(step, config, context, parentPath) {
+	const path = [...parentPath, step.name];
+	const issues = await runStepValidation(step, config, context);
+	const children = [];
+	if (isBranchStep(step) && step.children.length > 0) {
+		const resolved = await resolveBranchContext(step, context);
+		issues.push(...resolved.issues);
+		for (const child of step.children) {
+			if (child.when && !child.when(config)) continue;
+			children.push(await validateStep(child, config, resolved.childContext, path));
+		}
+	}
+	return {
+		name: step.name,
+		path,
+		meta: step.meta,
+		issues,
+		children
+	};
+}
+/** Resolves the child context for a branch step, reporting errors as issues. */
+async function resolveBranchContext(step, context) {
+	if (!step.context) return {
+		childContext: context,
+		issues: []
+	};
+	try {
+		const stepContext = await step.context(context);
+		return {
+			childContext: {
+				...context,
+				...stepContext
+			},
+			issues: []
+		};
+	} catch (err) {
+		return {
+			childContext: context,
+			issues: [{
+				code: "VALIDATION_CONTEXT_ERROR",
+				message: err instanceof Error ? err.message : String(err),
+				severity: "error"
+			}]
+		};
+	}
+}
+/** Runs a step's validate handler, catching any thrown errors as issues. */
+async function runStepValidation(step, config, context) {
+	if (!step.validate) return [];
+	try {
+		return await step.validate(config, context);
+	} catch (err) {
+		return [{
+			code: "VALIDATION_HANDLER_ERROR",
+			message: err instanceof Error ? err.message : String(err),
+			severity: "error"
+		}];
+	}
+}
+/** Recursively aggregates issue counts across the full validation tree. */
+function aggregateSummary(result) {
+	let errors = 0;
+	let warnings = 0;
+	for (const issue of result.issues) if (issue.severity === "error") errors++;
+	else if (issue.severity === "warning") warnings++;
+	for (const child of result.children) {
+		const childSummary = aggregateSummary(child);
+		errors += childSummary.errors;
+		warnings += childSummary.warnings;
+	}
+	return {
+		totalIssues: errors + warnings,
+		errors,
+		warnings
+	};
+}
+
 //#endregion
 //#region source/management/installation/custom-installation/custom-scripts.ts
 /**
@@ -332,7 +448,7 @@ function createCustomScriptStep(scriptConfig) {
 * defined in the configuration. Each script becomes a separate leaf step.
 */
 function createCustomScriptSteps(config) {
-	if (!require_installation.hasCustomInstallationSteps(config)) return [];
+	if (!require_webhooks.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));
@@ -347,7 +463,7 @@ const customInstallationStepBase = defineBranchStep({
 		label: "Custom Installation Steps",
 		description: "Executes custom installation scripts defined in the application configuration"
 	},
-	when: require_installation.hasCustomInstallationSteps,
+	when: require_webhooks.hasCustomInstallationSteps,
 	children: []
 });
 /**
@@ -410,7 +526,7 @@ const PROVIDER_TYPE_TO_LABEL = {
 */
 function generateInstanceId(metadata, provider) {
 	const slugLabel = provider.label.toLowerCase().replace(/\s+/g, "-");
-	return `${metadata.id}-${provider.key ?? slugLabel}`;
+	return `${metadata.id}-${provider.key ?? slugLabel}`.toLowerCase();
 }
 /**
 * Find an existing event provider by its instance ID.
@@ -444,7 +560,7 @@ function findExistingRegistrations(allRegistrations, clientId, name) {
 * @param name
 */
 function getNamespacedEvent(metadata, name) {
-	return `${metadata.id}.${name}`;
+	return `${metadata.id}.${name}`.toLowerCase();
 }
 /**
 * Get the fully qualified name of an event for I/O Events based on the provider type.
@@ -452,7 +568,7 @@ function getNamespacedEvent(metadata, name) {
 * @param providerType - The type of the event provider.
 */
 function getIoEventCode(name, providerType) {
-	return providerType === COMMERCE_PROVIDER_TYPE ? `com.adobe.commerce.${name}` : name;
+	return providerType === "dx_commerce_events" ? `com.adobe.commerce.${name}` : name;
 }
 /**
 * Generates a registration name and description based on the provider, events, and runtime action.
@@ -948,7 +1064,7 @@ const commerceEventsStep = defineLeafStep({
 		label: "Configure Commerce Events",
 		description: "Sets up I/O Events for Adobe Commerce event sources"
 	},
-	when: require_installation.hasCommerceEvents,
+	when: require_webhooks.hasCommerceEvents,
 	run: async (config, context) => {
 		const { logger } = context;
 		logger.debug("Starting installation of Commerce Events with config:", config);
@@ -1056,7 +1172,7 @@ const externalEventsStep = defineLeafStep({
 		label: "Configure External Events",
 		description: "Sets up I/O Events for external event sources"
 	},
-	when: require_installation.hasExternalEvents,
+	when: require_webhooks.hasExternalEvents,
 	run: async (config, context) => {
 		const { logger } = context;
 		logger.debug("Starting installation of External Events with config:", config);
@@ -1095,25 +1211,230 @@ const eventingStep = defineBranchStep({
 		label: "Eventing",
 		description: "Sets up the I/O Events and the Commerce events required by the application"
 	},
-	when: require_installation.hasEventing,
+	when: require_webhooks.hasEventing,
 	context: createEventsStepContext,
 	children: [commerceEventsStep, externalEventsStep]
 });
 
 //#endregion
-//#region source/management/installation/webhooks/helpers.ts
-function createWebhookSubscriptions(context) {
-	const { logger } = context;
-	logger.info("Creating webhooks in Commerce");
-	return { subscriptionsCreated: true };
+//#region source/management/installation/webhooks/context.ts
+/**
+* Create a custom Commerce Webhooks API Client with only the operations needed for installation.
+* @param params - The runtime action params to resolve the client params from.
+*/
+function createCommerceWebhooksApiClient(params) {
+	const commerceClientParams = (0, _adobe_aio_commerce_lib_api.resolveCommerceHttpClientParams)(params, { tryForwardAuthProvider: true });
+	commerceClientParams.fetchOptions ??= {};
+	commerceClientParams.fetchOptions.timeout = 1e3 * 60 * 2;
+	return (0, _adobe_aio_commerce_lib_webhooks_api.createCustomCommerceWebhooksApiClient)(commerceClientParams, {
+		getWebhookList: _adobe_aio_commerce_lib_webhooks_api.getWebhookList,
+		subscribeWebhook: _adobe_aio_commerce_lib_webhooks_api.subscribeWebhook
+	});
+}
+/** Creates the webhooks step context with a lazy-initialized API client. */
+function createWebhooksStepContext(installation) {
+	const { params } = installation;
+	let commerceWebhooksClient = null;
+	return { get commerceWebhooksClient() {
+		if (commerceWebhooksClient === null) commerceWebhooksClient = createCommerceWebhooksApiClient(params);
+		return commerceWebhooksClient;
+	} };
 }
 
 //#endregion
-//#region source/management/installation/webhooks/utils.ts
-/** Check if config has webhooks. */
-function hasWebhooks(config) {
-	"webhooks" in config && Array.isArray(config.webhooks) && config.webhooks.length;
-	return false;
+//#region source/management/installation/webhooks/helpers.ts
+/** Matches any character that is not a valid identifier character (letter, digit, or underscore). */
+const NON_IDENTIFIER_CHAR_REGEX = /[^a-zA-Z0-9_]/g;
+/** Matches two or more consecutive underscores. */
+const MULTIPLE_UNDERSCORES_REGEX = /_+/g;
+/** Matches the `.magento` segment in plugin webhook method names (e.g. `plugin.magento.foo`). */
+const PLUGIN_MAGENTO_REGEX = /^plugin\.magento\./;
+const ENVIRONMENT_PRODUCTION = "production";
+const ENVIRONMENT_STAGING = "staging";
+/**
+* Validates that no modification webhooks in the app config conflict with webhooks
+* already registered in Commerce by another app.
+*
+* A conflict is: Commerce has a webhook with the same `webhook_method` and `webhook_type`
+* that does NOT belong to this app (i.e. different `batch_name` or `hook_name` after prefix).
+*
+* Returns a `ValidationIssue` with code `WEBHOOK_CONFLICTS` and `details.conflictedWebhooks` listing
+* every conflicting Commerce webhook when conflicts are found, or an empty array otherwise.
+*
+* @param config - The app config (must have a non-empty `webhooks` array).
+* @param context - The webhooks execution context (provides the Commerce API client and logger).
+*/
+async function validateWebhookConflicts(config, context) {
+	const { logger, commerceWebhooksClient } = context;
+	const modificationWebhooks = config.webhooks.filter((entry) => entry.category === "modification");
+	if (modificationWebhooks.length === 0) {
+		logger.debug("No modification webhooks to validate, skipping conflict check.");
+		return [];
+	}
+	logger.debug(`Validating ${modificationWebhooks.length} modification webhook(s) for conflicts...`);
+	const existingWebhooks = await commerceWebhooksClient.getWebhookList();
+	const idPrefix = buildWebhookIdPrefix(config.metadata.id);
+	const conflictedWebhooks = [];
+	for (const entry of modificationWebhooks) {
+		const { webhook } = entry;
+		const resolvedBatch = `${idPrefix}${webhook.batch_name}`;
+		const resolvedHook = `${idPrefix}${webhook.hook_name}`;
+		for (const existing of existingWebhooks) if (existing.webhook_method === webhook.webhook_method && existing.webhook_type === webhook.webhook_type && !(existing.batch_name === resolvedBatch && existing.hook_name === resolvedHook)) {
+			conflictedWebhooks.push({
+				label: entry.label,
+				...existing
+			});
+			break;
+		}
+	}
+	if (conflictedWebhooks.length > 0) return [{
+		code: "WEBHOOK_CONFLICTS",
+		message: `Webhook conflicts detected: ${conflictedWebhooks.length} webhook(s) already registered for the same method and type by another app`,
+		severity: "warning",
+		details: { conflictedWebhooks }
+	}];
+	logger.info("No webhook conflicts found.");
+	return [];
+}
+/**
+* Subscribes each webhook from the app config to Adobe Commerce.
+* Throws on the first failure, aborting any remaining subscriptions.
+*
+* @param config - The app config (must have a non-empty `webhooks` array).
+* @param context - The webhooks execution context (provides the Commerce API client and logger).
+*/
+async function createWebhookSubscriptions(config, context) {
+	const { logger, commerceWebhooksClient, params } = context;
+	logger.info(`Subscribing ${config.webhooks.length} webhook(s) to Commerce...`);
+	const idPrefix = buildWebhookIdPrefix(config.metadata.id);
+	const subscribedWebhooks = [];
+	const existingWebhooks = await commerceWebhooksClient.getWebhookList();
+	for (const entry of config.webhooks) {
+		const { webhook } = entry;
+		const resolvedUrl = "runtimeAction" in entry ? generateUrlForRuntimeAction(entry.runtimeAction) : entry.webhook.url;
+		logger.debug(`Subscribing webhook "${getWebhookName(webhook)}" (runtimeAction: ${"runtimeAction" in entry ? entry.runtimeAction : "none"})`);
+		const resolvedWebhook = {
+			...webhook,
+			url: resolvedUrl,
+			batch_name: `${idPrefix}${webhook.batch_name}`,
+			hook_name: `${idPrefix}${webhook.hook_name}`,
+			..."runtimeAction" in entry && entry.requireAdobeAuth !== false && { developer_console_oauth: resolveDeveloperConsoleOAuthCredentials(params) }
+		};
+		subscribedWebhooks.push(await createOrGetWebhookSubscription(existingWebhooks, commerceWebhooksClient, resolvedWebhook, logger));
+	}
+	logger.info(`Webhook subscriptions complete: ${subscribedWebhooks.length} subscribed.`);
+	return { subscribedWebhooks };
+}
+/**
+* Subscribes a single webhook to Commerce, skipping the API call if the webhook
+* is already subscribed (matched by webhook_method, webhook_type, batch_name, hook_name).
+*/
+async function createOrGetWebhookSubscription(existingWebhooks, client, resolvedWebhook, logger) {
+	if (isAlreadySubscribed(existingWebhooks, resolvedWebhook)) {
+		logger.info(`Webhook already subscribed, skipping: ${getWebhookName(resolvedWebhook)}`);
+		return resolvedWebhook;
+	}
+	const subscribed = await createWebhookSubscription(client, resolvedWebhook);
+	logger.info(`Subscribed webhook: ${getWebhookName(resolvedWebhook)}`);
+	return subscribed;
+}
+/**
+* Subscribes a single webhook to Commerce, enriching the error with the webhook name
+* if the API responds with a string `message`.
+*/
+async function createWebhookSubscription(client, resolvedWebhook) {
+	try {
+		await client.subscribeWebhook(resolvedWebhook);
+		return resolvedWebhook;
+	} catch (err) {
+		if (err instanceof ky.HTTPError) {
+			let body;
+			try {
+				body = await err.response.json();
+			} catch {
+				throw err;
+			}
+			if (typeof body?.message === "string") throw new Error(`Webhook subscription failed for "${getWebhookName(resolvedWebhook)}": ${body.message}`);
+		}
+		throw err;
+	}
+}
+/**
+* Resolves and validates the IMS credentials required for `developer_console_oauth`.
+*
+* Delegates parsing and validation to `resolveImsAuthParams` from `aio-commerce-lib-auth`,
+* which correctly handles `AIO_COMMERCE_AUTH_IMS_CLIENT_SECRETS` whether it arrives as a
+* real array or as a JSON-stringified array string.
+*/
+function resolveDeveloperConsoleOAuthCredentials(params) {
+	const { AIO_COMMERCE_AUTH_IMS_ENVIRONMENT: imsEnvironment, ...imsParams } = params;
+	const { clientId, clientSecrets, imsOrgId } = (0, _adobe_aio_commerce_lib_auth.resolveImsAuthParams)(imsParams);
+	return {
+		client_id: clientId,
+		client_secret: clientSecrets[0],
+		org_id: imsOrgId,
+		environment: !imsEnvironment || String(imsEnvironment).startsWith("prod") ? ENVIRONMENT_PRODUCTION : ENVIRONMENT_STAGING
+	};
+}
+/**
+* Returns true when the candidate webhook is already present in the existing subscription list,
+* matched by the four-part identity: webhook_method, webhook_type, batch_name, hook_name.
+*
+* `webhook_method` is normalised before comparison to handle the case where Commerce strips the
+* `.magento` segment from plugin webhook methods on storage
+* (e.g. `plugin.magento.foo` and `plugin.foo` are treated as the same method).
+*/
+function isAlreadySubscribed(existing, candidate) {
+	const normalizedCandidate = normalizeWebhookMethod(candidate.webhook_method);
+	return existing.some((w) => normalizeWebhookMethod(w.webhook_method) === normalizedCandidate && w.webhook_type === candidate.webhook_type && w.batch_name === candidate.batch_name && w.hook_name === candidate.hook_name);
+}
+/**
+* Normalises a webhook method name by removing the `.magento` segment that Commerce
+* may drop when persisting plugin webhook methods.
+*
+* @example
+* normalizeWebhookMethod("plugin.magento.foo.bar") // → "plugin.foo.bar"
+* normalizeWebhookMethod("plugin.foo.bar")         // → "plugin.foo.bar" (unchanged)
+*/
+function normalizeWebhookMethod(method) {
+	return method.replace(PLUGIN_MAGENTO_REGEX, "plugin.");
+}
+/**
+* Generates a URL for a given runtime action using the AIO Runtime API host and namespace.
+* @param runtimeAction
+* @return The generated URL for the runtime action.
+*/
+function generateUrlForRuntimeAction(runtimeAction) {
+	const namespace = process.env.__OW_NAMESPACE;
+	if (!namespace) throw new Error(`Cannot generate URL for runtime action "${runtimeAction}": namespace environment variable is not set.`);
+	return `https://${namespace}.adobeioruntime.net/api/v1/web/${runtimeAction}`;
+}
+/**
+* Builds a prefix string from the app ID to namespace webhook batch/hook names.
+* Non-identifier characters are replaced with underscores; consecutive underscores
+* are collapsed to one; a trailing underscore is appended. The result is lowercased
+* to ensure consistent matching regardless of input casing.
+*
+* @example
+* ```typescript
+* buildWebhookIdPrefix("my--app.v2") // => "my_app_v2_"
+* buildWebhookIdPrefix("MyApp") // => "myapp_"
+* ```
+* @param appId - The app ID to build the prefix from.
+* @return The built prefix string.
+*/
+function buildWebhookIdPrefix(appId) {
+	const prefix = appId.toLowerCase().replace(NON_IDENTIFIER_CHAR_REGEX, "_").replace(MULTIPLE_UNDERSCORES_REGEX, "_");
+	return prefix.endsWith("_") ? prefix : `${prefix}_`;
+}
+/**
+* Generates a name for a webhook based on its method and type.
+*
+* @param webhook
+* @return A string in the format "webhook_method:webhook_type" to identify the webhook.
+*/
+function getWebhookName(webhook) {
+	return `${webhook.webhook_method}:${webhook.webhook_type}`;
 }
 
 //#endregion
@@ -1124,11 +1445,8 @@ const subscriptionsStep = defineLeafStep({
 		label: "Create Subscriptions",
 		description: "Creates webhook subscriptions in Adobe Commerce"
 	},
-	run: (config, context) => {
-		const { logger } = context;
-		logger.debug(config);
-		return createWebhookSubscriptions(context);
-	}
+	validate: (config, context) => validateWebhookConflicts(config, context),
+	run: (config, context) => createWebhookSubscriptions(config, context)
 });
 /** Branch step for setting up Commerce webhooks. */
 const webhooksStep = defineBranchStep({
@@ -1137,7 +1455,8 @@ const webhooksStep = defineBranchStep({
 		label: "Webhooks",
 		description: "Sets up Commerce webhooks"
 	},
-	when: hasWebhooks,
+	when: require_webhooks.hasWebhooks,
+	context: createWebhooksStepContext,
 	children: [subscriptionsStep]
 });
 
@@ -1194,6 +1513,22 @@ function runInstallation(options) {
 		hooks
 	});
 }
+/**
+* Runs pre-installation validation over the full step tree.
+*
+* Traverses the same step hierarchy used during installation but only calls
+* each step's optional `validate` handler rather than executing side effects.
+* Always resolves (never throws). Returns a structured result with per-step
+* issues and an aggregated summary.
+*/
+function runValidation(options) {
+	const { validationContext, config } = options;
+	return validateStepTree({
+		rootStep: createRootInstallationStep(config),
+		validationContext,
+		config
+	});
+}
 
 //#endregion
 Object.defineProperty(exports, 'createInitialInstallationState', {
@@ -1237,4 +1572,10 @@ Object.defineProperty(exports, 'runInstallation', {
   get: function () {
     return runInstallation;
   }
+});
+Object.defineProperty(exports, 'runValidation', {
+  enumerable: true,
+  get: function () {
+    return runValidation;
+  }
 });

package/dist/cjs/{router-DCw7oEQ9.cjs → router-KeQRduO3.cjs}

@@ -1,4 +1,18 @@
-const require_schemas = require('./schemas-CZ6c8Id9.cjs');
+/**
+ * @license
+ *
+ * Copyright 2026 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.
+ */
+
+const require_schemas = require('./schemas-nkIxa8sL.cjs');
 let _adobe_aio_commerce_lib_core_responses = require("@adobe/aio-commerce-lib-core/responses");
 let _adobe_aio_lib_core_logging = require("@adobe/aio-lib-core-logging");
 _adobe_aio_lib_core_logging = require_schemas.__toESM(_adobe_aio_lib_core_logging);

package/dist/cjs/{schemas-CZ6c8Id9.cjs → schemas-nkIxa8sL.cjs}

@@ -1,3 +1,17 @@
+/**
+ * @license
+ *
+ * Copyright 2026 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.
+ */
+
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -35,6 +49,20 @@ const ALPHANUMERIC_OR_HYPHEN_REGEX = {
 	uppercase: /^[A-Z0-9-]+$/
 };
 /**
+* A schema for a number value.
+* @param name The name of the field this schema refers to.
+*/
+function numberValueSchema(name) {
+	return valibot.number(`Expected a number value for '${name}'`);
+}
+/**
+* A schema for a positive number value (including zero).
+* @param name The name of the field this schema refers to.
+*/
+function positiveNumberValueSchema(name) {
+	return valibot.pipe(numberValueSchema(name), valibot.minValue(0, `The value of ${name} must be a non-negative number`));
+}
+/**
 * A schema for a string value.
 * @param name The name of the field this schema refers to.
 */
@@ -90,6 +118,12 @@ Object.defineProperty(exports, 'nonEmptyStringValueSchema', {
     return nonEmptyStringValueSchema;
   }
 });
+Object.defineProperty(exports, 'positiveNumberValueSchema', {
+  enumerable: true,
+  get: function () {
+    return positiveNumberValueSchema;
+  }
+});
 Object.defineProperty(exports, 'stringValueSchema', {
   enumerable: true,
   get: function () {

package/dist/cjs/{validate-Btzn9ilZ.cjs → validate-CwwYD8aC.cjs}

@@ -1,5 +1,19 @@
-const require_schemas = require('./schemas-CZ6c8Id9.cjs');
-const require_installation = require('./installation-CLbceU9F.cjs');
+/**
+ * @license
+ *
+ * Copyright 2026 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.
+ */
+
+const require_schemas = require('./schemas-nkIxa8sL.cjs');
+const require_webhooks = require('./webhooks-CbZpv9y_.cjs');
 let _adobe_aio_commerce_lib_core_error = require("@adobe/aio-commerce-lib-core/error");
 let valibot = require("valibot");
 valibot = require_schemas.__toESM(valibot);
@@ -35,7 +49,7 @@ 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"))
+	version: valibot.pipe(nonEmptyString("version"), valibot.regex(SEMVER_REGEX, "The version must follow semantic versioning (semver) format: Major.Minor.Patch (e.g., '1.0.0', '2.3.1')"))
 });
 /**
 * Check if config has metadata.
@@ -52,8 +66,9 @@ function hasMetadata(config) {
 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)
+	eventing: valibot.optional(require_webhooks.EventingSchema),
+	installation: valibot.optional(require_webhooks.InstallationSchema),
+	webhooks: valibot.optional(require_webhooks.WebhooksSchema)
 });
 
 //#endregion
@@ -62,29 +77,31 @@ const CommerceAppConfigSchema = valibot.looseObject({
 const CommerceAppConfigSchemas = {
 	metadata: MetadataSchema,
 	businessConfig: _adobe_aio_commerce_lib_config.SchemaBusinessConfig,
-	eventing: require_installation.EventingSchema,
-	installation: require_installation.InstallationSchema,
+	eventing: require_webhooks.EventingSchema,
+	installation: require_webhooks.InstallationSchema,
+	webhooks: require_webhooks.WebhooksSchema,
 	"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)
+	"eventing.commerce": valibot.unwrap(require_webhooks.EventingSchema.entries.commerce),
+	"eventing.external": valibot.unwrap(require_webhooks.EventingSchema.entries.external),
+	"installation.customInstallationSteps": valibot.unwrap(require_webhooks.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 withCommerceEvents = require_webhooks.hasCommerceEvents(config);
+	const withExternalEvents = require_webhooks.hasExternalEvents(config);
 	const domains = {
 		metadata: hasMetadata(config),
 		businessConfig: hasBusinessConfig(config),
 		eventing: withCommerceEvents || withExternalEvents,
-		installation: require_installation.hasCustomInstallation(config),
+		installation: require_webhooks.hasCustomInstallation(config),
+		webhooks: require_webhooks.hasWebhooks(config),
 		"businessConfig.schema": hasBusinessConfigSchema(config),
 		"eventing.commerce": withCommerceEvents,
 		"eventing.external": withExternalEvents,
-		"installation.customInstallationSteps": require_installation.hasCustomInstallationSteps(config)
+		"installation.customInstallationSteps": require_webhooks.hasCustomInstallationSteps(config)
 	};
 	const domainsList = Object.entries(domains).filter(([_, value]) => value).map(([key]) => key);
 	return new Set(domainsList);