@axium/server 0.24.1 → 0.26.0

package/dist/io.js

@@ -1,8 +1,7 @@
+import * as io from '@axium/core/node/io';
 import { Logger } from 'logzen';
-import { exec } from 'node:child_process';
 import * as fs from 'node:fs';
 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 dirs = _unique('dirs', [systemDir]);
@@ -22,130 +21,7 @@ export const logger = new Logger({
     hideWarningStack: true,
     noGlobalConsole: true,
 });
-/**
- * @internal
- */
-export const output = {
-    constructor: { name: 'Console' },
-    error(message) {
-        console.error(message.startsWith('\x1b') ? message : styleText('red', message));
-    },
-    warn(message) {
-        console.warn(message.startsWith('\x1b') ? message : styleText('yellow', message));
-    },
-    info(message) {
-        console.info(message.startsWith('\x1b') ? message : styleText('blue', message));
-    },
-    log(message) {
-        console.log(message);
-    },
-    debug(message) {
-        _debugOutput && console.debug(message.startsWith('\x1b') ? message : styleText('gray', message));
-    },
-};
-logger.attach(output);
-let timeout = 1000;
-export function setCommandTimeout(value) {
-    timeout = value;
-}
-/**
- * Run a system command with the fancy "Example... done."
- * @internal
- */
-export async function run(message, command) {
-    let stderr;
-    try {
-        start(message);
-        const { promise, resolve, reject } = Promise.withResolvers();
-        exec(command, { timeout }, (err, stdout, _stderr) => {
-            stderr = _stderr.startsWith('ERROR:') ? _stderr.slice(6).trim() : _stderr;
-            if (err)
-                reject('[command]');
-            else
-                resolve(stdout);
-        });
-        const value = await promise;
-        done();
-        return value;
-    }
-    catch (error) {
-        throw error == '[command]'
-            ? stderr?.slice(0, 100) || 'failed.'
-            : typeof error == 'object' && 'message' in error
-                ? error.message
-                : error;
-    }
-}
-/** Yet another convenience function */
-export function exit(message, code = 1) {
-    if (message instanceof Error)
-        message = message.message;
-    output.error(message);
-    process.exit(code);
-}
-export function handleError(e) {
-    if (typeof e == 'number')
-        process.exit(e);
-    else
-        exit(e);
-}
-let _debugOutput = false;
-/**
- * Enable or disable debug output.
- */
-export function _setDebugOutput(enabled) {
-    _debugOutput = enabled;
-}
-function defaultOutput(tag, message = '') {
-    switch (tag) {
-        case 'debug':
-            _debugOutput && output.debug(message);
-            break;
-        case 'info':
-            console.log(message);
-            break;
-        case 'warn':
-            console.warn(styleText('yellow', message));
-            break;
-        case 'error':
-            console.error(styleText('red', message));
-            break;
-        case 'start':
-            process.stdout.write(message + '... ');
-            break;
-        case 'done':
-            console.log('done.');
-            break;
-        case 'plugin':
-            console.log(styleText('whiteBright', 'Running plugin: ' + message));
-    }
-}
-let _taggedOutput = defaultOutput;
-export function useTaggedOutput(output) {
-    _taggedOutput = output;
-}
-// Shortcuts for tagged output
-export function done() {
-    _taggedOutput?.('done');
-}
-export function start(message) {
-    _taggedOutput?.('start', message);
-}
-export function plugin(name) {
-    _taggedOutput?.('plugin', name);
-}
-export function debug(message) {
-    _taggedOutput?.('debug', message);
-}
-export function info(message) {
-    _taggedOutput?.('info', message);
-}
-export function warn(message) {
-    _taggedOutput?.('warn', message);
-}
-export function error(message) {
-    _taggedOutput?.('error', message);
-}
+logger.attach(io);
 /** @internal */
 export const _portMethods = ['node-cap'];
 /** @internal */
@@ -156,72 +32,48 @@ export const _portActions = ['enable', 'disable'];
  * If the origin has a port, passkeys do not work correctly with some password managers.
  */
 export async function restrictedPorts(opt) {
-    start('Checking for root privileges');
+    io.start('Checking for root privileges');
     if (process.getuid?.() != 0)
         throw 'root privileges are needed to change restricted ports.';
-    done();
-    start('Checking ports method');
+    io.done();
+    io.start('Checking ports method');
     if (!_portMethods.includes(opt.method))
         throw 'invalid';
-    done();
-    start('Checking ports action');
+    io.done();
+    io.start('Checking ports action');
     if (!_portActions.includes(opt.action))
         throw 'invalid';
-    done();
+    io.done();
     switch (opt.method) {
         case 'node-cap': {
-            const setcap = await run('Finding setcap', 'command -v setcap')
+            const setcap = await io
+                .run('Finding setcap', 'command -v setcap')
                 .then(e => e.trim())
                 .catch(() => {
-                warn('not in path.');
-                start('Checking for /usr/sbin/setcap');
+                io.warn('not in path.');
+                io.start('Checking for /usr/sbin/setcap');
                 fs.accessSync('/usr/sbin/setcap', fs.constants.X_OK);
-                done();
+                io.done();
                 return '/usr/sbin/setcap';
             });
-            debug('Using setcap at ' + setcap);
+            io.debug('Using setcap at ' + setcap);
             let { node } = opt;
-            node ||= await run('Finding node', 'command -v node')
+            node ||= await io
+                .run('Finding node', 'command -v node')
                 .then(e => e.trim())
                 .catch(() => {
-                warn('not in path.');
-                start('Checking for /usr/bin/node');
+                io.warn('not in path.');
+                io.start('Checking for /usr/bin/node');
                 fs.accessSync('/usr/bin/node', fs.constants.X_OK);
-                done();
+                io.done();
                 return '/usr/bin/node';
             });
-            start('Resolving real path for node');
+            io.start('Resolving real path for node');
             node = fs.realpathSync(node);
-            done();
-            debug('Using node at ' + node);
-            await run('Setting ports capability', `${setcap} cap_net_bind_service=${opt.action == 'enable' ? '+' : '-'}ep ${node}`);
+            io.done();
+            io.debug('Using node at ' + node);
+            await io.run('Setting ports capability', `${setcap} cap_net_bind_service=${opt.action == 'enable' ? '+' : '-'}ep ${node}`);
             break;
         }
     }
 }
-/**
- * This is a factory for handling errors when performing operations.
- * The handler will allow the parent scope to continue if a relation already exists,
- * rather than fatally exiting.
- */
-export function someWarnings(...allowList) {
-    return (error) => {
-        error = typeof error == 'object' && 'message' in error ? error.message : error;
-        for (const [pattern, message = error] of allowList) {
-            if (!pattern.test(error))
-                continue;
-            warn(message);
-            return;
-        }
-        throw error;
-    };
-}
-const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-// Shortcut to convert to 2-digit. Mostly used to make the line shorter.
-const _2 = (v) => v.toString().padStart(2, '0');
-/**
- * Get a human-readable string for a date that also fits into CLIs well (fixed-width)
- */
-export function prettyDate(date) {
-    return `${date.getFullYear()} ${months[date.getMonth()]} ${_2(date.getDate())} ${_2(date.getHours())}:${_2(date.getMinutes())}:${_2(date.getSeconds())}.${date.getMilliseconds().toString().padStart(3, '0')}`;
-}

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

@@ -1,8 +1,8 @@
+import * as io from '@axium/core/node/io';
+import { plugins } from '@axium/core/plugins';
 import { existsSync, symlinkSync, unlinkSync } from 'node:fs';
 import { join, resolve } from 'node:path/posix';
 import config from './config.js';
-import * as io from './io.js';
-import { plugins } from './plugins.js';
 const textFor = {
     builtin: 'built-in routes',
 };
@@ -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) {
-        if (!plugin.routes)
+    for (const plugin of plugins.values()) {
+        if (!plugin.server?.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.server.routes));
         yield { text, id: plugin.name, from: link, to };
     }
 }

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,16 @@ 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 createSessionData(userId: string, elevated?: boolean): Promise<Response>;
+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 interface CreateSessionOptions {
+    elevated?: boolean;
+    noCookie?: boolean;
+}
+export declare function createSessionData(userId: string, { elevated, noCookie }?: CreateSessionOptions): 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;

package/dist/requests.js

@@ -1,5 +1,5 @@
 import { userProtectedFields, userPublicFields } from '@axium/core/user';
-import { serialize as serializeCookie } from 'cookie';
+import * as cookie from 'cookie_v1';
 import { pick } from 'utilium';
 import * as z from 'zod';
 import { createSession } from './auth.js';
@@ -29,11 +29,11 @@ export function json(data, init) {
     }
     return response;
 }
-export async function parseBody(event, schema) {
-    const contentType = event.request.headers.get('content-type');
+export async function parseBody(request, schema) {
+    const contentType = request.headers.get('content-type');
     if (!contentType || !contentType.includes('application/json'))
         error(415, 'Invalid content type');
-    const body = await event.request.json().catch(() => error(415, 'Invalid JSON'));
+    const body = await request.json().catch(() => error(415, 'Invalid JSON'));
     try {
         return schema.parse(body);
     }
@@ -41,18 +41,20 @@ export async function parseBody(event, schema) {
         error(400, e instanceof z.core.$ZodError ? z.prettifyError(e) : 'invalid body');
     }
 }
-export function getToken(event, sensitive = false) {
-    const header_token = event.request.headers.get('Authorization')?.replace('Bearer ', '');
+export function getToken(request, sensitive = false) {
+    const header_token = request.headers.get('Authorization')?.replace('Bearer ', '');
     if (header_token)
         return header_token;
     if (config.debug || !config.auth.header_only) {
-        return event.cookies.get(sensitive ? 'elevated_token' : 'session_token');
+        return cookie.parse(request.headers.get('cookie') || '')[sensitive ? 'elevated_token' : 'session_token'];
     }
 }
-export async function createSessionData(userId, elevated = false) {
+export async function createSessionData(userId, { elevated = false, noCookie } = {}) {
     const { token, expires } = await createSession(userId, elevated);
     const response = json({ userId, token: elevated ? '[[redacted:elevated]]' : token }, { status: 201 });
-    const cookies = serializeCookie(elevated ? 'elevated_token' : 'session_token', token, {
+    if (noCookie)
+        return response;
+    const cookies = cookie.serialize(elevated ? 'elevated_token' : 'session_token', token, {
         httpOnly: true,
         path: '/',
         expires,
@@ -72,18 +74,18 @@ export function withError(text, code = 500) {
         error(code, text + (config.debug && e.message ? `: ${e.message}` : ''));
     };
 }
-export async function handleAPIRequest(event, route) {
-    const method = event.request.method;
+export async function handleAPIRequest(request, params, route) {
+    const method = request.method;
     const _warnings = [];
-    if (route.api && !event.request.headers.get('Accept')?.includes('application/json')) {
+    if (route.api && !request.headers.get('Accept')?.includes('application/json')) {
         _warnings.push('Only application/json is supported');
-        event.request.headers.set('Accept', 'application/json');
+        request.headers.set('Accept', 'application/json');
     }
     for (const [key, type] of Object.entries(route.params || {})) {
         if (!type)
             continue;
         try {
-            event.params[key] = type.parse(event.params[key]);
+            params[key] = type.parse(params[key]);
         }
         catch (e) {
             error(400, `Invalid parameter: ${e instanceof z.core.$ZodError ? z.prettifyError(e) : '<unknown error>'}`);
@@ -91,7 +93,7 @@ export async function handleAPIRequest(event, route) {
     }
     if (typeof route[method] != 'function')
         error(405, `Method ${method} not allowed for ${route.path}`);
-    const result = await route[method](event);
+    const result = await route[method].call(route, request, params);
     if (result instanceof Response)
         return result;
     if (typeof result == 'object' || typeof result == 'function') {

package/dist/routes.d.ts

@@ -1,10 +1,9 @@
 import type { RequestMethod } from '@axium/core/requests';
 import type { Component } from 'svelte';
 import type z from 'zod';
-import type { RequestEvent } from './requests.js';
 type _Params = Partial<Record<string, string>>;
-type MaybePromise<T> = T | Promise<T>;
-export type EndpointHandlers<Params extends _Params = _Params> = Partial<Record<RequestMethod, (event: RequestEvent<Params>) => MaybePromise<object | Response>>>;
+export type MaybePromise<T> = T | Promise<T>;
+export type EndpointHandlers<Params extends _Params = _Params, This = unknown> = Partial<Record<RequestMethod, (this: This, request: Request, params: Params) => MaybePromise<object | Response>>>;
 export type RouteParamOptions = z.ZodType;
 export interface CommonRouteOptions<Params extends _Params = _Params> {
     path: string;
@@ -15,11 +14,11 @@ export interface CommonRouteOptions<Params extends _Params = _Params> {
 /**
  * A route with server-side handlers for different HTTP methods.
  */
-export interface ServerRouteOptions<Params extends _Params = _Params> extends CommonRouteOptions<Params>, EndpointHandlers<Params> {
+export interface ServerRouteOptions<Params extends _Params = _Params> extends CommonRouteOptions<Params>, EndpointHandlers<Params, RouteCommon> {
     api?: boolean;
 }
 export interface WebRouteOptions extends CommonRouteOptions {
-    load?(event: RequestEvent): object | Promise<object>;
+    load?(request: Request): object | Promise<object>;
     /** the Svelte page */
     page?: Component;
 }
@@ -34,7 +33,7 @@ export interface ServerRoute extends RouteCommon, EndpointHandlers {
 }
 export interface WebRoute extends RouteCommon {
     server: false;
-    load?(event: RequestEvent): object | Promise<object>;
+    load?(request: Request): object | Promise<object>;
     page: Component;
 }
 export type Route = ServerRoute | WebRoute;
@@ -50,8 +49,5 @@ export declare function addRoute(opt: RouteOptions): void;
  * Resolve a request URL into a route.
  * This handles parsing of parameters in the URL.
  */
-export declare function resolveRoute(event: {
-    url: URL;
-    params?: object;
-}): Route | undefined;
+export declare function resolveRoute(url: URL): [Route, params: object] | void;
 export {};

package/dist/routes.js

@@ -1,6 +1,6 @@
-import { apps } from './apps.js';
+import { apps } from '@axium/core';
+import { debug } from '@axium/core/node/io';
 import config from './config.js';
-import { output } from './io.js';
 import { _unique } from './state.js';
 /**
  * @internal
@@ -19,16 +19,16 @@ export function addRoute(opt) {
     if (route.api && !route.server)
         throw new Error(`API routes cannot have a client page: ${route.path}`);
     routes.set(route.path, route);
-    output.debug('Added route: ' + route.path);
+    debug('Added route: ' + route.path);
 }
 /**
  * Resolve a request URL into a route.
  * This handles parsing of parameters in the URL.
  */
-export function resolveRoute(event) {
-    const { pathname } = event.url;
+export function resolveRoute(url) {
+    const { pathname } = url;
     if (routes.has(pathname) && !pathname.split('/').some(p => p.startsWith(':')))
-        return routes.get(pathname);
+        return [routes.get(pathname), {}];
     // Otherwise we must have a parameterized route
     _routes: for (const route of routes.values()) {
         const params = {};
@@ -50,7 +50,6 @@ export function resolveRoute(event) {
         // we didn't find a match, since an exact match would have been found already
         if (pathParts.length || !Object.keys(params).length)
             continue;
-        event.params = params;
-        return route;
+        return [route, params];
     }
 }

package/dist/serve.d.ts

@@ -1,12 +1,17 @@
-import type { Server } from 'node:http';
 import '@axium/server/api/index';
+import type { Server } from 'node:http';
+export declare const appDisabledContent: {
+    head: string;
+    body: string;
+};
 export interface ServeOptions {
     secure: boolean;
     ssl_key: string;
     ssl_cert: string;
     build: string;
+    multiBuild: boolean;
 }
-export declare function serveSvelteKit(opt: Partial<ServeOptions>): Promise<Server>;
+export declare function serve(opt: Partial<ServeOptions>): Promise<Server>;
 /**
  * Perform initial setup for when the server is serving web pages.
  */