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

package/dist/es/actions/config.mjs

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

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

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

package/dist/es/actions/{index.mjs → installation.mjs}

@@ -1,413 +1,13 @@
-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 { n as logger, t as HttpActionRouter } from "../router-CJ4VWoCt.mjs";
+import { r as nonEmptyStringValueSchema } from "../schemas-B8yIv0_b.mjs";
+import { a as isFailedState, i as isCompletedState, n as runInstallation, o as isInProgressState, s as isSucceededState, t as createInitialInstallationState } from "../runner-DB2tDBQS.mjs";
+import { accepted, badRequest, conflict, internalServerError, noContent, ok } from "@adobe/aio-commerce-lib-core/responses";
+import * as v from "valibot";
+import { object, string } from "valibot";
 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";
@@ -692,14 +292,14 @@ const router = new HttpActionRouter().use(logger({ name: () => "installation" })
 * 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...");
+router.get("/", { handler: async (_req, { logger }) => {
+	logger.debug("Getting installation execution status...");
 	const state = await (await createInstallationStore()).get(getStorageKey());
 	if (state) {
-		logger$1.debug(`Found execution: ${state.status}`);
+		logger.debug(`Found execution: ${state.status}`);
 		return ok({ body: state });
 	}
-	logger$1.debug("No execution found");
+	logger.debug("No execution found");
 	return noContent();
 } });
 /**
@@ -718,25 +318,25 @@ router.post("/", {
 		ioEventsUrl: string(),
 		ioEventsEnv: string()
 	}),
-	handler: async (req, { logger: logger$1, rawParams }) => {
-		logger$1.debug("Starting installation...");
+	handler: async (req, { logger, rawParams }) => {
+		logger.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}`);
+				logger.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");
+				logger.debug("Installation already succeeded");
 				return conflict("Installation has already completed successfully.");
 			}
-			logger$1.debug("Previous installation failed, allowing retry");
+			logger.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}`);
+		logger.debug(`Created initial state: ${initialState.id}`);
 		await store.put(getStorageKey(), initialState);
 		const activation = await openwhisk().actions.invoke({
 			name: DEFAULT_ACTION_NAME,
@@ -755,7 +355,7 @@ router.post("/", {
 				__ow_method: "post"
 			}
 		});
-		logger$1.debug(`Async execution started: ${activation.activationId}`);
+		logger.debug(`Async execution started: ${activation.activationId}`);
 		return accepted({ body: {
 			message: "Installation started",
 			activationId: activation.activationId,
@@ -769,20 +369,20 @@ router.post("/", {
 * 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 }) => {
+router.post("/execution", { handler: async (_req, { logger, 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 hooks = createInstallationHooks(store, (msg) => logger.debug(msg));
 	const installationContext = {
 		appData,
 		params,
-		logger: logger$1,
-		customScripts: params.customScriptsLoader?.(appConfig, logger$1) || {}
+		logger,
+		customScripts: params.customScriptsLoader?.(appConfig, logger) || {}
 	};
-	logger$1.debug(`Executing installation: ${initialState.id}`);
+	logger.debug(`Executing installation: ${initialState.id}`);
 	const result = await runInstallation({
 		installationContext,
 		config: appConfig,
@@ -790,7 +390,7 @@ router.post("/execution", { handler: async (_req, { logger: logger$1, rawParams
 		hooks
 	});
 	await store.put(getStorageKey(), result);
-	logger$1.debug(`Installation completed: ${result.status}`);
+	logger.debug(`Installation completed: ${result.status}`);
 	if (isFailedState(result)) return internalServerError({ body: {
 		message: "Installation failed",
 		error: result.error,
@@ -803,13 +403,13 @@ router.post("/execution", { handler: async (_req, { logger: logger$1, rawParams
 *
 * This endpoint allows clearing the installation state.
 */
-router.delete("/", { handler: async (_req, { logger: logger$1 }) => {
-	logger$1.debug("Clearing installation state...");
+router.delete("/", { handler: async (_req, { logger }) => {
+	logger.debug("Clearing installation state...");
 	await (await createInstallationStore()).delete(getStorageKey());
-	logger$1.debug("Installation state cleared");
+	logger.debug("Installation state cleared");
 	return noContent();
 } });
-/** The route handler for the runtime action. */
+/** Factory to create the route handler for the `installation` action. */
 const installationRuntimeAction = ({ appConfig, customScriptsLoader }) => async (params) => {
 	return await router.handler()({
 		...params,

package/dist/es/actions/scope-tree.d.mts

@@ -0,0 +1,8 @@
+import * as _adobe_aio_commerce_lib_core_responses0 from "@adobe/aio-commerce-lib-core/responses";
+import * as _adobe_aio_commerce_lib_core_params0 from "@adobe/aio-commerce-lib-core/params";
+
+//#region source/actions/scope-tree.d.ts
+/** The handler method for the `scope-tree` action. */
+declare const scopeTreeRuntimeAction: (args: _adobe_aio_commerce_lib_core_params0.RuntimeActionParams) => Promise<_adobe_aio_commerce_lib_core_responses0.ActionResponse>;
+//#endregion
+export { scopeTreeRuntimeAction };