@axium/server 0.44.1 → 0.44.3

package/dist/{cli.d.ts → cli/common.d.ts}

@@ -7,7 +7,7 @@ export declare function lookupUser(lookup: string): Promise<UserInternal>;
  * Only returns whether the array was updated and diff text for what actually changed.
  */
 export declare function diffUpdate(original: string[], add?: string[], remove?: string[]): [updated: boolean, newValue: string[], diffText: string];
-export declare const cliOptions: {
+export declare const sharedOptions: {
     check: Option<"--check", undefined, false, undefined, false, undefined>;
     force: Option<"-f, --force", undefined, false, undefined, false, undefined>;
     global: Option<"-g, --global", undefined, false, undefined, false, undefined>;

package/dist/{cli.js → cli/common.js}

@@ -53,7 +53,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 import * as io from 'ioium/node';
 import { styleText } from 'node:util';
 import * as z from 'zod';
-import * as db from './db/index.js';
+import * as db from '../db/index.js';
 import { Option } from 'commander';
 import { createInterface } from 'node:readline/promises';
 export function userText(user, bold = false) {
@@ -99,7 +99,7 @@ export function diffUpdate(original, add, remove) {
     return [!!diffs.length, original, diffs.join(', ')];
 }
 // Options shared by multiple (sub)commands
-export const cliOptions = {
+export const sharedOptions = {
     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),

package/dist/cli/config.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/config.js

@@ -0,0 +1,69 @@
+import { program } from 'commander';
+import * as io from 'ioium/node';
+import { getByString, isJSON, setByString } from 'utilium';
+import * as z from 'zod';
+import config, { ConfigFile } from '../config.js';
+import { sharedOptions as opts } from './common.js';
+const axiumConfig = program
+    .command('config')
+    .description('Manage the configuration')
+    .addOption(opts.global)
+    .option('-j, --json', 'values are JSON encoded', false)
+    .option('-r, --redact', 'Do not output sensitive values', false);
+function configReplacer(opt) {
+    return (key, value) => {
+        return opt.redact && ['password', 'secret'].includes(key) ? '[redacted]' : value;
+    };
+}
+axiumConfig
+    .command('dump')
+    .description('Output the entire current configuration')
+    .action(function axium_config_dump() {
+    const opt = this.optsWithGlobals();
+    const value = config.plain();
+    console.log(opt.json ? JSON.stringify(value, configReplacer(opt), 4) : value);
+});
+axiumConfig
+    .command('get')
+    .description('Get a config value')
+    .argument('<key>', 'the key to get')
+    .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);
+});
+axiumConfig
+    .command('set')
+    .description('Set a config value. Note setting objects is not supported.')
+    .argument('<key>', 'the key to set')
+    .argument('<value>', 'the value')
+    .action(function axium_config_set(key, value) {
+    const opt = this.optsWithGlobals();
+    if (opt.json && !isJSON(value))
+        io.exit('Invalid JSON');
+    const obj = {};
+    setByString(obj, key, opt.json ? JSON.parse(value) : value);
+    config.save(obj, opt.global);
+});
+axiumConfig
+    .command('list')
+    .alias('ls')
+    .alias('files')
+    .description('List loaded config files')
+    .action(() => {
+    for (const path of config.files.keys())
+        console.log(path);
+});
+axiumConfig
+    .command('schema')
+    .description('Get the JSON schema for the configuration file')
+    .action(() => {
+    const opt = axiumConfig.optsWithGlobals();
+    try {
+        const schema = z.toJSONSchema(ConfigFile, { io: 'input' });
+        console.log(opt.json ? JSON.stringify(schema, configReplacer(opt), 4) : schema);
+    }
+    catch (e) {
+        io.exit(e);
+    }
+});

package/dist/{db/cli.js → cli/db.js}

@@ -56,8 +56,8 @@ 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';
+import { sharedOptions as opts, rlConfirm } from './common.js';
+import * as db from '../db/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 };
@@ -204,14 +204,8 @@ axiumDB
         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);
-        }
+        const schema = db.schema.getFull();
+        io.done();
         for (const [name, table] of Object.entries(schema.tables)) {
             await db.checkTableTypes(name, table, opt, tableMetadata);
             delete tables[name];
@@ -251,13 +245,8 @@ axiumDB
     .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);
-    }
+    const schema = z.toJSONSchema(db.schema.SchemaFile, { io: 'input' });
+    console.log(opt.json ? JSON.stringify(schema, null, 4) : schema);
 });
 axiumDB
     .command('upgrade')
@@ -307,22 +296,11 @@ axiumDB
     }
     await rlConfirm();
     io.start('Computing delta');
-    let delta;
-    try {
-        delta = db.delta.collapse(deltas);
-        io.done();
-    }
-    catch (e) {
-        io.exit(e);
-    }
+    const delta = db.delta.collapse(deltas);
+    io.done();
     io.start('Validating delta');
-    try {
-        db.delta.validate(delta);
-        io.done();
-    }
-    catch (e) {
-        io.exit(e);
-    }
+    db.delta.validate(delta);
+    io.done();
     console.log('Applying delta.');
     await db.delta.apply(delta, opt.abort);
     info.upgrades.push({ timestamp: new Date(), from, to });

package/dist/cli/index.d.ts

@@ -0,0 +1,5 @@
+export * from './common.js';
+import './config.js';
+import './db.js';
+import './plugins.js';
+import './user.js';

package/dist/cli/index.js

@@ -0,0 +1,304 @@
+export * from './common.js';
+import { apps } from '@axium/core';
+import { AuditFilter, severityNames } from '@axium/core/audit';
+import { formatBytes, formatMs } from '@axium/core/format';
+import { outputDaemonStatus } from '@axium/core/node';
+import { plugins } from '@axium/core/plugins';
+import { Argument, Option, program } from 'commander';
+import * as io from 'ioium/node';
+import { allLogLevels } from 'logzen';
+import { createWriteStream, readFileSync } from 'node:fs';
+import { access, watch } from 'node:fs/promises';
+import { join, resolve } from 'node:path/posix';
+import { styleText } from 'node:util';
+import { searchForWorkspaceRoot } from 'vite';
+import * as z from 'zod';
+import $pkg from '../../package.json' with { type: 'json' };
+import { getEvents, styleSeverity } from '../audit.js';
+import { build } from '../build.js';
+import config from '../config.js';
+import * as db from '../db/index.js';
+import { _portActions, _portMethods, dirs, logger, restrictedPorts } from '../io.js';
+import { linkRoutes, listRouteLinks, unlinkRoutes, writePluginHooks } from '../linking.js';
+import { serve } from '../serve.js';
+import { sharedOptions as opts } from './common.js';
+import { dbInitTables } from './db.js';
+// other subcommands
+import './config.js';
+import './db.js';
+import './plugins.js';
+import './user.js';
+const noAutoDB = ['init', 'serve', 'check'];
+program
+    .version($pkg.version)
+    .name('axium')
+    .description('Axium server CLI')
+    .configureHelp({ showGlobalOptions: true })
+    .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')
+    .hook('preAction', (_, action) => {
+    const opt = action.optsWithGlobals();
+    opt.force && io.warn('--force: Protections disabled.');
+    if (typeof opt.debug == 'boolean') {
+        config.set({ debug: opt.debug });
+        io._setDebugOutput(opt.debug);
+    }
+    try {
+        db.connect();
+    }
+    catch (e) {
+        if (!noAutoDB.includes(action.name()))
+            throw e;
+    }
+})
+    .hook('postAction', async (_, action) => {
+    if (!noAutoDB.includes(action.name()))
+        await db.database.destroy();
+})
+    .on('option:debug', () => config.set({ debug: true }));
+const axiumApps = program.command('apps').description('Manage Axium apps').addOption(opts.global);
+axiumApps
+    .command('list')
+    .alias('ls')
+    .description('List apps added by plugins')
+    .option('-l, --long', 'use the long listing format')
+    .option('-b, --builtin', 'include built-in apps')
+    .action(opt => {
+    if (!apps.size) {
+        console.log('No apps.');
+        return;
+    }
+    if (!opt.long) {
+        console.log(Array.from(apps.values().map(app => app.name)).join(', '));
+        return;
+    }
+    console.log(styleText('whiteBright', apps.size + ' app(s) loaded:'));
+    for (const app of apps.values()) {
+        console.log(app.name, styleText('dim', `(${app.id})`));
+    }
+});
+program
+    .command('status')
+    .alias('stats')
+    .description('Get information about the server')
+    .action(async () => {
+    console.log('Axium Server v' + $pkg.version);
+    console.log(styleText('whiteBright', 'Debug mode:'), config.debug ? styleText('yellow', 'enabled') : 'disabled');
+    const configFiles = config.files.keys().toArray();
+    console.log(styleText('whiteBright', 'Loaded config files:'), styleText(['dim', 'bold'], `(${configFiles.length})`), configFiles.join(', '));
+    outputDaemonStatus('axium');
+    process.stdout.write(styleText('whiteBright', 'Database: '));
+    try {
+        console.log(await db.statText());
+    }
+    catch {
+        console.log(styleText('red', 'Unavailable'));
+    }
+    console.log(styleText('whiteBright', 'Loaded plugins:'), styleText(['dim', 'bold'], `(${plugins.size || 'none'})`), Array.from(plugins.keys()).join(', '));
+    for (const plugin of plugins.values()) {
+        if (!plugin._hooks?.statusText)
+            continue;
+        const text = await plugin._hooks?.statusText();
+        console.log(styleText('bold', plugin.name), plugin.version + ':', text.includes('\n') ? '\n' + text : text);
+    }
+});
+program
+    .command('ports')
+    .description('Enable or disable use of restricted ports (e.g. 443)')
+    .addArgument(new Argument('<action>', 'The action to take').choices(_portActions))
+    .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 });
+});
+program
+    .command('init')
+    .description('Install Axium server')
+    .addOption(opts.force)
+    .addOption(opts.check)
+    .option('-s, --skip', 'Skip already initialized steps', false)
+    .action(async (opt) => {
+    await db.init(opt);
+    await dbInitTables();
+    await restrictedPorts({ method: 'node-cap', action: 'enable' });
+});
+program
+    .command('serve')
+    .description('Start the Axium server')
+    .option('-p, --port <port>', 'the port to listen on', Number.parseInt)
+    .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) => {
+    opt.port ||= config.web.port;
+    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,
+    });
+    logger.attach(createWriteStream(join(dirs.at(-1), 'server.log')), { output: allLogLevels });
+    db.connect();
+    await db.clean({});
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    process.on('beforeExit', () => db.database.destroy());
+    server.listen(opt.port, () => {
+        console.log('Server is listening on port ' + opt.port);
+    });
+});
+program
+    .command('link')
+    .description('Link routes provided by plugins and the server')
+    .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 axium_link(names) {
+    const opt = this.optsWithGlobals();
+    const linkOpts = { only: names };
+    if (opt.list) {
+        let idTextLength = 0, fromLength = 0, toLength = 0;
+        const links = [];
+        for (const link of listRouteLinks(linkOpts)) {
+            const idText = link.id.startsWith('#') ? `(${link.id.slice(1)})` : link.id;
+            idTextLength = Math.max(idTextLength, idText.length);
+            fromLength = Math.max(fromLength, link.from.length);
+            toLength = Math.max(toLength, link.to.length);
+            links.push(Object.assign(link, { idText }));
+        }
+        idTextLength++;
+        for (const link of links) {
+            const fromColor = await access(link.from)
+                .then(() => 'cyanBright')
+                .catch(() => 'redBright');
+            console.log((link.idText + ':').padEnd(idTextLength), styleText(fromColor, link.from.padEnd(fromLength)), '->', link.to.padEnd(toLength).replace(/.*\/node_modules\//, styleText('dim', '$&')));
+        }
+        return;
+    }
+    if (opt.delete) {
+        unlinkRoutes(linkOpts);
+        return;
+    }
+    io.start('Linking routes');
+    linkRoutes(linkOpts);
+    io.done();
+    io.start('Writing web client hooks for plugins');
+    writePluginHooks();
+    io.done();
+});
+program
+    .command('audit')
+    .description('View audit logs')
+    .option('-x, --extra', 'Include the extra object when listing events')
+    .option('-t, --include-tags', 'Include tags when listing events')
+    .addOption(new Option('-s, --summary', 'Summarize audit log entries instead of displaying individual ones').conflicts(['extra', 'includeTags']))
+    .optionsGroup('Filters:')
+    .option('--since <date>', 'Filter for events since a date')
+    .option('--until <date>', 'Filter for events until a date')
+    .option('--user <uuid|null>', 'Filter for events triggered by a user')
+    .addOption(new Option('--severity <level>', 'Filter for events at or above a severity level').choices(severityNames))
+    .option('--source <source>', 'Filter by source')
+    .option('--tag <tag...>', 'Filter by tag(s)')
+    .option('--event <event>', 'Filter by event name')
+    .action(async (opt) => {
+    const filter = await AuditFilter.parseAsync(opt).catch(e => io.exit('Invalid filter: ' + z.prettifyError(e)));
+    const events = await getEvents(filter).execute();
+    if (opt.summary) {
+        const groups = Object.groupBy(events, e => e.severity);
+        const maxGroupLength = Math.max(...Object.values(groups).map(g => g.length.toString().length), 0);
+        for (const [severity, group] of Object.entries(groups)) {
+            if (!group?.length)
+                continue;
+            console.log(styleText('white', group.length.toString().padStart(maxGroupLength)), styleSeverity(severity, true), 'events. Latest occurred', group.at(-1).timestamp.toLocaleString());
+        }
+        return;
+    }
+    let maxSource = 0, maxName = 0, maxTags = 0, maxExtra = 0;
+    for (const event of events) {
+        maxSource = Math.max(maxSource, event.source.length);
+        maxName = Math.max(maxName, event.name.length);
+        event._tags = !event.tags.length
+            ? ''
+            : opt.includeTags
+                ? '# ' + event.tags.join(', ')
+                : `(${event.tags.length} tag${event.tags.length == 1 ? '' : 's'})`;
+        maxTags = Math.max(maxTags, event._tags.length);
+        const extraKeys = Object.keys(event.extra);
+        event._extra = !extraKeys.length ? '' : opt.extra ? JSON.stringify(event.extra) : '+' + extraKeys.length;
+        maxExtra = Math.max(maxExtra, event._extra.length);
+    }
+    for (const event of events) {
+        console.log(styleSeverity(event.severity, true), styleText('dim', io.prettyDate(event.timestamp)), event.source.padEnd(maxSource), styleText('whiteBright', event.name.padEnd(maxName)), styleText('gray', event._tags.padEnd(maxTags)), 'by', event.userId ? event.userId : styleText(['dim', 'italic'], 'unknown'.padEnd(36)), styleText('blue', event._extra));
+    }
+});
+program
+    .command('build')
+    .description('Create the Vite build for the server')
+    .option('--show-garbage-output', 'Show all output from the build process')
+    .option('-s, --diagnostics', 'Show build time and bundle size')
+    .option('-m, --no-minify', 'Whether to use minification')
+    .action(async (options) => {
+    io.start('Building');
+    const { time, size } = await build(options);
+    io.done();
+    if (options.diagnostics) {
+        console.log('Took', styleText('blueBright', formatMs(time)), 'with a bundle size of', styleText('blueBright', formatBytes(size)));
+    }
+});
+program
+    .command('develop')
+    .alias('dev')
+    .description('Develop with axium')
+    .argument('[dir]', 'The project directory', searchForWorkspaceRoot(process.cwd()))
+    .option('-g, --git', 'Use .gitignore to ignore files (can improve performance)')
+    .action(async (dir, opts) => {
+    let buildId = 0, server;
+    logger.attach(createWriteStream(join(dirs.at(-1), 'server.log')), { output: allLogLevels });
+    db.connect();
+    await db.clean({});
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    process.on('beforeExit', () => db.database.destroy());
+    async function rebuild() {
+        server?.close();
+        process.stdout.clearLine(0);
+        process.stdout.cursorTo(0);
+        io.start('Building');
+        const { time } = await build({ minify: false });
+        buildId++;
+        process.stdout.clearLine(0);
+        process.stdout.cursorTo(0);
+        server = await serve(config.web);
+        server.listen(config.web.port);
+        process.stdout.write(`Build #${buildId} finished in ${formatMs(time)}`);
+    }
+    const ignore = ['node_modules', '.git'];
+    try {
+        if (!opts.git)
+            throw null;
+        const gitignore = readFileSync(join(dir, '.gitignore'), 'utf8');
+        for (const rawLine of gitignore.split('\n')) {
+            const line = rawLine.trim();
+            if (!line || line[0] == '#')
+                continue;
+            ignore.push(line);
+        }
+    }
+    catch {
+        // It's fine if we don't have a .gitignore
+    }
+    io.debug('Watching', dir);
+    await rebuild();
+    try {
+        for await (const _event of watch(dir, { recursive: true, ignore })) {
+            // @todo see if we can be more efficient based on event data
+            await rebuild();
+        }
+    }
+    catch (err) {
+        if (err.name === 'AbortError')
+            return;
+        throw err;
+    }
+});

package/dist/cli/plugins.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/plugins.js

@@ -0,0 +1,148 @@
+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 { pluginText } from '@axium/core/node';
+import { _findPlugin, plugins } from '@axium/core/plugins';
+import { program } from 'commander';
+import * as io from 'ioium/node';
+import { styleText } from 'node:util';
+import { configFiles, saveConfigTo } from '../config.js';
+import * as db from '../db/index.js';
+import { sharedOptions as opts, rlConfirm } from './common.js';
+const axiumPlugin = program.command('plugins').alias('plugin').description('Manage plugins').addOption(opts.global);
+axiumPlugin
+    .command('list')
+    .alias('ls')
+    .description('List loaded plugins')
+    .option('-l, --long', 'use the long listing format')
+    .option('--no-versions', 'do not show plugin versions')
+    .action(opt => {
+    if (!plugins.size) {
+        console.log('No plugins loaded.');
+        return;
+    }
+    if (!opt.long) {
+        console.log(Array.from(plugins.keys()).join(', '));
+        return;
+    }
+    console.log(styleText('whiteBright', plugins.size + ' plugin(s) loaded:'));
+    for (const plugin of plugins.values()) {
+        console.log(plugin.name, opt.versions ? plugin.version : '');
+    }
+});
+axiumPlugin
+    .command('info')
+    .description('Get information about a plugin')
+    .argument('<plugin>', 'the plugin to get information about')
+    .action((search) => {
+    const plugin = _findPlugin(search);
+    for (const line of pluginText(plugin))
+        console.log(line);
+});
+axiumPlugin
+    .command('remove')
+    .alias('rm')
+    .description('Remove a plugin')
+    .argument('<plugin>', 'the plugin to remove')
+    .action(async (search, opt) => {
+    const plugin = _findPlugin(search);
+    await plugin._hooks?.remove?.(opt);
+    for (const [path, data] of configFiles) {
+        if (!data.plugins)
+            continue;
+        data.plugins = data.plugins.filter(p => p !== plugin.specifier);
+        saveConfigTo(path, data);
+    }
+    plugins.delete(plugin.name);
+});
+axiumPlugin
+    .command('init')
+    .alias('setup')
+    .alias('install')
+    .description('Initialize a plugin. This could include adding tables to the database or linking routes.')
+    .addOption(opts.timeout)
+    .addOption(opts.check)
+    .argument('<plugin>', 'the plugin to initialize')
+    .action(async (search) => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const plugin = _findPlugin(search);
+        if (!plugin)
+            io.exit(`Can't find a plugin matching "${search}"`);
+        const _ = __addDisposableResource(env_1, db.connect(), true);
+        const info = db.getUpgradeInfo();
+        const exclude = Object.keys(info.current);
+        if (exclude.includes(plugin.name))
+            io.exit('Plugin is already initialized (database)');
+        const schema = db.schema.getFull({ exclude });
+        const delta = db.delta.compute({ tables: {}, indexes: {} }, schema);
+        if (db.delta.isEmpty(delta)) {
+            io.info('Plugin does not define any database schema.');
+            return;
+        }
+        for (const text of db.delta.display(delta))
+            console.log(text);
+        await rlConfirm();
+        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;
+    }
+});

package/dist/cli/user.d.ts

@@ -0,0 +1 @@
+export {};