@axium/server 0.5.3 → 0.6.1

package/dist/auth.js

@@ -6,7 +6,7 @@ import { Login, Registration } from '@axium/core/schemas';
 import { genSaltSync, hashSync } from 'bcryptjs';
 import { randomBytes } from 'node:crypto';
 import { omit } from 'utilium';
-import * as config from './config.js';
+import config from './config.js';
 import * as db from './database.js';
 import { logger } from './io.js';
 export let adapter;

package/dist/cli.js

@@ -3,9 +3,10 @@ import { Argument, Option, program } from 'commander';
 import { styleText } from 'node:util';
 import { getByString, isJSON, setByString } from 'utilium';
 import $pkg from '../package.json' with { type: 'json' };
-import * as config from './config.js';
+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';
 program
     .version($pkg.version)
     .name('axium')
@@ -16,8 +17,9 @@ program
     .option('-c, --config <path>', 'path to the config file');
 program.on('option:debug', () => config.set({ debug: true }));
 program.on('option:config', () => config.load(program.opts().config));
-program.hook('preAction', function (_, action) {
+program.hook('preAction', async function (_, action) {
     config.loadDefaults();
+    await loadDefaultPlugins();
     const opt = action.optsWithGlobals();
     opt.force && output.warn('--force: Protections disabled.');
     if (opt.debug === false)
@@ -32,25 +34,26 @@ const opts = {
         config.db.port = port && Number.isSafeInteger(parseInt(port)) ? parseInt(port) : config.db.port;
     }),
     force: new Option('-f, --force', 'force the operation').default(false),
+    global: new Option('-g, --global', 'apply the operation globally').default(false),
 };
 const axiumDB = program
     .command('db')
     .alias('database')
-    .description('manage the database')
+    .description('Manage the database')
     .option('-t, --timeout <ms>', 'how long to wait for commands to complete.', '1000')
     .addOption(opts.host);
 axiumDB
     .command('init')
-    .description('initialize the database')
+    .description('Initialize the database')
     .addOption(opts.force)
-    .option('-s, --skip', 'Skip existing database and/or user')
+    .option('-s, --skip', 'If the user, database, or schema already exists, skip trying to create it.')
     .action(async (opt) => {
     await db.init(opt).catch(handleError);
 });
 axiumDB
     .command('status')
     .alias('stats')
-    .description('check the status of the database')
+    .description('Check the status of the database')
     .action(async () => {
     try {
         console.log(await db.statusText());
@@ -65,7 +68,7 @@ axiumDB
 });
 axiumDB
     .command('drop')
-    .description('drop the database')
+    .description('Drop the Axium database and user')
     .addOption(opts.force)
     .action(async (opt) => {
     const stats = await db.status().catch(exit);
@@ -81,7 +84,7 @@ axiumDB
 });
 axiumDB
     .command('wipe')
-    .description('wipe the database')
+    .description('Wipe the database')
     .addOption(opts.force)
     .action(async (opt) => {
     const stats = await db.status().catch(exit);
@@ -95,21 +98,17 @@ axiumDB
     await db.wipe(opt).catch(exit);
     await db.database.destroy();
 });
-const axiumConfig = program
-    .command('config')
-    .description('manage the configuration')
-    .option('-j, --json', 'values are JSON encoded')
-    .option('-g, --global', 'apply to the global config');
+const axiumConfig = program.command('config').description('Manage the configuration').addOption(opts.global).option('-j, --json', 'values are JSON encoded');
 axiumConfig
     .command('dump')
     .description('Output the entire current configuration')
     .action(() => {
-    const value = config.get();
+    const value = config;
     console.log(axiumConfig.optsWithGlobals().json ? JSON.stringify(value) : value);
 });
 axiumConfig
     .command('get')
-    .description('get a config value')
+    .description('Get a config value')
     .argument('<key>', 'the key to get')
     .action((key) => {
     const value = getByString(config, key);
@@ -137,16 +136,53 @@ 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.');
+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)
+            .map(plugin => plugin.name)
+            .join(', '));
+        return;
+    }
+    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 : '');
+    }
+});
+axiumPlugin
+    .command('info')
+    .description('Get information about a plugin')
+    .argument('<plugin>', 'the plugin to get information about')
+    .action((search) => {
+    const plugin = resolvePlugin(search);
+    if (!plugin)
+        exit(`Can't find a plugin matching "${search}"`);
+    console.log(pluginText(plugin));
+});
 program
     .command('status')
     .alias('stats')
-    .description('get information about the server')
+    .description('Get information about the server')
     .addOption(opts.host)
     .action(async () => {
     console.log('Axium Server v' + program.version());
-    console.log('Debug mode:', config.debug ? styleText('yellow', 'enabled') : 'disabled');
-    console.log('Loaded config files:', config.files.keys().toArray().join(', '));
-    process.stdout.write('Database: ');
+    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: '));
     try {
         console.log(await db.statusText());
     }
@@ -154,7 +190,16 @@ program
         output.error('Unavailable');
     }
     await db.database.destroy();
-    console.log('Credentials authentication:', config.auth.credentials ? styleText('yellow', 'enabled') : 'disabled');
+    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 + ':'));
+        console.log(plugin.statusText());
+    }
 });
 program
     .command('ports')

package/dist/config.d.ts

@@ -1,170 +1,144 @@
 import { type PartialRecursive } from 'utilium';
 import * as z from 'zod';
-export declare const Database: z.ZodObject<{
-    host: z.ZodString;
-    port: z.ZodNumber;
-    password: z.ZodString;
-    user: z.ZodString;
-    database: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    host: string;
-    port: number;
-    password: string;
-    user: string;
-    database: string;
-}, {
-    host: string;
-    port: number;
-    password: string;
-    user: string;
-    database: string;
-}>;
-export type Database = z.infer<typeof Database>;
-export declare const db: Database;
-export declare const Auth: z.ZodObject<{
-    credentials: z.ZodBoolean;
-    debug: z.ZodOptional<z.ZodBoolean>;
-    secret: z.ZodString;
-    secure_cookies: z.ZodBoolean;
-}, "strip", z.ZodTypeAny, {
-    credentials: boolean;
-    secret: string;
-    secure_cookies: boolean;
-    debug?: boolean | undefined;
-}, {
-    credentials: boolean;
-    secret: string;
-    secure_cookies: boolean;
-    debug?: boolean | undefined;
-}>;
-export type Auth = z.infer<typeof Auth>;
-export declare const auth: Auth;
-export declare const Log: z.ZodObject<{
-    level: z.ZodEnum<["error", "warn", "notice", "info", "debug"]>;
-    console: z.ZodBoolean;
-}, "strip", z.ZodTypeAny, {
-    level: "warn" | "error" | "debug" | "notice" | "info";
-    console: boolean;
-}, {
-    level: "warn" | "error" | "debug" | "notice" | "info";
-    console: boolean;
-}>;
-export type Log = z.infer<typeof Log>;
-export declare const log: Log;
-export declare const Web: z.ZodObject<{
-    prefix: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    prefix: string;
-}, {
-    prefix: string;
-}>;
-export type Web = z.infer<typeof Web>;
-export declare const web: Web;
-export declare const Config: z.ZodObject<{
+export declare const Schema: z.ZodObject<{
     auth: z.ZodObject<{
-        credentials: z.ZodOptional<z.ZodBoolean>;
-        debug: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
-        secret: z.ZodOptional<z.ZodString>;
-        secure_cookies: z.ZodOptional<z.ZodBoolean>;
+        credentials: z.ZodBoolean;
+        debug: z.ZodBoolean;
+        secret: z.ZodString;
+        secure_cookies: z.ZodBoolean;
     }, "strip", z.ZodTypeAny, {
-        debug?: boolean | undefined;
-        credentials?: boolean | undefined;
-        secret?: string | undefined;
-        secure_cookies?: boolean | undefined;
+        debug: boolean;
+        credentials: boolean;
+        secret: string;
+        secure_cookies: boolean;
     }, {
-        debug?: boolean | undefined;
-        credentials?: boolean | undefined;
-        secret?: string | undefined;
-        secure_cookies?: boolean | undefined;
+        debug: boolean;
+        credentials: boolean;
+        secret: string;
+        secure_cookies: boolean;
     }>;
-    debug: z.ZodBoolean;
     db: z.ZodObject<{
-        host: z.ZodOptional<z.ZodString>;
-        port: z.ZodOptional<z.ZodNumber>;
-        password: z.ZodOptional<z.ZodString>;
-        user: z.ZodOptional<z.ZodString>;
-        database: z.ZodOptional<z.ZodString>;
+        host: z.ZodString;
+        port: z.ZodNumber;
+        password: z.ZodString;
+        user: z.ZodString;
+        database: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        host?: string | undefined;
-        port?: number | undefined;
-        password?: string | undefined;
-        user?: string | undefined;
-        database?: string | undefined;
+        host: string;
+        port: number;
+        password: string;
+        user: string;
+        database: string;
     }, {
-        host?: string | undefined;
-        port?: number | undefined;
-        password?: string | undefined;
-        user?: string | undefined;
-        database?: string | undefined;
+        host: string;
+        port: number;
+        password: string;
+        user: string;
+        database: string;
     }>;
+    debug: z.ZodBoolean;
     log: z.ZodObject<{
-        level: z.ZodOptional<z.ZodEnum<["error", "warn", "notice", "info", "debug"]>>;
-        console: z.ZodOptional<z.ZodBoolean>;
+        level: z.ZodEnum<["error", "warn", "notice", "info", "debug"]>;
+        console: z.ZodBoolean;
     }, "strip", z.ZodTypeAny, {
-        level?: "warn" | "error" | "debug" | "notice" | "info" | undefined;
-        console?: boolean | undefined;
+        level: "debug" | "info" | "warn" | "error" | "notice";
+        console: boolean;
     }, {
-        level?: "warn" | "error" | "debug" | "notice" | "info" | undefined;
-        console?: boolean | undefined;
+        level: "debug" | "info" | "warn" | "error" | "notice";
+        console: boolean;
     }>;
     web: z.ZodObject<{
-        prefix: z.ZodOptional<z.ZodString>;
+        prefix: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        prefix?: string | undefined;
+        prefix: string;
     }, {
-        prefix?: string | undefined;
+        prefix: string;
     }>;
 }, "strip", z.ZodTypeAny, {
-    log: {
-        level?: "warn" | "error" | "debug" | "notice" | "info" | undefined;
-        console?: boolean | undefined;
-    };
     debug: boolean;
     auth: {
-        debug?: boolean | undefined;
-        credentials?: boolean | undefined;
-        secret?: string | undefined;
-        secure_cookies?: boolean | undefined;
+        debug: boolean;
+        credentials: boolean;
+        secret: string;
+        secure_cookies: boolean;
     };
     db: {
-        host?: string | undefined;
-        port?: number | undefined;
-        password?: string | undefined;
-        user?: string | undefined;
-        database?: string | undefined;
+        host: string;
+        port: number;
+        password: string;
+        user: string;
+        database: string;
+    };
+    log: {
+        level: "debug" | "info" | "warn" | "error" | "notice";
+        console: boolean;
     };
     web: {
-        prefix?: string | undefined;
+        prefix: string;
     };
 }, {
-    log: {
-        level?: "warn" | "error" | "debug" | "notice" | "info" | undefined;
-        console?: boolean | undefined;
-    };
     debug: boolean;
     auth: {
-        debug?: boolean | undefined;
-        credentials?: boolean | undefined;
-        secret?: string | undefined;
-        secure_cookies?: boolean | undefined;
+        debug: boolean;
+        credentials: boolean;
+        secret: string;
+        secure_cookies: boolean;
     };
     db: {
-        host?: string | undefined;
-        port?: number | undefined;
-        password?: string | undefined;
-        user?: string | undefined;
-        database?: string | undefined;
+        host: string;
+        port: number;
+        password: string;
+        user: string;
+        database: string;
+    };
+    log: {
+        level: "debug" | "info" | "warn" | "error" | "notice";
+        console: boolean;
     };
     web: {
-        prefix?: string | undefined;
+        prefix: string;
     };
 }>;
+export interface Config extends Record<string, unknown>, z.infer<typeof Schema> {
+}
+export declare const configFiles: Map<string, PartialRecursive<Config>>;
+export declare const config: {
+    auth: {
+        credentials: false;
+        debug: false;
+        secret: string;
+        secure_cookies: true;
+    };
+    db: {
+        database: string;
+        host: string;
+        password: string;
+        port: number;
+        user: string;
+    };
+    debug: false;
+    log: {
+        console: true;
+        level: "info";
+    };
+    web: {
+        prefix: string;
+    };
+    findPath: typeof findConfigPath;
+    load: typeof loadConfig;
+    loadDefaults: typeof loadDefaultConfigs;
+    save: typeof saveConfig;
+    saveTo: typeof saveConfigTo;
+    set: typeof setConfig;
+    files: Map<string, PartialRecursive<Config>>;
+};
+export default config;
 export declare const File: z.ZodObject<z.objectUtil.extendShape<{
     auth: z.ZodOptional<z.ZodObject<{
-        credentials: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
-        debug: z.ZodOptional<z.ZodOptional<z.ZodOptional<z.ZodBoolean>>>;
-        secret: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-        secure_cookies: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        credentials: z.ZodOptional<z.ZodBoolean>;
+        debug: z.ZodOptional<z.ZodBoolean>;
+        secret: z.ZodOptional<z.ZodString>;
+        secure_cookies: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         debug?: boolean | undefined;
         credentials?: boolean | undefined;
@@ -176,13 +150,12 @@ export declare const File: z.ZodObject<z.objectUtil.extendShape<{
         secret?: string | undefined;
         secure_cookies?: boolean | undefined;
     }>>;
-    debug: z.ZodOptional<z.ZodBoolean>;
     db: z.ZodOptional<z.ZodObject<{
-        host: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-        port: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
-        password: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-        user: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-        database: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+        password: z.ZodOptional<z.ZodString>;
+        user: z.ZodOptional<z.ZodString>;
+        database: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         host?: string | undefined;
         port?: number | undefined;
@@ -196,18 +169,19 @@ export declare const File: z.ZodObject<z.objectUtil.extendShape<{
         user?: string | undefined;
         database?: string | undefined;
     }>>;
+    debug: z.ZodOptional<z.ZodBoolean>;
     log: z.ZodOptional<z.ZodObject<{
-        level: z.ZodOptional<z.ZodOptional<z.ZodEnum<["error", "warn", "notice", "info", "debug"]>>>;
-        console: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        level: z.ZodOptional<z.ZodEnum<["error", "warn", "notice", "info", "debug"]>>;
+        console: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
-        level?: "warn" | "error" | "debug" | "notice" | "info" | undefined;
+        level?: "debug" | "info" | "warn" | "error" | "notice" | undefined;
         console?: boolean | undefined;
     }, {
-        level?: "warn" | "error" | "debug" | "notice" | "info" | undefined;
+        level?: "debug" | "info" | "warn" | "error" | "notice" | undefined;
         console?: boolean | undefined;
     }>>;
     web: z.ZodOptional<z.ZodObject<{
-        prefix: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        prefix: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         prefix?: string | undefined;
     }, {
@@ -216,10 +190,6 @@ export declare const File: z.ZodObject<z.objectUtil.extendShape<{
 }, {
     include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }>, "strip", z.ZodTypeAny, {
-    log?: {
-        level?: "warn" | "error" | "debug" | "notice" | "info" | undefined;
-        console?: boolean | undefined;
-    } | undefined;
     debug?: boolean | undefined;
     auth?: {
         debug?: boolean | undefined;
@@ -234,15 +204,15 @@ export declare const File: z.ZodObject<z.objectUtil.extendShape<{
         user?: string | undefined;
         database?: string | undefined;
     } | undefined;
+    log?: {
+        level?: "debug" | "info" | "warn" | "error" | "notice" | undefined;
+        console?: boolean | undefined;
+    } | undefined;
     web?: {
         prefix?: string | undefined;
     } | undefined;
     include?: string[] | undefined;
 }, {
-    log?: {
-        level?: "warn" | "error" | "debug" | "notice" | "info" | undefined;
-        console?: boolean | undefined;
-    } | undefined;
     debug?: boolean | undefined;
     auth?: {
         debug?: boolean | undefined;
@@ -257,21 +227,21 @@ export declare const File: z.ZodObject<z.objectUtil.extendShape<{
         user?: string | undefined;
         database?: string | undefined;
     } | undefined;
+    log?: {
+        level?: "debug" | "info" | "warn" | "error" | "notice" | undefined;
+        console?: boolean | undefined;
+    } | undefined;
     web?: {
         prefix?: string | undefined;
     } | undefined;
     include?: string[] | undefined;
 }>;
-export type File = z.infer<typeof File>;
-export interface Config extends z.infer<typeof Config> {
+export interface File extends PartialRecursive<Config>, z.infer<typeof File> {
 }
-export declare let debug: boolean;
-export declare function get(): Config;
 /**
  * Update the current config
  */
-export declare function set(config: PartialRecursive<Config>): void;
-export declare const files: Map<string, PartialRecursive<Config>>;
+export declare function setConfig(other: PartialRecursive<Config>): void;
 export interface LoadOptions {
     /**
      * If enabled, the config file will be not be loaded if it does not match the schema.
@@ -289,17 +259,17 @@ export interface LoadOptions {
 /**
  * Load the config from the provided path
  */
-export declare function load(path: string, options?: LoadOptions): void;
-export declare function loadDefaults(): void;
+export declare function loadConfig(path: string, options?: LoadOptions): void;
+export declare function loadDefaultConfigs(): void;
 /**
  * Update the current config and write the updated config to the appropriate file
  */
-export declare function save(changed: PartialRecursive<Config>, global?: boolean): void;
+export declare function saveConfig(changed: PartialRecursive<Config>, global?: boolean): void;
 /**
  * Update the current config and write the updated config to the provided path
  */
-export declare function saveTo(path: string, changed: PartialRecursive<Config>): void;
+export declare function saveConfigTo(path: string, changed: PartialRecursive<Config>): void;
 /**
  * Find the path to the config file
  */
-export declare function findPath(global: boolean): string;
+export declare function findConfigPath(global: boolean): string;

package/dist/config.js

@@ -2,87 +2,81 @@
 import { levelText } from 'logzen';
 import { readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path/posix';
-import { assignWithDefaults } from 'utilium';
+import { deepAssign } from 'utilium';
 import * as z from 'zod';
 import { findDir, logger, output } from './io.js';
-export const Database = z.object({
-    host: z.string(),
-    port: z.number(),
-    password: z.string(),
-    user: z.string(),
-    database: z.string(),
-});
-export const db = {
-    host: process.env.PGHOST || 'localhost',
-    port: process.env.PGPORT && Number.isSafeInteger(parseInt(process.env.PGPORT)) ? parseInt(process.env.PGPORT) : 5432,
-    password: process.env.PGPASSWORD || '',
-    user: process.env.PGUSER || 'axium',
-    database: process.env.PGDATABASE || 'axium',
-};
-export const Auth = z.object({
-    credentials: z.boolean(),
-    debug: z.boolean().optional(),
-    secret: z.string(),
-    secure_cookies: z.boolean(),
-});
-export const auth = {
-    credentials: false,
-    secret: '',
-    secure_cookies: false,
-};
-export const Log = z.object({
-    level: z.enum(levelText),
-    console: z.boolean(),
-});
-export const log = {
-    level: 'info',
-    console: true,
-};
-export const Web = z.object({
-    prefix: z.string(),
-});
-export const web = {
-    prefix: '',
-};
-export const Config = z.object({
-    auth: Auth.partial(),
+export const Schema = z.object({
+    auth: z.object({
+        credentials: z.boolean(),
+        debug: z.boolean(),
+        secret: z.string(),
+        secure_cookies: z.boolean(),
+    }),
+    db: z.object({
+        host: z.string(),
+        port: z.number(),
+        password: z.string(),
+        user: z.string(),
+        database: z.string(),
+    }),
     debug: z.boolean(),
-    db: Database.partial(),
-    log: Log.partial(),
-    web: Web.partial(),
+    log: z.object({
+        level: z.enum(levelText),
+        console: z.boolean(),
+    }),
+    web: z.object({
+        prefix: z.string(),
+    }),
 });
+export const configFiles = new Map();
+export const config = {
+    auth: {
+        credentials: false,
+        debug: false,
+        secret: '',
+        secure_cookies: true,
+    },
+    db: {
+        database: process.env.PGDATABASE || 'axium',
+        host: process.env.PGHOST || 'localhost',
+        password: process.env.PGPASSWORD || '',
+        port: process.env.PGPORT && Number.isSafeInteger(parseInt(process.env.PGPORT)) ? parseInt(process.env.PGPORT) : 5432,
+        user: process.env.PGUSER || 'axium',
+    },
+    debug: false,
+    log: {
+        console: true,
+        level: 'info',
+    },
+    web: {
+        prefix: '',
+    },
+    findPath: findConfigPath,
+    load: loadConfig,
+    loadDefaults: loadDefaultConfigs,
+    save: saveConfig,
+    saveTo: saveConfigTo,
+    set: setConfig,
+    files: configFiles,
+};
+export default config;
 // config from file
-export const File = Config.deepPartial().extend({
+export const File = Schema.deepPartial().extend({
     include: z.array(z.string()).optional(),
 });
-export let debug = false;
-export function get() {
-    return {
-        auth,
-        db,
-        debug,
-        log,
-        web,
-    };
-}
 /**
  * Update the current config
  */
-export function set(config) {
-    assignWithDefaults(auth, config.auth ?? {});
-    debug = config.debug ?? debug;
-    assignWithDefaults(db, config.db ?? {});
-    assignWithDefaults(log, config.log ?? {});
-    assignWithDefaults(web, config.web ?? {});
+export function setConfig(other) {
+    deepAssign(config, other);
     logger.detach(output);
-    if (log.console)
-        logger.attach(output, { output: log.level });
+    if (config.log.console)
+        logger.attach(output, { output: config.log.level });
 }
-export const files = new Map();
 /**
  * Load the config from the provided path
  */
-export function load(path, options = {}) {
+export function loadConfig(path, options = {}) {
     let json;
     try {
         json = JSON.parse(readFileSync(path, 'utf8'));
@@ -90,42 +84,42 @@ export function load(path, options = {}) {
     catch (e) {
         if (!options.optional)
             throw e;
-        debug && output.debug(`Skipping config at ${path} (${e.message})`);
+        config.debug && output.debug(`Skipping config at ${path} (${e.message})`);
         return;
     }
-    const config = options.strict ? File.parse(json) : json;
-    files.set(path, config);
-    set(config);
-    for (const include of config.include ?? [])
-        load(join(dirname(path), include), { optional: true });
+    const file = options.strict ? File.parse(json) : json;
+    configFiles.set(path, file);
+    setConfig(file);
+    for (const include of file.include ?? [])
+        loadConfig(join(dirname(path), include), { optional: true });
 }
-export function loadDefaults() {
-    load(findPath(true), { optional: true });
-    load(findPath(false), { optional: true });
+export function loadDefaultConfigs() {
+    loadConfig(findConfigPath(true), { optional: true });
+    loadConfig(findConfigPath(false), { optional: true });
 }
 /**
  * Update the current config and write the updated config to the appropriate file
  */
-export function save(changed, global = false) {
-    saveTo(process.env.AXIUM_CONFIG ?? findPath(global), changed);
+export function saveConfig(changed, global = false) {
+    saveConfigTo(process.env.AXIUM_CONFIG ?? findConfigPath(global), changed);
 }
 /**
  * Update the current config and write the updated config to the provided path
  */
-export function saveTo(path, changed) {
-    set(changed);
-    const config = files.get(path) ?? {};
+export function saveConfigTo(path, changed) {
+    setConfig(changed);
+    const config = configFiles.get(path) ?? {};
     Object.assign(config, { ...changed, db: { ...config.db, ...changed.db } });
-    debug && output.debug(`Wrote config to ${path}`);
+    config.debug && output.debug(`Wrote config to ${path}`);
     writeFileSync(path, JSON.stringify(config));
 }
 /**
  * Find the path to the config file
  */
-export function findPath(global) {
+export function findConfigPath(global) {
     if (process.env.AXIUM_CONFIG)
         return process.env.AXIUM_CONFIG;
     return join(findDir(global), 'config.json');
 }
 if (process.env.AXIUM_CONFIG)
-    load(process.env.AXIUM_CONFIG);
+    loadConfig(process.env.AXIUM_CONFIG);

package/dist/database.d.ts

@@ -1,7 +1,6 @@
 import type { AdapterAccountType as db } from '@auth/core/adapters';
 import { Kysely, type GeneratedAlways } from 'kysely';
 import type { Preferences } from './auth.js';
-import * as config from './config.js';
 import { type MaybeOutput, type WithOutput } from './io.js';
 export interface Schema {
     User: {
@@ -67,7 +66,7 @@ export interface InitOptions extends OpOptions {
     skip: boolean;
 }
 export declare function shouldRecreate(opt: InitOptions & WithOutput): boolean;
-export declare function init(opt: InitOptions): Promise<config.Database>;
+export declare function init(opt: InitOptions): Promise<void>;
 /**
  * Completely remove Axium from the database.
  */

package/dist/database.js

@@ -53,8 +53,9 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 import { Kysely, PostgresDialect, sql } from 'kysely';
 import { randomBytes } from 'node:crypto';
 import pg from 'pg';
-import * as config from './config.js';
+import config from './config.js';
 import { _fixOutput, run, someWarnings } from './io.js';
+import { plugins } from './plugins.js';
 export let database;
 export function connect() {
     if (database)
@@ -107,7 +108,7 @@ export async function init(opt) {
             opt.output('debug', 'Generated password and wrote to global config');
         }
         const _sql = (command, message) => run(opt, message, `sudo -u postgres psql -c "${command}"`);
-        const relationExists = someWarnings(opt.output, [/relation "\w+" already exists/, 'already exists.']);
+        const warnExists = someWarnings(opt.output, [/(schema|relation) "\w+" already exists/, 'already exists.']);
         const done = () => opt.output('done');
         await _sql('CREATE DATABASE axium', 'Creating database').catch(async (error) => {
             if (error != 'database "axium" already exists')
@@ -145,7 +146,7 @@ export async function init(opt) {
             .addColumn('preferences', 'jsonb', col => col.notNull().defaultTo(sql `'{}'::jsonb`))
             .execute()
             .then(done)
-            .catch(relationExists);
+            .catch(warnExists);
         opt.output('start', 'Creating table Account');
         await db.schema
             .createTable('Account')
@@ -163,9 +164,9 @@ export async function init(opt) {
             .addColumn('session_state', 'text')
             .execute()
             .then(done)
-            .catch(relationExists);
+            .catch(warnExists);
         opt.output('start', 'Creating index for Account.userId');
-        await db.schema.createIndex('Account_userId_index').on('Account').column('userId').execute().then(done).catch(relationExists);
+        await db.schema.createIndex('Account_userId_index').on('Account').column('userId').execute().then(done).catch(warnExists);
         opt.output('start', 'Creating table Session');
         await db.schema
             .createTable('Session')
@@ -175,9 +176,9 @@ export async function init(opt) {
             .addColumn('expires', 'timestamptz', col => col.notNull())
             .execute()
             .then(done)
-            .catch(relationExists);
+            .catch(warnExists);
         opt.output('start', 'Creating index for Session.userId');
-        await db.schema.createIndex('Session_userId_index').on('Session').column('userId').execute().then(done).catch(relationExists);
+        await db.schema.createIndex('Session_userId_index').on('Session').column('userId').execute().then(done).catch(warnExists);
         opt.output('start', 'Creating table VerificationToken');
         await db.schema
             .createTable('VerificationToken')
@@ -186,7 +187,7 @@ export async function init(opt) {
             .addColumn('expires', 'timestamptz', col => col.notNull())
             .execute()
             .then(done)
-            .catch(relationExists);
+            .catch(warnExists);
         opt.output('start', 'Creating table Authenticator');
         await db.schema
             .createTable('Authenticator')
@@ -200,10 +201,15 @@ export async function init(opt) {
             .addColumn('transports', 'text')
             .execute()
             .then(done)
-            .catch(relationExists);
+            .catch(warnExists);
         opt.output('start', 'Creating index for Authenticator.credentialID');
-        await db.schema.createIndex('Authenticator_credentialID_key').on('Authenticator').column('credentialID').execute().then(done).catch(relationExists);
-        return config.db;
+        await db.schema.createIndex('Authenticator_credentialID_key').on('Authenticator').column('credentialID').execute().then(done).catch(warnExists);
+        for (const plugin of plugins) {
+            if (!plugin.db)
+                continue;
+            opt.output('plugin', plugin.name);
+            await plugin.db.init(opt, db, { warnExists, done });
+        }
     }
     catch (e_1) {
         env_1.error = e_1;
@@ -220,6 +226,14 @@ export async function init(opt) {
  */
 export async function uninstall(opt) {
     _fixOutput(opt);
+    const db = connect();
+    for (const plugin of plugins) {
+        if (!plugin.db)
+            continue;
+        opt.output('plugin', plugin.name);
+        await plugin.db.remove(opt, db);
+    }
+    await db.destroy();
     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');
@@ -231,6 +245,12 @@ export async function uninstall(opt) {
 export async function wipe(opt) {
     _fixOutput(opt);
     const db = connect();
+    for (const plugin of plugins) {
+        if (!plugin.db)
+            continue;
+        opt.output('plugin', plugin.name);
+        await plugin.db.wipe(opt, db);
+    }
     for (const table of ['User', 'Account', 'Session', 'VerificationToken', 'Authenticator']) {
         opt.output('start', `Removing data from ${table}`);
         await db.deleteFrom(table).execute();

package/dist/io.d.ts

@@ -25,10 +25,10 @@ export declare function run(opts: WithOutput & {
 /** Yet another convenience function */
 export declare function exit(message: string | Error, code?: number): never;
 export declare function handleError(e: number | string | Error): void;
-export type OutputState = 'done' | 'log' | 'warn' | 'error' | 'start' | 'debug';
+export type OutputTag = 'debug' | 'info' | 'warn' | 'error' | 'start' | 'done' | 'plugin';
 export interface Output {
-    (state: 'done'): void;
-    (state: Exclude<OutputState, 'done'>, message: string): void;
+    (tag: 'done'): void;
+    (tag: Exclude<OutputTag, 'done'>, message: string): void;
 }
 export interface MaybeOutput {
     output?: Output | null | false;
@@ -36,8 +36,8 @@ export interface MaybeOutput {
 export interface WithOutput {
     output: Output;
 }
-export declare function defaultOutput(state: 'done'): void;
-export declare function defaultOutput(state: Exclude<OutputState, 'done'>, message: string): void;
+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

package/dist/io.js

@@ -4,7 +4,7 @@ import * as fs from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path/posix';
 import { styleText } from 'node:util';
-import { debug } from './config.js';
+import config from './config.js';
 /**
  * Find the Axium directory.
  * This directory includes things like config files, secrets, etc.
@@ -81,15 +81,12 @@ export function handleError(e) {
     else
         exit(e);
 }
-export function defaultOutput(state, message = '') {
-    switch (state) {
-        case 'start':
-            process.stdout.write(message + '... ');
-            break;
+export function defaultOutput(tag, message = '') {
+    switch (tag) {
         case 'debug':
-            debug && output.debug(message);
+            config.debug && output.debug(message);
             break;
-        case 'log':
+        case 'info':
             console.log(message);
             break;
         case 'warn':
@@ -98,9 +95,14 @@ export function defaultOutput(state, message = '') {
         case 'error':
             console.error(styleText('red', message));
             break;
+        case 'start':
+            process.stdout.write(message + '... ');
+            break;
         case 'done':
             console.log('done.');
             break;
+        case 'plugin':
+            console.log(styleText('whiteBright', 'Running plugin: ' + message));
     }
 }
 /**

package/dist/plugins.d.ts

@@ -0,0 +1,51 @@
+import * as z from 'zod';
+export declare const Plugin: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    statusText: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>>;
+    db: z.ZodOptional<z.ZodObject<{
+        init: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
+        remove: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
+        wipe: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        init: (...args: unknown[]) => unknown;
+        remove: (...args: unknown[]) => unknown;
+        wipe: (...args: unknown[]) => unknown;
+    }, {
+        init: (...args: unknown[]) => unknown;
+        remove: (...args: unknown[]) => unknown;
+        wipe: (...args: unknown[]) => unknown;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    version: string;
+    db?: {
+        init: (...args: unknown[]) => unknown;
+        remove: (...args: unknown[]) => unknown;
+        wipe: (...args: unknown[]) => unknown;
+    } | undefined;
+    description?: string | undefined;
+    statusText?: ((...args: unknown[]) => string | Promise<string>) | undefined;
+}, {
+    name: string;
+    id: string;
+    version: string;
+    db?: {
+        init: (...args: unknown[]) => unknown;
+        remove: (...args: unknown[]) => unknown;
+        wipe: (...args: unknown[]) => unknown;
+    } | undefined;
+    description?: string | undefined;
+    statusText?: ((...args: unknown[]) => string | Promise<string>) | undefined;
+}>;
+export interface Plugin extends z.infer<typeof Plugin> {
+}
+export declare const plugins: Set<Plugin>;
+export declare function resolvePlugin(search: string): Plugin | undefined;
+export declare function pluginText(plugin: Plugin): string;
+export declare function loadPlugin(path: string): Promise<void>;
+export declare function loadPlugins(dir: string): Promise<void>;
+export declare function loadDefaultPlugins(): Promise<void>;

package/dist/plugins.js

@@ -0,0 +1,68 @@
+import * as fs from 'node:fs';
+import { join, resolve } from 'node:path/posix';
+import { styleText } from 'node:util';
+import * as z from 'zod';
+import { findDir, output } from './io.js';
+import { fromZodError } from 'zod-validation-error';
+export const Plugin = z.object({
+    id: z.string(),
+    name: z.string(),
+    version: z.string(),
+    description: z.string().optional(),
+    statusText: z
+        .function()
+        .args()
+        .returns(z.union([z.string(), z.promise(z.string())]))
+        .optional(),
+    db: z
+        .object({
+        init: z.function(),
+        remove: z.function(),
+        wipe: z.function(),
+    })
+        .optional(),
+});
+export const plugins = new Set();
+export function resolvePlugin(search) {
+    for (const plugin of plugins) {
+        if (plugin.name.startsWith(search) || plugin.id.startsWith(search))
+            return plugin;
+    }
+}
+export function pluginText(plugin) {
+    return [
+        styleText('whiteBright', plugin.name),
+        plugin.id,
+        `Version: ${plugin.version}`,
+        `Description: ${plugin.description ?? styleText('dim', '(none)')}`,
+        `Status text integration: ${plugin.statusText ? styleText('whiteBright', 'yes') : styleText('yellow', 'no')}`,
+        `Database integration: ${plugin.db ? 'yes' : 'no'}`,
+    ].join('\n');
+}
+export async function loadPlugin(path) {
+    path = resolve(path);
+    const stats = fs.statSync(path);
+    if (stats.isDirectory() || !['.js', '.mjs'].some(ext => path.endsWith(ext)))
+        return;
+    try {
+        const plugin = await Plugin.parseAsync(await import(path)).catch(e => {
+            throw fromZodError(e);
+        });
+        plugins.add(plugin);
+        output.debug(`Loaded plugin: "${plugin.name}" (${plugin.id}) ${plugin.version}`);
+    }
+    catch (e) {
+        output.debug(`Failed to load plugin from ${path}: ${e}`);
+    }
+}
+export async function loadPlugins(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+        await loadPlugin(join(dir, file));
+    }
+}
+export async function loadDefaultPlugins() {
+    await loadPlugins(join(findDir(true), 'plugins'));
+    await loadPlugins(join(findDir(false), 'plugins'));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@axium/server",
-	"version": "0.5.3",
+	"version": "0.6.1",
 	"author": "James Prevett <axium@jamespre.dev> (https://jamespre.dev)",
 	"funding": {
 		"type": "individual",
@@ -46,7 +46,7 @@
 		"kysely": "^0.27.5",
 		"logzen": "^0.6.2",
 		"pg": "^8.14.1",
-		"utilium": "^2.2.3",
+		"utilium": "^2.3.0",
 		"zod-validation-error": "^3.4.0"
 	},
 	"devDependencies": {

package/web/auth.ts

@@ -2,11 +2,11 @@ import { SvelteKitAuth } from '@auth/sveltekit';
 import { createWriteStream } from 'node:fs';
 import { join } from 'node:path/posix';
 import { getConfig } from '../dist/auth.js';
-import { loadDefaults as loadDefaultConfigs } from '../dist/config.js';
+import config from '../dist/config.js';
 import { findDir, logger } from '../dist/io.js';
 import { allLogLevels } from 'logzen';
 
 logger.attach(createWriteStream(join(findDir(false), 'server.log')), { output: allLogLevels });
-loadDefaultConfigs();
+config.loadDefaults();
 
 export const { handle, signIn, signOut } = SvelteKitAuth(getConfig());

package/web/routes/signup/+page.server.ts

@@ -1,5 +1,5 @@
 import { redirect } from '@sveltejs/kit';
-import * as config from '../../../dist/config.js';
+import config from '../../../dist/config.js';
 import { signup } from '../../actions.js';
 import type { Actions } from './$types.js';
 

package/web/utils.ts

@@ -3,12 +3,12 @@ import type { ActionFailure, RequestEvent } from '@sveltejs/kit';
 import { fail, redirect } from '@sveltejs/kit';
 import type * as z from 'zod';
 import { fromError } from 'zod-validation-error';
-import { web } from '../dist/config.js';
+import config from '../dist/config.js';
 
 export async function loadSession(event: RequestEvent): Promise<{ session: Session }> {
 	const session = await event.locals.auth();
 	if (!session) redirect(307, '/auth/signin');
-	if (!session.user.name && event.url.pathname != web.prefix + '/name') redirect(307, web.prefix + '/name');
+	if (!session.user.name && event.url.pathname != config.web.prefix + '/name') redirect(307, config.web.prefix + '/name');
 	return { session };
 }