@axium/server 0.24.0 → 0.25.0

package/dist/config.js

@@ -10,6 +10,8 @@ const audit_severity_levels = ['emergency', 'alert', 'critical', 'error', 'warni
 const z_audit_severity = z.literal([...audit_severity_levels, ...audit_severity_levels.map(capitalize)]);
 export const ConfigSchema = z
     .looseObject({
+    /** Whether /api/admin is enabled */
+    admin_api: z.boolean(),
     allow_new_users: z.boolean(),
     apps: z
         .looseObject({
@@ -59,11 +61,10 @@ export const ConfigSchema = z
         console: z.boolean(),
     })
         .partial(),
+    request_size_limit: z.number().min(0).optional(),
     show_duplicate_state: z.boolean(),
     web: z
         .looseObject({
-        assets: z.string(),
-        build: z.string(),
         disable_cache: z.boolean(),
         port: z.number().min(1).max(65535),
         prefix: z.string(),
@@ -71,7 +72,6 @@ export const ConfigSchema = z
         secure: z.boolean(),
         ssl_key: z.string(),
         ssl_cert: z.string(),
-        template: z.string(),
     })
         .partial(),
 })
@@ -80,18 +80,8 @@ export const configFiles = _unique('configFiles', new Map());
 export function plainConfig() {
     return omit(config, Object.keys(configShortcuts));
 }
-const configShortcuts = {
-    findPath: findConfigPaths,
-    load: loadConfig,
-    loadDefaults: loadDefaultConfigs,
-    plain: plainConfig,
-    save: saveConfig,
-    saveTo: saveConfigTo,
-    set: setConfig,
-    files: configFiles,
-};
-export const config = _unique('config', {
-    ...configShortcuts,
+export const defaultConfig = {
+    admin_api: true,
     allow_new_users: true,
     apps: {
         disabled: [],
@@ -131,9 +121,8 @@ export const config = _unique('config', {
         level: 'info',
     },
     show_duplicate_state: false,
+    request_size_limit: 0,
     web: {
-        assets: '',
-        build: '../build/handler.js',
         disable_cache: false,
         port: 443,
         prefix: '',
@@ -141,8 +130,22 @@ export const config = _unique('config', {
         secure: true,
         ssl_key: resolve(dirs[0], 'ssl_key.pem'),
         ssl_cert: resolve(dirs[0], 'ssl_cert.pem'),
-        template: join(import.meta.dirname, '../web/template.html'),
     },
+};
+const configShortcuts = {
+    findPath: findConfigPaths,
+    load: loadConfig,
+    loadDefaults: loadDefaultConfigs,
+    plain: plainConfig,
+    save: saveConfig,
+    saveTo: saveConfigTo,
+    set: setConfig,
+    files: configFiles,
+    defaults: defaultConfig,
+};
+export const config = _unique('config', {
+    ...configShortcuts,
+    ...defaultConfig,
 });
 export default config;
 // config from file
@@ -153,14 +156,16 @@ export const FileSchema = z
     plugins: z.array(z.string()),
 })
     .partial();
-export function addConfigDefaults(other, _target = config) {
+export function addConfigDefaults(other, _target = config, _noDefault = false) {
+    if (!_noDefault)
+        deepAssign(defaultConfig, other);
     for (const [key, value] of Object.entries(other)) {
         if (!(key in _target) || _target[key] === null || _target[key] === undefined || Number.isNaN(_target[key])) {
             _target[key] = value;
             continue;
         }
         if (typeof value == 'object' && value != null && typeof _target[key] == 'object') {
-            addConfigDefaults(value, _target[key]);
+            addConfigDefaults(value, _target[key], true);
         }
     }
 }
@@ -175,6 +180,7 @@ export function setConfig(other) {
     _setDebugOutput(config.debug);
     _duplicateStateWarnings(config.show_duplicate_state);
 }
+const kWasIncluded = Symbol.for('_wasIncluded');
 /**
  * Load the config from the provided path
  */
@@ -201,15 +207,15 @@ export async function loadConfig(path, options = {}) {
         output.debug(`Loading invalid config from ${path} (${e.message})`);
         file = json;
     }
-    configFiles.set(path, file);
+    configFiles.set(path, { ...file, [kWasIncluded]: !!options._markIncluded });
     setConfig(file);
     output.debug('Loaded config: ' + path);
     for (const include of file.include ?? [])
-        await loadConfig(resolve(dirname(path), include), { optional: true });
+        await loadConfig(resolve(dirname(path), include), { ...options, optional: true, _markIncluded: true });
     for (const plugin of file.plugins ?? [])
-        await loadPlugin(plugin.startsWith('.') ? resolve(dirname(path), plugin) : plugin);
+        await loadPlugin(plugin, path, options.safe);
 }
-export async function loadDefaultConfigs() {
+export async function loadDefaultConfigs(safe = false) {
     for (const path of findConfigPaths()) {
         if (!existsSync(path)) {
             try {
@@ -219,9 +225,20 @@ export async function loadDefaultConfigs() {
                 continue;
             }
         }
-        await loadConfig(path, { optional: true });
+        await loadConfig(path, { optional: true, safe });
     }
 }
+export async function reloadConfigs(safe = false) {
+    const paths = Array.from(configFiles
+        .entries()
+        .filter(([, cfg]) => !cfg[kWasIncluded])
+        .map(([p]) => p));
+    configFiles.clear();
+    setConfig(defaultConfig);
+    for (const path of paths)
+        await loadConfig(path, { safe });
+    output.info('Reloaded configuration files');
+}
 /**
  * Update the current config and write the updated config to the appropriate file
  */

package/dist/database.d.ts

@@ -1,9 +1,8 @@
-import type { Permission, Preferences } from '@axium/core';
+import type { Permission, Preferences, Severity, UserInternal } from '@axium/core';
 import type { AuthenticatorTransportFuture, CredentialDeviceType } from '@simplewebauthn/server';
 import type * as kysely from 'kysely';
 import { Kysely } from 'kysely';
-import type { Severity } from './audit.js';
-import type { UserInternal, VerificationRole } from './auth.js';
+import type { VerificationRole } from './auth.js';
 export interface DBAccessControl {
     itemId: string;
     userId: string;
@@ -43,7 +42,7 @@ export interface Schema {
         name: string | null;
         createdAt: kysely.GeneratedAlways<Date>;
         userId: string;
-        publicKey: Uint8Array;
+        publicKey: Uint8Array<ArrayBuffer>;
         counter: number;
         deviceType: CredentialDeviceType;
         backedUp: boolean;

package/dist/database.js

@@ -277,11 +277,11 @@ export async function init(opt) {
             .catch(maybeCheck('audit_log'));
         io.start('Creating schema acl');
         await database.schema.createSchema('acl').execute().then(io.done).catch(warnExists);
-        for (const plugin of plugins) {
-            if (!plugin.hooks.db_init)
+        for (const plugin of plugins.values()) {
+            if (!plugin._hooks?.db_init)
                 continue;
             io.plugin(plugin.name);
-            await plugin.hooks.db_init(opt);
+            await plugin._hooks?.db_init(opt);
         }
     }
     catch (e_1) {
@@ -432,22 +432,22 @@ export async function clean(opt) {
     await database.deleteFrom('sessions').where('sessions.expires', '<', now).execute().then(io.done);
     io.start('Removing expired verifications');
     await database.deleteFrom('verifications').where('verifications.expires', '<', now).execute().then(io.done);
-    for (const plugin of plugins) {
-        if (!plugin.hooks.clean)
+    for (const plugin of plugins.values()) {
+        if (!plugin._hooks?.clean)
             continue;
         io.plugin(plugin.name);
-        await plugin.hooks.clean(opt);
+        await plugin._hooks?.clean(opt);
     }
 }
 /**
  * Completely remove Axium from the database.
  */
 export async function uninstall(opt) {
-    for (const plugin of plugins) {
-        if (!plugin.hooks.remove)
+    for (const plugin of plugins.values()) {
+        if (!plugin._hooks?.remove)
             continue;
         io.plugin(plugin.name);
-        await plugin.hooks.remove(opt);
+        await plugin._hooks?.remove(opt);
     }
     await _sql('DROP DATABASE axium', 'Dropping database');
     await _sql('REVOKE ALL PRIVILEGES ON SCHEMA public FROM axium', 'Revoking schema privileges');
@@ -469,11 +469,11 @@ export async function uninstall(opt) {
  * Removes all data from tables.
  */
 export async function wipe(opt) {
-    for (const plugin of plugins) {
-        if (!plugin.hooks.db_wipe)
+    for (const plugin of plugins.values()) {
+        if (!plugin._hooks?.db_wipe)
             continue;
         io.plugin(plugin.name);
-        await plugin.hooks.db_wipe(opt);
+        await plugin._hooks?.db_wipe(opt);
     }
     for (const table of ['users', 'passkeys', 'sessions', 'verifications']) {
         io.start(`Wiping ${table}`);

package/dist/internal_requests.d.ts

@@ -0,0 +1,3 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export declare function convertToRequest(req: IncomingMessage): Request;
+export declare function convertFromResponse(res: ServerResponse, response: Response): Promise<void>;

package/dist/internal_requests.js

@@ -0,0 +1,119 @@
+import { config } from './config.js';
+/* Credit to the SvelteKit team: https://github.com/sveltejs/kit/blob/8d1ba04825a540324bc003e85f36559a594aadc2/packages/kit/src/exports/node/index.js */
+function get_raw_body(req) {
+    const h = req.headers;
+    if (!h['content-type'])
+        return null;
+    const content_length = Number(h['content-length']);
+    // check if no request body
+    if ((req.httpVersionMajor === 1 && isNaN(content_length) && h['transfer-encoding'] == null) || content_length === 0) {
+        return null;
+    }
+    let length = content_length;
+    if (config.request_size_limit) {
+        if (!length)
+            length = config.request_size_limit;
+        else if (length > config.request_size_limit)
+            throw 413;
+    }
+    if (req.destroyed) {
+        const readable = new ReadableStream();
+        void readable.cancel();
+        return readable;
+    }
+    let size = 0;
+    let cancelled = false;
+    return new ReadableStream({
+        start(controller) {
+            req.on('error', error => {
+                cancelled = true;
+                controller.error(error);
+            });
+            req.on('end', () => {
+                if (cancelled)
+                    return;
+                controller.close();
+            });
+            req.on('data', chunk => {
+                if (cancelled)
+                    return;
+                size += chunk.length;
+                if (size > length) {
+                    cancelled = true;
+                    controller.error(413);
+                    return;
+                }
+                controller.enqueue(chunk);
+                if (controller.desiredSize === null || controller.desiredSize <= 0) {
+                    req.pause();
+                }
+            });
+        },
+        pull() {
+            req.resume();
+        },
+        cancel(reason) {
+            cancelled = true;
+            req.destroy(reason);
+        },
+    });
+}
+export function convertToRequest(req) {
+    const headers = req.headers;
+    const request = new Request(config.auth.origin + req.url, {
+        // @ts-expect-error 2353
+        duplex: 'half',
+        method: req.method,
+        headers,
+        body: get_raw_body(req),
+    });
+    return request;
+}
+export async function convertFromResponse(res, response) {
+    res.writeHead(response.status, Object.fromEntries(response.headers));
+    if (!response.body) {
+        res.end();
+        return;
+    }
+    if (response.body.locked) {
+        res.write('Fatal error: Response body is locked. ' +
+            `This can happen when the response was already read (for example through 'response.json()' or 'response.text()').`);
+        res.end();
+        return;
+    }
+    const reader = response.body.getReader();
+    if (res.destroyed) {
+        await reader.cancel();
+        return;
+    }
+    const cancel = (error) => {
+        res.off('close', cancel);
+        res.off('error', cancel);
+        // If the reader has already been interrupted with an error earlier,
+        // then it will appear here, it is useless, but it needs to be catch.
+        reader.cancel(error).catch(() => { });
+        if (error)
+            res.destroy(error);
+    };
+    res.on('close', cancel);
+    res.on('error', cancel);
+    async function next() {
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (!res.write(value)) {
+                    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+                    res.once('drain', next);
+                    return;
+                }
+            }
+            res.end();
+        }
+        catch (error) {
+            cancel(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    void next();
+}

package/dist/io.d.ts

@@ -1,6 +1,5 @@
 import { Logger } from 'logzen';
 export declare const systemDir = "/etc/axium";
-export declare const userDir: string;
 export declare const dirs: string[];
 export declare const logger: Logger;
 /**
@@ -30,6 +29,7 @@ export interface Output {
     (tag: 'done'): void;
     (tag: Exclude<OutputTag, 'done'>, message: string): void;
 }
+export declare let _debugOutput: boolean;
 /**
  * Enable or disable debug output.
  */

package/dist/io.js

@@ -1,13 +1,11 @@
 import { Logger } from 'logzen';
 import { exec } from 'node:child_process';
 import * as fs from 'node:fs';
-import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path/posix';
 import { styleText } from 'node:util';
 import { _unique } from './state.js';
 export const systemDir = '/etc/axium';
-export const userDir = join(homedir(), '.axium');
-export const dirs = _unique('dirs', [systemDir, userDir]);
+export const dirs = _unique('dirs', [systemDir]);
 for (let dir = resolve(process.cwd()); dir !== '/'; dir = dirname(dir)) {
     if (fs.existsSync(join(dir, '.axium')))
         dirs.push(join(dir, '.axium'));
@@ -20,7 +18,6 @@ try {
 catch {
     // Missing permissions
 }
-fs.mkdirSync(userDir, { recursive: true });
 export const logger = new Logger({
     hideWarningStack: true,
     noGlobalConsole: true,
@@ -92,7 +89,7 @@ export function handleError(e) {
     else
         exit(e);
 }
-let _debugOutput = false;
+export let _debugOutput = false;
 /**
  * Enable or disable debug output.
  */

package/dist/linking.d.ts

@@ -5,7 +5,6 @@ interface LinkInfo {
     text: string;
 }
 export interface LinkOptions {
-    packagesDir?: string;
     only?: string[];
 }
 export declare function listRouteLinks(options?: LinkOptions): Generator<LinkInfo>;

package/dist/linking.js

@@ -11,21 +11,18 @@ function info(id) {
     const link = join(config.web.routes, `(${id.startsWith('#') ? id.slice(1) : id.replaceAll('/', '__')})`);
     return [text, link];
 }
-const defaultPackagesDir = join(import.meta.dirname, '../../..');
 export function* listRouteLinks(options = {}) {
-    const packagesDir = options.packagesDir || defaultPackagesDir;
-    io.debug('Using packages from ' + packagesDir);
     if (!options.only) {
         const [text, link] = info('#builtin');
         yield { text, id: '#builtin', from: link, to: resolve(import.meta.dirname, '../routes') };
     }
-    for (const plugin of plugins) {
+    for (const plugin of plugins.values()) {
         if (!plugin.routes)
             continue;
         if (options.only && !options.only.includes(plugin.name))
             continue;
         const [text, link] = info(plugin.name);
-        const to = resolve(join(packagesDir, plugin.name, plugin.routes));
+        const to = resolve(join(plugin.dirname, plugin.routes));
         yield { text, id: plugin.name, from: link, to };
     }
 }

package/dist/plugins.d.ts

@@ -1,38 +1,7 @@
-import * as z from 'zod';
+import { type PluginInternal } from '@axium/core/plugins';
 import type { InitOptions, OpOptions } from './database.js';
-export declare const PluginMetadata: z.ZodObject<{
-    name: z.ZodString;
-    version: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    routes: z.ZodOptional<z.ZodString>;
-    apps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodOptional<z.ZodString>;
-        image: z.ZodOptional<z.ZodString>;
-        icon: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-}, z.core.$loose>;
-export declare const Plugin: z.ZodObject<{
-    name: z.ZodString;
-    version: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    routes: z.ZodOptional<z.ZodString>;
-    apps: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodOptional<z.ZodString>;
-        image: z.ZodOptional<z.ZodString>;
-        icon: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    statusText: z.ZodCustom<z.core.$InferInnerFunctionTypeAsync<z.core.$ZodTuple<[], null>, z.ZodString>, z.core.$InferInnerFunctionTypeAsync<z.core.$ZodTuple<[], null>, z.ZodString>>;
-    hooks: z.ZodOptional<z.ZodRecord<z.ZodLiteral<"remove" | "db_init" | "db_wipe" | "clean"> & z.core.$partial, z.ZodCustom<(...args: any[]) => any, (...args: any[]) => any>>>;
-}, z.core.$loose>;
-declare const kSpecifier: unique symbol;
-export type Plugin = z.infer<typeof Plugin>;
-interface PluginInternal extends Plugin {
-    [kSpecifier]: string;
-    hooks: Hooks;
-}
 export interface Hooks {
+    statusText?(): string | Promise<string>;
     db_init?: (opt: InitOptions) => void | Promise<void>;
     remove?: (opt: {
         force?: boolean;
@@ -40,10 +9,6 @@ export interface Hooks {
     db_wipe?: (opt: OpOptions) => void | Promise<void>;
     clean?: (opt: Partial<OpOptions>) => void | Promise<void>;
 }
-export declare const plugins: Set<PluginInternal>;
-export declare function resolvePlugin(search: string): PluginInternal | undefined;
+export declare const plugins: Map<string, PluginInternal>;
 export declare function pluginText(plugin: PluginInternal): string;
-export declare function loadPlugin(specifier: string): Promise<void>;
-export declare function getSpecifier(plugin: PluginInternal): string;
-export declare function loadPlugins(dir: string): Promise<void>;
-export {};
+export declare function loadPlugin(specifier: string, _loadedBy: string, safeMode?: boolean): Promise<void>;

package/dist/plugins.js

@@ -1,54 +1,52 @@
-import { App } from '@axium/core';
-import { zAsyncFunction } from '@axium/core/schemas';
+import { Plugin } from '@axium/core/plugins';
 import * as fs from 'node:fs';
-import { resolve } from 'node:path/posix';
+import { dirname, join, resolve } from 'node:path/posix';
+import { fileURLToPath } from 'node:url';
 import { styleText } from 'node:util';
 import * as z from 'zod';
 import { apps } from './apps.js';
 import { output } from './io.js';
 import { _unique } from './state.js';
-export const PluginMetadata = z.looseObject({
-    name: z.string(),
-    version: z.string(),
-    description: z.string().optional(),
-    routes: z.string().optional(),
-    apps: z.array(App).optional(),
-});
-const hookNames = ['db_init', 'remove', 'db_wipe', 'clean'];
-const fn = z.custom(data => typeof data === 'function');
-export const Plugin = PluginMetadata.extend({
-    statusText: zAsyncFunction(z.function({ input: [], output: z.string() })),
-    hooks: z.partialRecord(z.literal(hookNames), fn).optional(),
-});
-const kSpecifier = Symbol('specifier');
-export const plugins = _unique('plugins', new Set());
-export function resolvePlugin(search) {
-    for (const plugin of plugins) {
-        if (plugin.name === search)
-            return plugin;
-    }
-}
+export const plugins = _unique('plugins', new Map());
 export function pluginText(plugin) {
     return [
         styleText('whiteBright', plugin.name),
         `Version: ${plugin.version}`,
         `Description: ${plugin.description ?? styleText('dim', '(none)')}`,
-        `Hooks: ${Object.keys(plugin.hooks).join(', ') || styleText('dim', '(none)')}`,
-        // @todo list the routes when debug output is enabled
-        `Routes: ${plugin.routes || styleText('dim', '(none)')}`,
+        `Hooks: ${plugin._hooks ? styleText(['dim', 'bold'], `(${Object.keys(plugin._hooks).length}) `) + Object.keys(plugin._hooks).join(', ') : plugin.hooks || styleText('dim', '(none)')}`,
+        `HTTP Handler: ${plugin.http_handler ?? styleText('dim', '(none)')}`,
     ].join('\n');
 }
-const _importedPlugins = _unique('imported_raw', new Set());
-export async function loadPlugin(specifier) {
+function _locatePlugin(specifier, _loadedBy) {
+    if (specifier[0] == '/' || specifier.startsWith('./') || specifier.startsWith('../')) {
+        return resolve(dirname(_loadedBy), specifier);
+    }
+    let packageDir = dirname(fileURLToPath(import.meta.resolve(specifier)));
+    for (; !fs.existsSync(join(packageDir, 'package.json')); packageDir = dirname(packageDir))
+        ;
+    return join(packageDir, 'package.json');
+}
+export async function loadPlugin(specifier, _loadedBy, safeMode = false) {
     try {
-        const imported = await import(/* @vite-ignore */ specifier);
-        if (_importedPlugins.has(imported))
-            return; // already loaded this exact module
-        _importedPlugins.add(imported);
-        const maybePlugin = 'default' in imported ? imported.default : imported;
-        const plugin = Object.assign({ hooks: {}, [kSpecifier]: specifier }, await Plugin.parseAsync(maybePlugin).catch(e => {
+        const path = _locatePlugin(specifier, _loadedBy);
+        let imported;
+        try {
+            imported = JSON.parse(fs.readFileSync(path, 'utf8'));
+        }
+        catch (e) {
+            throw new Error('Invalid or missing metadata for ' + specifier);
+        }
+        if ('axium' in imported)
+            Object.assign(imported, imported.axium); // support axium field in package.json
+        const plugin = Object.assign(await Plugin.parseAsync(imported).catch(e => {
             throw e instanceof z.core.$ZodError ? z.prettifyError(e) : e;
-        }));
+        }), { path, specifier, _loadedBy, dirname: dirname(path) });
+        if (!safeMode && plugin.hooks) {
+            Object.assign(plugin, { _hooks: await import(resolve(plugin.dirname, plugin.hooks)) });
+        }
+        Object.freeze(plugin);
+        if (plugins.has(plugin.name))
+            throw 'Plugin already loaded';
         if (plugin.name.startsWith('#') || plugin.name.includes(' ')) {
             throw 'Invalid plugin name. Plugin names can not start with a hash or contain spaces.';
         }
@@ -57,24 +55,10 @@ export async function loadPlugin(specifier) {
                 throw new ReferenceError(`App with ID "${app.id}" already exists.`);
             apps.set(app.id, app);
         }
-        plugins.add(plugin);
+        plugins.set(plugin.name, plugin);
         output.debug(`Loaded plugin: ${plugin.name} ${plugin.version}`);
     }
     catch (e) {
         output.debug(`Failed to load plugin from ${specifier}: ${e ? (e instanceof Error ? e.message : e.toString()) : e}`);
     }
 }
-export function getSpecifier(plugin) {
-    return plugin[kSpecifier];
-}
-export async function loadPlugins(dir) {
-    fs.mkdirSync(dir, { recursive: true });
-    const files = fs.readdirSync(dir);
-    for (const file of files) {
-        const path = resolve(dir, file);
-        const stats = fs.statSync(path);
-        if (stats.isDirectory() || !['.js', '.mjs'].some(ext => path.endsWith(ext)))
-            return;
-        await loadPlugin(path);
-    }
-}

package/dist/requests.d.ts

@@ -1,12 +1,12 @@
-import { type User } from '@axium/core/user';
+import type { User, UserInternal } from '@axium/core';
 import * as z from 'zod';
-import { type UserInternal } from './auth.js';
 import type { ServerRoute } from './routes.js';
 /**
  * @todo Add parsing for Node.js `IncomingMessage` -> standard `Request` and standard `Response` -> Node.js `ServerResponse`
  */
 /**
  * A `Request` with some commonly used stuff pre-parsed for convenience.
+ * @deprecated
  */
 export interface RequestEvent<Params extends Partial<Record<string, string>> = Partial<Record<string, string>>> {
     request: Request;
@@ -32,12 +32,12 @@ export declare function isRedirect(e: unknown): e is Redirect;
  */
 export declare function redirect(location: string, status?: number): never;
 export declare function json(data: object, init?: ResponseInit): Response;
-export declare function parseBody<const Schema extends z.ZodType, const Result extends z.infer<Schema> = z.infer<Schema>>(event: RequestEvent, schema: Schema): Promise<Result>;
-export declare function getToken(event: RequestEvent, sensitive?: boolean): string | undefined;
+export declare function parseBody<const Schema extends z.ZodType, const Result extends z.infer<Schema> = z.infer<Schema>>(request: Request, schema: Schema): Promise<Result>;
+export declare function getToken(request: Request, sensitive?: boolean): string | undefined;
 export declare function createSessionData(userId: string, elevated?: boolean): Promise<Response>;
 export declare function stripUser(user: UserInternal, includeProtected?: boolean): User;
 export declare function withError(text: string, code?: number): (e: Error | ResponseError) => never;
-export declare function handleAPIRequest(event: RequestEvent, route: ServerRoute): Promise<Response>;
+export declare function handleAPIRequest(request: Request, params: Record<string, any>, route: ServerRoute): Promise<Response>;
 export declare function handleResponseError(e: Error | ResponseError | Redirect): Response;
 export declare const noCacheHeaders: {
     'Content-Type': string;