@axium/server 0.8.0 → 0.10.0

package/dist/auth.js

@@ -3,17 +3,7 @@ import { randomBytes, randomUUID } from 'node:crypto';
 import { connect, database as db } from './database.js';
 export async function getUser(id) {
     connect();
-    const result = await db.selectFrom('users').selectAll().where('id', '=', id).executeTakeFirst();
-    if (!result)
-        return null;
-    return result;
-}
-export async function getUserByEmail(email) {
-    connect();
-    const result = await db.selectFrom('users').selectAll().where('email', '=', email).executeTakeFirst();
-    if (!result)
-        return null;
-    return result;
+    return await db.selectFrom('users').selectAll().where('id', '=', id).executeTakeFirstOrThrow();
 }
 export async function updateUser({ id, ...user }) {
     connect();
@@ -35,12 +25,6 @@ export async function createSession(userId, elevated = false) {
     await db.insertInto('sessions').values(session).execute();
     return session;
 }
-export async function checkExpiration(session) {
-    if (session.expires.getTime() > Date.now())
-        return;
-    await db.deleteFrom('sessions').where('sessions.id', '=', session.id).executeTakeFirstOrThrow();
-    throw new Error('Session expired');
-}
 export async function getSessionAndUser(token) {
     connect();
     const result = await db
@@ -48,26 +32,24 @@ export async function getSessionAndUser(token) {
         .selectAll()
         .select(eb => jsonObjectFrom(eb.selectFrom('users').selectAll().whereRef('users.id', '=', 'sessions.userId')).as('user'))
         .where('sessions.token', '=', token)
-        .executeTakeFirst();
-    if (!result)
-        throw new Error('Session not found');
-    await checkExpiration(result);
+        .where('sessions.expires', '>', new Date())
+        .executeTakeFirstOrThrow();
+    if (!result.user)
+        throw new Error('Session references non-existing user');
     return result;
 }
 export async function getSession(sessionId) {
     connect();
-    const session = await db.selectFrom('sessions').selectAll().where('id', '=', sessionId).executeTakeFirstOrThrow();
-    await checkExpiration(session);
-    return session;
+    return await db
+        .selectFrom('sessions')
+        .selectAll()
+        .where('id', '=', sessionId)
+        .where('sessions.expires', '>', new Date())
+        .executeTakeFirstOrThrow();
 }
 export async function getSessions(userId) {
     connect();
-    return await db.selectFrom('sessions').selectAll().where('userId', '=', userId).execute();
-}
-export async function updateSession(session) {
-    connect();
-    const query = db.updateTable('sessions').set(session).where('sessions.token', '=', session.token);
-    return await query.returningAll().executeTakeFirstOrThrow();
+    return await db.selectFrom('sessions').selectAll().where('userId', '=', userId).where('sessions.expires', '>', new Date()).execute();
 }
 /**
  * Create a verification
@@ -94,10 +76,7 @@ export async function useVerification(role, userId, token) {
 }
 export async function getPasskey(id) {
     connect();
-    const result = await db.selectFrom('passkeys').selectAll().where('id', '=', id).executeTakeFirst();
-    if (!result)
-        return null;
-    return result;
+    return await db.selectFrom('passkeys').selectAll().where('id', '=', id).executeTakeFirstOrThrow();
 }
 export async function createPasskey(passkey) {
     connect();
@@ -116,3 +95,10 @@ export async function updatePasskeyCounter(id, newCounter) {
         throw new Error('Passkey not found');
     return passkey;
 }
+export async function authenticate(event) {
+    const maybe_header = event.request.headers.get('Authorization');
+    const token = maybe_header?.startsWith('Bearer ') ? maybe_header.slice(7) : event.cookies.get('session_token');
+    if (!token)
+        return null;
+    return await getSessionAndUser(token).catch(() => null);
+}

package/dist/cli.js

@@ -1,13 +1,67 @@
 #!/usr/bin/env node
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { Argument, Option, program } from 'commander';
+import { join } from 'node:path/posix';
 import { styleText } from 'node:util';
 import { getByString, isJSON, setByString } from 'utilium';
 import $pkg from '../package.json' with { type: 'json' };
-import config from './config.js';
-import * as db from './database.js';
-import { _portActions, _portMethods, exit, handleError, output, restrictedPorts } from './io.js';
-import { loadDefaultPlugins, plugins, pluginText, resolvePlugin } from './plugins.js';
 import { apps } from './apps.js';
+import config, { configFiles, saveConfigTo } from './config.js';
+import * as db from './database.js';
+import { _portActions, _portMethods, defaultOutput, exit, handleError, output, restrictedPorts } from './io.js';
+import { getSpecifier, plugins, pluginText, resolvePlugin } from './plugins.js';
+import { serve } from './serve.js';
 program
     .version($pkg.version)
     .name('axium')
@@ -20,15 +74,10 @@ program.on('option:debug', () => config.set({ debug: true }));
 program.on('option:config', () => void config.load(program.opts().config));
 program.hook('preAction', async function (_, action) {
     await config.loadDefaults();
-    await loadDefaultPlugins();
     const opt = action.optsWithGlobals();
     opt.force && output.warn('--force: Protections disabled.');
     if (opt.debug === false)
         config.set({ debug: false });
-    /* if (!config.auth.secret) {
-        config.save({ auth: { secret: process.env.AUTH_SECRET || randomBytes(32).toString('base64') } }, true);
-        output.debug('Auto-generated a new auth secret');
-    } */
 });
 // Options shared by multiple (sub)commands
 const opts = {
@@ -76,32 +125,56 @@ axiumDB
     .description('Drop the Axium database and user')
     .addOption(opts.force)
     .action(async (opt) => {
-    const stats = await db.status().catch(exit);
-    if (!opt.force)
-        for (const key of ['users', 'passkeys', 'sessions']) {
-            if (stats[key] == 0)
-                continue;
-            output.warn(`Database has existing ${key}. Use --force if you really want to drop the database.`);
-            process.exit(2);
-        }
-    await db.uninstall(opt).catch(exit);
-    await db.database.destroy();
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const _ = __addDisposableResource(env_1, db.connect(), true);
+        const stats = await db.status().catch(exit);
+        if (!opt.force)
+            for (const key of ['users', 'passkeys', 'sessions']) {
+                if (stats[key] == 0)
+                    continue;
+                output.warn(`Database has existing ${key}. Use --force if you really want to drop the database.`);
+                process.exit(2);
+            }
+        await db.uninstall(opt).catch(exit);
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
+    }
 });
 axiumDB
     .command('wipe')
     .description('Wipe the database')
     .addOption(opts.force)
     .action(async (opt) => {
-    const stats = await db.status().catch(exit);
-    if (!opt.force)
-        for (const key of ['users', 'passkeys', 'sessions']) {
-            if (stats[key] == 0)
-                continue;
-            output.warn(`Database has existing ${key}. Use --force if you really want to wipe the database.`);
-            process.exit(2);
-        }
-    await db.wipe(opt).catch(exit);
-    await db.database.destroy();
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const _ = __addDisposableResource(env_2, db.connect(), true);
+        const stats = await db.status().catch(exit);
+        if (!opt.force)
+            for (const key of ['users', 'passkeys', 'sessions']) {
+                if (stats[key] == 0)
+                    continue;
+                output.warn(`Database has existing ${key}. Use --force if you really want to wipe the database.`);
+                process.exit(2);
+            }
+        await db.wipe(opt).catch(exit);
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        const result_2 = __disposeResources(env_2);
+        if (result_2)
+            await result_2;
+    }
 });
 axiumDB
     .command('check')
@@ -109,6 +182,26 @@ axiumDB
     .action(async (opt) => {
     await db.check(opt).catch(exit);
 });
+axiumDB
+    .command('clean')
+    .description('Remove expired rows')
+    .addOption(opts.force)
+    .action(async (opt) => {
+    const env_3 = { stack: [], error: void 0, hasError: false };
+    try {
+        const _ = __addDisposableResource(env_3, db.connect(), true);
+        await db.clean(opt).catch(exit);
+    }
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
+    }
+    finally {
+        const result_3 = __disposeResources(env_3);
+        if (result_3)
+            await result_3;
+    }
+});
 const axiumConfig = program
     .command('config')
     .description('Manage the configuration')
@@ -117,7 +210,6 @@ const axiumConfig = program
     .option('-r, --redact', 'Do not output sensitive values');
 function configReplacer(opt) {
     return (key, value) => {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return opt.redact && ['password', 'secret'].includes(key) ? '[redacted]' : value;
     };
 }
@@ -160,11 +252,7 @@ axiumConfig
     for (const path of config.files.keys())
         console.log(path);
 });
-const axiumPlugin = program
-    .command('plugins')
-    .description('Manage plugins')
-    .addOption(opts.global)
-    .option('--safe', 'do not perform actions that would execute code from plugins.');
+const axiumPlugin = program.command('plugins').description('Manage plugins').addOption(opts.global);
 axiumPlugin
     .command('list')
     .alias('ls')
@@ -184,7 +272,7 @@ axiumPlugin
     }
     console.log(styleText('whiteBright', plugins.size + ' plugin(s) loaded:'));
     for (const plugin of plugins) {
-        console.log(plugin.name, styleText('dim', `(${plugin.id})`), opt.versions ? plugin.version : '');
+        console.log(plugin.name, opt.versions ? plugin.version : '');
     }
 });
 axiumPlugin
@@ -197,6 +285,38 @@ axiumPlugin
         exit(`Can't find a plugin matching "${search}"`);
     console.log(pluginText(plugin));
 });
+axiumPlugin
+    .command('remove')
+    .alias('rm')
+    .description('Remove a plugin')
+    .argument('<plugin>', 'the plugin to remove')
+    .action(async (search, opt) => {
+    const env_4 = { stack: [], error: void 0, hasError: false };
+    try {
+        const plugin = resolvePlugin(search);
+        if (!plugin)
+            exit(`Can't find a plugin matching "${search}"`);
+        const specifier = getSpecifier(plugin);
+        const _ = __addDisposableResource(env_4, db.connect(), true);
+        await plugin.db_remove?.({ ...opt, output: defaultOutput }, db.database);
+        for (const [path, data] of configFiles) {
+            if (!data.plugins)
+                continue;
+            data.plugins = data.plugins.filter(p => p !== specifier);
+            saveConfigTo(path, data);
+        }
+        plugins.delete(plugin);
+    }
+    catch (e_4) {
+        env_4.error = e_4;
+        env_4.hasError = true;
+    }
+    finally {
+        const result_4 = __disposeResources(env_4);
+        if (result_4)
+            await result_4;
+    }
+});
 const axiumApps = program.command('apps').description('Manage Axium apps').addOption(opts.global);
 axiumApps
     .command('list')
@@ -224,27 +344,38 @@ program
     .description('Get information about the server')
     .addOption(opts.host)
     .action(async () => {
-    console.log('Axium Server v' + program.version());
-    console.log(styleText('whiteBright', 'Debug mode:'), config.debug ? styleText('yellow', 'enabled') : 'disabled');
-    console.log(styleText('whiteBright', 'Loaded config files:'), config.files.keys().toArray().join(', '));
-    process.stdout.write(styleText('whiteBright', 'Database: '));
+    const env_5 = { stack: [], error: void 0, hasError: false };
     try {
-        console.log(await db.statusText());
+        console.log('Axium Server v' + program.version());
+        console.log(styleText('whiteBright', 'Debug mode:'), config.debug ? styleText('yellow', 'enabled') : 'disabled');
+        console.log(styleText('whiteBright', 'Loaded config files:'), config.files.keys().toArray().join(', '));
+        process.stdout.write(styleText('whiteBright', 'Database: '));
+        const _ = __addDisposableResource(env_5, db.connect(), true);
+        try {
+            console.log(await db.statusText());
+        }
+        catch {
+            output.error('Unavailable');
+        }
+        console.log(styleText('whiteBright', 'Loaded plugins:'), Array.from(plugins)
+            .map(plugin => plugin.name)
+            .join(', ') || styleText('dim', '(none)'));
+        for (const plugin of plugins) {
+            if (!plugin.statusText)
+                continue;
+            console.log(styleText('bold', plugin.name), plugin.version + ':');
+            console.log(await plugin.statusText());
+        }
     }
-    catch {
-        output.error('Unavailable');
+    catch (e_5) {
+        env_5.error = e_5;
+        env_5.hasError = true;
     }
-    console.log(styleText('whiteBright', 'Credentials authentication:'), config.auth.credentials ? styleText('yellow', 'enabled') : 'disabled');
-    console.log(styleText('whiteBright', 'Loaded plugins:'), Array.from(plugins)
-        .map(plugin => plugin.id)
-        .join(', ') || styleText('dim', '(none)'));
-    for (const plugin of plugins) {
-        if (!plugin.statusText)
-            continue;
-        console.log(styleText('bold', plugin.name), plugin.version + ':');
-        console.log(await plugin.statusText());
+    finally {
+        const result_5 = __disposeResources(env_5);
+        if (result_5)
+            await result_5;
     }
-    await db.database.destroy();
 });
 program
     .command('ports')
@@ -261,8 +392,23 @@ program
     .addOption(opts.force)
     .addOption(opts.host)
     .action(async (opt) => {
-    /* config.save({ auth: { secret: randomBytes(32).toString('base64') } }, true); */
     await db.init({ ...opt, skip: opt.dbSkip }).catch(handleError);
     await restrictedPorts({ method: 'node-cap', action: 'enable' }).catch(handleError);
 });
+program
+    .command('serve')
+    .description('Start the Axium server')
+    .option('-p, --port <port>', 'the port to listen on')
+    .option('--ssl <prefix>', 'the prefix for the cert.pem and key.pem SSL files')
+    .action(async (opt) => {
+    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,
+    });
+    const port = !Number.isNaN(Number.parseInt(opt.port ?? '')) ? Number.parseInt(opt.port) : config.web.port;
+    server.listen(port, () => {
+        console.log('Server is listening on port ' + port);
+    });
+});
 program.parse();