@axium/server 0.8.0 → 0.9.0

package/dist/auth.d.ts

@@ -30,23 +30,13 @@ export declare function updateUser({ id, ...user }: UserInternal): Promise<{
 }>;
 export interface SessionInternal extends Session {
     token: string;
-    elevated: boolean;
 }
 export declare function createSession(userId: string, elevated?: boolean): Promise<SessionInternal>;
-export declare function checkExpiration(session: SessionInternal): Promise<void>;
 export declare function getSessionAndUser(token: string): Promise<SessionInternal & {
     user: UserInternal | null;
 }>;
 export declare function getSession(sessionId: string): Promise<SessionInternal>;
 export declare function getSessions(userId: string): Promise<SessionInternal[]>;
-export declare function updateSession(session: SessionInternal): Promise<{
-    id: string;
-    expires: Date;
-    token: string;
-    userId: string;
-    created: Date;
-    elevated: boolean;
-}>;
 export type VerificationRole = 'verify_email' | 'login';
 export interface VerificationInternal extends Verification {
     token: string;

package/dist/auth.js

@@ -35,12 +35,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 +42,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)
+        .where('sessions.expires', '>', new Date())
         .executeTakeFirst();
     if (!result)
         throw new Error('Session not found');
-    await checkExpiration(result);
     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

package/dist/cli.js

@@ -1,4 +1,56 @@
 #!/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 { styleText } from 'node:util';
 import { getByString, isJSON, setByString } from 'utilium';
@@ -76,32 +128,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 +185,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 +213,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;
     };
 }
@@ -224,27 +319,39 @@ 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_4 = { 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_4, db.connect(), true);
+        try {
+            console.log(await db.statusText());
+        }
+        catch {
+            output.error('Unavailable');
+        }
+        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());
+        }
     }
-    catch {
-        output.error('Unavailable');
+    catch (e_4) {
+        env_4.error = e_4;
+        env_4.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_4 = __disposeResources(env_4);
+        if (result_4)
+            await result_4;
     }
-    await db.database.destroy();
 });
 program
     .command('ports')