@axium/server 0.9.0 → 0.11.0

package/dist/database.d.ts

@@ -1,16 +1,19 @@
 import type { Preferences } from '@axium/core';
+import type { AuthenticatorTransportFuture, CredentialDeviceType } from '@simplewebauthn/server';
 import { Kysely, type GeneratedAlways } from 'kysely';
 import type { VerificationRole } from './auth.js';
-import type { MaybeOutput, WithOutput } from './io.js';
-import type { AuthenticatorTransportFuture, CredentialDeviceType } from '@simplewebauthn/server';
 export interface Schema {
     users: {
-        id: GeneratedAlways<string> & string;
+        id: string;
         email: string;
         name: string;
         image?: string | null;
         emailVerified?: Date | null;
-        preferences?: Preferences;
+        preferences: Preferences;
+        isAdmin: boolean;
+        roles: string[];
+        tags: string[];
+        registeredAt: GeneratedAlways<Date>;
     };
     sessions: {
         id: GeneratedAlways<string>;
@@ -49,19 +52,16 @@ export interface Stats {
 export declare function count<const T extends keyof Schema>(table: T): Promise<number>;
 export declare function status(): Promise<Stats>;
 export declare function statusText(): Promise<string>;
-export interface OpOptions extends MaybeOutput {
-    timeout: number;
+export interface OpOptions {
     force: boolean;
 }
 export interface InitOptions extends OpOptions {
     skip: boolean;
 }
-export declare function shouldRecreate(opt: InitOptions & WithOutput): boolean;
-export declare function getHBA(opt: OpOptions & WithOutput): Promise<[content: string, writeBack: (newContent: string) => void]>;
-export interface PluginShortcuts {
-    done: () => void;
-    warnExists: (error: string | Error) => void;
-}
+export declare function shouldRecreate(opt: InitOptions): boolean;
+export declare function getHBA(opt: OpOptions): Promise<[content: string, writeBack: (newContent: string) => void]>;
+/** Shortcut to output a warning if an error is thrown because relation already exists */
+export declare const warnExists: (error: string | Error) => void;
 export declare function init(opt: InitOptions): Promise<void>;
 export declare function check(opt: OpOptions): Promise<void>;
 export declare function clean(opt: Partial<OpOptions>): Promise<void>;

package/dist/database.js

@@ -55,12 +55,15 @@ import { randomBytes } from 'node:crypto';
 import { readFileSync, writeFileSync } from 'node:fs';
 import pg from 'pg';
 import config from './config.js';
-import { _fixOutput, run, someWarnings } from './io.js';
+import * as io from './io.js';
 import { plugins } from './plugins.js';
+const sym = Symbol.for('Axium:database');
 export let database;
 export function connect() {
     if (database)
         return database;
+    if (globalThis[sym])
+        return (database = globalThis[sym]);
     const _db = new Kysely({
         dialect: new PostgresDialect({ pool: new pg.Pool(config.db) }),
     });
@@ -69,6 +72,7 @@ export function connect() {
             await _db.destroy();
         },
     });
+    globalThis[sym] = database;
     return database;
 }
 export async function count(table) {
@@ -95,32 +99,32 @@ export async function statusText() {
 }
 export function shouldRecreate(opt) {
     if (opt.skip) {
-        opt.output('warn', 'already exists. (skipped)');
+        io.warn('already exists. (skipped)');
         return true;
     }
     if (opt.force) {
-        opt.output('warn', 'already exists. (re-creating)');
+        io.warn('already exists. (re-creating)');
         return false;
     }
-    opt.output('warn', 'already exists. Use --skip to skip or --force to re-create.');
+    io.warn('already exists. Use --skip to skip or --force to re-create.');
     throw 2;
 }
 export async function getHBA(opt) {
-    const hbaShowResult = await run(opt, 'Finding pg_hba.conf', `sudo -u postgres psql -c "SHOW hba_file"`);
-    opt.output('start', 'Resolving pg_hba.conf path');
+    const hbaShowResult = await io.run('Finding pg_hba.conf', `sudo -u postgres psql -c "SHOW hba_file"`);
+    io.start('Resolving pg_hba.conf path');
     const hbaPath = hbaShowResult.match(/^\s*(.+\.conf)\s*$/m)?.[1]?.trim();
     if (!hbaPath) {
         throw 'failed. You will need to add password-based auth for the axium user manually.';
     }
-    opt.output('done');
-    opt.output('debug', `Found pg_hba.conf at ${hbaPath}`);
-    opt.output('start', 'Reading HBA configuration');
+    io.done();
+    io.debug(`Found pg_hba.conf at ${hbaPath}`);
+    io.start('Reading HBA configuration');
     const content = readFileSync(hbaPath, 'utf-8');
-    opt.output('done');
+    io.done();
     const writeBack = (newContent) => {
-        opt.output('start', 'Writing HBA configuration');
+        io.start('Writing HBA configuration');
         writeFileSync(hbaPath, newContent);
-        opt.output('done');
+        io.done();
     };
     return [content, writeBack];
 }
@@ -129,19 +133,23 @@ local axium axium md5
 host  axium axium 127.0.0.1/32 md5
 host  axium axium ::1/128 md5
 `;
+const _sql = (command, message) => io.run(message, `sudo -u postgres psql -c "${command}"`);
+/** Shortcut to output a warning if an error is thrown because relation already exists */
+export const warnExists = io.someWarnings([/\w+ "[\w.]+" already exists/, 'already exists.']);
+const throwUnlessRows = (text) => {
+    if (text.includes('(0 rows)'))
+        throw 'missing.';
+    return text;
+};
 export async function init(opt) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        _fixOutput(opt);
         if (!config.db.password) {
             config.save({ db: { password: randomBytes(32).toString('base64') } }, true);
-            opt.output('debug', 'Generated password and wrote to global config');
+            io.debug('Generated password and wrote to global config');
         }
-        await run(opt, 'Checking for sudo', 'which sudo');
-        await run(opt, 'Checking for psql', 'which psql');
-        const _sql = (command, message) => run(opt, message, `sudo -u postgres psql -c "${command}"`);
-        const warnExists = someWarnings(opt.output, [/(schema|relation) "[\w.]+" already exists/, 'already exists.']);
-        const done = () => opt.output('done');
+        await io.run('Checking for sudo', 'which sudo');
+        await io.run('Checking for psql', 'which psql');
         await _sql('CREATE DATABASE axium', 'Creating database').catch(async (error) => {
             if (error != 'database "axium" already exists')
                 throw error;
@@ -165,19 +173,19 @@ export async function init(opt) {
         await _sql('ALTER DATABASE axium OWNER TO axium', 'Setting database owner');
         await getHBA(opt)
             .then(([content, writeBack]) => {
-            opt.output('start', 'Checking for Axium HBA configuration');
+            io.start('Checking for Axium HBA configuration');
             if (content.includes(pgHba))
                 throw 'already exists.';
-            done();
-            opt.output('start', 'Adding Axium HBA configuration');
+            io.done();
+            io.start('Adding Axium HBA configuration');
             const newContent = content.replace(/^local\s+all\s+all.*$/m, `$&\n${pgHba}`);
-            done();
+            io.done();
             writeBack(newContent);
         })
-            .catch(e => opt.output('warn', e));
+            .catch(io.warn);
         await _sql('SELECT pg_reload_conf()', 'Reloading configuration');
         const db = __addDisposableResource(env_1, connect(), true);
-        opt.output('start', 'Creating table users');
+        io.start('Creating table users');
         await db.schema
             .createTable('users')
             .addColumn('id', 'uuid', col => col.primaryKey().defaultTo(sql `gen_random_uuid()`))
@@ -185,11 +193,15 @@ export async function init(opt) {
             .addColumn('email', 'text', col => col.unique().notNull())
             .addColumn('emailVerified', 'timestamptz')
             .addColumn('image', 'text')
+            .addColumn('isAdmin', 'boolean', col => col.notNull().defaultTo(false))
+            .addColumn('roles', sql `text[]`, col => col.notNull().defaultTo(sql `'{}'::text[]`))
+            .addColumn('tags', sql `text[]`, col => col.notNull().defaultTo(sql `'{}'::text[]`))
             .addColumn('preferences', 'jsonb', col => col.notNull().defaultTo(sql `'{}'::jsonb`))
+            .addColumn('registeredAt', 'timestamptz', col => col.notNull().defaultTo(sql `now()`))
             .execute()
-            .then(done)
+            .then(io.done)
             .catch(warnExists);
-        opt.output('start', 'Creating table sessions');
+        io.start('Creating table sessions');
         await db.schema
             .createTable('sessions')
             .addColumn('id', 'uuid', col => col.primaryKey().defaultTo(sql `gen_random_uuid()`))
@@ -199,11 +211,11 @@ export async function init(opt) {
             .addColumn('expires', 'timestamptz', col => col.notNull())
             .addColumn('elevated', 'boolean', col => col.notNull())
             .execute()
-            .then(done)
+            .then(io.done)
             .catch(warnExists);
-        opt.output('start', 'Creating index for sessions.userId');
-        await db.schema.createIndex('sessions_userId_index').on('sessions').column('userId').execute().then(done).catch(warnExists);
-        opt.output('start', 'Creating table verifications');
+        io.start('Creating index for sessions.userId');
+        await db.schema.createIndex('sessions_userId_index').on('sessions').column('userId').execute().then(io.done).catch(warnExists);
+        io.start('Creating table verifications');
         await db.schema
             .createTable('verifications')
             .addColumn('userId', 'uuid', col => col.references('users.id').onDelete('cascade').notNull())
@@ -211,9 +223,9 @@ export async function init(opt) {
             .addColumn('expires', 'timestamptz', col => col.notNull())
             .addColumn('role', 'text', col => col.notNull())
             .execute()
-            .then(done)
+            .then(io.done)
             .catch(warnExists);
-        opt.output('start', 'Creating table passkeys');
+        io.start('Creating table passkeys');
         await db.schema
             .createTable('passkeys')
             .addColumn('id', 'text', col => col.primaryKey().notNull())
@@ -226,15 +238,15 @@ export async function init(opt) {
             .addColumn('backedUp', 'boolean', col => col.notNull())
             .addColumn('transports', sql `text[]`)
             .execute()
-            .then(done)
+            .then(io.done)
             .catch(warnExists);
-        opt.output('start', 'Creating index for passkeys.id');
-        await db.schema.createIndex('passkeys_id_key').on('passkeys').column('id').execute().then(done).catch(warnExists);
+        io.start('Creating index for passkeys.id');
+        await db.schema.createIndex('passkeys_id_key').on('passkeys').column('id').execute().then(io.done).catch(warnExists);
         for (const plugin of plugins) {
-            if (!plugin.db_init)
+            if (!plugin.hooks.db_init)
                 continue;
-            opt.output('plugin', plugin.name);
-            await plugin.db_init(opt, db, { warnExists, done });
+            io.plugin(plugin.name);
+            await plugin.hooks.db_init(opt, db);
         }
     }
     catch (e_1) {
@@ -250,33 +262,25 @@ export async function init(opt) {
 export async function check(opt) {
     const env_2 = { stack: [], error: void 0, hasError: false };
     try {
-        _fixOutput(opt);
-        await run(opt, 'Checking for sudo', 'which sudo');
-        await run(opt, 'Checking for psql', 'which psql');
-        const _sql = (command, message) => run(opt, message, `sudo -u postgres psql -c "${command}"`);
-        const done = () => opt.output('done');
-        const throwUnlessRows = (text) => {
-            if (text.includes('(0 rows)'))
-                throw 'missing.';
-            return text;
-        };
+        await io.run('Checking for sudo', 'which sudo');
+        await io.run('Checking for psql', 'which psql');
         await _sql(`SELECT 1 FROM pg_database WHERE datname = 'axium'`, 'Checking for database').then(throwUnlessRows);
         await _sql(`SELECT 1 FROM pg_roles WHERE rolname = 'axium'`, 'Checking for user').then(throwUnlessRows);
-        opt.output('start', 'Connecting to database');
+        io.start('Connecting to database');
         const db = __addDisposableResource(env_2, connect(), true);
-        done();
-        opt.output('start', `Checking users table`);
-        await db.selectFrom('users').select(['id', 'email', 'emailVerified', 'image', 'name', 'preferences']).execute().then(done);
-        opt.output('start', `Checking sessions table`);
-        await db.selectFrom('sessions').select(['id', 'userId', 'token', 'created', 'expires', 'elevated']).execute().then(done);
-        opt.output('start', `Checking verifications table`);
-        await db.selectFrom('verifications').select(['userId', 'token', 'expires', 'role']).execute().then(done);
-        opt.output('start', `Checking passkeys table`);
+        io.done();
+        io.start('Checking users table');
+        await db.selectFrom('users').select(['id', 'email', 'emailVerified', 'image', 'name', 'preferences']).execute().then(io.done);
+        io.start('Checking sessions table');
+        await db.selectFrom('sessions').select(['id', 'userId', 'token', 'created', 'expires', 'elevated']).execute().then(io.done);
+        io.start('Checking verifications table');
+        await db.selectFrom('verifications').select(['userId', 'token', 'expires', 'role']).execute().then(io.done);
+        io.start('Checking passkeys table');
         await db
             .selectFrom('passkeys')
             .select(['id', 'name', 'createdAt', 'userId', 'publicKey', 'counter', 'deviceType', 'backedUp', 'transports'])
             .execute()
-            .then(done);
+            .then(io.done);
     }
     catch (e_2) {
         env_2.error = e_2;
@@ -289,19 +293,17 @@ export async function check(opt) {
     }
 }
 export async function clean(opt) {
-    _fixOutput(opt);
-    const done = () => opt.output('done');
     const now = new Date();
     const db = connect();
-    opt.output('start', 'Removing expired sessions');
-    await db.deleteFrom('sessions').where('sessions.expires', '<', now).execute().then(done);
-    opt.output('start', 'Removing expired verifications');
-    await db.deleteFrom('verifications').where('verifications.expires', '<', now).execute().then(done);
+    io.start('Removing expired sessions');
+    await db.deleteFrom('sessions').where('sessions.expires', '<', now).execute().then(io.done);
+    io.start('Removing expired verifications');
+    await db.deleteFrom('verifications').where('verifications.expires', '<', now).execute().then(io.done);
     for (const plugin of plugins) {
-        if (!plugin.db_clean)
+        if (!plugin.hooks.clean)
             continue;
-        opt.output('plugin', plugin.name);
-        await plugin.db_clean(opt, db);
+        io.plugin(plugin.name);
+        await plugin.hooks.clean(opt, db);
     }
 }
 /**
@@ -310,30 +312,28 @@ export async function clean(opt) {
 export async function uninstall(opt) {
     const env_3 = { stack: [], error: void 0, hasError: false };
     try {
-        _fixOutput(opt);
         const db = __addDisposableResource(env_3, connect(), true);
         for (const plugin of plugins) {
-            if (!plugin.db_remove)
+            if (!plugin.hooks.remove)
                 continue;
-            opt.output('plugin', plugin.name);
-            await plugin.db_remove(opt, db);
+            io.plugin(plugin.name);
+            await plugin.hooks.remove(opt, db);
         }
-        const _sql = (command, message) => run(opt, message, `sudo -u postgres psql -c "${command}"`);
         await _sql('DROP DATABASE axium', 'Dropping database');
         await _sql('REVOKE ALL PRIVILEGES ON SCHEMA public FROM axium', 'Revoking schema privileges');
         await _sql('DROP USER axium', 'Dropping user');
         await getHBA(opt)
             .then(([content, writeBack]) => {
-            opt.output('start', 'Checking for Axium HBA configuration');
+            io.start('Checking for Axium HBA configuration');
             if (!content.includes(pgHba))
                 throw 'missing.';
-            opt.output('done');
-            opt.output('start', 'Removing Axium HBA configuration');
+            io.done();
+            io.start('Removing Axium HBA configuration');
             const newContent = content.replace(pgHba, '');
-            opt.output('done');
+            io.done();
             writeBack(newContent);
         })
-            .catch(e => opt.output('warn', e));
+            .catch(io.warn);
     }
     catch (e_3) {
         env_3.error = e_3;
@@ -349,17 +349,16 @@ export async function uninstall(opt) {
  * Removes all data from tables.
  */
 export async function wipe(opt) {
-    _fixOutput(opt);
     const db = connect();
     for (const plugin of plugins) {
-        if (!plugin.db_wipe)
+        if (!plugin.hooks.db_wipe)
             continue;
-        opt.output('plugin', plugin.name);
-        await plugin.db_wipe(opt, db);
+        io.plugin(plugin.name);
+        await plugin.hooks.db_wipe(opt, db);
     }
     for (const table of ['users', 'passkeys', 'sessions', 'verifications']) {
-        opt.output('start', `Removing data from ${table}`);
+        io.start(`Removing data from ${table}`);
         await db.deleteFrom(table).execute();
-        opt.output('done');
+        io.done();
     }
 }

package/dist/io.d.ts

@@ -1,10 +1,11 @@
 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;
 /**
- * Find the Axium directory.
- * This directory includes things like config files, secrets, etc.
+ * @internal
  */
-export declare function findDir(global: boolean): string;
-export declare const logger: Logger;
 export declare const output: {
     constructor: {
         name: string;
@@ -15,13 +16,12 @@ export declare const output: {
     log(message: string): void;
     debug(message: string): void;
 };
+export declare function setCommandTimeout(value: number): void;
 /**
  * Run a system command with the fancy "Example... done."
  * @internal
  */
-export declare function run(opts: WithOutput & {
-    timeout?: number;
-}, message: string, command: string): Promise<string>;
+export declare function run(message: string, command: string): Promise<string>;
 /** Yet another convenience function */
 export declare function exit(message: string | Error, code?: number): never;
 export declare function handleError(e: number | string | Error): void;
@@ -30,19 +30,18 @@ export interface Output {
     (tag: 'done'): void;
     (tag: Exclude<OutputTag, 'done'>, message: string): void;
 }
-export interface MaybeOutput {
-    output?: Output | null | false;
-}
-export interface WithOutput {
-    output: Output;
-}
-export declare function defaultOutput(tag: 'done'): void;
-export declare function defaultOutput(tag: Exclude<OutputTag, 'done'>, message: string): void;
 /**
- * TS can't tell when we do this inline
- * @internal
+ * Enable or disable debug output.
  */
-export declare function _fixOutput<T extends MaybeOutput>(opt: T): asserts opt is T & WithOutput;
+export declare function _setDebugOutput(enabled: boolean): void;
+export declare function useTaggedOutput(output: Output | null): void;
+export declare function done(): void;
+export declare function start(message: string): void;
+export declare function plugin(name: string): void;
+export declare function debug(message: string): void;
+export declare function info(message: string): void;
+export declare function warn(message: string): void;
+export declare function error(message: string): void;
 /** @internal */
 export declare const _portMethods: readonly ["node-cap"];
 /** @internal */
@@ -53,7 +52,7 @@ export declare const _portActions: readonly ["enable", "disable"];
  * Method:
  * - `node-cap`: Use the `cap_net_bind_service` capability on the node binary.
  */
-export interface PortOptions extends MaybeOutput {
+export interface PortOptions {
     method: (typeof _portMethods)[number];
     action: (typeof _portActions)[number];
     node?: string;
@@ -69,4 +68,4 @@ export declare function restrictedPorts(opt: PortOptions): Promise<void>;
  * The handler will allow the parent scope to continue if a relation already exists,
  * rather than fatally exiting.
  */
-export declare function someWarnings(output: Output, ...allowList: [RegExp, string?][]): (error: string | Error) => void;
+export declare function someWarnings(...allowList: [RegExp, string?][]): (error: string | Error) => void;