@human-synthesis/norns 0.0.5 → 0.0.7

package/src/server/handle/error.js

@@ -0,0 +1,18 @@
+/** @typedef {import('@sveltejs/kit').HandleServerError} HandleServerError */
+
+/**
+ * Default `handleError` implementation: logs the error with request context
+ * and returns a safe payload for the client.
+ *
+ * Apps can wrap this or replace it via `boot({ handleError: custom })`.
+ *
+ * @param {{ logger?: { error: (msg: string, err: unknown) => void } }} [opts]
+ * @returns {HandleServerError}
+ */
+export function errorHandle(opts = {}) {
+	const log = opts.logger ?? { error: (msg, err) => console.error(msg, err) };
+	return ({ error, event, status, message }) => {
+		log.error(`[norns] ${event.request.method} ${event.url.pathname} ${status}`, error);
+		return { message: message || 'Internal error' };
+	};
+}

package/src/server/index.js

@@ -0,0 +1,9 @@
+export { Container, createContainer } from './container.js';
+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 { page } from './page.js';
+export { validate, ValidationError } from './validate.js';
+export { betterSqlite, d1, libsql, postgres, withTransaction } from './db.js';

package/src/server/page.js

@@ -0,0 +1,107 @@
+import { fail } from '@sveltejs/kit';
+import { validate, ValidationError } from './validate.js';
+
+/** @typedef {import('@sveltejs/kit').ServerLoadEvent} ServerLoadEvent */
+/** @typedef {import('@sveltejs/kit').RequestEvent} RequestEvent */
+/** @typedef {import('./container.js').Container} Container */
+
+/**
+ * @typedef {Object} LoadContext
+ * @property {Container} container
+ * @property {ServerLoadEvent} event
+ * @property {ServerLoadEvent['params']} params
+ * @property {ServerLoadEvent['url']} url
+ * @property {any} user
+ */
+
+/**
+ * @typedef {Object} ActionContext
+ * @property {any} input parsed form data (after validation)
+ * @property {Container} container
+ * @property {RequestEvent} event
+ * @property {any} user
+ */
+
+/**
+ * Wrappers for `+page.server.c` exports — `load` and `actions`. They mirror
+ * `route()` but: (a) `load` returns its result as data (no JSON wrapper), and
+ * (b) actions return `fail(400, ...)` on validation rather than throwing
+ * `error(400)`, which is the SvelteKit-idiomatic shape for forms.
+ */
+export const page = {
+	/**
+	 * Wrap a SvelteKit `load`.
+	 *
+	 * @param {{ handler: (ctx: LoadContext) => any | Promise<any> }} opts
+	 * @returns {(event: ServerLoadEvent) => Promise<any>}
+	 */
+	load(opts) {
+		if (typeof opts?.handler !== 'function') {
+			throw new Error('page.load(): `handler` is required');
+		}
+		return async (event) => {
+			return opts.handler({
+				container: event.locals.container,
+				event,
+				params: event.params,
+				url: event.url,
+				user: event.locals.user
+			});
+		};
+	},
+
+	/**
+	 * Wrap a SvelteKit `actions` object. Each action takes `{ input?, run }`
+	 * — `input` is a schema, `run` is the handler.
+	 *
+	 * @param {Record<string, { input?: any, run: (ctx: ActionContext) => any | Promise<any> }>} spec
+	 * @returns {Record<string, (event: RequestEvent) => Promise<any>>}
+	 */
+	actions(spec) {
+		/** @type {Record<string, (event: RequestEvent) => Promise<any>>} */
+		const out = {};
+		for (const [name, def] of Object.entries(spec)) {
+			if (typeof def?.run !== 'function') {
+				throw new Error(`page.actions(): action "${name}" missing \`run\` function`);
+			}
+			out[name] = async (event) => {
+				let raw = null;
+				let input;
+				if (def.input !== undefined) {
+					raw = await readForm(event.request);
+					try {
+						input = validate(def.input, raw);
+					} catch (e) {
+						if (e instanceof ValidationError) {
+							return fail(400, { errors: e.issues, values: raw });
+						}
+						throw e;
+					}
+				}
+				return def.run({
+					input,
+					container: event.locals.container,
+					event,
+					user: event.locals.user
+				});
+			};
+		}
+		return out;
+	}
+};
+
+/**
+ * Read form-encoded body into a plain object. Designed for `actions` —
+ * SvelteKit only invokes them via form POST.
+ *
+ * @param {Request} request
+ * @returns {Promise<any>}
+ */
+async function readForm(request) {
+	try {
+		const data = await request.formData();
+		return Object.fromEntries(data);
+	} catch {
+		return null;
+	}
+}

package/src/server/route.js

@@ -0,0 +1,114 @@
+import { json, error } from '@sveltejs/kit';
+import { validate, ValidationError } from './validate.js';
+
+/** @typedef {import('@sveltejs/kit').RequestEvent} RequestEvent */
+/** @typedef {import('./container.js').Container} Container */
+
+/**
+ * @typedef {Object} RouteContext
+ * @property {any} input parsed body (after validation)
+ * @property {any} query parsed query (after validation)
+ * @property {Container} container request-scoped container
+ * @property {RequestEvent} event raw SvelteKit event
+ * @property {any} user shortcut for `event.locals.user`
+ */
+
+/**
+ * @typedef {Object} RouteOptions
+ * @property {any} [input] body schema (Standard Schema or function)
+ * @property {any} [query] query schema (Standard Schema or function)
+ * @property {(ctx: RouteContext) => any | Promise<any>} handler
+ */
+
+/**
+ * Wrap a `+server.c` handler. Bakes in:
+ *   1. body parsing (JSON / urlencoded / multipart) + validation
+ *   2. query validation
+ *   3. container resolution from `event.locals.container`
+ *   4. JSON serialization of the return value (or pass-through if it's a Response)
+ *   5. 400 errors on validation failure (via SvelteKit `error()`)
+ *
+ * Use `throw error(...)` / `throw redirect(...)` from inside the handler for
+ * non-success outcomes; SvelteKit will surface them.
+ *
+ * @param {RouteOptions} opts
+ * @returns {(event: RequestEvent) => Promise<Response>}
+ */
+export function route(opts) {
+	const { input: inputSchema, query: querySchema, handler } = opts;
+	if (typeof handler !== 'function') {
+		throw new Error('route(): `handler` is required');
+	}
+
+	return async (event) => {
+		const container = event.locals.container;
+
+		let input;
+		if (inputSchema !== undefined) {
+			const raw = await readBody(event.request);
+			try {
+				input = validate(inputSchema, raw);
+			} catch (e) {
+				if (e instanceof ValidationError) {
+					throw error(400, { message: e.message, issues: e.issues });
+				}
+				throw e;
+			}
+		}
+
+		let query;
+		if (querySchema !== undefined) {
+			const raw = Object.fromEntries(event.url.searchParams);
+			try {
+				query = validate(querySchema, raw);
+			} catch (e) {
+				if (e instanceof ValidationError) {
+					throw error(400, { message: e.message, issues: e.issues });
+				}
+				throw e;
+			}
+		}
+
+		const result = await handler({
+			input,
+			query,
+			container,
+			event,
+			user: event.locals.user
+		});
+
+		if (result instanceof Response) return result;
+		return json(result ?? null);
+	};
+}
+
+/**
+ * Read and decode the request body based on its content-type. Returns `null`
+ * for empty bodies or unsupported types — the schema is then free to reject
+ * (or accept `null`).
+ *
+ * @param {Request} request
+ * @returns {Promise<any>}
+ */
+async function readBody(request) {
+	const contentType = request.headers.get('content-type')?.split(';', 1)[0]?.trim() ?? '';
+	if (contentType === 'application/json') {
+		try {
+			return await request.json();
+		} catch {
+			return null;
+		}
+	}
+	if (
+		contentType === 'application/x-www-form-urlencoded' ||
+		contentType === 'multipart/form-data'
+	) {
+		try {
+			const data = await request.formData();
+			return Object.fromEntries(data);
+		} catch {
+			return null;
+		}
+	}
+	return null;
+}

package/src/server/scope.js

@@ -0,0 +1,50 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+/**
+ * Per-request async context. Used to make `event.locals.container` (and the
+ * scoped `db`, `user`) implicitly available to callees that don't get the
+ * SvelteKit `event` passed in.
+ *
+ * On Cloudflare Workers, requires the `nodejs_als` + `nodejs_compat` compat
+ * flags in `wrangler.toml`.
+ *
+ * @template T
+ */
+
+/** @typedef {{ container: import('./container.js').Container, [key: string]: any }} RequestScope */
+
+/** @type {AsyncLocalStorage<RequestScope>} */
+const storage = new AsyncLocalStorage();
+
+/**
+ * Run `fn` with `scope` as the current request scope.
+ *
+ * @template T
+ * @param {RequestScope} scope
+ * @param {() => T | Promise<T>} fn
+ * @returns {T | Promise<T>}
+ */
+export function withScope(scope, fn) {
+	return storage.run(scope, fn);
+}
+
+/**
+ * Get the current request scope. Returns `undefined` outside a request.
+ *
+ * @returns {RequestScope | undefined}
+ */
+export function getScope() {
+	return storage.getStore();
+}
+
+/**
+ * Get the current request-scoped container, or throw if called outside a
+ * request.
+ *
+ * @returns {import('./container.js').Container}
+ */
+export function getContainer() {
+	const scope = storage.getStore();
+	if (!scope) throw new Error('getContainer() called outside a request scope');
+	return scope.container;
+}

package/src/server/validate.js

@@ -0,0 +1,60 @@
+/**
+ * Validation glue. Norns doesn't bundle a schema library — it speaks the
+ * Standard Schema interface (https://github.com/standard-schema/standard-schema)
+ * supported by Valibot, Zod 3.24+, ArkType, etc. A plain function (`input -> parsed`)
+ * also works, for ad-hoc cases or simple Coffee parsers.
+ */
+
+/** @typedef {{ '~standard': { validate: (input: unknown) => any } }} StandardSchema */
+/** @typedef {{ kind: 'validation', path?: any[], message: string }} Issue */
+
+export class ValidationError extends Error {
+	/**
+	 * @param {Array<Issue>} issues
+	 */
+	constructor(issues) {
+		const summary = issues
+			.map((i) => `${formatPath(i.path)}: ${i.message}`)
+			.join(', ');
+		super(`Validation failed: ${summary}`);
+		this.name = 'ValidationError';
+		this.issues = issues;
+	}
+}
+
+/**
+ * Validate `input` against `schema`. Returns the parsed value or throws
+ * `ValidationError`.
+ *
+ * Accepts:
+ *   - Standard Schema instance (Valibot, Zod, ArkType, …)
+ *   - a plain function `(input) => parsed` that throws on invalid input
+ *   - `undefined` / `null` → passthrough (no validation)
+ *
+ * @template T
+ * @param {StandardSchema | ((input: unknown) => T) | undefined | null} schema
+ * @param {unknown} input
+ * @returns {T}
+ */
+export function validate(schema, input) {
+	if (schema == null) return /** @type {T} */ (input);
+	if (typeof schema === 'function') return schema(input);
+	if (schema['~standard'] && typeof schema['~standard'].validate === 'function') {
+		const result = schema['~standard'].validate(input);
+		if (result instanceof Promise) {
+			throw new Error('Async schema validation is not supported in route()/page.actions()');
+		}
+		if (result.issues) throw new ValidationError(result.issues);
+		return result.value;
+	}
+	throw new Error('validate(): schema must implement Standard Schema or be a function');
+}
+
+/**
+ * @param {any[] | undefined} path
+ * @returns {string}
+ */
+function formatPath(path) {
+	if (!path || path.length === 0) return '$';
+	return path.map((p) => (typeof p === 'object' ? p.key : p)).join('.');
+}

package/src/vite.js

@@ -1,29 +1,143 @@
-import { readFile } from 'node:fs/promises';
-import CoffeeScript from 'coffeescript';
+import { readFile, stat, realpath } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { createRequire } from 'node:module';
+import { compile as compileCivet } from '@danielx/civet';
+
+const DEFAULT_EXTENSIONS = ['.mjs', '.js', '.mts', '.ts', '.jsx', '.tsx', '.json'];
+const NORNS_EXTENSIONS = ['.svelte', '.n', '.civet', '.c'];
+const RESOLVE_EXTENSIONS = [...NORNS_EXTENSIONS, '.ts', '.js'];
+const FRAMEWORK_PKGS = ['@human-synthesis/norns-core', '@human-synthesis/norns'];
+
+async function fileExists(path) {
+	try {
+		const s = await stat(path);
+		return s.isFile();
+	} catch {
+		return false;
+	}
+}
 
 /**
- * Vite plugin that compiles .coffee files to JavaScript.
- * Used so SvelteKit special files like +page.coffee, +page.server.coffee,
- * hooks.server.coffee, and +server.coffee work the same as their .js / .ts
- * counterparts.
+ * Resolve framework package src dirs that live OUTSIDE the consuming app's
+ * node_modules (i.e. workspace symlinks pointing at sibling repos). Returns
+ * real on-disk paths to watch. Empty array when packages are installed
+ * normally — published consumers never enter this branch.
+ *
+ * @param {string} root
+ * @returns {Promise<string[]>}
+ */
+async function resolveWorkspaceFrameworkSrcs(root) {
+	const require = createRequire(join(root, 'package.json'));
+	const out = [];
+	for (const pkg of FRAMEWORK_PKGS) {
+		try {
+			const pkgJsonPath = require.resolve(`${pkg}/package.json`);
+			const real = await realpath(pkgJsonPath);
+			const pkgDir = dirname(real);
+			// Only watch when the real path resolves outside any node_modules —
+			// that's the workspace-symlink case. A normal install resolves to
+			// a real path inside node_modules and we leave it alone.
+			if (!pkgDir.includes(`${join('/', 'node_modules', '/')}`)) {
+				out.push(join(pkgDir, 'src'));
+			}
+		} catch {
+			// Package not installed (e.g. only norns-core present) — skip.
+		}
+	}
+	return out;
+}
+
+/**
+ * Vite plugin that:
+ *  - compiles `.civet` and `.c` files via @danielx/civet, so SvelteKit
+ *    special files like `+page.civet`, `+page.server.c`, `hooks.server.civet`,
+ *    and `+server.c` work the same as their `.js` / `.ts` counterparts;
+ *  - registers `.svelte`, `.n`, `.civet`, `.c` with Vite's resolver so bare
+ *    imports (`import X from './Foo'`) try those extensions in priority
+ *    order, on top of Vite's defaults;
+ *  - resolves bare-name imports (`import X from 'Foo'`, no `./` prefix) to a
+ *    sibling file when one exists, in the same priority order. Real package
+ *    imports (`'svelte/store'`, `'@scope/pkg'`) are unaffected because they
+ *    contain a slash or scope marker;
+ *  - in workspace-linked dev (sibling repos symlinked into node_modules),
+ *    excludes the framework packages from `optimizeDeps` pre-bundling and
+ *    lifts them out of the default `**\/node_modules\/**` watch ignore so
+ *    Vite reads source on each request and HMR fires. No-op for normal
+ *    (published) installs. The companion `norns dev` CLI handles
+ *    process-level respawn when framework source changes — needed because
+ *    Node's ESM module cache survives `server.restart()`.
+ *
+ * `.c` is recognised as an alias for `.civet` — both compile through Civet.
+ * CoffeeScript is no longer supported.
  *
  * @returns {import('vite').Plugin}
  */
-export function nornsCoffeePlugin() {
+export function nornsCivetPlugin() {
+	/** @type {string[]} */
+	let watchSrcs = [];
 	return {
-		name: 'norns:coffee',
+		name: 'norns:civet',
 		enforce: 'pre',
+		async config(_userConfig, { command }) {
+			if (command === 'serve') {
+				watchSrcs = await resolveWorkspaceFrameworkSrcs(process.cwd());
+			}
+			/** @type {import('vite').UserConfig} */
+			const cfg = {
+				resolve: {
+					extensions: [...DEFAULT_EXTENSIONS, ...NORNS_EXTENSIONS]
+				},
+				optimizeDeps: {
+					exclude: [...FRAMEWORK_PKGS]
+				}
+			};
+			if (watchSrcs.length > 0) {
+				cfg.server = {
+					fs: { allow: watchSrcs.map((p) => dirname(p)) },
+					watch: {
+						ignored: [
+							'**/.git/**',
+							(path) => {
+								if (watchSrcs.some((src) => path.startsWith(src))) return false;
+								return path.includes(`${join('/', 'node_modules', '/')}`);
+							}
+						]
+					}
+				};
+			}
+			return cfg;
+		},
+		async resolveId(source, importer) {
+			if (!importer) return null;
+			// Already explicit relative or absolute — let the default resolver run.
+			if (source.startsWith('.') || source.startsWith('/')) return null;
+			// Scoped package or package-with-subpath — treat as a bare module.
+			if (source.startsWith('@') || source.includes('/')) return null;
+			// Skip imports from inside node_modules — library code uses proper
+			// module resolution; we'd otherwise hijack legitimate package imports
+			// (e.g. `import { parse } from 'cookie'`) when a sibling file with
+			// the same name happens to exist in the same dir.
+			if (importer.includes(`${join('/', 'node_modules', '/')}`)) return null;
+
+			// Single bare name — try resolving as a sibling file first, falling
+			// back to the default resolver (node_modules) if nothing matches.
+			const dir = dirname(importer);
+			for (const ext of RESOLVE_EXTENSIONS) {
+				const candidate = join(dir, source + ext);
+				if (await fileExists(candidate)) return candidate;
+			}
+			return null;
+		},
 		async load(id) {
 			const [path] = id.split('?');
-			if (!path.endsWith('.coffee')) return null;
+			if (!path.endsWith('.civet') && !path.endsWith('.c')) return null;
 			const source = await readFile(path, 'utf8');
-			const { js, sourceMap } = CoffeeScript.compile(source, {
-				bare: true,
+			const result = await compileCivet(source, {
+				js: true,
 				sourceMap: true,
-				inlineMap: false,
 				filename: path
 			});
-			return { code: js, map: sourceMap?.generate?.() ?? null };
+			return { code: result.code, map: result.sourceMap?.json?.(path) ?? null };
 		}
 	};
 }

package/src/uno.js

@@ -1 +0,0 @@
-export { nornsUno } from '@human-synthesis/norns-core/uno';