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

package/dist/es/router-CJ4VWoCt.mjs

@@ -0,0 +1,404 @@
+import { badRequest, internalServerError, methodNotAllowed, notFound } from "@adobe/aio-commerce-lib-core/responses";
+import AioLogger from "@adobe/aio-lib-core-logging";
+import { parse } from "regexparam";
+
+//#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
+export { logger as n, HttpActionRouter as t };

package/dist/es/{management-Y7pwEbNI.mjs → runner-DB2tDBQS.mjs}

@@ -1,5 +1,6 @@
-import { a as hasExternalEvents, c as hasCustomInstallationSteps, i as hasEventing, r as hasCommerceEvents, t as stringifyError } from "./error-P7JgUTds.mjs";
-import { t as inspect } from "./logging-VgerMhp6.mjs";
+import { a as hasCommerceEvents, o as hasEventing, r as hasCustomInstallationSteps, s as hasExternalEvents } from "./installation-SWIwhpKT.mjs";
+import { t as stringifyError } from "./error-CMV3IjBz.mjs";
+import { t as inspect } from "./logging-CzmXDzxI.mjs";
 import camelcase from "camelcase";
 import { resolveAuthParams } from "@adobe/aio-commerce-lib-auth";
 import { resolveCommerceHttpClientParams, resolveIoEventsHttpClientParams } from "@adobe/aio-commerce-lib-api";
@@ -558,9 +559,9 @@ async function getIoEventsExistingData(context) {
 	});
 	const providersWithMetadata = existingProviders.map((providerHal) => {
 		const { _embedded, _links, ...providerData } = providerHal;
-		const actualMetadata = (_embedded?.eventmetadata ?? []).map(({ _embedded: _embedded$1, _links: _links$1, ...meta }) => ({
+		const actualMetadata = (_embedded?.eventmetadata ?? []).map(({ _embedded, _links, ...meta }) => ({
 			...meta,
-			sample: _embedded$1?.sample_event ?? null
+			sample: _embedded?.sample_event ?? null
 		}));
 		return {
 			...providerData,
@@ -749,13 +750,13 @@ async function configureCommerceEventing(params, existingData) {
 		enabled: true
 	};
 	if (existingData.isDefaultWorkspaceConfigurationEmpty) {
-		if (!config.workspaceConfiguration) {
+		if (!config.workspace_configuration) {
 			const message = "Workspace configuration is required to enable Commerce Eventing when there is not an existing one.";
 			logger.error(message);
 			throw new Error(message);
 		}
 		logger.info("Default provider workspace configuration already present, it will not be overriden");
-		const { workspaceConfiguration, ...rest } = updateParams;
+		const { workspace_configuration, ...rest } = updateParams;
 		updateParams = rest;
 	}
 	logger.info("Updating Commerce Eventing configuration with provided workspace configuration.");
@@ -779,11 +780,8 @@ async function createCommerceProvider(params) {
 	const { commerceEventsClient, logger } = context;
 	logger.info(`Creating Commerce provider "${provider.label}" with instance ID "${provider.instance_id}"`);
 	return commerceEventsClient.createEventProvider({
-		providerId: provider.id,
-		instanceId: provider.instance_id,
-		label: provider.label,
-		description: provider.description,
-		associatedWorkspaceConfiguration: provider.workspaceConfiguration
+		...provider,
+		provider_id: provider.id
 	}).then((res) => {
 		logger.info(`Commerce provider "${provider.label}" created with ID '${res.provider_id}'`);
 		return res;
@@ -820,10 +818,10 @@ async function createCommerceEventSubscription(params) {
 		name: eventName,
 		parent: event.config.name,
 		fields: event.config.fields,
-		providerId: provider.id,
+		provider_id: provider.id,
 		destination: event.config.destination,
-		hipaaAuditRequired: event.config.hipaaAuditRequired,
-		prioritary: event.config.prioritary,
+		hipaa_audit_required: event.config.hipaa_audit_required,
+		priority: event.config.priority,
 		force: event.config.force
 	};
 	logger.debug(`Event subscription specification for event "${event.config.name}": ${inspect(eventSpec)}`);
@@ -846,12 +844,7 @@ async function createOrGetCommerceEventSubscription(params, existingData) {
 	const existing = findExistingSubscription(existingData, getNamespacedEvent(metadata, event.config.name));
 	if (existing) {
 		logger.info(`Subscription for event "${event.config.name}" already exists, skipping creation.`);
-		return {
-			name: existing.name,
-			parent: existing.parent,
-			fields: existing.fields,
-			providerId: existing.provider_id
-		};
+		return existing;
 	}
 	return createCommerceEventSubscription(params);
 }
@@ -920,7 +913,7 @@ async function onboardCommerceEventing(params, existingData) {
 	const subscriptions = [];
 	await configureCommerceEventing({
 		context,
-		config: { workspaceConfiguration }
+		config: { workspace_configuration: workspaceConfiguration }
 	}, existingData);
 	const { workspace_configuration: _, ...commerceProviderData } = await createOrGetCommerceProvider({
 		context,
@@ -929,7 +922,7 @@ async function onboardCommerceEventing(params, existingData) {
 			instance_id: instanceId,
 			label: provider.label,
 			description: provider.description,
-			workspaceConfiguration
+			workspace_configuration: workspaceConfiguration
 		}
 	}, existingData.providers);
 	for (const event of events) subscriptions.push(await createOrGetCommerceEventSubscription({
@@ -984,9 +977,9 @@ const commerceEventsStep = defineLeafStep({
 				data: {
 					ioEvents: providerData,
 					commerce: commerceProvider,
-					events: eventsData.map(({ config: config$1, data }, index) => {
+					events: eventsData.map(({ config, data }, index) => {
 						return {
-							config: config$1,
+							config,
 							data: {
 								...data,
 								subscription: subscriptions[index]