@adobe/aio-commerce-lib-app 0.3.1 → 1.0.0

package/dist/cjs/actions/index.cjs

@@ -1,824 +0,0 @@
-const require_error = require('../error-Byj1DVHZ.cjs');
-const require_management = require('../management-Dm5h0E6l.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_error.__toESM(_adobe_aio_lib_core_logging);
-let regexparam = require("regexparam");
-let _adobe_aio_lib_files = require("@adobe/aio-lib-files");
-let _adobe_aio_lib_state = require("@adobe/aio-lib-state");
-let openwhisk = require("openwhisk");
-openwhisk = require_error.__toESM(openwhisk);
-let valibot = require("valibot");
-valibot = require_error.__toESM(valibot);
-
-//#region ../../packages-private/common-utils/source/actions/http/middleware/logger.ts
-/**
-* Creates a logger middleware that adds logging capabilities to the context.
-*
-* @example
-* ```typescript
-* router.use(logger({ level: "debug", name: () => "my-logger-name" }));
-*
-* router.get("/test", {
-*   handler: (req, ctx) => {
-*     ctx.logger.info("Hello world");
-*     return ok({ body: {} });
-*   },
-* });
-* ```
-*/
-function logger({ name, ...restOptions } = {}) {
-	return (ctx) => {
-		const params = ctx.rawParams;
-		return { logger: (0, _adobe_aio_lib_core_logging.default)(`${params.__ow_method}-${name?.(ctx) ?? process.env.__OW_ACTION_NAME}`, {
-			level: `${params.LOG_LEVEL ?? "info"}`,
-			...restOptions
-		}) };
-	};
-}
-
-//#endregion
-//#region ../../packages-private/common-utils/source/actions/http/utils.ts
-/**
-* Validates input against a Standard Schema and returns a result.
-*
-* @template TInput - The input type expected by the schema
-* @template TOutput - The output type produced by the schema
-* @param schema - A Standard Schema v1 compliant schema
-* @param input - The input data to validate
-* @returns A promise resolving to either success with validated data or failure with issues
-*
-* @example
-* ```typescript
-* const result = await validateSchema(mySchema, userInput);
-* if (result.success) {
-*   console.log(result.data); // Typed as TOutput
-* } else {
-*   console.error(result.issues); // Validation errors
-* }
-* ```
-*/
-async function validateSchema(schema, input) {
-	const result = await schema["~standard"].validate(input);
-	if (result.issues) return {
-		success: false,
-		issues: result.issues.map((issue) => ({
-			message: issue.message,
-			path: issue.path?.map((segment) => typeof segment === "object" && segment !== null && "key" in segment ? segment.key : segment)
-		}))
-	};
-	return {
-		success: true,
-		data: result.value
-	};
-}
-/**
-* Parses a request body from OpenWhisk/Runtime.
-* Handles multiple formats:
-* - Base64-encoded strings (__ow_body)
-* - Already-parsed objects
-* - Body properties mixed into args (web actions with JSON content-type)
-*
-* @param owBody - Body from __ow_body (base64 string, JSON string, or object)
-* @param args - Full args object to extract body from if __ow_body is not present
-*
-* @example
-* ```typescript
-* const body = parseRequestBody(params.__ow_body, params);
-* ```
-*/
-function parseRequestBody(owBody, args) {
-	if (owBody) {
-		if (typeof owBody === "object") return owBody;
-		if (typeof owBody === "string") {
-			try {
-				return JSON.parse(owBody);
-			} catch {}
-			try {
-				const decoded = Buffer.from(owBody, "base64").toString();
-				return JSON.parse(decoded);
-			} catch {}
-		}
-	}
-	if (args && typeof args === "object") {
-		const body = {};
-		for (const [key, value] of Object.entries(args)) if (!key.startsWith("__ow_")) body[key] = value;
-		return body;
-	}
-	return {};
-}
-/**
-* Parses query parameters from OpenWhisk/Runtime format.
-*
-* @param queryString - Query string from __ow_query
-* @param fallbackParams - Fallback params object (used when __ow_query is not present)
-* @returns Parsed query parameters as a record
-*
-* @example
-* ```typescript
-* const query = parseQueryParams(params.__ow_query, params);
-* ```
-*/
-function parseQueryParams(queryString, fallbackParams) {
-	if (queryString) return Object.fromEntries(new URLSearchParams(queryString));
-	if (fallbackParams) {
-		const { __ow_method, __ow_path, __ow_headers, __ow_body, __ow_query, ...rest } = fallbackParams;
-		return rest;
-	}
-	return {};
-}
-
-//#endregion
-//#region ../../packages-private/common-utils/source/actions/http/router.ts
-/**
-* HTTP router for Adobe I/O Runtime actions.
-* Provides type-safe routing with schema validation and OpenWhisk integration.
-*
-* @example
-* ```typescript
-* const router = new HttpActionRouter();
-*
-* router.get("/users/:id", {
-*   handler: (req) => ok({ id: req.params.id, context: req.context })
-* });
-*
-* // Add context builders
-* router.use(async (base) => ({
-*   user: await getUser(base.rawParams.__ow_headers?.authorization),
-* }));
-*
-* export const main = router.handler();
-* ```
-*/
-var HttpActionRouter = class {
-	constructor() {
-		this.routes = [];
-		this.contextBuilders = [];
-	}
-	/**
-	* Internal method to add a route to the router.
-	*/
-	addRoute(method, path, config) {
-		const { pattern, keys } = (0, regexparam.parse)(path);
-		this.routes.push({
-			method,
-			pattern,
-			keys,
-			params: config.params,
-			body: config.body,
-			query: config.query,
-			handler: config.handler
-		});
-		return this;
-	}
-	/**
-	* Register a GET route.
-	*
-	* @example
-	* ```typescript
-	* router.get("/users/:id", {
-	*   handler: (req) => ok({ id: req.params.id })
-	* });
-	* ```
-	*/
-	get(path, config) {
-		return this.addRoute("GET", path, config);
-	}
-	/**
-	* Register a POST route.
-	*
-	* @example
-	* ```typescript
-	* router.post("/users", {
-	*   body: userSchema,
-	*   handler: (req) => created(req.body)
-	* });
-	* ```
-	*/
-	post(path, config) {
-		return this.addRoute("POST", path, config);
-	}
-	/**
-	* Register a PUT route.
-	*
-	* @example
-	* ```typescript
-	* router.put("/users/:id", {
-	*   body: userSchema,
-	*   handler: (req) => ok(req.body)
-	* });
-	* ```
-	*/
-	put(path, config) {
-		return this.addRoute("PUT", path, config);
-	}
-	/**
-	* Register a PATCH route.
-	*
-	* @example
-	* ```typescript
-	* router.patch("/users/:id", {
-	*   body: partialUserSchema,
-	*   handler: (req) => ok(req.body)
-	* });
-	* ```
-	*/
-	patch(path, config) {
-		return this.addRoute("PATCH", path, config);
-	}
-	/**
-	* Register a DELETE route.
-	*
-	* @example
-	* ```typescript
-	* router.delete("/users/:id", {
-	*   handler: (req) => noContent()
-	* });
-	* ```
-	*/
-	delete(path, config) {
-		return this.addRoute("DELETE", path, config);
-	}
-	/**
-	* Register a context builder that runs before route handlers.
-	* Context builders can add properties to the request context.
-	* Multiple builders are executed in order and their results are merged.
-	*
-	* The returned router has an updated context type that includes the new properties,
-	* enabling type-safe access in route handlers.
-	*
-	* @param builder - Function that receives base context and returns additional context
-	* @returns The router instance with updated context type for chaining
-	*
-	* @example
-	* ```typescript
-	* const router = new HttpActionRouter()
-	*   .use(logger()) // HttpActionRouter<BaseContext & { logger: Logger }>
-	*   .use(auth());  // HttpActionRouter<BaseContext & { logger: Logger } & { user: User }>
-	*
-	* router.get("/me", {
-	*   handler: (req, ctx) => {
-	*     ctx.logger.info("Hello"); // ✅ typed
-	*     return ok({ body: ctx.user }); // ✅ typed
-	*   },
-	* });
-	* ```
-	*/
-	use(builder) {
-		this.contextBuilders.push(builder);
-		return this;
-	}
-	/**
-	* Builds the full context by running all context builders.
-	*/
-	async buildContext(args) {
-		let context = { rawParams: args };
-		for (const builder of this.contextBuilders) {
-			const result = await builder(context);
-			if (result) context = {
-				...context,
-				...result
-			};
-		}
-		return context;
-	}
-	/**
-	* Validates and extracts route parameters.
-	*/
-	async validateParams(route, params) {
-		if (!route.params) return {
-			success: true,
-			data: params
-		};
-		const result = await validateSchema(route.params, params);
-		if (!result.success) return {
-			success: false,
-			issues: result.issues
-		};
-		return {
-			success: true,
-			data: result.data
-		};
-	}
-	/**
-	* Validates request body.
-	*/
-	async validateBody(route, body) {
-		if (!route.body) return {
-			success: true,
-			data: body
-		};
-		const result = await validateSchema(route.body, body);
-		if (!result.success) return {
-			success: false,
-			issues: result.issues
-		};
-		return {
-			success: true,
-			data: result.data
-		};
-	}
-	/**
-	* Validates query parameters.
-	*/
-	async validateQuery(route, query) {
-		if (!route.query) return {
-			success: true,
-			data: query
-		};
-		const result = await validateSchema(route.query, query);
-		if (!result.success) return {
-			success: false,
-			issues: result.issues
-		};
-		return {
-			success: true,
-			data: result.data
-		};
-	}
-	/** Handles a matched route by validating inputs and calling the handler. */
-	async handleRoute(route, match, body, query, headers, method, path, context) {
-		const params = {};
-		route.keys.forEach((key, i) => {
-			params[key] = decodeURIComponent(match[i + 1] || "");
-		});
-		const paramsResult = await this.validateParams(route, params);
-		if (!paramsResult.success) return (0, _adobe_aio_commerce_lib_core_responses.badRequest)({ body: {
-			message: "Invalid route parameters",
-			issues: paramsResult.issues
-		} });
-		const bodyResult = await this.validateBody(route, body);
-		if (!bodyResult.success) return (0, _adobe_aio_commerce_lib_core_responses.badRequest)({ body: {
-			message: "Invalid request body",
-			issues: bodyResult.issues
-		} });
-		const queryResult = await this.validateQuery(route, query);
-		if (!queryResult.success) return (0, _adobe_aio_commerce_lib_core_responses.badRequest)({ body: {
-			message: "Invalid query parameters",
-			issues: queryResult.issues
-		} });
-		try {
-			return await route.handler({
-				params: paramsResult.data,
-				body: bodyResult.data,
-				query: queryResult.data,
-				headers,
-				method,
-				path
-			}, context);
-		} catch (err) {
-			console.error("Handler error:", err);
-			return (0, _adobe_aio_commerce_lib_core_responses.internalServerError)({ body: {
-				message: "Internal server error",
-				error: err instanceof Error ? err.message : "Unknown error"
-			} });
-		}
-	}
-	/**
-	* Creates an OpenWhisk/Runtime action handler from the registered routes.
-	*
-	* @example
-	* ```typescript
-	* const router = new HttpActionRouter();
-	* router.get("/hello", { handler: () => ok({ message: "Hello!" }) });
-	*
-	* export const main = router.handler();
-	* ```
-	*/
-	handler() {
-		return async (args) => {
-			const method = (args.__ow_method ?? "get").toUpperCase();
-			const rawPath = args.__ow_path ?? "/";
-			const path = rawPath.startsWith("/") ? rawPath : `/${rawPath}`;
-			const headers = args.__ow_headers ?? {};
-			const body = parseRequestBody(args.__ow_body, args);
-			const query = parseQueryParams(args.__ow_query, args);
-			const context = await this.buildContext(args);
-			const matchedMethods = [];
-			for (const route of this.routes) {
-				const match = route.pattern.exec(path);
-				if (!match) continue;
-				matchedMethods.push(route.method);
-				if (route.method !== method) continue;
-				const response = await this.handleRoute(route, match, body, query, headers, method, path, context);
-				if (response) return response;
-			}
-			if (matchedMethods.length > 0) return (0, _adobe_aio_commerce_lib_core_responses.methodNotAllowed)(`Method ${method} not allowed`);
-			return (0, _adobe_aio_commerce_lib_core_responses.notFound)(`No route matches ${path}`);
-		};
-	}
-};
-
-//#endregion
-//#region ../../packages-private/common-utils/source/storage/files-store.ts
-/** Default directory prefix. */
-const DEFAULT_DIR_PREFIX = "store";
-/**
-* Creates a generic key-value store backed by @adobe/aio-lib-files.
-* Provides persistent storage that survives beyond TTL.
-*
-* @typeParam T - The type of data to store.
-* @param options - Configuration options for the store.
-* @returns A KeyValueStore implementation.
-*
-* @example
-* ```typescript
-* interface UserProfile {
-*   id: string;
-*   name: string;
-*   email: string;
-* }
-*
-* const store = await createFilesStore<UserProfile>({
-*   dirPrefix: "profiles",
-* });
-*
-* await store.put("user-123", { id: "123", name: "John", email: "john@example.com" });
-* const profile = await store.get("user-123");
-* ```
-*/
-async function createFilesStore(options = {}) {
-	const { dirPrefix = DEFAULT_DIR_PREFIX } = options;
-	return new FilesStore(await (0, _adobe_aio_lib_files.init)(), dirPrefix);
-}
-/**
-* Key-value store implementation using @adobe/aio-lib-files.
-*/
-var FilesStore = class {
-	constructor(files, dirPrefix) {
-		this.files = files;
-		this.dirPrefix = dirPrefix;
-	}
-	async get(key) {
-		const filePath = this.buildFilePath(key);
-		try {
-			const content = await this.files.read(filePath);
-			if (!content) return null;
-			return JSON.parse(content.toString("utf8"));
-		} catch {
-			return null;
-		}
-	}
-	async put(key, data) {
-		const filePath = this.buildFilePath(key);
-		await this.files.write(filePath, JSON.stringify(data));
-	}
-	async delete(key) {
-		const filePath = this.buildFilePath(key);
-		try {
-			const result = await this.files.delete(filePath);
-			return Array.isArray(result) && result.length > 0;
-		} catch {
-			return false;
-		}
-	}
-	buildFilePath(key) {
-		return `${this.dirPrefix}/${key}.json`;
-	}
-};
-
-//#endregion
-//#region ../../packages-private/common-utils/source/storage/state-store.ts
-/** Default TTL for state entries (3 hours in seconds). */
-const DEFAULT_TTL_SECONDS = 10800;
-/** Default key prefix. */
-const DEFAULT_KEY_PREFIX = "store";
-/**
-* Creates a generic key-value store backed by @adobe/aio-lib-state.
-* Provides fast, TTL-based caching for temporary data.
-*
-* @typeParam T - The type of data to store.
-* @param options - Configuration options for the store.
-* @returns A KeyValueStore implementation.
-*
-* @example
-* ```typescript
-* interface UserSession {
-*   userId: string;
-*   token: string;
-* }
-*
-* const store = await createStateStore<UserSession>({
-*   keyPrefix: "session",
-*   ttlSeconds: 3600, // 1 hour
-* });
-*
-* await store.put("user-123", { userId: "123", token: "abc" });
-* const session = await store.get("user-123");
-* ```
-*/
-async function createStateStore(options = {}) {
-	const { keyPrefix = DEFAULT_KEY_PREFIX, ttlSeconds = DEFAULT_TTL_SECONDS } = options;
-	return new StateStore(await (0, _adobe_aio_lib_state.init)(), keyPrefix, ttlSeconds);
-}
-/**
-* Key-value store implementation using @adobe/aio-lib-state.
-*/
-var StateStore = class {
-	constructor(state, keyPrefix, ttlSeconds) {
-		this.state = state;
-		this.keyPrefix = keyPrefix;
-		this.ttlSeconds = ttlSeconds;
-	}
-	async get(key) {
-		const fullKey = this.buildKey(key);
-		const result = await this.state.get(fullKey);
-		if (!result?.value) return null;
-		try {
-			return JSON.parse(result.value);
-		} catch {
-			return null;
-		}
-	}
-	async put(key, data) {
-		const fullKey = this.buildKey(key);
-		const value = JSON.stringify(data);
-		await this.state.put(fullKey, value, { ttl: this.ttlSeconds });
-	}
-	async delete(key) {
-		const fullKey = this.buildKey(key);
-		try {
-			await this.state.delete(fullKey);
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	buildKey(key) {
-		return `${this.keyPrefix}-${key}`;
-	}
-};
-
-//#endregion
-//#region ../../packages-private/common-utils/source/storage/combined-store.ts
-/** Default TTL for cache (10 minutes). */
-const DEFAULT_CACHE_TTL_SECONDS = 600;
-/**
-* Creates a combined key-value store that uses:
-* - lib-state for fast cache during active operations
-* - lib-files for persistent storage
-*
-* Read strategy: cache first, then persistent storage
-* Write strategy:
-* - Always write to cache for fast reads
-* - Write to persistent storage based on shouldPersist predicate
-*
-* @typeParam T - The type of data to store.
-* @param options - Configuration options for the stores.
-*
-* @example
-* ```typescript
-* interface Task {
-*   id: string;
-*   status: "pending" | "completed";
-*   result?: unknown;
-* }
-*
-* const store = await createCombinedStore<Task>({
-*   cache: { keyPrefix: "task", ttlSeconds: 600 },
-*   persistent: {
-*     dirPrefix: "tasks",
-*     shouldPersist: (task) => task.status === "completed",
-*   },
-* });
-*
-* // During processing: writes to cache only
-* await store.put("task-1", { id: "1", status: "pending" });
-*
-* // On completion (as shouldPersist indicates): writes to both cache and persistent
-* await store.put("task-1", { id: "1", status: "completed", result: {} });
-* ```
-*/
-async function createCombinedStore(options = {}) {
-	const { cache = {}, persistent = {} } = options;
-	const { shouldPersist, ...filesOptions } = persistent;
-	const cacheOptions = {
-		ttlSeconds: DEFAULT_CACHE_TTL_SECONDS,
-		...cache
-	};
-	const [cacheStore, persistentStore] = await Promise.all([createStateStore(cacheOptions), createFilesStore(filesOptions)]);
-	return new CombinedStore(cacheStore, persistentStore, shouldPersist);
-}
-/**
-* Combined key-value store implementation.
-* Uses lib-state for cache and lib-files for persistence.
-*/
-var CombinedStore = class {
-	constructor(cache, persistent, shouldPersist) {
-		this.cache = cache;
-		this.persistent = persistent;
-		this.shouldPersist = shouldPersist;
-	}
-	async get(key) {
-		const cached = await this.cache.get(key);
-		if (cached !== null && cached !== void 0) return cached;
-		const persisted = await this.persistent.get(key);
-		if (persisted !== null && persisted !== void 0) {
-			await this.cache.put(key, persisted).catch(() => {});
-			return persisted;
-		}
-		return null;
-	}
-	async put(key, data) {
-		await this.cache.put(key, data);
-		if (!this.shouldPersist || this.shouldPersist(data)) await this.persistent.put(key, data);
-	}
-	async delete(key) {
-		const [cacheDeleted, persistentDeleted] = await Promise.all([this.cache.delete?.(key) ?? Promise.resolve(false), this.persistent.delete?.(key) ?? Promise.resolve(false)]);
-		return cacheDeleted || persistentDeleted;
-	}
-};
-
-//#endregion
-//#region source/management/installation/schema.ts
-/** Schema for validating Adobe I/O app credentials required for installation. */
-const AppDataSchema = valibot.object({
-	consumerOrgId: require_error.nonEmptyStringValueSchema("consumerOrgId"),
-	orgName: require_error.nonEmptyStringValueSchema("orgName"),
-	projectId: require_error.nonEmptyStringValueSchema("projectId"),
-	projectName: require_error.nonEmptyStringValueSchema("projectName"),
-	projectTitle: require_error.nonEmptyStringValueSchema("projectTitle"),
-	workspaceId: require_error.nonEmptyStringValueSchema("workspaceId"),
-	workspaceName: require_error.nonEmptyStringValueSchema("workspaceName"),
-	workspaceTitle: require_error.nonEmptyStringValueSchema("workspaceTitle")
-});
-
-//#endregion
-//#region source/actions/installation.ts
-const DEFAULT_ACTION_NAME = "app-management/installation";
-/** Creates an installation state store using lib-core combined storage. */
-function createInstallationStore() {
-	return createCombinedStore({
-		cache: { keyPrefix: "installation" },
-		persistent: {
-			dirPrefix: "installation",
-			shouldPersist: require_management.isCompletedState
-		}
-	});
-}
-/** Returns the storage key used to store the current installation ID. */
-function getStorageKey() {
-	return "current";
-}
-/**
-* Creates hooks to sync installation state to storage.
-*/
-function createInstallationHooks(store, logFn) {
-	const logAndSave = async (message, data) => {
-		logFn(message);
-		await store.put(getStorageKey(), data);
-	};
-	return {
-		onInstallationStart: (state) => logAndSave("Installation started", state),
-		onInstallationFailure: (state) => logAndSave("Installation failed", state),
-		onInstallationSuccess: (state) => logAndSave("Installation succeeded", state),
-		onStepStart: (event, state) => logAndSave(`Step started: ${event.stepName}`, state),
-		onStepSuccess: (event, state) => logAndSave(`Step succeeded: ${event.stepName}`, state),
-		onStepFailure: (event, state) => logAndSave(`Step failed: ${event.stepName}`, state)
-	};
-}
-/**
-* Installation action router.
-*
-* Routes:
-* - POST /installation - Start installation (creates plan, invokes execution async)
-* - GET /installation/execution - Get current execution status
-* - POST /installation/execution - Execute installation (internal, called async)
-*/
-const router = new HttpActionRouter().use(logger({ name: () => "installation" }));
-/**
-* GET /installation/execution - Get current execution status
-*
-* Flow:
-* 1. Find execution in state store
-* 2. If found: return execution plan with step statuses
-* 3. If not found: return empty status
-*/
-router.get("/", { handler: async (_req, { logger: logger$1 }) => {
-	logger$1.debug("Getting installation execution status...");
-	const state = await (await createInstallationStore()).get(getStorageKey());
-	if (state) {
-		logger$1.debug(`Found execution: ${state.status}`);
-		return (0, _adobe_aio_commerce_lib_core_responses.ok)({ body: state });
-	}
-	logger$1.debug("No execution found");
-	return (0, _adobe_aio_commerce_lib_core_responses.noContent)();
-} });
-/**
-* POST / - Start installation
-*
-* Flow:
-* 1. Find execution in state store
-* 2. If found and (pending/in-progress or succeeded): return 409 Conflict
-* 3. If not found or failed: create plan, invoke execution async, return 202 Accepted
-*/
-router.post("/", {
-	body: (0, valibot.object)({
-		appData: AppDataSchema,
-		commerceBaseUrl: (0, valibot.string)(),
-		commerceEnv: (0, valibot.string)(),
-		ioEventsUrl: (0, valibot.string)(),
-		ioEventsEnv: (0, valibot.string)()
-	}),
-	handler: async (req, { logger: logger$1, rawParams }) => {
-		logger$1.debug("Starting installation...");
-		const store = await createInstallationStore();
-		const existingState = await store.get(getStorageKey());
-		if (existingState) {
-			if (require_management.isInProgressState(existingState)) {
-				logger$1.debug(`Installation already in progress: ${existingState.status}`);
-				return (0, _adobe_aio_commerce_lib_core_responses.conflict)(`Installation is already ${existingState.status}. Wait for it to complete.`);
-			}
-			if (require_management.isSucceededState(existingState)) {
-				logger$1.debug("Installation already succeeded");
-				return (0, _adobe_aio_commerce_lib_core_responses.conflict)("Installation has already completed successfully.");
-			}
-			logger$1.debug("Previous installation failed, allowing retry");
-		}
-		const appConfig = rawParams.appConfig;
-		if (!appConfig) return (0, _adobe_aio_commerce_lib_core_responses.internalServerError)("Could not find or parse the app.commerce.manifest.json file, is it present and valid?");
-		const initialState = require_management.createInitialInstallationState({ config: appConfig });
-		logger$1.debug(`Created initial state: ${initialState.id}`);
-		await store.put(getStorageKey(), initialState);
-		const activation = await (0, openwhisk.default)().actions.invoke({
-			name: DEFAULT_ACTION_NAME,
-			blocking: false,
-			result: false,
-			params: {
-				...rawParams,
-				appData: req.body.appData,
-				AIO_EVENTS_API_BASE_URL: req.body.ioEventsUrl,
-				AIO_COMMERCE_AUTH_IMS_ENVIRONMENT: req.body.ioEventsEnv,
-				AIO_COMMERCE_API_BASE_URL: req.body.commerceBaseUrl,
-				AIO_COMMERCE_API_FLAVOR: req.body.commerceEnv,
-				initialState,
-				appConfig,
-				__ow_path: "/execution",
-				__ow_method: "post"
-			}
-		});
-		logger$1.debug(`Async execution started: ${activation.activationId}`);
-		return (0, _adobe_aio_commerce_lib_core_responses.accepted)({ body: {
-			message: "Installation started",
-			activationId: activation.activationId,
-			...initialState
-		} });
-	}
-});
-/**
-* POST /installation/execution - Execute installation (internal)
-*
-* This endpoint is called asynchronously by POST /installation.
-* It runs the actual installation workflow and saves state.
-*/
-router.post("/execution", { handler: async (_req, { logger: logger$1, rawParams }) => {
-	const { appData, ...params } = rawParams;
-	const { initialState, appConfig } = params;
-	if (!initialState) return (0, _adobe_aio_commerce_lib_core_responses.badRequest)("initialState is required for execution");
-	if (!appConfig) return (0, _adobe_aio_commerce_lib_core_responses.badRequest)("appConfig is required for execution");
-	const store = await createInstallationStore();
-	const hooks = createInstallationHooks(store, (msg) => logger$1.debug(msg));
-	const installationContext = {
-		appData,
-		params,
-		logger: logger$1,
-		customScripts: params.customScriptsLoader?.(appConfig, logger$1) || {}
-	};
-	logger$1.debug(`Executing installation: ${initialState.id}`);
-	const result = await require_management.runInstallation({
-		installationContext,
-		config: appConfig,
-		initialState,
-		hooks
-	});
-	await store.put(getStorageKey(), result);
-	logger$1.debug(`Installation completed: ${result.status}`);
-	if (require_management.isFailedState(result)) return (0, _adobe_aio_commerce_lib_core_responses.internalServerError)({ body: {
-		message: "Installation failed",
-		error: result.error,
-		state: result
-	} });
-	return (0, _adobe_aio_commerce_lib_core_responses.ok)({ body: result });
-} });
-/**
-* DELETE / - Clear installation state
-*
-* This endpoint allows clearing the installation state.
-*/
-router.delete("/", { handler: async (_req, { logger: logger$1 }) => {
-	logger$1.debug("Clearing installation state...");
-	await (await createInstallationStore()).delete(getStorageKey());
-	logger$1.debug("Installation state cleared");
-	return (0, _adobe_aio_commerce_lib_core_responses.noContent)();
-} });
-/** The route handler for the runtime action. */
-const installationRuntimeAction = ({ appConfig, customScriptsLoader }) => async (params) => {
-	return await router.handler()({
-		...params,
-		appConfig,
-		customScriptsLoader
-	});
-};
-
-//#endregion
-exports.installationRuntimeAction = installationRuntimeAction;