@axium/server 0.29.0 → 0.31.0

package/dist/database.js

@@ -63,6 +63,7 @@ import * as z from 'zod';
 import config from './config.js';
 import rawSchema from './db.json' with { type: 'json' };
 import { dirs, systemDir } from './io.js';
+pg.types.setTypeParser(pg.types.builtins.INT8, BigInt);
 const sym = Symbol.for('Axium:database');
 export let database;
 export function connect() {
@@ -230,8 +231,55 @@ export async function init(opt) {
             await result_1;
     }
 }
+const numberTypes = [
+    'integer',
+    'int2',
+    'int4',
+    'int8',
+    'smallint',
+    'real',
+    'double precision',
+    'float4',
+    'float8',
+    'decimal',
+    'numeric',
+    'serial',
+];
+const bigintTypes = ['bigint', 'bigserial'];
+const booleanTypes = ['boolean', 'bool'];
+const stringTypes = ['varchar', 'char', 'text'];
+const dateTypes = ['date', 'datetime', 'time', 'timetz', 'timestamp', 'timestamptz'];
+const binaryTypes = ['binary', 'bytea', 'varbinary', 'blob'];
+const numericRangeTypes = ['int4range', 'numrange'];
+const stringRangeTypes = ['tsrange', 'tstzrange', 'daterange'];
+const multirangeTypes = ['int4multirange', 'int8multirange', 'nummultirange', 'tsmultirange', 'tstzmultirange', 'datemultirange'];
+const _primitive = z.literal([
+    ...numberTypes,
+    ...bigintTypes,
+    ...booleanTypes,
+    ...stringTypes,
+    ...dateTypes,
+    ...binaryTypes,
+    ...numericRangeTypes,
+    ...stringRangeTypes,
+    ...multirangeTypes,
+    'uuid',
+    'json',
+    'jsonb',
+]);
+const _ColumnType = z.union([
+    _primitive,
+    z.templateLiteral([
+        z.literal(['char', 'varchar', 'binary', 'varbinary', 'datetime', 'time', 'timetz', 'timestamp', 'timestamptz']),
+        '(',
+        z.int().nonnegative(),
+        ')',
+    ]),
+    z.templateLiteral([z.literal(['decimal', 'numeric']), '(', z.int().nonnegative(), z.literal([',', ', ']), z.int().nonnegative(), ')']),
+]);
+const ColumnType = z.union([_ColumnType, z.templateLiteral([_ColumnType, '[', z.int().nonnegative().optional(), ']'])]);
 export const Column = z.strictObject({
-    type: z.string(),
+    type: ColumnType,
     required: z.boolean().default(false),
     unique: z.boolean().default(false),
     primary: z.boolean().default(false),
@@ -275,7 +323,7 @@ export const SchemaDecl = z.strictObject({
     indexes: IndexString.array().optional().default([]),
 });
 export const ColumnDelta = z.strictObject({
-    type: z.string().optional(),
+    type: ColumnType.optional(),
     default: z.string().optional(),
     ops: z.literal(['drop_default', 'set_required', 'drop_required']).array().optional(),
 });
@@ -317,8 +365,7 @@ export function* getSchemaFiles() {
             yield [name, SchemaFile.parse(plugin._db)];
         }
         catch (e) {
-            const text = e instanceof z.core.$ZodError ? z.prettifyError(e) : e instanceof Error ? e.message : String(e);
-            throw `Invalid database configuration for plugin "${name}":\n${text}`;
+            throw `Invalid database configuration for plugin "${name}":\n${io.errorText(e)}`;
         }
     }
 }
@@ -334,10 +381,16 @@ export function getFullSchema(opt = {}) {
         let currentSchema = { tables: {}, indexes: [] };
         fullSchema.versions[pluginName] = file.latest;
         for (const [version, schema] of file.versions.entries()) {
-            if (schema.delta)
-                applyDeltaToSchema(currentSchema, schema);
-            else
+            if (!schema.delta)
                 currentSchema = schema;
+            else {
+                try {
+                    applyDeltaToSchema(currentSchema, schema);
+                }
+                catch (e) {
+                    throw `Failed to apply version ${version - 1}->${version} delta to ${pluginName}: ${io.errorText(e)}`;
+                }
+            }
             if (version === file.latest)
                 break;
         }
@@ -375,20 +428,20 @@ export function setUpgradeInfo(info) {
 }
 export function applyTableDeltaToSchema(table, delta) {
     for (const column of delta.drop_columns) {
-        if (column in table)
+        if (column in table.columns)
             delete table.columns[column];
         else
-            throw `Can't drop column ${column} because it does not exist`;
+            throw `can't drop column ${column} because it does not exist`;
     }
     for (const [name, column] of Object.entries(delta.add_columns)) {
-        if (name in table)
-            throw `Can't add column ${name} because it already exists`;
+        if (name in table.columns)
+            throw `can't add column ${name} because it already exists`;
         table.columns[name] = column;
     }
     for (const [name, columnDelta] of Object.entries(delta.alter_columns)) {
         const column = table.columns[name];
         if (!column)
-            throw `Can't modify column ${name} because it does not exist`;
+            throw `can't modify column ${name} because it does not exist`;
         if (columnDelta.type)
             column.type = columnDelta.type;
         if (columnDelta.default)
@@ -411,11 +464,11 @@ export function applyTableDeltaToSchema(table, delta) {
         if (table.constraints[name])
             delete table.constraints[name];
         else
-            throw `Can't drop constraint ${name} because it does not exist`;
+            throw `can't drop constraint ${name} because it does not exist`;
     }
     for (const [name, constraint] of Object.entries(delta.add_constraints)) {
         if (table.constraints[name])
-            throw `Can't add constraint ${name} because it already exists`;
+            throw `can't add constraint ${name} because it already exists`;
         table.constraints[name] = constraint;
     }
 }
@@ -424,11 +477,11 @@ export function applyDeltaToSchema(schema, delta) {
         if (tableName in schema.tables)
             delete schema.tables[tableName];
         else
-            throw `Can't drop table ${tableName} because it does not exist`;
+            throw `can't drop table ${tableName} because it does not exist`;
     }
     for (const [tableName, table] of Object.entries(delta.add_tables)) {
         if (tableName in schema.tables)
-            throw `Can't add table ${tableName} because it already exists`;
+            throw `can't add table ${tableName} because it already exists`;
         else
             schema.tables[tableName] = table;
     }
@@ -436,7 +489,7 @@ export function applyDeltaToSchema(schema, delta) {
         if (tableName in schema.tables)
             applyTableDeltaToSchema(schema.tables[tableName], tableDelta);
         else
-            throw `Can't modify table ${tableName} because it does not exist`;
+            throw `can't modify table ${tableName} because it does not exist`;
     }
 }
 export function validateDelta(delta) {
@@ -734,10 +787,10 @@ export async function applyDelta(delta, forceAbort = false) {
 /**
  * Checks that a table has the expected column types, nullability, and default values.
  */
-export async function checkTableTypes(tableName, types, opt) {
+export async function checkTableTypes(tableName, types, opt, tableMetadata) {
     io.start(`Checking table ${tableName}`);
-    const dbTables = opt._metadata || (await database.introspection.getTables());
-    const table = dbTables.find(t => (t.schema == 'public' ? t.name : `${t.schema}.${t.name}`) === tableName);
+    tableMetadata ||= await database.introspection.getTables();
+    const table = tableMetadata.find(t => (t.schema == 'public' ? t.name : `${t.schema}.${t.name}`) === tableName);
     if (!table)
         throw 'missing.';
     const columns = Object.fromEntries(table.columns.map(c => [c.name, c]));

package/dist/db.json

@@ -65,6 +65,16 @@
                 }
             },
             "indexes": ["sessions:id", "passkeys:userId"]
+        },
+        {
+            "delta": true,
+            "alter_tables": {
+                "users": {
+                    "alter_columns": {
+                        "name": { "ops": ["set_required"] }
+                    }
+                }
+            }
         }
     ],
     "wipe": ["users", "verifications", "passkeys", "sessions", "audit_log"]

package/dist/linking.js

@@ -40,7 +40,7 @@ export function linkRoutes(options = {}) {
                 unlinkSync(from);
             }
             catch (e) {
-                io.exit(e && e instanceof Error ? e.message : e.toString());
+                io.exit(e);
             }
             io.done();
             io.start('Re-linking ' + text);
@@ -50,7 +50,7 @@ export function linkRoutes(options = {}) {
             io.done();
         }
         catch (e) {
-            io.exit(e && e instanceof Error ? e.message : e.toString());
+            io.exit(e);
         }
     }
 }
@@ -65,7 +65,7 @@ export function unlinkRoutes(options = {}) {
             io.done();
         }
         catch (e) {
-            io.exit(e && e instanceof Error ? e.message : e.toString());
+            io.exit(e);
         }
     }
 }

package/dist/main.js

@@ -60,17 +60,17 @@ import { Argument, Option, program } from 'commander';
 import { access } from 'node:fs/promises';
 import { join, resolve } from 'node:path/posix';
 import { createInterface } from 'node:readline/promises';
-import { styleText, parseArgs } from 'node:util';
+import { parseArgs, styleText } from 'node:util';
 import { getByString, isJSON, setByString } from 'utilium';
 import * as z from 'zod';
 import $pkg from '../package.json' with { type: 'json' };
 import { audit, getEvents, styleSeverity } from './audit.js';
+import { diffUpdate, lookupUser, userText } from './cli.js';
 import config, { configFiles, FileSchema, saveConfigTo } from './config.js';
 import * as db from './database.js';
 import { _portActions, _portMethods, restrictedPorts } from './io.js';
 import { linkRoutes, listRouteLinks, unlinkRoutes } from './linking.js';
 import { serve } from './serve.js';
-import { diffUpdate, lookupUser, userText } from './cli.js';
 async function rlConfirm(question = 'Is this ok') {
     const { data, error } = z
         .stringbool()
@@ -122,13 +122,11 @@ try {
         .name('axium')
         .description('Axium server CLI')
         .configureHelp({ showGlobalOptions: true })
-        .option('--safe', 'do not execute code from plugins')
+        .option('--safe', 'do not execute code from plugins', false)
         .option('--debug', 'override debug mode')
         .option('--no-debug', 'override debug mode')
-        .option('-c, --config <path>', 'path to the config file');
-    program.on('option:debug', () => config.set({ debug: true }));
-    noAutoDB = ['init', 'serve', 'check'];
-    program.hook('preAction', (_, action) => {
+        .option('-c, --config <path>', 'path to the config file')
+        .hook('preAction', (_, action) => {
         const opt = action.optsWithGlobals();
         opt.force && io.warn('--force: Protections disabled.');
         if (typeof opt.debug == 'boolean') {
@@ -142,23 +140,19 @@ try {
             if (!noAutoDB.includes(action.name()))
                 throw e;
         }
-    });
-    program.hook('postAction', async (_, action) => {
+    })
+        .hook('postAction', async (_, action) => {
         if (!noAutoDB.includes(action.name()))
             await db.database.destroy();
-    });
+    })
+        .on('option:debug', () => config.set({ debug: true }));
+    noAutoDB = ['init', 'serve', 'check'];
     // Options shared by multiple (sub)commands
     opts = {
-        // database specific
-        host: new Option('-H, --host <host>', 'the host of the database.').argParser(value => {
-            const [hostname, port] = value?.split(':') ?? [];
-            config.db.host = hostname || config.db.host;
-            config.db.port = port && Number.isSafeInteger(parseInt(port)) ? parseInt(port) : config.db.port;
-        }),
         check: new Option('--check', 'check the database schema after initialization').default(false),
         force: new Option('-f, --force', 'force the operation').default(false),
         global: new Option('-g, --global', 'apply the operation globally').default(false),
-        timeout: new Option('-t, --timeout <ms>', 'how long to wait for commands to complete.').default('1000').argParser(value => {
+        timeout: new Option('-t, --timeout <ms>', 'how long to wait for commands to complete.').default(1000).argParser(value => {
             const timeout = parseInt(value);
             if (!Number.isSafeInteger(timeout) || timeout < 0)
                 io.warn('Invalid timeout value, using default.');
@@ -166,17 +160,17 @@ try {
         }),
         packagesDir: new Option('-p, --packages-dir <dir>', 'the directory to look for packages in'),
     };
-    axiumDB = program.command('db').alias('database').description('Manage the database').addOption(opts.timeout).addOption(opts.host);
+    axiumDB = program.command('db').alias('database').description('Manage the database').addOption(opts.timeout);
     axiumDB
         .command('init')
         .description('Initialize the database')
         .addOption(opts.force)
-        .option('-s, --skip', 'If the user, database, or schema already exists, skip trying to create it.')
+        .option('-s, --skip', 'If the user, database, or schema already exists, skip trying to create it.', false)
         .addOption(opts.check)
-        .action(async (_localOpts, _) => {
-        const opt = _.optsWithGlobals();
-        await db.init(opt).catch(io.handleError);
-        await dbInitTables().catch(io.handleError);
+        .action(async function axium_db_init() {
+        const opt = this.optsWithGlobals();
+        await db.init(opt).catch(io.exit);
+        await dbInitTables().catch(io.exit);
     });
     axiumDB
         .command('status')
@@ -204,9 +198,9 @@ try {
                 io.warn(`Database has existing ${key}. Use --force if you really want to drop the database.`);
                 process.exit(2);
             }
-        await db._sql('DROP DATABASE axium', 'Dropping database').catch(io.handleError);
-        await db._sql('REVOKE ALL PRIVILEGES ON SCHEMA public FROM axium', 'Revoking schema privileges').catch(io.handleError);
-        await db._sql('DROP USER axium', 'Dropping user').catch(io.handleError);
+        await db._sql('DROP DATABASE axium', 'Dropping database').catch(io.exit);
+        await db._sql('REVOKE ALL PRIVILEGES ON SCHEMA public FROM axium', 'Revoking schema privileges').catch(io.exit);
+        await db._sql('DROP USER axium', 'Dropping user').catch(io.exit);
         await db
             .getHBA(opt)
             .then(([content, writeBack]) => {
@@ -249,7 +243,7 @@ try {
             console.log(table + ' '.repeat(maxTableName - table.length), '|', plugins);
         }
         await rlConfirm('Are you sure you want to wipe these tables and any dependents');
-        await db.database.deleteFrom(Array.from(tables.keys())).execute().catch(io.handleError);
+        await db.database.deleteFrom(Array.from(tables.keys())).execute().catch(io.exit);
     });
     axiumDB
         .command('check')
@@ -258,23 +252,20 @@ try {
         .action(async (opt) => {
         const env_2 = { stack: [], error: void 0, hasError: false };
         try {
-            await io.run('Checking for sudo', 'which sudo').catch(io.handleError);
-            await io.run('Checking for psql', 'which psql').catch(io.handleError);
+            await io.run('Checking for sudo', 'which sudo').catch(io.exit);
+            await io.run('Checking for psql', 'which psql').catch(io.exit);
             const throwUnlessRows = (text) => {
                 if (text.includes('(0 rows)'))
                     throw 'missing.';
                 return text;
             };
-            await db
-                ._sql(`SELECT 1 FROM pg_database WHERE datname = 'axium'`, 'Checking for database')
-                .then(throwUnlessRows)
-                .catch(io.handleError);
-            await db._sql(`SELECT 1 FROM pg_roles WHERE rolname = 'axium'`, 'Checking for user').then(throwUnlessRows).catch(io.handleError);
+            await db._sql(`SELECT 1 FROM pg_database WHERE datname = 'axium'`, 'Checking for database').then(throwUnlessRows).catch(io.exit);
+            await db._sql(`SELECT 1 FROM pg_roles WHERE rolname = 'axium'`, 'Checking for user').then(throwUnlessRows).catch(io.exit);
             io.start('Connecting to database');
             const _ = __addDisposableResource(env_2, db.connect(), true);
             io.done();
             io.start('Getting schema metadata');
-            const schemas = await db.database.introspection.getSchemas().catch(io.handleError);
+            const schemas = await db.database.introspection.getSchemas().catch(io.exit);
             io.done();
             io.start('Checking for acl schema');
             if (!schemas.find(s => s.name == 'acl'))
@@ -284,13 +275,21 @@ try {
             const tablePromises = await Promise.all([
                 db.database.introspection.getTables(),
                 db.database.withSchema('acl').introspection.getTables(),
-            ]).catch(io.handleError);
-            opt._metadata = tablePromises.flat();
-            const tables = Object.fromEntries(opt._metadata.map(t => [t.schema == 'public' ? t.name : `${t.schema}.${t.name}`, t]));
+            ]).catch(io.exit);
+            const tableMetadata = tablePromises.flat();
+            const tables = Object.fromEntries(tableMetadata.map(t => [t.schema == 'public' ? t.name : `${t.schema}.${t.name}`, t]));
             io.done();
-            const schema = db.getFullSchema();
+            io.start('Resolving database schemas');
+            let schema;
+            try {
+                schema = db.getFullSchema();
+                io.done();
+            }
+            catch (e) {
+                io.exit(e);
+            }
             for (const [name, table] of Object.entries(schema.tables)) {
-                await db.checkTableTypes(name, table, opt);
+                await db.checkTableTypes(name, table, opt, tableMetadata);
                 delete tables[name];
             }
             io.start('Checking for extra tables');
@@ -327,13 +326,13 @@ try {
         .command('schema')
         .description('Get the JSON schema for the database configuration file')
         .option('-j, --json', 'values are JSON encoded')
-        .action((opt) => {
+        .action(opt => {
         try {
             const schema = z.toJSONSchema(db.SchemaFile, { io: 'input' });
             console.log(opt.json ? JSON.stringify(schema, null, 4) : schema);
         }
         catch (e) {
-            io.handleError(e instanceof z.core.$ZodError ? z.prettifyError(e) : e);
+            io.exit(e);
         }
     });
     axiumDB
@@ -342,7 +341,7 @@ try {
         .alias('up')
         .description('Upgrade the database to the latest version')
         .option('--abort', 'Rollback changes instead of committing them')
-        .action(async (opt) => {
+        .action(async function axium_db_upgrade(opt) {
         const deltas = [];
         const info = db.getUpgradeInfo();
         let empty = true;
@@ -401,7 +400,7 @@ try {
             io.exit(e);
         }
         console.log('Applying delta.');
-        await db.applyDelta(delta, opt.abort).catch(io.handleError);
+        await db.applyDelta(delta, opt.abort).catch(io.exit);
         info.upgrades.push({ timestamp: new Date(), from, to });
         db.setUpgradeInfo(info);
     });
@@ -442,20 +441,20 @@ try {
             lengths.available = Math.max(lengths.available || 0, available.length);
         }
         for (const [i, entry] of entries.entries()) {
-            console.log(...['name', 'current', 'latest', 'available'].map(key => styleText(i === 0 ? ['whiteBright', 'underline'] : entry[key] === undefined ? 'none' : [], entry[key].padStart(lengths[key]))));
+            console.log(...['name', 'current', 'latest', 'available'].map(key => styleText(i === 0 ? ['whiteBright', 'underline'] : entry[key] === undefined ? 'reset' : [], entry[key].padStart(lengths[key]))));
         }
     });
     axiumConfig = program
         .command('config')
         .description('Manage the configuration')
         .addOption(opts.global)
-        .option('-j, --json', 'values are JSON encoded')
-        .option('-r, --redact', 'Do not output sensitive values');
+        .option('-j, --json', 'values are JSON encoded', false)
+        .option('-r, --redact', 'Do not output sensitive values', false);
     axiumConfig
         .command('dump')
         .description('Output the entire current configuration')
-        .action(() => {
-        const opt = axiumConfig.optsWithGlobals();
+        .action(function axium_config_dump() {
+        const opt = this.optsWithGlobals();
         const value = config.plain();
         console.log(opt.json ? JSON.stringify(value, configReplacer(opt), 4) : value);
     });
@@ -463,8 +462,8 @@ try {
         .command('get')
         .description('Get a config value')
         .argument('<key>', 'the key to get')
-        .action((key) => {
-        const opt = axiumConfig.optsWithGlobals();
+        .action(function axium_config_get(key) {
+        const opt = this.optsWithGlobals();
         const value = getByString(config.plain(), key);
         console.log(opt.json ? JSON.stringify(value, configReplacer(opt), 4) : value);
     });
@@ -473,8 +472,8 @@ try {
         .description('Set a config value. Note setting objects is not supported.')
         .argument('<key>', 'the key to set')
         .argument('<value>', 'the value')
-        .action((key, value) => {
-        const opt = axiumConfig.optsWithGlobals();
+        .action(function axium_config_set(key, value) {
+        const opt = this.optsWithGlobals();
         if (opt.json && !isJSON(value))
             io.exit('Invalid JSON');
         const obj = {};
@@ -500,7 +499,7 @@ try {
             console.log(opt.json ? JSON.stringify(schema, configReplacer(opt), 4) : schema);
         }
         catch (e) {
-            io.handleError(e instanceof z.core.$ZodError ? z.prettifyError(e) : e);
+            io.exit(e);
         }
     });
     axiumPlugin = program.command('plugin').alias('plugins').description('Manage plugins').addOption(opts.global);
@@ -510,7 +509,7 @@ try {
         .description('List loaded plugins')
         .option('-l, --long', 'use the long listing format')
         .option('--no-versions', 'do not show plugin versions')
-        .action((opt) => {
+        .action(opt => {
         if (!plugins.size) {
             console.log('No plugins loaded.');
             return;
@@ -557,7 +556,7 @@ try {
         .addOption(opts.timeout)
         .addOption(opts.check)
         .argument('<plugin>', 'the plugin to initialize')
-        .action(async (search, opt) => {
+        .action(async (search) => {
         const env_3 = { stack: [], error: void 0, hasError: false };
         try {
             const plugin = _findPlugin(search);
@@ -582,7 +581,7 @@ try {
         .description('List apps added by plugins')
         .option('-l, --long', 'use the long listing format')
         .option('-b, --builtin', 'include built-in apps')
-        .action((opt) => {
+        .action(opt => {
         if (!apps.size) {
             console.log('No apps.');
             return;
@@ -692,7 +691,6 @@ try {
         .command('status')
         .alias('stats')
         .description('Get information about the server')
-        .addOption(opts.host)
         .action(async () => {
         console.log('Axium Server v' + $pkg.version);
         console.log(styleText('whiteBright', 'Debug mode:'), config.debug ? styleText('yellow', 'enabled') : 'disabled');
@@ -721,37 +719,37 @@ try {
         .addOption(new Option('-m, --method <method>', 'the method to use').choices(_portMethods).default('node-cap'))
         .option('-N, --node <path>', 'the path to the node binary')
         .action(async (action, opt) => {
-        await restrictedPorts({ ...opt, action }).catch(io.handleError);
+        await restrictedPorts({ ...opt, action }).catch(io.exit);
     });
     program
         .command('init')
         .description('Install Axium server')
         .addOption(opts.force)
-        .addOption(opts.host)
         .addOption(opts.check)
         .addOption(opts.packagesDir)
-        .option('-s, --skip', 'Skip already initialized steps')
+        .option('-s, --skip', 'Skip already initialized steps', false)
         .action(async (opt) => {
-        await db.init(opt).catch(io.handleError);
-        await dbInitTables().catch(io.handleError);
-        await restrictedPorts({ method: 'node-cap', action: 'enable' }).catch(io.handleError);
+        await db.init(opt).catch(io.exit);
+        await dbInitTables().catch(io.exit);
+        await restrictedPorts({ method: 'node-cap', action: 'enable' }).catch(io.exit);
     });
     program
         .command('serve')
         .description('Start the Axium server')
-        .option('-p, --port <port>', 'the port to listen on')
+        .option('-p, --port <port>', 'the port to listen on', Number.parseInt, config.web.port)
         .option('--ssl <prefix>', 'the prefix for the cert.pem and key.pem SSL files')
         .option('-b, --build <path>', 'the path to the handler build')
         .action(async (opt) => {
+        if (opt.port < 1 || opt.port > 65535)
+            io.exit('Invalid port');
         const server = await serve({
             secure: opt.ssl ? true : config.web.secure,
             ssl_cert: opt.ssl ? join(opt.ssl, 'cert.pem') : config.web.ssl_cert,
             ssl_key: opt.ssl ? join(opt.ssl, 'key.pem') : config.web.ssl_key,
             build: opt.build ? resolve(opt.build) : config.web.build,
         });
-        const port = !Number.isNaN(Number.parseInt(opt.port ?? 'NaN')) ? Number.parseInt(opt.port) : config.web.port;
-        server.listen(port, () => {
-            console.log('Server is listening on port ' + port);
+        server.listen(opt.port, () => {
+            console.log('Server is listening on port ' + opt.port);
         });
     });
     program
@@ -761,12 +759,11 @@ try {
         .addOption(new Option('-l, --list', 'list route links').conflicts('delete'))
         .option('-d, --delete', 'delete route links')
         .argument('[name...]', 'List of plugin names to operate on. If not specified, operates on all plugins and built-in routes.')
-        .action(async function (names) {
+        .action(async function axium_link(names) {
         const opt = this.optsWithGlobals();
-        if (names.length)
-            opt.only = names;
+        const linkOpts = { only: names };
         if (opt.list) {
-            for (const link of listRouteLinks(opt)) {
+            for (const link of listRouteLinks(linkOpts)) {
                 const idText = link.id.startsWith('#') ? `(${link.id.slice(1)})` : link.id;
                 const fromColor = await access(link.from)
                     .then(() => 'cyanBright')
@@ -776,10 +773,10 @@ try {
             return;
         }
         if (opt.delete) {
-            unlinkRoutes(opt);
+            unlinkRoutes(linkOpts);
             return;
         }
-        linkRoutes(opt);
+        linkRoutes(linkOpts);
     });
     program
         .command('audit')

package/dist/requests.d.ts

@@ -32,7 +32,8 @@ 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>>(request: Request, schema: Schema): Promise<Result>;
+export declare function parseBody<const Schema extends z.ZodType>(request: Request, schema: Schema): Promise<z.infer<Schema>>;
+export declare function parseSearch<const Schema extends z.ZodType>(request: Request, schema: Schema): z.infer<Schema>;
 export declare function getToken(request: Request, sensitive?: boolean): string | undefined;
 export interface CreateSessionOptions {
     elevated?: boolean;

package/dist/requests.js

@@ -44,6 +44,16 @@ export async function parseBody(request, schema) {
         error(400, e instanceof z.core.$ZodError ? z.prettifyError(e) : 'invalid body');
     }
 }
+export function parseSearch(request, schema) {
+    const url = new URL(request.url);
+    const searchParams = Object.fromEntries(url.searchParams.entries());
+    try {
+        return schema.parse(searchParams);
+    }
+    catch (e) {
+        error(400, e instanceof z.core.$ZodError ? z.prettifyError(e) : 'invalid query parameters');
+    }
+}
 export function getToken(request, sensitive = false) {
     const header_token = request.headers.get('Authorization')?.replace('Bearer ', '');
     if (header_token)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@axium/server",
-	"version": "0.29.0",
+	"version": "0.31.0",
 	"author": "James Prevett <axium@jamespre.dev>",
 	"funding": {
 		"type": "individual",
@@ -48,9 +48,9 @@
 	},
 	"peerDependencies": {
 		"@axium/client": ">=0.9.5",
-		"@axium/core": ">=0.14.0",
+		"@axium/core": ">=0.15.0",
 		"kysely": "^0.28.0",
-		"utilium": "^2.3.8",
+		"utilium": "^2.6.0",
 		"zod": "^4.0.5"
 	},
 	"dependencies": {