@human-synthesis/norns 0.0.15 → 0.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@human-synthesis/norns",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "description": "Norns — SvelteKit with Civet, Pug, and the .n / .civet / .c file extensions",
   "license": "MIT",
   "author": "Daniel Teodoroiu (https://humansynthesis.ai)",

package/src/server/boot.js

@@ -2,6 +2,7 @@ import { sequence } from '@sveltejs/kit/hooks';
 import { Container } from './container.js';
 import { contextHandle } from './handle/context.js';
 import { errorHandle } from './handle/error.js';
+import { setSerializer } from './route.js';
 
 /**
  * Create a fresh root container with no features registered. Useful for tests
@@ -36,7 +37,8 @@ export function createApp() {
  * @param {{
  *   features?: Record<string, FeatureModule>,
  *   extraHandle?: import('@sveltejs/kit').Handle | import('@sveltejs/kit').Handle[],
- *   handleError?: import('@sveltejs/kit').HandleServerError
+ *   handleError?: import('@sveltejs/kit').HandleServerError,
+ *   serializer?: import('./route.js').Serializer | null
  * }} [opts]
  * @returns {Promise<{
  *   container: Container,
@@ -47,6 +49,10 @@ export function createApp() {
 export async function boot(opts = {}) {
 	const container = createApp();
 
+	// App-wide route() response serializer (e.g. tronSerializer() from
+	// @human-synthesis/norns-tron/server). Omit to keep plain JSON.
+	if (opts.serializer !== undefined) setSerializer(opts.serializer);
+
 	if (opts.features) {
 		for (const [path, mod] of Object.entries(opts.features)) {
 			const register = /** @type {ModuleRegister | undefined} */ (

package/src/server/index.js

@@ -3,7 +3,7 @@ export { withScope, getScope, getContainer } from './scope.js';
 export { boot, createApp } from './boot.js';
 export { contextHandle } from './handle/context.js';
 export { errorHandle } from './handle/error.js';
-export { route } from './route.js';
+export { route, setSerializer, getSerializer } from './route.js';
 export { page } from './page.js';
 export { validate, ValidationError } from './validate.js';
 export { betterSqlite, d1, libsql, postgres, withTransaction } from './db.js';

package/src/server/route.js

@@ -13,13 +13,44 @@ import { validate, ValidationError } from './validate.js';
  * @property {any} user shortcut for `event.locals.user`
  */
 
+/**
+ * @typedef {Object} Serializer
+ * @property {(result: any, event: RequestEvent) => Response | null} serialize
+ *   turn the handler's return value into a Response, or return null to fall
+ *   through to the default JSON serialization
+ * @property {(request: Request, contentType: string) => Promise<any> | undefined} [parseBody]
+ *   read a request body for a content type route() doesn't handle natively;
+ *   return undefined to fall through to the built-in JSON/form readers
+ */
+
 /**
  * @typedef {Object} RouteOptions
  * @property {any} [input] body schema (Standard Schema or function)
  * @property {any} [query] query schema (Standard Schema or function)
+ * @property {Serializer | null} [serializer] per-route serializer; null forces
+ *   plain JSON even when an app-wide serializer is set
  * @property {(ctx: RouteContext) => any | Promise<any>} handler
  */
 
+/** @type {Serializer | null} */
+let defaultSerializer = null;
+
+/**
+ * Set the app-wide response serializer used by every route() that doesn't
+ * declare its own (e.g. tronSerializer() from @human-synthesis/norns-tron).
+ * Pass null to go back to plain JSON. Usually wired via boot({ serializer }).
+ *
+ * @param {Serializer | null} serializer
+ */
+export function setSerializer(serializer) {
+	defaultSerializer = serializer ?? null;
+}
+
+/** @returns {Serializer | null} */
+export function getSerializer() {
+	return defaultSerializer;
+}
+
 /**
  * Wrap a `+server.c` handler. Bakes in:
  *   1. body parsing (JSON / urlencoded / multipart) + validation
@@ -39,13 +70,17 @@ export function route(opts) {
 	if (typeof handler !== 'function') {
 		throw new Error('route(): `handler` is required');
 	}
+	const hasOwnSerializer = 'serializer' in opts;
 
 	return async (event) => {
 		const container = event.locals.container;
+		// Resolved per request so boot({ serializer }) applies regardless of
+		// module evaluation order.
+		const serializer = hasOwnSerializer ? opts.serializer : defaultSerializer;
 
 		let input;
 		if (inputSchema !== undefined) {
-			const raw = await readBody(event.request);
+			const raw = await readBody(event.request, serializer);
 			try {
 				input = validate(inputSchema, raw);
 			} catch (e) {
@@ -78,6 +113,10 @@ export function route(opts) {
 		});
 
 		if (result instanceof Response) return result;
+		if (serializer?.serialize) {
+			const response = serializer.serialize(result ?? null, event);
+			if (response instanceof Response) return response;
+		}
 		return json(result ?? null);
 	};
 }
@@ -88,10 +127,15 @@ export function route(opts) {
  * (or accept `null`).
  *
  * @param {Request} request
+ * @param {Serializer | null} [serializer]
  * @returns {Promise<any>}
  */
-async function readBody(request) {
+async function readBody(request, serializer) {
 	const contentType = request.headers.get('content-type')?.split(';', 1)[0]?.trim() ?? '';
+	if (serializer?.parseBody) {
+		const parsed = serializer.parseBody(request, contentType);
+		if (parsed !== undefined) return await parsed;
+	}
 	if (contentType === 'application/json') {
 		try {
 			return await request.json();