@adobe/aio-commerce-lib-app 2.0.0-beta-20260820174436 → 2.0.0

package/dist/cjs/{management-BhMdRr8i.cjs → management-Bki3hlxL.cjs}

@@ -16,7 +16,7 @@ const require_rolldown_runtime = require('./rolldown-runtime-CDQd2xEI.cjs');
 const require_utils = require('./utils-CHfNw_aP.cjs');
 const require_error = require('./error-D-N0PKSl.cjs');
 const require_environment = require('./environment-B6533pAY.cjs');
-const require_webhooks = require('./webhooks-E1KDx3Yu.cjs');
+const require_webhooks = require('./webhooks-Bcq2Qy7q.cjs');
 const require_logging = require('./logging-Br3xfBNe.cjs');
 let _adobe_aio_commerce_lib_api = require("@adobe/aio-commerce-lib-api");
 let _adobe_aio_commerce_lib_config = require("@adobe/aio-commerce-lib-config");
@@ -25,11 +25,11 @@ let safe_stable_stringify = require("safe-stable-stringify");
 safe_stable_stringify = require_rolldown_runtime.__toESM(safe_stable_stringify, 1);
 let valibot = require("valibot");
 valibot = require_rolldown_runtime.__toESM(valibot, 1);
+let _adobe_aio_commerce_lib_admin_ui_api = require("@adobe/aio-commerce-lib-admin-ui/api");
 let ky = require("ky");
 let _adobe_aio_commerce_lib_api_utils = require("@adobe/aio-commerce-lib-api/utils");
 let camelcase = require("camelcase");
 camelcase = require_rolldown_runtime.__toESM(camelcase, 1);
-let _adobe_aio_commerce_lib_admin_ui_api = require("@adobe/aio-commerce-lib-admin-ui/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");
@@ -515,6 +515,18 @@ function resolveCustomScriptHandler(scriptModule, handler) {
 	return null;
 }
 /**
+* Resolves a script module from the customScripts context, throwing when it's absent.
+*
+* @param customScripts - The customScripts context containing the loaded modules.
+* @param script - The script path to resolve the module for.
+* @throws If the script is not present in the context.
+*/
+function getScriptModuleOrThrow(customScripts, script) {
+	const scriptModule = getScriptModule(customScripts, script);
+	if (!scriptModule) throw new Error(`Script ${script} not found in customScripts context. Make sure the script is defined in the configuration and the action was generated with custom scripts support.`);
+	return scriptModule;
+}
+/**
 * Creates a leaf step for executing a single custom installation script.
 */
 function createCustomScriptStep(scriptConfig) {
@@ -525,9 +537,7 @@ function createCustomScriptStep(scriptConfig) {
 			const customScripts = context.customScripts || {};
 			logger.info(`Executing custom installation script: ${name}`);
 			logger.debug(`Script path: ${script}`);
-			const scriptModule = getScriptModule(customScripts, script);
-			if (!scriptModule) throw new Error(`Script ${script} not found in customScripts context. Make sure the script is defined in the configuration and the action was generated with custom scripts support.`);
-			const scriptResult = await resolveCustomScriptHandler(scriptModule, "install")(config, context);
+			const scriptResult = await resolveCustomScriptHandler(getScriptModuleOrThrow(customScripts, script), "install")(config, context);
 			logger.info(`Successfully executed script: ${name}`);
 			return {
 				data: scriptResult,
@@ -569,8 +579,134 @@ function createCustomScriptSteps(config) {
 	return steps.map((scriptConfig) => createCustomScriptStep(scriptConfig));
 }
 
+//#endregion
+//#region source/management/domains/custom-installation/apply.ts
+/** Runs a newly-added step's `install` handler and returns its persisted identity. */
+async function runAddedStep(step, targetConfig, context) {
+	const { logger } = context;
+	const scriptModule = getScriptModuleOrThrow(context.customScripts ?? {}, step.script);
+	logger.info(`Executing custom installation script: ${step.name}`);
+	await resolveCustomScriptHandler(scriptModule, "install")(targetConfig, context);
+	logger.info(`Successfully executed script: ${step.name}`);
+	return {
+		name: step.name,
+		script: step.script
+	};
+}
+/**
+* Applies the plan: runs `install` for first-time steps, warns about retained steps that point to
+* a different script (without re-running them), and ignores steps no longer in the config. Returns
+* the baseline history with the newly-added steps appended.
+*/
+async function applyCustomInstallationSteps(plan, context) {
+	const { baselineExecutedSteps, targetConfig, operations } = plan;
+	if (!targetConfig) return { snapshotData: { executedSteps: baselineExecutedSteps } };
+	const targetSteps = require_webhooks.hasCustomInstallationSteps(targetConfig) ? targetConfig.installation.customInstallationSteps : [];
+	const addedNames = new Set(operations.filter((op) => op.kind === "add").map((op) => op.after.name));
+	for (const targetStep of targetSteps) {
+		if (addedNames.has(targetStep.name)) continue;
+		const baselineStep = baselineExecutedSteps.find((step) => step.name === targetStep.name);
+		if (baselineStep && baselineStep.script !== targetStep.script) context.logger.warn(`Custom installation step "${targetStep.name}" now points to a different script ("${targetStep.script}" instead of "${baselineStep.script}"). This does not affect append-only behavior: its install already ran and will not run again.`);
+	}
+	const addedSteps = targetSteps.filter((step) => addedNames.has(step.name));
+	const addedIdentities = [];
+	for (const step of addedSteps) addedIdentities.push(await runAddedStep(step, targetConfig, context));
+	return { snapshotData: { executedSteps: [...baselineExecutedSteps, ...addedIdentities] } };
+}
+
+//#endregion
+//#region source/management/domains/custom-installation/plan.ts
+/** Builds an `add` operation for a step run for the first time. */
+function buildAddOperation(step) {
+	return {
+		after: {
+			name: step.name,
+			script: step.script
+		},
+		id: `add:${step.name}`,
+		kind: "add",
+		label: `Run custom installation step "${step.name}"`
+	};
+}
+/**
+* Builds an informational `remove` operation for a step no longer in the target config. No
+* `uninstall` runs from it; it exists so the plan reflects that the step left the configuration.
+*/
+function buildRemoveOperation(step) {
+	return {
+		before: {
+			name: step.name,
+			script: step.script
+		},
+		id: `remove:${step.name}`,
+		kind: "remove",
+		label: `Custom installation step "${step.name}" no longer in the configuration`
+	};
+}
+/**
+* Resolves the executed-step history to diff the target against. Prefers the reconciliation
+* snapshot when present, and otherwise reconstructs it from the baseline config's own steps.
+*/
+function resolveBaselineExecutedSteps(baseline) {
+	const recorded = baseline?.data?.executedSteps;
+	if (recorded) return recorded;
+	if (baseline && require_webhooks.hasCustomInstallationSteps(baseline.config)) return baseline.config.installation.customInstallationSteps.map((step) => ({
+		name: step.name,
+		script: step.script
+	}));
+	return [];
+}
+/**
+* Plans the custom installation steps domain by diffing the baseline's executed-step history
+* against the target config's steps, by `name`: `add` for names not seen before, `remove` for
+* names no longer configured. Steps present in both produce no operation and are never re-run.
+*/
+function planCustomInstallationSteps(input, _context) {
+	const { path, baseline, targetConfig } = input;
+	const baselineExecutedSteps = resolveBaselineExecutedSteps(baseline);
+	const targetSteps = targetConfig && require_webhooks.hasCustomInstallationSteps(targetConfig) ? targetConfig.installation.customInstallationSteps : [];
+	const baselineNames = new Set(baselineExecutedSteps.map((s) => s.name));
+	const targetNames = new Set(targetSteps.map((s) => s.name));
+	const operations = [...targetSteps.filter((step) => !baselineNames.has(step.name)).map((step) => buildAddOperation(step)), ...baselineExecutedSteps.filter((step) => !targetNames.has(step.name)).map((step) => buildRemoveOperation(step))];
+	return Promise.resolve({
+		kind: "planned",
+		plan: {
+			baselineExecutedSteps,
+			operations,
+			path,
+			targetConfig
+		}
+	});
+}
+
 //#endregion
 //#region source/management/domains/custom-installation/branch.ts
+/**
+* Leaf step that reconciles the custom installation steps domain as a whole via `plan`/`apply`.
+* It participates only in the upgrade tree; the per-script leaves handle install and uninstall.
+*/
+const reconciliationStep = defineLeafStep({
+	apply: applyCustomInstallationSteps,
+	install: (config) => {
+		if (!require_webhooks.hasCustomInstallationSteps(config)) return { executedSteps: [] };
+		return { executedSteps: config.installation.customInstallationSteps.map((step) => ({
+			name: step.name,
+			script: step.script
+		})) };
+	},
+	meta: {
+		install: {
+			description: "Records which custom installation steps ran, so future upgrades can detect additions and removals",
+			label: "Reconcile Custom Installation Steps"
+		},
+		upgrade: {
+			description: "Runs custom installation steps added since the last version",
+			label: "Reconcile Custom Installation Steps"
+		}
+	},
+	name: "reconciliation",
+	plan: planCustomInstallationSteps
+});
 /** Root custom installation step that executes custom installation scripts. */
 const customInstallationStepBase = defineBranchStep({
 	children: [],
@@ -583,18 +719,33 @@ const customInstallationStepBase = defineBranchStep({
 		uninstall: {
 			description: "Executes custom uninstallation scripts defined in the application configuration",
 			label: "Custom Uninstallation Steps"
+		},
+		upgrade: {
+			description: "Reconciles custom installation steps added or removed between versions",
+			label: "Custom Installation Steps"
 		}
 	},
 	name: "customInstallationSteps"
 });
 /**
-* Creates the custom installation step with dynamic children based on config.
-* Each custom script becomes a direct child step.
-*/
-function createCustomInstallationStep(config) {
+* Creates the custom installation step with dynamic children based on config. `executedSteps` is
+* the recorded run history, only passed when building the full-uninstall tree.
+* `includeReconciliation` adds the reconciliation leaf, which only runs on upgrade; install and
+* uninstall leave it out.
+*/
+function createCustomInstallationStep(config, executedSteps = [], includeReconciliation = false) {
+	const children = executedSteps.length > 0 ? [...executedSteps].reverse().map((identity) => {
+		const currentStep = require_webhooks.hasCustomInstallationSteps(config) ? config.installation.customInstallationSteps.find((step) => step.name === identity.name) : void 0;
+		return createCustomScriptStep(currentStep ?? {
+			description: "Previously executed custom installation step, no longer present in the configuration.",
+			name: identity.name,
+			script: identity.script
+		});
+	}) : [...createCustomScriptSteps(config), ...includeReconciliation ? [reconciliationStep] : []];
 	return {
 		...customInstallationStepBase,
-		children: createCustomScriptSteps(config)
+		children,
+		isConfigured: (candidateConfig) => require_webhooks.hasCustomInstallationSteps(candidateConfig) || executedSteps.length > 0
 	};
 }
 
@@ -845,6 +996,18 @@ function enumerateComponents(adminUi) {
 		label: "menu",
 		ref: { kind: "menu" }
 	});
+	for (const aclEntry of adminUi.acl ?? []) {
+		const key = `acl.${aclEntry.id}`;
+		components.set(key, {
+			config: aclEntry,
+			key,
+			label: `acl resource "${aclEntry.id}"`,
+			ref: {
+				id: aclEntry.id,
+				kind: "acl"
+			}
+		});
+	}
 	for (const entity of ADMIN_UI_ENTITIES) {
 		const entityConfig = adminUi[entity];
 		if (!entityConfig) continue;
@@ -1120,15 +1283,24 @@ async function reconcileProviderSubResources(baseline, target, targetMetadata, b
 	}
 	await removeDroppedMetadata(providerData, options.type, target.events, baseline.events, targetMetadata, baselineMetadata, context);
 }
-/** Finds the deployed I/O Events provider by its current or legacy instance id. */
+/**
+* Finds the deployed I/O Events provider for a target, preferring the current workspace-scoped
+* instance id over the legacy (workspace-less) one, and a metadata-bearing provider over an empty
+* duplicate that shares its instance id.
+*/
 function resolveDeployedProvider(target, targetMetadata, baselineMetadata, workspaceId, existingData) {
-	const candidates = /* @__PURE__ */ new Set([
+	const orderedCandidates = [
 		require_utils.generateInstanceId(targetMetadata, target.provider, workspaceId),
-		require_utils.generateInstanceIdDeprecated(targetMetadata, target.provider),
 		require_utils.generateInstanceId(baselineMetadata, target.provider, workspaceId),
+		require_utils.generateInstanceIdDeprecated(targetMetadata, target.provider),
 		require_utils.generateInstanceIdDeprecated(baselineMetadata, target.provider)
-	]);
-	return existingData.providersWithMetadata.find((candidate) => candidates.has(candidate.instance_id)) ?? null;
+	];
+	for (const candidate of orderedCandidates) {
+		const matches = existingData.providersWithMetadata.filter((provider) => provider.instance_id === candidate);
+		if (matches.length === 0) continue;
+		return matches.find((provider) => provider.metadata.length > 0) ?? matches[0];
+	}
+	return null;
 }
 /** The fully-qualified I/O Events code set for a group of events under a provider type. */
 function eventCodeSet(events, type, metadata) {
@@ -2945,22 +3117,26 @@ const webhooksStep = defineBranchStep({
 //#endregion
 //#region source/management/installation/root.ts
 /**
-* Creates the default child steps built-in in the library with dynamic children based on the config.
+* Creates the default child steps built-in in the library with dynamic children based on the
+* config. `executedCustomInstallationSteps` is only meaningful for a full uninstall (see
+* {@link createRootUninstallationStep}). `includeReconciliation` adds the reconciliation leaf,
+* which only runs on upgrade.
 */
-function createDefaultChildSteps(config) {
+function createDefaultChildSteps(config, executedCustomInstallationSteps = [], includeReconciliation = false) {
 	return [
 		eventingStep,
 		webhooksStep,
 		adminUiStep,
-		createCustomInstallationStep(config)
+		createCustomInstallationStep(config, executedCustomInstallationSteps, includeReconciliation)
 	];
 }
 /**
-* Creates a root installation step with dynamic children based on the config.
+* Creates a root installation step with dynamic children based on the config. `forUpgrade` adds the
+* reconciliation leaf, which only runs on upgrade.
 */
-function createRootInstallationStep(config) {
+function createRootInstallationStep(config, { forUpgrade = false } = {}) {
 	return defineBranchStep({
-		children: createDefaultChildSteps(config),
+		children: createDefaultChildSteps(config, [], forUpgrade),
 		meta: {
 			install: {
 				description: "App installation workflow",
@@ -2980,10 +3156,14 @@ function createRootInstallationStep(config) {
 }
 /**
 * Creates a root uninstallation step with dynamic children based on the config.
+*
+* `executedCustomInstallationSteps` is the persisted history of every custom installation step
+* that ever ran (from the lifecycle baseline snapshot). Passing it lets a full unassociate reach
+* steps that ran in a previous version but were since removed from the config.
 */
-function createRootUninstallationStep(config) {
+function createRootUninstallationStep(config, executedCustomInstallationSteps = []) {
 	return defineBranchStep({
-		children: createDefaultChildSteps(config),
+		children: createDefaultChildSteps(config, executedCustomInstallationSteps),
 		meta: { install: {
 			description: "App uninstallation workflow",
 			label: "Uninstallation"
@@ -3071,8 +3251,8 @@ async function runInstallation(options) {
 * Creates an initial uninstallation state from the config and step definitions.
 */
 function createInitialUninstallationState(options) {
-	const { config } = options;
-	const rootStep = createRootUninstallationStep(config);
+	const { config, executedCustomInstallationSteps = [] } = options;
+	const rootStep = createRootUninstallationStep(config, executedCustomInstallationSteps);
 	return createInitialState({
 		config,
 		mode: "uninstall",
@@ -3083,8 +3263,8 @@ function createInitialUninstallationState(options) {
 * Runs the full uninstallation workflow. Returns the final state (never throws).
 */
 function runUninstallation(options) {
-	const { installationContext, config, initialState, hooks } = options;
-	const rootStep = createRootUninstallationStep(config);
+	const { installationContext, config, initialState, hooks, executedCustomInstallationSteps = [] } = options;
+	const rootStep = createRootUninstallationStep(config, executedCustomInstallationSteps);
 	return executeUninstallWorkflow({
 		config,
 		failureKey: "INSTALLATION_FAILED",