@analogjs/router 3.0.0-alpha.1 → 3.0.0-alpha.11

package/fesm2022/analogjs-router-server-actions.mjs

@@ -1,39 +1,335 @@
+import { getRequestURL, readBody, readFormData, toRequest } from "nitro/h3";
+//#region packages/router/server/actions/src/actions.ts
 function fail(status, errors) {
-    return new Response(JSON.stringify(errors), {
-        status,
-        headers: {
-            'X-Analog-Errors': 'true',
-        },
-    });
+	return new Response(JSON.stringify(errors), {
+		status,
+		headers: { "X-Analog-Errors": "true" }
+	});
 }
 function json(data, config) {
-    return new Response(JSON.stringify(data), {
-        headers: {
-            'Content-Type': 'application/json; charset=utf-8',
-        },
-        ...config,
-    });
+	return new Response(JSON.stringify(data), {
+		headers: { "Content-Type": "application/json; charset=utf-8" },
+		...config
+	});
 }
 function redirect(url, config = 302) {
-    if (typeof config === 'number') {
-        return new Response(null, {
-            status: config,
-            headers: {
-                Location: `${url}`,
-            },
-        });
-    }
-    return new Response(null, {
-        headers: {
-            Location: `${url}`,
-        },
-        ...config,
-    });
+	if (typeof config === "number") return new Response(null, {
+		status: config,
+		headers: { Location: `${url}` }
+	});
+	return new Response(null, {
+		headers: { Location: `${url}` },
+		...config
+	});
+}
+//#endregion
+//#region packages/router/server/actions/src/parse-request-data.ts
+function appendEntry(target, key, value) {
+	const existingValue = target[key];
+	if (existingValue === void 0) {
+		target[key] = value;
+		return;
+	}
+	if (Array.isArray(existingValue)) {
+		existingValue.push(value);
+		return;
+	}
+	target[key] = [existingValue, value];
+}
+function getRequest(event) {
+	const maybeRequest = event.request;
+	if (maybeRequest) return maybeRequest;
+	return toRequest(event);
+}
+function getContentType(event) {
+	return getRequest(event).headers.get("content-type") ?? event.headers.get("content-type") ?? event.headers.get("Content-Type") ?? "";
+}
+function isJsonContentType(contentType) {
+	const mimeType = contentType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+	return mimeType === "application/json" || mimeType.endsWith("+json");
+}
+function isFormContentType(contentType) {
+	return contentType.includes("multipart/form-data") || contentType.includes("application/x-www-form-urlencoded");
+}
+function parseSearchParams(searchParams) {
+	const result = {};
+	searchParams.forEach((value, key) => {
+		appendEntry(result, key, value);
+	});
+	return result;
+}
+function parseFormData(formData) {
+	const result = {};
+	formData.forEach((value, key) => {
+		appendEntry(result, key, value);
+	});
+	return result;
+}
+async function parseRequestData(event) {
+	const request = getRequest(event);
+	const httpEvent = event;
+	const h3Event = event;
+	const method = event.method.toUpperCase();
+	if (method === "GET" || method === "HEAD") return parseSearchParams(new URL(request.url, "http://localhost").searchParams);
+	const contentType = getContentType(event);
+	if (isJsonContentType(contentType)) try {
+		return await readBody(httpEvent) ?? {};
+	} catch {
+		try {
+			return await request.json();
+		} catch {
+			return {};
+		}
+	}
+	if (isFormContentType(contentType)) try {
+		return parseFormData(await readFormData(h3Event));
+	} catch {
+		if (typeof request.formData === "function") return parseFormData(await request.formData());
+		return {};
+	}
+	try {
+		return await readBody(httpEvent) ?? {};
+	} catch {
+		try {
+			return await request.json();
+		} catch {
+			return {};
+		}
+	}
+}
+//#endregion
+//#region packages/router/server/actions/src/validate.ts
+/**
+* Validates unknown input against a Standard Schema.
+*
+* Handles both sync and async `validate` implementations — the Standard
+* Schema spec allows either return shape.
+*/
+async function validateWithSchema(schema, data) {
+	return schema["~standard"].validate(data);
+}
+//#endregion
+//#region packages/router/server/actions/src/define-action.ts
+/**
+* Creates a server action handler with Standard Schema input validation.
+*
+* Parses the request body (JSON or FormData) and validates it against the
+* provided schema before invoking the handler. On validation failure,
+* returns `fail(422, issues)` with `StandardSchemaV1.Issue[]`.
+* Repeated form fields are preserved as arrays instead of being collapsed
+* to the last value.
+*
+* @example
+* ```typescript
+* import { defineAction, json } from '@analogjs/router/server/actions';
+* import * as v from 'valibot';
+*
+* const Schema = v.object({
+*   email: v.pipe(v.string(), v.email()),
+* });
+*
+* export const action = defineAction({
+*   schema: Schema,
+*   handler: async ({ data }) => {
+*     // data is typed as { email: string }
+*     return json({ ok: true });
+*   },
+* });
+* ```
+*/
+function defineAction(options) {
+	function getParams(params) {
+		return params ?? {};
+	}
+	return async (ctx) => {
+		const rawParams = getParams(ctx.params);
+		if (options.params) {
+			const paramsResult = await validateWithSchema(options.params, rawParams);
+			if (paramsResult.issues) return fail(422, paramsResult.issues);
+			return handleValidatedRequest(ctx, options, paramsResult.value);
+		}
+		return handleValidatedRequest(ctx, options, rawParams);
+	};
+}
+async function handleValidatedRequest(ctx, options, params) {
+	const body = await parseRequestData(ctx.event);
+	let data = body;
+	if (options.schema) {
+		const result = await validateWithSchema(options.schema, body);
+		if (result.issues) return fail(422, result.issues);
+		data = result.value;
+	}
+	return options.handler({
+		data,
+		params,
+		req: ctx.req,
+		res: ctx.res,
+		fetch: ctx.fetch,
+		event: ctx.event
+	});
+}
+//#endregion
+//#region packages/router/server/actions/src/define-server-route.ts
+function isDevEnvironment() {
+	return typeof process !== "undefined" && (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test");
+}
+function warnOnOutputIssues(issues) {
+	console.warn(`[analog] Server route output validation failed:\n` + issues.map((i) => {
+		const path = i.path ? ` at "${i.path.map((p) => typeof p === "object" ? p.key : p).join(".")}"` : "";
+		return `  - ${i.message}${path}`;
+	}).join("\n"));
+}
+function getRequestUrl(event) {
+	try {
+		return getRequestURL(event).href;
+	} catch {
+		return event.request.url;
+	}
 }
-
 /**
- * Generated bundle index. Do not edit.
- */
+* Creates an h3-compatible event handler with Standard Schema validation.
+*
+* - `input` schema validates the request body (POST/PUT/PATCH) or query
+*   params (GET). Returns 422 with `StandardSchemaV1.Issue[]` on failure.
+* - `output` schema validates the response in development only (stripped
+*   in production for zero overhead). Logs a warning on mismatch.
+* - Plain return values are serialized with `json(...)`; raw `Response`
+*   objects are returned unchanged.
+*
+* @example
+* ```typescript
+* import { defineServerRoute } from '@analogjs/router/server/actions';
+* import * as v from 'valibot';
+*
+* const Input = v.object({
+*   name: v.pipe(v.string(), v.minLength(1)),
+*   email: v.pipe(v.string(), v.email()),
+* });
+* const Output = v.object({
+*   id: v.string(),
+*   name: v.string(),
+* });
+*
+* export default defineServerRoute({
+*   input: Input,
+*   output: Output,
+*   handler: async ({ data }) => {
+*     const user = await db.users.create(data);
+*     return user;
+*   },
+* });
+* ```
+*/
+function defineServerRoute(options) {
+	return (async (event) => {
+		const method = event.method.toUpperCase();
+		let data;
+		let query;
+		let body;
+		let params = event.context?.params ?? {};
+		if (options.params) {
+			const paramsResult = await validateWithSchema(options.params, params);
+			if (paramsResult.issues) return fail(422, paramsResult.issues);
+			params = paramsResult.value;
+		}
+		if (options.input) {
+			data = await parseRequestData(event);
+			const inputResult = await validateWithSchema(options.input, data);
+			if (inputResult.issues) return fail(422, inputResult.issues);
+			data = inputResult.value;
+		} else {
+			if (options.query) {
+				const url = new URL(getRequestUrl(event), "http://localhost");
+				const queryResult = await validateWithSchema(options.query, parseSearchParams(url.searchParams));
+				if (queryResult.issues) return fail(422, queryResult.issues);
+				query = queryResult.value;
+			}
+			if (options.body && method !== "GET" && method !== "HEAD") {
+				body = await parseRequestData(event);
+				const bodyResult = await validateWithSchema(options.body, body);
+				if (bodyResult.issues) return fail(422, bodyResult.issues);
+				body = bodyResult.value;
+			}
+			if (method === "GET" || method === "HEAD") data = query;
+			else if (body !== void 0) data = body;
+			else data = query;
+		}
+		const result = await options.handler({
+			data,
+			query,
+			body,
+			params,
+			event
+		});
+		if (result instanceof Response) return result;
+		if (options.output && isDevEnvironment()) {
+			const outputResult = await validateWithSchema(options.output, result);
+			if (outputResult.issues) warnOnOutputIssues(outputResult.issues);
+		}
+		return json(result);
+	});
+}
+//#endregion
+//#region packages/router/server/actions/src/define-page-load.ts
+/**
+* Creates a typed page server load function with optional
+* Standard Schema validation for route params and query.
+*
+* Follows the same validation patterns as `defineAction` and
+* `defineServerRoute`: validates before invoking the handler,
+* returns `fail(422, issues)` on validation failure.
+*
+* @example
+* ```typescript
+* // src/app/pages/users/[id].server.ts
+* import { definePageLoad } from '@analogjs/router/server/actions';
+* import * as v from 'valibot';
+*
+* export const routeParamsSchema = v.object({
+*   id: v.pipe(v.string(), v.regex(/^\d+$/)),
+* });
+*
+* export const load = definePageLoad({
+*   params: routeParamsSchema,
+*   handler: async ({ params, fetch }) => {
+*     // params.id is typed as string (validated)
+*     const user = await fetch(`/api/users/${params.id}`);
+*     return user;
+*   },
+* });
+* ```
+*/
+function definePageLoad(options) {
+	return async (ctx) => {
+		let params = ctx.params ?? {};
+		let requestUrl;
+		try {
+			requestUrl = getRequestURL(ctx.event).href;
+		} catch {
+			requestUrl = ctx.event.request.url;
+		}
+		let query = parseSearchParams(new URL(requestUrl, "http://localhost").searchParams);
+		if (options.params) {
+			const result = await validateWithSchema(options.params, params);
+			if (result.issues) return fail(422, result.issues);
+			params = result.value;
+		}
+		if (options.query) {
+			const result = await validateWithSchema(options.query, query);
+			if (result.issues) return fail(422, result.issues);
+			query = result.value;
+		}
+		return options.handler({
+			params,
+			query,
+			req: ctx.req,
+			res: ctx.res,
+			fetch: ctx.fetch,
+			event: ctx.event
+		});
+	};
+}
+//#endregion
+export { defineAction, definePageLoad, defineServerRoute, fail, json, redirect, validateWithSchema };
 
-export { fail, json, redirect };
-//# sourceMappingURL=analogjs-router-server-actions.mjs.map
+//# sourceMappingURL=analogjs-router-server-actions.mjs.map