@human-synthesis/norns 0.0.15 → 0.1.0

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();

package/src/server/storage.js

@@ -0,0 +1,97 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync, existsSync, readdirSync } from 'node:fs';
+import { dirname, join, normalize, sep } from 'node:path';
+
+/**
+ * Storage behind `container.resolve('storage')` — backing for the `file`
+ * field type. Two adapters with one surface:
+ *
+ *   put(key, data, { contentType? })  → { key }
+ *   get(key)                          → { body: Uint8Array, contentType? } | null
+ *   delete(key)                       → void
+ *   list(prefix)                      → string[] (keys, sorted)
+ *
+ * Keys are `/`-separated paths (`orders/abc/invoice.pdf`).
+ */
+
+/**
+ * Cloudflare R2 adapter over a bucket binding.
+ * @param {*} bucket R2Bucket binding
+ */
+export function r2Storage(bucket) {
+	return {
+		async put(key, data, { contentType } = {}) {
+			await bucket.put(key, data, contentType ? { httpMetadata: { contentType } } : undefined);
+			return { key };
+		},
+		async get(key) {
+			const obj = await bucket.get(key);
+			if (!obj) return null;
+			return {
+				body: new Uint8Array(await obj.arrayBuffer()),
+				contentType: obj.httpMetadata?.contentType
+			};
+		},
+		async delete(key) {
+			await bucket.delete(key);
+		},
+		async list(prefix = '') {
+			const keys = [];
+			let cursor;
+			do {
+				const page = await bucket.list({ prefix, cursor });
+				for (const obj of page.objects) keys.push(obj.key);
+				cursor = page.truncated ? page.cursor : undefined;
+			} while (cursor);
+			return keys.sort();
+		}
+	};
+}
+
+/**
+ * Local-dir shim for `norns dev` / tests. Content types ride in a `.meta`
+ * sidecar next to each object.
+ * @param {string} root
+ */
+export function dirStorage(root) {
+	const safe = (key) => {
+		const p = normalize(join(root, key));
+		if (!p.startsWith(normalize(root) + sep)) throw new Error(`storage: invalid key ${key}`);
+		return p;
+	};
+	return {
+		async put(key, data, { contentType } = {}) {
+			const path = safe(key);
+			mkdirSync(dirname(path), { recursive: true });
+			writeFileSync(path, typeof data === 'string' ? data : new Uint8Array(data));
+			if (contentType) writeFileSync(`${path}.meta`, contentType);
+			return { key };
+		},
+		async get(key) {
+			const path = safe(key);
+			if (!existsSync(path)) return null;
+			const meta = existsSync(`${path}.meta`) ? readFileSync(`${path}.meta`, 'utf8') : undefined;
+			return { body: new Uint8Array(readFileSync(path)), contentType: meta };
+		},
+		async delete(key) {
+			const path = safe(key);
+			rmSync(path, { force: true });
+			rmSync(`${path}.meta`, { force: true });
+		},
+		async list(prefix = '') {
+			if (!existsSync(root)) return [];
+			const out = [];
+			const walk = (dir) => {
+				for (const entry of readdirSync(dir, { withFileTypes: true })) {
+					const full = join(dir, entry.name);
+					if (entry.isDirectory()) walk(full);
+					else if (!entry.name.endsWith('.meta')) {
+						const key = full.slice(normalize(root).length + 1).split(sep).join('/');
+						if (key.startsWith(prefix)) out.push(key);
+					}
+				}
+			};
+			walk(root);
+			return out.sort();
+		}
+	};
+}