@axium/server 0.43.0 → 0.44.0

package/dist/db/cli.js

@@ -0,0 +1,392 @@
+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 { Option, program } from 'commander';
+import * as io from 'ioium/node';
+import { createWriteStream } from 'node:fs';
+import { styleText } from 'node:util';
+import { capitalize } from 'utilium';
+import * as z from 'zod';
+import { cliOptions as opts, rlConfirm } from '../cli.js';
+import * as db from './index.js';
+const axiumDB = program.command('db').alias('database').description('Manage the database').addOption(opts.timeout);
+export async function dbInitTables() {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const info = db.getUpgradeInfo();
+        const schema = db.schema.getFull({ exclude: Object.keys(info.current) });
+        const delta = db.delta.compute({ tables: {}, indexes: {} }, schema);
+        if (db.delta.isEmpty(delta))
+            return;
+        for (const text of db.delta.display(delta))
+            console.log(text);
+        await rlConfirm();
+        const _ = __addDisposableResource(env_1, db.connect(), true);
+        await db.delta.apply(delta);
+        Object.assign(info.current, schema.versions);
+        db.setUpgradeInfo(info);
+    }
+    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('init')
+    .description('Initialize the database')
+    .addOption(opts.force)
+    .option('-s, --skip', 'If the user, database, or schema already exists, skip trying to create it.', false)
+    .addOption(opts.check)
+    .action(async function axium_db_init() {
+    const opt = this.optsWithGlobals();
+    await db.init(opt);
+    await dbInitTables();
+});
+axiumDB
+    .command('status')
+    .alias('stats')
+    .description('Check the status of the database')
+    .action(async () => {
+    try {
+        console.log(await db.statText());
+    }
+    catch {
+        io.error('Unavailable');
+        process.exitCode = 1;
+    }
+});
+axiumDB
+    .command('drop')
+    .description('Drop the Axium database and user')
+    .addOption(opts.force)
+    .action(async (opt) => {
+    const stats = await db.count('users', 'passkeys', 'sessions');
+    if (!opt.force)
+        for (const key of ['users', 'passkeys', 'sessions']) {
+            if (stats[key] == 0)
+                continue;
+            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');
+    await db._sql('REVOKE ALL PRIVILEGES ON SCHEMA public FROM axium', 'Revoking schema privileges');
+    await db._sql('DROP USER axium', 'Dropping user');
+    await db
+        .getHBA(opt)
+        .then(([content, writeBack]) => {
+        io.start('Checking for Axium HBA configuration');
+        if (!content.includes(db._pgHba))
+            throw 'missing.';
+        io.done();
+        io.start('Removing Axium HBA configuration');
+        const newContent = content.replace(db._pgHba, '');
+        io.done();
+        writeBack(newContent);
+    })
+        .catch(io.warn);
+});
+axiumDB
+    .command('wipe')
+    .description('Wipe the database')
+    .addOption(opts.force)
+    .action(async (opt) => {
+    const tables = new Map();
+    for (const [plugin, schema] of db.schema.getFiles()) {
+        for (const table of schema.wipe) {
+            const maybePlugin = tables.get(table);
+            tables.set(table, maybePlugin ? `${maybePlugin}, ${plugin}` : plugin);
+        }
+    }
+    if (!opt.force) {
+        const stats = await db.count(...tables.keys());
+        const nonEmpty = Object.entries(stats)
+            .filter(([, v]) => v)
+            .map(([k]) => k);
+        if (nonEmpty.length) {
+            io.exit(`Some tables are not empty, use --force if you really want to wipe them: ${nonEmpty.join(', ')}`, 2);
+        }
+    }
+    const maxTableName = Math.max(5, ...Array.from(tables.keys()).map(t => t.length));
+    console.log('Table' + ' '.repeat(maxTableName - 5), '|', 'Plugin(s)');
+    console.log('-'.repeat(maxTableName), '|', '-'.repeat(20));
+    for (const [table, plugins] of [...tables].sort((a, b) => a[0].localeCompare(b[0]))) {
+        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();
+});
+axiumDB
+    .command('check')
+    .description('Check the structure of the database')
+    .option('-s, --strict', 'Throw errors instead of emitting warnings for most column problems')
+    .action(async (opt) => {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        await io.run('Checking for sudo', 'which sudo');
+        await io.run('Checking for psql', 'which psql');
+        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);
+        await db._sql(`SELECT 1 FROM pg_roles WHERE rolname = 'axium'`, 'Checking for user').then(throwUnlessRows);
+        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();
+        io.done();
+        io.start('Checking for acl schema');
+        if (!schemas.find(s => s.name == 'acl'))
+            io.exit('missing.');
+        io.done();
+        io.start('Getting table metadata');
+        const tablePromises = await Promise.all([
+            db.database.introspection.getTables(),
+            db.database.withSchema('acl').introspection.getTables(),
+        ]);
+        const tableMetadata = tablePromises.flat();
+        const tables = Object.fromEntries(tableMetadata.map(t => [t.schema == 'public' ? t.name : `${t.schema}.${t.name}`, t]));
+        io.done();
+        io.start('Resolving database schemas');
+        let schema;
+        try {
+            schema = db.schema.getFull();
+            io.done();
+        }
+        catch (e) {
+            io.exit(e);
+        }
+        for (const [name, table] of Object.entries(schema.tables)) {
+            await db.checkTableTypes(name, table, opt, tableMetadata);
+            delete tables[name];
+        }
+        io.start('Checking for extra tables');
+        const unchecked = Object.keys(tables).join(', ');
+        if (!unchecked.length)
+            io.done();
+        else if (opt.strict)
+            io.exit(unchecked);
+        else
+            io.warn(unchecked);
+    }
+    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('clean')
+    .description('Remove expired rows')
+    .addOption(opts.force)
+    .action(async (opt) => {
+    await db.clean(opt);
+});
+axiumDB
+    .command('rotate-password')
+    .description('Generate a new password for the database user and update the config')
+    .action(db.rotatePassword);
+axiumDB
+    .command('json-schema')
+    .description('Get the JSON schema for the database configuration file')
+    .option('-j, --json', 'values are JSON encoded')
+    .action(opt => {
+    try {
+        const schema = z.toJSONSchema(db.schema.SchemaFile, { io: 'input' });
+        console.log(opt.json ? JSON.stringify(schema, null, 4) : schema);
+    }
+    catch (e) {
+        io.exit(e);
+    }
+});
+axiumDB
+    .command('upgrade')
+    .alias('update')
+    .alias('up')
+    .description('Upgrade the database to the latest version')
+    .option('--abort', 'Rollback changes instead of committing them')
+    .action(async function axium_db_upgrade(opt) {
+    const deltas = [];
+    const info = db.getUpgradeInfo();
+    let empty = true;
+    const from = {}, to = {};
+    for (const [name, schema] of db.schema.getFiles()) {
+        if (!(name in info.current))
+            io.exit('Plugin is not initialized: ' + name);
+        const currentVersion = info.current[name];
+        const target = schema.latest ?? schema.versions.length - 1;
+        if (currentVersion >= target)
+            continue;
+        from[name] = currentVersion;
+        to[name] = target;
+        info.current[name] = target;
+        let versions = schema.versions.slice(currentVersion + 1);
+        const v0 = schema.versions[0];
+        if (v0.delta)
+            throw 'Initial version can not be a delta';
+        for (const [i, v] of versions.toReversed().entries()) {
+            if (v.delta || v == v0)
+                continue;
+            versions = [db.delta.compute(v0, v), ...versions.slice(-i)];
+            break;
+        }
+        const delta = db.delta.collapse(versions);
+        deltas.push(delta);
+        console.log('Upgrading', name, styleText('dim', currentVersion.toString() + '->') + styleText('blueBright', target.toString()) + ':');
+        if (!db.delta.isEmpty(delta))
+            empty = false;
+        for (const text of db.delta.display(delta))
+            console.log(text);
+    }
+    if (empty) {
+        console.log('Already up to date.');
+        return;
+    }
+    if (opt.abort) {
+        io.warn('--abort: Changes will be rolled back instead of being committed.');
+    }
+    await rlConfirm();
+    io.start('Computing delta');
+    let delta;
+    try {
+        delta = db.delta.collapse(deltas);
+        io.done();
+    }
+    catch (e) {
+        io.exit(e);
+    }
+    io.start('Validating delta');
+    try {
+        db.delta.validate(delta);
+        io.done();
+    }
+    catch (e) {
+        io.exit(e);
+    }
+    console.log('Applying delta.');
+    await db.delta.apply(delta, opt.abort);
+    info.upgrades.push({ timestamp: new Date(), from, to });
+    db.setUpgradeInfo(info);
+});
+axiumDB
+    .command('upgrade-history')
+    .alias('update-history')
+    .description('Show the history of database upgrades')
+    .action(() => {
+    const info = db.getUpgradeInfo();
+    if (!info.upgrades.length) {
+        console.log('No upgrade history.');
+        return;
+    }
+    for (const up of info.upgrades) {
+        console.log(styleText(['whiteBright', 'underline'], up.timestamp.toString()) + ':');
+        for (const [name, from] of Object.entries(up.from)) {
+            console.log(name, styleText('dim', from.toString() + '->') + styleText('blueBright', up.to[name].toString()));
+        }
+    }
+});
+function colorCurrent(info) {
+    if (info.current > Math.max(info.latest, info.available))
+        return 'magentaBright';
+    if (info.current > info.latest && info.current <= info.available)
+        return 'cyanBright';
+    if (info.current >= info.latest)
+        return 'greenBright';
+    return 'yellowBright';
+}
+axiumDB
+    .command('versions')
+    .description('Show information about database versions')
+    .action(() => {
+    const { current: currentVersions } = db.getUpgradeInfo();
+    const lengths = { name: 4, current: 7, latest: 6, available: 9 };
+    const entries = [];
+    for (const [name, file] of db.schema.getFiles()) {
+        const available = file.versions.length - 1;
+        const latest = file.latest ?? available;
+        const current = currentVersions[name];
+        entries.push({ name, latest, available, current });
+        lengths.name = Math.max(lengths.name || 0, name.length);
+        lengths.current = Math.max(lengths.current || 0, current.toString().length);
+        lengths.latest = Math.max(lengths.latest || 0, latest.toString().length);
+        lengths.available = Math.max(lengths.available || 0, available.toString().length);
+    }
+    console.log(...['name', 'current', 'latest', 'available'].map(key => styleText(['whiteBright', 'underline'], capitalize(key).padStart(lengths[key]))));
+    for (const entry of entries) {
+        console.log(entry.name.padStart(lengths.name), styleText(colorCurrent(entry), entry.current.toString().padStart(lengths.current)), entry.latest.toString().padStart(lengths.latest), entry.available.toString().padStart(lengths.available));
+    }
+});
+axiumDB
+    .command('export-schema')
+    .description('Export the DB schema')
+    .addOption(new Option('-f, --format <format>', 'Output format').choices(['sql', 'graph']).default('sql'))
+    .option('-o, --output <file>', 'Output file path')
+    .action(opt => {
+    const schema = db.schema.getFull();
+    const it = opt.format == 'sql' ? db.schema.toSQL(schema) : db.schema.toGraph(schema);
+    const out = opt.output ? createWriteStream(opt.output) : process.stdout;
+    for (const data of it)
+        out.write(data);
+    if (opt.output)
+        out.close();
+});

package/dist/db/connection.d.ts

@@ -1,5 +1,5 @@
 import { Kysely } from 'kysely';
-import type { Schema } from '../database.js';
+import type { Schema } from '../db/index.js';
 export type Database = Kysely<Schema> & AsyncDisposable;
 export declare let database: Database;
 export declare function connect(): Database;

package/dist/{database.d.ts → db/index.d.ts}

@@ -3,11 +3,10 @@ import type { AuthenticatorTransportFuture, CredentialDeviceType } from '@simple
 import type * as kysely from 'kysely';
 import type { Expand } from 'utilium';
 import * as z from 'zod';
-import { connect, database } from './db/connection.js';
-export { connect, database };
-import * as schema from './db/schema.js';
-export * as delta from './db/delta.js';
-export * as schema from './db/schema.js';
+import { connect, database } from './connection.js';
+import * as schema from './schema.js';
+export * as delta from './delta.js';
+export { connect, database, schema };
 export interface DBAccessControl {
     itemId: string;
     userId?: string | null;

package/dist/{database.js → db/index.js}

@@ -60,13 +60,12 @@ import { join } from 'node:path';
 import { styleText } from 'node:util';
 import pg from 'pg';
 import * as z from 'zod';
-import config from './config.js';
-import { dirs, systemDir } from './io.js';
-import { connect, database } from './db/connection.js';
-export { connect, database };
-import * as schema from './db/schema.js';
-export * as delta from './db/delta.js';
-export * as schema from './db/schema.js';
+import config from '../config.js';
+import { dirs, systemDir } from '../io.js';
+import { connect, database } from './connection.js';
+import * as schema from './schema.js';
+export * as delta from './delta.js';
+export { connect, database, schema };
 pg.types.setTypeParser(pg.types.builtins.INT8, BigInt);
 // @ts-expect-error 2339
 BigInt.prototype.toJSON = function () {

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export * as auth from './auth.js';
 export * as config from './config.js';
-export * as db from './database.js';
+export * as db from './db/index.js';

package/dist/index.js

@@ -1,3 +1,3 @@
 export * as auth from './auth.js';
 export * as config from './config.js';
-export * as db from './database.js';
+export * as db from './db/index.js';

package/dist/linking.d.ts

@@ -2,7 +2,6 @@ interface LinkInfo {
     id: string;
     from: string;
     to: string;
-    text: string;
 }
 export interface LinkOptions {
     only?: string[];

package/dist/linking.js

@@ -3,27 +3,22 @@ import { plugins } from '@axium/core/plugins';
 import { existsSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
 import { join, relative, resolve } from 'node:path/posix';
 import config from './config.js';
-const textFor = {
-    builtin: 'built-in routes',
-};
-function info(id) {
-    const text = id.startsWith('#') ? textFor[id.slice(1)] : `routes for plugin: ${id}`;
-    const link = join(config.web.routes, `(${id.startsWith('#') ? id.slice(1) : id.replaceAll('/', '__')})`);
-    return [text, link];
+function resolveLink(id) {
+    return join(config.web.routes, `(${id.startsWith('#') ? id.slice(1) : id.replaceAll('/', '__')})`);
 }
 export function* listRouteLinks(options = {}) {
     if (!options.only || !options.only.length) {
-        const [text, link] = info('#builtin');
-        yield { text, id: '#builtin', from: link, to: resolve(import.meta.dirname, '../routes') };
+        const link = resolveLink('#builtin');
+        yield { id: '#builtin', from: link, to: resolve(import.meta.dirname, '../routes') };
     }
     for (const plugin of plugins.values()) {
         if (!plugin.server?.routes)
             continue;
         if (options.only && options.only.length && !options.only.includes(plugin.name))
             continue;
-        const [text, link] = info(plugin.name);
+        const link = resolveLink(plugin.name);
         const to = resolve(join(plugin.dirname, plugin.server.routes));
-        yield { text, id: plugin.name, from: link, to };
+        yield { id: plugin.name, from: link, to };
     }
 }
 /**
@@ -31,27 +26,12 @@ export function* listRouteLinks(options = {}) {
  */
 export function linkRoutes(options = {}) {
     for (const info of listRouteLinks(options)) {
-        const { text, from, to } = info;
-        io.start('Linking ' + text);
+        const { from, to } = info;
         if (existsSync(from)) {
-            io.warn('already exists.');
-            io.start('Unlinking ' + text);
-            try {
-                unlinkSync(from);
-            }
-            catch (e) {
-                io.exit(e);
-            }
-            io.done();
-            io.start('Re-linking ' + text);
-        }
-        try {
-            symlinkSync(to, from, 'dir');
-            io.done();
-        }
-        catch (e) {
-            io.exit(e);
+            unlinkSync(from);
         }
+        io.debug('Linking routes:', from, '->', to);
+        symlinkSync(to, from, 'dir');
     }
 }
 const hooksBuiltin = `
@@ -64,7 +44,6 @@ export function handleError({ error, status }) {
 `;
 export function writePluginHooks() {
     const hooksPath = join(import.meta.dirname, '../.hooks.js');
-    io.start('Writing web client hooks for plugins');
     let hooks = `// auto-generated plugin hooks //\n`;
     for (const plugin of plugins.values()) {
         if (!plugin.server?.web_client_hooks)
@@ -74,21 +53,14 @@ export function writePluginHooks() {
     }
     hooks += hooksBuiltin;
     writeFileSync(hooksPath, hooks, 'utf8');
-    io.done();
-    io.debug('Wrote', hooksPath);
+    io.debug('Wrote hooks to', hooksPath);
 }
 export function unlinkRoutes(options = {}) {
     for (const info of listRouteLinks(options)) {
-        const { text, from } = info;
+        const { from } = info;
         if (!existsSync(from))
             return;
-        io.start('Unlinking ' + text);
-        try {
-            unlinkSync(from);
-            io.done();
-        }
-        catch (e) {
-            io.exit(e);
-        }
+        io.debug('Unlinking routes:', from);
+        unlinkSync(from);
     }
 }

package/dist/main.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+import './db/cli.js';