@axium/server 0.0.1

package/dist/cli.js

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import chalk from 'chalk';
+import { Option, program } from 'commander';
+import { sql } from 'kysely';
+import { exec } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import * as _db from './database.js';
+program.version('0.0.0').name('axium').description('Axium server CLI');
+// Options shared by multiple commands
+const opts = {
+    host: new Option('-H, --host <host>', 'the host of the database.').default('localhost:5432'),
+    timeout: new Option('-t, --timeout <ms>', 'how long to wait for commands to complete.').default(1000),
+    force: new Option('-f, --force', 'force the operation').default(false),
+    verbose: new Option('-v, --verbose', 'verbose output').default(false),
+};
+const axiumDB = program.command('db').alias('database').description('manage the database');
+/** Convenience function for `example... [Done. / error]` */
+async function report(promise, message, success = 'done.') {
+    process.stdout.write(message + '... ');
+    try {
+        const result = await promise;
+        console.log(success);
+        return result;
+    }
+    catch (error) {
+        throw typeof error == 'object' && 'message' in error ? error.message : error;
+    }
+}
+/** Convenience function for `sudo -u postgres psql -c "${command}"`, plus `report` coolness */
+async function runSQL(opts, command, message) {
+    let stderr;
+    try {
+        process.stdout.write(message + '... ');
+        const { promise, resolve, reject } = Promise.withResolvers();
+        exec(`sudo -u postgres psql -c "${command}"`, { timeout: 1000, ...opts }, (err, _, _stderr) => {
+            stderr = _stderr.startsWith('ERROR:') ? _stderr.slice(6).trim() : _stderr;
+            if (err)
+                reject('[command]');
+            else
+                resolve();
+        });
+        await promise;
+        console.log('done.');
+    }
+    catch (error) {
+        throw error == '[command]' ? stderr?.slice(0, 100) || 'failed.' : typeof error == 'object' && 'message' in error ? error.message : error;
+    }
+}
+function err(message) {
+    if (message instanceof Error)
+        message = message.message;
+    console.error(message.startsWith('\x1b') ? message : chalk.red(message));
+}
+/** Yet another convenience function */
+function exit(message, code = 1) {
+    err(message);
+    process.exit(code);
+}
+function shouldRecreate(opt) {
+    if (opt.skip) {
+        console.warn(chalk.yellow('already exists. (skipped)'));
+        return true;
+    }
+    if (opt.force) {
+        console.warn(chalk.yellow('already exists. (re-creating)'));
+        return false;
+    }
+    console.warn(chalk.yellow('already exists. Use --skip to skip or --force to re-create.'));
+    process.exit(2);
+}
+axiumDB
+    .command('init')
+    .description('initialize the database')
+    .addOption(opts.host)
+    .addOption(opts.timeout)
+    .addOption(opts.force)
+    .addOption(opts.verbose)
+    .option('-s, --skip', 'Skip existing database and/or user')
+    .action(async (opt) => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        opt.verbose && opt.force && console.log(chalk.yellow('--force: Protections disabled.'));
+        const config = _db.normalizeConfig(opt);
+        config.password ??= process.env.PGPASSWORD || randomBytes(32).toString('base64').replaceAll('=', '').replaceAll('/', '_').replaceAll('+', '-');
+        await runSQL(opt, 'CREATE DATABASE axium', 'Creating database')
+            .catch(async (error) => {
+            if (error != 'database "axium" already exists')
+                exit(error);
+            if (shouldRecreate(opt))
+                return;
+            await runSQL(opt, 'DROP DATABASE axium', 'Dropping database');
+            await runSQL(opt, 'CREATE DATABASE axium', 'Re-creating database');
+        })
+            .catch(exit);
+        const createQuery = `CREATE USER axium WITH ENCRYPTED PASSWORD '${config.password}' LOGIN`;
+        await runSQL(opt, createQuery, 'Creating user')
+            .catch(async (error) => {
+            if (error != 'role "axium" already exists')
+                exit(error);
+            if (shouldRecreate(opt))
+                return;
+            await runSQL(opt, 'REVOKE ALL PRIVILEGES ON SCHEMA public FROM axium', 'Revoking schema privileges');
+            await runSQL(opt, 'DROP USER axium', 'Dropping user');
+            await runSQL(opt, createQuery, 'Re-creating user');
+        })
+            .catch(exit);
+        await runSQL(opt, 'GRANT ALL PRIVILEGES ON DATABASE axium TO axium', 'Granting database privileges').catch(exit);
+        await runSQL(opt, 'GRANT ALL PRIVILEGES ON SCHEMA public TO axium', 'Granting schema privileges').catch(exit);
+        await runSQL(opt, 'ALTER DATABASE axium OWNER TO axium', 'Setting database owner').catch(exit);
+        await runSQL(opt, 'SELECT pg_reload_conf()', 'Reloading configuration').catch(exit);
+        const db = __addDisposableResource(env_1, _db.connect(config), true);
+        const relationExists = (table) => (error) => (error == `relation "${table}" already exists` ? console.warn(chalk.yellow('already exists.')) : exit(error));
+        const created = chalk.green('created.');
+        await report(db.schema
+            .createTable('User')
+            .addColumn('id', 'uuid', col => col.primaryKey().defaultTo(sql `gen_random_uuid()`))
+            .addColumn('name', 'text')
+            .addColumn('email', 'text', col => col.unique().notNull())
+            .addColumn('emailVerified', 'timestamptz')
+            .addColumn('image', 'text')
+            .execute(), 'Creating table User', created).catch(relationExists('User'));
+        await report(db.schema
+            .createTable('Account')
+            .addColumn('id', 'uuid', col => col.primaryKey().defaultTo(sql `gen_random_uuid()`))
+            .addColumn('userId', 'uuid', col => col.references('User.id').onDelete('cascade').notNull())
+            .addColumn('type', 'text', col => col.notNull())
+            .addColumn('provider', 'text', col => col.notNull())
+            .addColumn('providerAccountId', 'text', col => col.notNull())
+            .addColumn('refresh_token', 'text')
+            .addColumn('access_token', 'text')
+            .addColumn('expires_at', 'bigint')
+            .addColumn('token_type', 'text')
+            .addColumn('scope', 'text')
+            .addColumn('id_token', 'text')
+            .addColumn('session_state', 'text')
+            .execute(), 'Creating table Account', created).catch(relationExists('Account'));
+        await report(db.schema.createIndex('Account_userId_index').on('Account').column('userId').execute(), 'Creating index for Account.userId', created).catch(relationExists('Account_userId_index'));
+        await report(db.schema
+            .createTable('Session')
+            .addColumn('id', 'uuid', col => col.primaryKey().defaultTo(sql `gen_random_uuid()`))
+            .addColumn('userId', 'uuid', col => col.references('User.id').onDelete('cascade').notNull())
+            .addColumn('sessionToken', 'text', col => col.notNull().unique())
+            .addColumn('expires', 'timestamptz', col => col.notNull())
+            .execute(), 'Creating table Session', created).catch(relationExists('Session'));
+        await report(db.schema.createIndex('Session_userId_index').on('Session').column('userId').execute(), 'Creating index for Session.userId', created).catch(relationExists('Session_userId_index'));
+        await report(db.schema
+            .createTable('VerificationToken')
+            .addColumn('identifier', 'text', col => col.notNull())
+            .addColumn('token', 'text', col => col.notNull().unique())
+            .addColumn('expires', 'timestamptz', col => col.notNull())
+            .execute(), 'Creating table VerificationToken', created).catch(relationExists('VerificationToken'));
+        await report(db.schema
+            .createTable('Authenticator')
+            .addColumn('credentialID', 'text', col => col.primaryKey().notNull())
+            .addColumn('userId', 'uuid', col => col.notNull().references('User.id').onDelete('cascade').onUpdate('cascade'))
+            .addColumn('providerAccountId', 'text', col => col.notNull())
+            .addColumn('credentialPublicKey', 'text', col => col.notNull())
+            .addColumn('counter', 'integer', col => col.notNull())
+            .addColumn('credentialDeviceType', 'text', col => col.notNull())
+            .addColumn('credentialBackedUp', 'boolean', col => col.notNull())
+            .addColumn('transports', 'text')
+            .execute(), 'Creating table Authenticator', created).catch(relationExists('Authenticator'));
+        await report(db.schema.createIndex('Authenticator_credentialID_key').on('Authenticator').column('credentialID').execute(), 'Creating index for Authenticator.credentialID', created).catch(relationExists('Authenticator_credentialID_key'));
+        console.log('Done!\nPassword: ' + config.password);
+    }
+    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('status')
+    .alias('stats')
+    .description('check the status of the database')
+    .addOption(opts.host)
+    .addOption(opts.verbose)
+    .action(async (opt) => _db
+    .statusText(opt)
+    .then(console.log)
+    .catch(() => exit('Unavailable')));
+axiumDB
+    .command('drop')
+    .description('drop the database')
+    .addOption(opts.host)
+    .addOption(opts.verbose)
+    .addOption(opts.force)
+    .addOption(opts.timeout)
+    .action(async (opt) => {
+    opt.verbose && opt.force && console.log(chalk.yellow('--force: Protections disabled.'));
+    _db.normalizeConfig(opt);
+    const stats = await _db.status(opt).catch(exit);
+    if (!opt.force)
+        for (const key of ['users', 'accounts', 'sessions']) {
+            if (stats[key] == 0)
+                continue;
+            console.warn(chalk.yellow(`Database has existing ${key}. Use --force if you really want to drop the database.`));
+            process.exit(2);
+        }
+    await runSQL(opt, 'DROP DATABASE axium', 'Dropping database').catch(exit);
+    await runSQL(opt, 'REVOKE ALL PRIVILEGES ON SCHEMA public FROM axium', 'Revoking schema privileges').catch(exit);
+    await runSQL(opt, 'DROP USER axium', 'Dropping user').catch(exit);
+});
+program
+    .command('status')
+    .alias('stats')
+    .description('get information about the server')
+    .option('-D --db-host <host>', 'the host of the database.', 'localhost:5432')
+    .action(async (opt) => {
+    console.log('Axium Server v' + program.version());
+    process.stdout.write('Database: ');
+    await _db
+        .statusText({ host: opt.dbHost })
+        .then(console.log)
+        .catch(() => err('Unavailable'));
+});
+program.parse();

package/dist/database.js

@@ -0,0 +1,116 @@
+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 { Kysely, PostgresDialect, sql } from 'kysely';
+import pg from 'pg';
+export function normalizeConfig(config) {
+    config.host ??= 'localhost';
+    if (!config.port) {
+        const [hostname, port] = config.host.split(':');
+        config.port = port ? parseInt(port) : 5432;
+        config.host = hostname;
+    }
+    if (config.host.includes(':'))
+        config.host = config.host.split(':')[0];
+    return config;
+}
+export let database;
+export function connect(config) {
+    if (database)
+        return database;
+    normalizeConfig(config);
+    const _db = new Kysely({
+        dialect: new PostgresDialect({
+            pool: new pg.Pool({
+                ...config,
+                user: 'axium',
+                database: 'axium',
+            }),
+        }),
+    });
+    database = Object.assign(_db, {
+        async [Symbol.asyncDispose]() {
+            await _db.destroy();
+        },
+    });
+    return database;
+}
+export async function status(config) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        normalizeConfig(config);
+        const db = __addDisposableResource(env_1, connect(config), true);
+        return {
+            users: (await db.selectFrom('User').select(db.fn.countAll().as('count')).executeTakeFirstOrThrow()).count,
+            accounts: (await db.selectFrom('Account').select(db.fn.countAll().as('count')).executeTakeFirstOrThrow()).count,
+            sessions: (await db.selectFrom('Session').select(db.fn.countAll().as('count')).executeTakeFirstOrThrow()).count,
+        };
+    }
+    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;
+    }
+}
+export async function statusText(config) {
+    try {
+        const stats = await status(config);
+        return `${stats.users} users, ${stats.accounts} accounts, ${stats.sessions} sessions`;
+    }
+    catch (error) {
+        throw typeof error == 'object' && 'message' in error ? error.message : error;
+    }
+}

package/dist/index.js

@@ -0,0 +1 @@
+export * as db from './database.js';

package/package.json

@@ -0,0 +1,37 @@
+{
+	"name": "@axium/server",
+	"version": "0.0.1",
+	"main": "dist/index.js",
+	"author": "James Prevett <axium@jamespre.dev> (https://jamespre.dev)",
+	"funding": {
+		"type": "individual",
+		"url": "https://github.com/sponsors/james-pre"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/james-pre/axium.git"
+	},
+	"homepage": "https://github.com/james-pre/axium#readme",
+	"bugs": {
+		"url": "https://github.com/james-pre/axium/issues"
+	},
+	"types": "dist/index.d.ts",
+	"type": "module",
+	"files": [
+		"dist"
+	],
+	"bin": {
+		"axium": "./dist/cli.js"
+	},
+	"scripts": {
+		"build": "tsc"
+	},
+	"dependencies": {
+		"@types/pg": "^8.11.11",
+		"chalk": "^5.4.1",
+		"commander": "^13.1.0",
+		"kysely": "^0.27.5",
+		"pg": "^8.14.1",
+		"@auth/kysely-adapter": "^1.8.0"
+	}
+}