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

package/dist/es/actions/index.mjs

@@ -0,0 +1,822 @@
+import { u as nonEmptyStringValueSchema } from "../error-P7JgUTds.mjs";
+import { a as isFailedState, i as isCompletedState, n as runInstallation, o as isInProgressState, s as isSucceededState, t as createInitialInstallationState } from "../management-Y7pwEbNI.mjs";
+import { accepted, badRequest, conflict, internalServerError, methodNotAllowed, noContent, notFound, ok } from "@adobe/aio-commerce-lib-core/responses";
+import AioLogger from "@adobe/aio-lib-core-logging";
+import { parse } from "regexparam";
+import { init } from "@adobe/aio-lib-files";
+import { init as init$1 } from "@adobe/aio-lib-state";
+import openwhisk from "openwhisk";
+import * as v from "valibot";
+import { object, string } from "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: AioLogger(`${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 } = 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 badRequest({ body: {
+			message: "Invalid route parameters",
+			issues: paramsResult.issues
+		} });
+		const bodyResult = await this.validateBody(route, body);
+		if (!bodyResult.success) return badRequest({ body: {
+			message: "Invalid request body",
+			issues: bodyResult.issues
+		} });
+		const queryResult = await this.validateQuery(route, query);
+		if (!queryResult.success) return 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 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 methodNotAllowed(`Method ${method} not allowed`);
+			return 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 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 init$1(), 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 = v.object({
+	consumerOrgId: nonEmptyStringValueSchema("consumerOrgId"),
+	orgName: nonEmptyStringValueSchema("orgName"),
+	projectId: nonEmptyStringValueSchema("projectId"),
+	projectName: nonEmptyStringValueSchema("projectName"),
+	projectTitle: nonEmptyStringValueSchema("projectTitle"),
+	workspaceId: nonEmptyStringValueSchema("workspaceId"),
+	workspaceName: nonEmptyStringValueSchema("workspaceName"),
+	workspaceTitle: 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: 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 ok({ body: state });
+	}
+	logger$1.debug("No execution found");
+	return 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: object({
+		appData: AppDataSchema,
+		commerceBaseUrl: string(),
+		commerceEnv: string(),
+		ioEventsUrl: string(),
+		ioEventsEnv: 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 (isInProgressState(existingState)) {
+				logger$1.debug(`Installation already in progress: ${existingState.status}`);
+				return conflict(`Installation is already ${existingState.status}. Wait for it to complete.`);
+			}
+			if (isSucceededState(existingState)) {
+				logger$1.debug("Installation already succeeded");
+				return conflict("Installation has already completed successfully.");
+			}
+			logger$1.debug("Previous installation failed, allowing retry");
+		}
+		const appConfig = rawParams.appConfig;
+		if (!appConfig) return internalServerError("Could not find or parse the app.commerce.manifest.json file, is it present and valid?");
+		const initialState = createInitialInstallationState({ config: appConfig });
+		logger$1.debug(`Created initial state: ${initialState.id}`);
+		await store.put(getStorageKey(), initialState);
+		const activation = await openwhisk().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 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 badRequest("initialState is required for execution");
+	if (!appConfig) return 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 runInstallation({
+		installationContext,
+		config: appConfig,
+		initialState,
+		hooks
+	});
+	await store.put(getStorageKey(), result);
+	logger$1.debug(`Installation completed: ${result.status}`);
+	if (isFailedState(result)) return internalServerError({ body: {
+		message: "Installation failed",
+		error: result.error,
+		state: result
+	} });
+	return 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 noContent();
+} });
+/** The route handler for the runtime action. */
+const installationRuntimeAction = ({ appConfig, customScriptsLoader }) => async (params) => {
+	return await router.handler()({
+		...params,
+		appConfig,
+		customScriptsLoader
+	});
+};
+
+//#endregion
+export { installationRuntimeAction };