@axium/server 0.0.2 → 0.0.3

package/dist/auth.d.ts

@@ -1,22 +1,28 @@
 import type { Adapter } from '@auth/core/adapters';
 import type { Provider } from '@auth/core/providers';
 import type { AuthConfig } from '@auth/core/types';
-import { Registration } from '@axium/core/api';
+import { Registration } from '@axium/core/schemas';
 declare module '@auth/core/adapters' {
     interface AdapterUser {
-        password: string;
-        salt: string;
+        password: string | null;
+        salt: string | null;
     }
 }
 export declare let adapter: Adapter;
-export declare function createAdapter(): Adapter;
+export declare function createAdapter(): void;
+/**
+ * Login using credentials
+ */
 export declare function register(credentials: Registration): Promise<{
-    user: import("@auth/core/adapters").AdapterUser | undefined;
-    session: import("@auth/core/adapters").AdapterSession | undefined;
+    user: import("@auth/core/adapters").AdapterUser;
+    session: import("@auth/core/adapters").AdapterSession;
 }>;
-export declare function authorize(credentials: Partial<Record<string, unknown>>): Promise<Omit<import("@auth/core/adapters").AdapterUser, "password" | "salt"> | null>;
 /**
- * Get the providers current enabled in the Axium config.
+ * Authorize using credentials
  */
-export declare function getProviders(): Provider[];
-export declare function getConfig(): AuthConfig;
+export declare function authorize(credentials: Partial<Record<string, unknown>>): Promise<Omit<import("@auth/core/adapters").AdapterUser, "password" | "salt"> | null>;
+type Providers = Exclude<Provider, (...args: any[]) => any>[];
+export declare function getConfig(): AuthConfig & {
+    providers: Providers;
+};
+export {};

package/dist/auth.js

@@ -2,17 +2,19 @@ import { CredentialsSignin } from '@auth/core/errors';
 import Credentials from '@auth/core/providers/credentials';
 import Passkey from '@auth/core/providers/passkey';
 import { KyselyAdapter } from '@auth/kysely-adapter';
-import { Login, Registration } from '@axium/core/api';
+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 * as db from './database.js';
+import { logger } from './io.js';
 export let adapter;
 export function createAdapter() {
+    if (adapter)
+        return;
     const conn = db.connect();
     adapter = Object.assign(KyselyAdapter(conn), {
-        _axium: { config },
         async getAccount(providerAccountId, provider) {
             const result = await conn.selectFrom('Account').selectAll().where('providerAccountId', '=', providerAccountId).where('provider', '=', provider).executeTakeFirst();
             return result ?? null;
@@ -37,8 +39,10 @@ export function createAdapter() {
             return authenticator;
         },
     });
-    return adapter;
 }
+/**
+ * Login using credentials
+ */
 export async function register(credentials) {
     const { email, password, name } = Registration.parse(credentials);
     const existing = await adapter.getUserByEmail?.(email);
@@ -48,41 +52,40 @@ export async function register(credentials) {
     while (await adapter.getUser?.(id))
         id = crypto.randomUUID();
     const salt = genSaltSync(10);
-    const user = await adapter.createUser?.({
+    const user = await adapter.createUser({
         id,
         name,
         email,
         emailVerified: null,
-        salt,
-        password: hashSync(password, salt),
+        salt: password ? salt : null,
+        password: password ? hashSync(password, salt) : null,
     });
     const expires = new Date();
     expires.setMonth(expires.getMonth() + 1);
-    const session = await adapter.createSession?.({
+    const session = await adapter.createSession({
         sessionToken: randomBytes(64).toString('base64'),
         userId: id,
         expires,
     });
     return { user, session };
 }
+/**
+ * Authorize using credentials
+ */
 export async function authorize(credentials) {
     const { success, error, data } = Login.safeParse(credentials);
     if (!success)
         throw new CredentialsSignin(error);
     const user = await adapter.getUserByEmail?.(data.email);
-    if (!user)
+    if (!user || !data.password || !user.salt)
         return null;
     if (user.password !== hashSync(data.password, user.salt))
         return null;
     return omit(user, 'password', 'salt');
 }
-/**
- * Get the providers current enabled in the Axium config.
- */
-export function getProviders() {
-    const providers = [];
-    if (config.auth.passkeys)
-        providers.push(Passkey);
+export function getConfig() {
+    createAdapter();
+    const providers = [Passkey({})];
     if (config.auth.credentials) {
         providers.push(Credentials({
             credentials: {
@@ -92,19 +95,42 @@ export function getProviders() {
             authorize,
         }));
     }
-    return providers;
-}
-export function getConfig() {
-    createAdapter();
+    const debug = config.auth.debug ?? config.debug;
     return {
         adapter,
-        providers: getProviders(),
-        debug: config.auth.debug ?? config.debug,
+        providers,
+        debug,
         experimental: { enableWebAuthn: true },
         secret: config.auth.secret,
         useSecureCookies: config.auth.secure_cookies,
-        session: {
-            strategy: 'database',
+        session: { strategy: 'database' },
+        logger: {
+            error(error) {
+                logger.error('[auth] ' + error.message);
+            },
+            warn(code) {
+                switch (code) {
+                    case 'experimental-webauthn':
+                    case 'debug-enabled':
+                        return;
+                    case 'csrf-disabled':
+                        logger.warn('CSRF protection is disabled.');
+                        break;
+                    case 'env-url-basepath-redundant':
+                    case 'env-url-basepath-mismatch':
+                    default:
+                        logger.warn('[auth] ' + code);
+                }
+            },
+            debug(message, metadata) {
+                debug && logger.debug('[auth]', message, metadata ? JSON.stringify(metadata, (k, v) => (k && JSON.stringify(v).length > 100 ? '...' : v)) : '');
+            },
+        },
+        callbacks: {
+            signIn({ user }) {
+                logger.info('[auth] signin', user.id ?? '', user.email ? `(${user.email})` : '');
+                return true;
+            },
         },
     };
 }

package/dist/cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import chalk from 'chalk';
 import { Option, program } from 'commander';
+import { styleText } from 'node:util';
 import { getByString, isJSON, pick, setByString } from 'utilium';
 import $pkg from '../package.json' with { type: 'json' };
 import * as config from './config.js';
 import * as db from './database.js';
-import { err, exit } from './io.js';
+import { exit, output } from './io.js';
 program
     .version($pkg.version)
     .name('axium')
@@ -18,7 +18,7 @@ program.on('option:config', () => config.load(program.opts().config));
 program.hook('preAction', function (_, action) {
     config.loadDefaults();
     const opt = action.optsWithGlobals();
-    opt.force && console.log(chalk.yellow('--force: Protections disabled.'));
+    opt.force && output.warn('--force: Protections disabled.');
 });
 // Options shared by multiple (sub)commands
 const opts = {
@@ -36,17 +36,17 @@ const axiumDB = program
     .description('manage the database')
     .option('-t, --timeout <ms>', 'how long to wait for commands to complete.', '1000')
     .addOption(opts.host);
-function db_output(state, message) {
+function db_output(state, message = '') {
     switch (state) {
         case 'start':
             process.stdout.write(message + '... ');
             break;
         case 'log':
         case 'warn':
-            process.stdout.write(chalk.yellow(message));
+            process.stdout.write(styleText('yellow', message));
             break;
         case 'error':
-            process.stdout.write(chalk.red(message));
+            process.stdout.write(styleText('red', message));
             break;
         case 'done':
             console.log('done.');
@@ -70,10 +70,18 @@ axiumDB
     .command('status')
     .alias('stats')
     .description('check the status of the database')
-    .action(async () => db
-    .statusText()
-    .then(console.log)
-    .catch(() => exit('Unavailable')));
+    .action(async () => {
+    try {
+        console.log(await db.statusText());
+    }
+    catch {
+        output.error('Unavailable');
+        process.exitCode = 1;
+    }
+    finally {
+        await db.database.destroy();
+    }
+});
 axiumDB
     .command('drop')
     .description('drop the database')
@@ -84,10 +92,27 @@ axiumDB
         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.`));
+            output.warn(`Database has existing ${key}. Use --force if you really want to drop the database.`);
+            process.exit(2);
+        }
+    await db.uninstall({ ...opt, output: db_output }).catch(exit);
+    await db.database.destroy();
+});
+axiumDB
+    .command('wipe')
+    .description('wipe the database')
+    .addOption(opts.force)
+    .action(async (opt) => {
+    const stats = await db.status().catch(exit);
+    if (!opt.force)
+        for (const key of ['users', 'accounts', 'sessions']) {
+            if (stats[key] == 0)
+                continue;
+            output.warn(`Database has existing ${key}. Use --force if you really want to wipe the database.`);
             process.exit(2);
         }
-    await db.remove({ ...opt, output: db_output }).catch(exit);
+    await db.wipe({ ...opt, output: db_output }).catch(exit);
+    await db.database.destroy();
 });
 const axiumConfig = program
     .command('config')
@@ -139,14 +164,17 @@ program
     .addOption(opts.host)
     .action(async () => {
     console.log('Axium Server v' + program.version());
-    console.log('Debug mode:', config.debug ? chalk.yellow('enabled') : 'disabled');
+    console.log('Debug mode:', config.debug ? styleText('yellow', 'enabled') : 'disabled');
     console.log('Loaded config files:', config.files.keys().toArray().join(', '));
     process.stdout.write('Database: ');
-    await db
-        .statusText()
-        .then(console.log)
-        .catch(() => err('Unavailable'));
-    console.log('Enabled auth providers:', config.authProviders.filter(provider => config.auth[provider]).join(', '));
+    try {
+        console.log(await db.statusText());
+    }
+    catch {
+        output.error('Unavailable');
+    }
+    await db.database.destroy();
+    console.log('Credentials authentication:', config.auth.credentials ? styleText('yellow', 'enabled') : 'disabled');
 });
 program
     .command('init')

package/dist/config.d.ts

@@ -24,43 +24,47 @@ export declare const db: Database;
 export declare const Auth: z.ZodObject<{
     credentials: z.ZodBoolean;
     debug: z.ZodOptional<z.ZodBoolean>;
-    passkeys: z.ZodBoolean;
     secret: z.ZodString;
     secure_cookies: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
     credentials: boolean;
-    passkeys: boolean;
     secret: string;
     secure_cookies: boolean;
     debug?: boolean | undefined;
 }, {
     credentials: boolean;
-    passkeys: boolean;
     secret: string;
     secure_cookies: boolean;
     debug?: boolean | undefined;
 }>;
 export type Auth = z.infer<typeof Auth>;
 export declare const auth: Auth;
-export declare const authProviders: readonly ["credentials", "passkeys"];
-export type AuthProvider = (typeof authProviders)[number];
+export declare const Log: z.ZodObject<{
+    level: z.ZodEnum<["error", "warn", "notice", "info", "debug"]>;
+    console: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    level: "debug" | "error" | "warn" | "notice" | "info";
+    console: boolean;
+}, {
+    level: "debug" | "error" | "warn" | "notice" | "info";
+    console: boolean;
+}>;
+export type Log = z.infer<typeof Log>;
+export declare const log: Log;
 export declare const Config: z.ZodObject<{
     auth: z.ZodObject<{
         credentials: z.ZodOptional<z.ZodBoolean>;
         debug: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
-        passkeys: z.ZodOptional<z.ZodBoolean>;
         secret: z.ZodOptional<z.ZodString>;
         secure_cookies: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         credentials?: boolean | undefined;
         debug?: boolean | undefined;
-        passkeys?: boolean | undefined;
         secret?: string | undefined;
         secure_cookies?: boolean | undefined;
     }, {
         credentials?: boolean | undefined;
         debug?: boolean | undefined;
-        passkeys?: boolean | undefined;
         secret?: string | undefined;
         secure_cookies?: boolean | undefined;
     }>;
@@ -84,12 +88,21 @@ export declare const Config: z.ZodObject<{
         user?: string | undefined;
         database?: string | undefined;
     }>;
+    log: z.ZodObject<{
+        level: z.ZodOptional<z.ZodEnum<["error", "warn", "notice", "info", "debug"]>>;
+        console: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        level?: "debug" | "error" | "warn" | "notice" | "info" | undefined;
+        console?: boolean | undefined;
+    }, {
+        level?: "debug" | "error" | "warn" | "notice" | "info" | undefined;
+        console?: boolean | undefined;
+    }>;
 }, "strip", z.ZodTypeAny, {
     debug: boolean;
     auth: {
         credentials?: boolean | undefined;
         debug?: boolean | undefined;
-        passkeys?: boolean | undefined;
         secret?: string | undefined;
         secure_cookies?: boolean | undefined;
     };
@@ -100,12 +113,15 @@ export declare const Config: z.ZodObject<{
         user?: string | undefined;
         database?: string | undefined;
     };
+    log: {
+        level?: "debug" | "error" | "warn" | "notice" | "info" | undefined;
+        console?: boolean | undefined;
+    };
 }, {
     debug: boolean;
     auth: {
         credentials?: boolean | undefined;
         debug?: boolean | undefined;
-        passkeys?: boolean | undefined;
         secret?: string | undefined;
         secure_cookies?: boolean | undefined;
     };
@@ -116,24 +132,25 @@ export declare const Config: z.ZodObject<{
         user?: string | undefined;
         database?: string | undefined;
     };
+    log: {
+        level?: "debug" | "error" | "warn" | "notice" | "info" | undefined;
+        console?: boolean | undefined;
+    };
 }>;
 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>>>;
-        passkeys: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
         secret: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         secure_cookies: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
     }, "strip", z.ZodTypeAny, {
         credentials?: boolean | undefined;
         debug?: boolean | undefined;
-        passkeys?: boolean | undefined;
         secret?: string | undefined;
         secure_cookies?: boolean | undefined;
     }, {
         credentials?: boolean | undefined;
         debug?: boolean | undefined;
-        passkeys?: boolean | undefined;
         secret?: string | undefined;
         secure_cookies?: boolean | undefined;
     }>>;
@@ -157,6 +174,16 @@ export declare const File: z.ZodObject<z.objectUtil.extendShape<{
         user?: string | undefined;
         database?: string | undefined;
     }>>;
+    log: z.ZodOptional<z.ZodObject<{
+        level: z.ZodOptional<z.ZodOptional<z.ZodEnum<["error", "warn", "notice", "info", "debug"]>>>;
+        console: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        level?: "debug" | "error" | "warn" | "notice" | "info" | undefined;
+        console?: boolean | undefined;
+    }, {
+        level?: "debug" | "error" | "warn" | "notice" | "info" | undefined;
+        console?: boolean | undefined;
+    }>>;
 }, {
     include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }>, "strip", z.ZodTypeAny, {
@@ -164,7 +191,6 @@ export declare const File: z.ZodObject<z.objectUtil.extendShape<{
     auth?: {
         credentials?: boolean | undefined;
         debug?: boolean | undefined;
-        passkeys?: boolean | undefined;
         secret?: string | undefined;
         secure_cookies?: boolean | undefined;
     } | undefined;
@@ -175,13 +201,16 @@ export declare const File: z.ZodObject<z.objectUtil.extendShape<{
         user?: string | undefined;
         database?: string | undefined;
     } | undefined;
+    log?: {
+        level?: "debug" | "error" | "warn" | "notice" | "info" | undefined;
+        console?: boolean | undefined;
+    } | undefined;
     include?: string[] | undefined;
 }, {
     debug?: boolean | undefined;
     auth?: {
         credentials?: boolean | undefined;
         debug?: boolean | undefined;
-        passkeys?: boolean | undefined;
         secret?: string | undefined;
         secure_cookies?: boolean | undefined;
     } | undefined;
@@ -192,6 +221,10 @@ export declare const File: z.ZodObject<z.objectUtil.extendShape<{
         user?: string | undefined;
         database?: string | undefined;
     } | undefined;
+    log?: {
+        level?: "debug" | "error" | "warn" | "notice" | "info" | undefined;
+        console?: boolean | undefined;
+    } | undefined;
     include?: string[] | undefined;
 }>;
 export type File = z.infer<typeof File>;

package/dist/config.js

@@ -1,10 +1,10 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import chalk from 'chalk';
+import { levelText } from 'logzen';
 import { readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path/posix';
 import { assignWithDefaults } from 'utilium';
 import * as z from 'zod';
-import { findDir } from './io.js';
+import { findDir, logger, output } from './io.js';
 export const Database = z.object({
     host: z.string(),
     port: z.number(),
@@ -22,22 +22,29 @@ export const db = {
 export const Auth = z.object({
     credentials: z.boolean(),
     debug: z.boolean().optional(),
-    passkeys: z.boolean(),
     secret: z.string(),
     secure_cookies: z.boolean(),
 });
 export const auth = {
-    credentials: true,
-    passkeys: true,
+    credentials: false,
     secret: '',
     secure_cookies: false,
 };
-export const authProviders = ['credentials', 'passkeys'];
+export const Log = z.object({
+    level: z.enum(levelText),
+    console: z.boolean(),
+});
+export const log = {
+    level: 'info',
+    console: true,
+};
 export const Config = z.object({
     auth: Auth.partial(),
     debug: z.boolean(),
     db: Database.partial(),
+    log: Log.partial(),
 });
+// config from file
 export const File = Config.deepPartial().extend({
     include: z.array(z.string()).optional(),
 });
@@ -47,6 +54,7 @@ export function get() {
         auth,
         db,
         debug,
+        log,
     };
 }
 /**
@@ -56,6 +64,10 @@ export function set(config) {
     assignWithDefaults(auth, config.auth ?? {});
     debug = config.debug ?? debug;
     assignWithDefaults(db, config.db ?? {});
+    assignWithDefaults(log, config.log ?? {});
+    logger.detach(output);
+    if (log.console)
+        logger.attach(output, { output: log.level });
 }
 export const files = new Map();
 /**
@@ -69,7 +81,7 @@ export function load(path, options = {}) {
     catch (e) {
         if (!options.optional)
             throw e;
-        debug && console.debug(chalk.gray(`Skipping config at ${path} (${e.message})`));
+        logger.debug(`Skipping config at ${path} (${e.message})`);
         return;
     }
     const config = options.strict ? File.parse(json) : json;
@@ -95,7 +107,7 @@ export function saveTo(path, changed) {
     set(changed);
     const config = files.get(path) ?? {};
     Object.assign(config, { ...changed, db: { ...config.db, ...changed.db } });
-    debug && console.debug(chalk.gray(`Wrote config to ${path}`));
+    logger.debug(`Wrote config to ${path}`);
     writeFileSync(path, JSON.stringify(config));
 }
 /**

package/dist/database.d.ts

@@ -73,4 +73,8 @@ export declare function init(opt: InitOptions): Promise<config.Database>;
 /**
  * Completely remove Axium from the database.
  */
-export declare function remove(opt: OpOptions): Promise<void>;
+export declare function uninstall(opt: OpOptions): Promise<void>;
+/**
+ * Removes all data from tables.
+ */
+export declare function wipe(opt: OpOptions): Promise<void>;

package/dist/database.js

@@ -55,7 +55,7 @@ import { exec } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
 import pg from 'pg';
 import * as config from './config.js';
-import { verbose } from './io.js';
+import { logger } from './io.js';
 export let database;
 export function connect() {
     if (database)
@@ -71,24 +71,12 @@ export function connect() {
     return database;
 }
 export async function status() {
-    const env_1 = { stack: [], error: void 0, hasError: false };
-    try {
-        const db = __addDisposableResource(env_1, connect(), 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;
-    }
+    const db = connect();
+    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,
+    };
 }
 export async function statusText() {
     try {
@@ -141,12 +129,12 @@ function shouldRecreate(opt) {
     throw 2;
 }
 export async function init(opt) {
-    const env_2 = { stack: [], error: void 0, hasError: false };
+    const env_1 = { stack: [], error: void 0, hasError: false };
     try {
         _fixOutput(opt);
         if (!config.db.password) {
             config.save({ db: { password: randomBytes(32).toString('base64') } }, true);
-            verbose('Generated password and wrote to global config');
+            logger.debug('Generated password and wrote to global config');
         }
         const _sql = (command, message) => execSQL(opt, command, message);
         await _sql('CREATE DATABASE axium', 'Creating database').catch(async (error) => {
@@ -171,7 +159,7 @@ export async function init(opt) {
         await _sql('GRANT ALL PRIVILEGES ON SCHEMA public TO axium', 'Granting schema privileges');
         await _sql('ALTER DATABASE axium OWNER TO axium', 'Setting database owner');
         await _sql('SELECT pg_reload_conf()', 'Reloading configuration');
-        const db = __addDisposableResource(env_2, connect(), true);
+        const db = __addDisposableResource(env_1, connect(), true);
         const relationExists = (table) => (error) => {
             error = typeof error == 'object' && 'message' in error ? error.message : error;
             if (error == `relation "${table}" already exists`)
@@ -254,22 +242,34 @@ export async function init(opt) {
         opt.output('done');
         return config.db;
     }
-    catch (e_2) {
-        env_2.error = e_2;
-        env_2.hasError = true;
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
     }
     finally {
-        const result_2 = __disposeResources(env_2);
-        if (result_2)
-            await result_2;
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
     }
 }
 /**
  * Completely remove Axium from the database.
  */
-export async function remove(opt) {
+export async function uninstall(opt) {
     _fixOutput(opt);
     await execSQL(opt, 'DROP DATABASE axium', 'Dropping database');
     await execSQL(opt, 'REVOKE ALL PRIVILEGES ON SCHEMA public FROM axium', 'Revoking schema privileges');
     await execSQL(opt, 'DROP USER axium', 'Dropping user');
 }
+/**
+ * Removes all data from tables.
+ */
+export async function wipe(opt) {
+    _fixOutput(opt);
+    const db = connect();
+    for (const table of ['User', 'Account', 'Session', 'VerificationToken', 'Authenticator']) {
+        opt.output('start', `Removing data from ${table}`);
+        await db.deleteFrom(table).execute();
+        opt.output('done');
+    }
+}

package/dist/io.d.ts

@@ -1,15 +1,21 @@
-/** Convenience function for `example... [Done. / error]` */
-export declare function report<T>(promise: Promise<T>, message: string, success?: string): Promise<T>;
-export declare function err(message: string | Error): void;
-/** Yet another convenience function */
-export declare function exit(message: string | Error, code?: number): never;
-export declare function verbose(...message: any[]): void;
+import { Logger } from 'logzen';
 /**
  * Find the Axium directory.
  * This directory includes things like config files, secrets, etc.
  */
 export declare function findDir(global: boolean): string;
-/**
- *
- */
-export declare function checkDir(path: string): void;
+export declare const logger: Logger;
+export declare const output: {
+    constructor: {
+        name: string;
+    };
+    error(message: string): void;
+    warn(message: string): void;
+    info(message: string): void;
+    log(message: string): void;
+    debug(message: string): void;
+};
+/** Yet another convenience function */
+export declare function exit(message: string | Error, code?: number): never;
+/** Convenience function for `example... [done. / error]` */
+export declare function report<T>(promise: Promise<T>, message: string, success?: string): Promise<T>;

package/dist/io.js

@@ -1,35 +1,8 @@
-import chalk from 'chalk';
-import { existsSync, mkdirSync } from 'node:fs';
+import { Logger } from 'logzen';
+import { mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path/posix';
-import { debug } from './config.js';
-/** Convenience function for `example... [Done. / error]` */
-export 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;
-    }
-}
-export function err(message) {
-    if (message instanceof Error)
-        message = message.message;
-    console.error(message.startsWith('\x1b') ? message : chalk.red(message));
-}
-/** Yet another convenience function */
-export function exit(message, code = 1) {
-    err(message);
-    process.exit(code);
-}
-export function verbose(...message) {
-    if (!debug)
-        return;
-    console.debug(chalk.gray(message));
-}
+import { styleText } from 'node:util';
 /**
  * Find the Axium directory.
  * This directory includes things like config files, secrets, etc.
@@ -37,19 +10,54 @@ export function verbose(...message) {
 export function findDir(global) {
     if (process.env.AXIUM_DIR)
         return process.env.AXIUM_DIR;
-    if (process.getuid?.() === 0)
+    if (global && process.getuid?.() === 0)
         return '/etc/axium';
     if (global)
         return join(homedir(), '.axium');
     return '.axium';
 }
-/**
- *
- */
-export function checkDir(path) {
-    if (existsSync(path))
-        return;
-    mkdirSync(path, { recursive: true });
-}
 if (process.getuid?.() === 0)
-    checkDir('/etc/axium');
+    mkdirSync('/etc/axium', { recursive: true });
+mkdirSync(findDir(false), { recursive: true });
+export const logger = new Logger({
+    hideWarningStack: true,
+    noGlobalConsole: true,
+});
+export const output = {
+    constructor: { name: 'Console' },
+    error(message) {
+        console.error(message.startsWith('\x1b') ? message : styleText('red', message));
+    },
+    warn(message) {
+        console.warn(message.startsWith('\x1b') ? message : styleText('yellow', message));
+    },
+    info(message) {
+        console.info(message.startsWith('\x1b') ? message : styleText('blue', message));
+    },
+    log(message) {
+        console.log(message);
+    },
+    debug(message) {
+        console.debug(message.startsWith('\x1b') ? message : styleText('gray', message));
+    },
+};
+logger.attach(output);
+/** Yet another convenience function */
+export function exit(message, code = 1) {
+    if (message instanceof Error)
+        message = message.message;
+    output.error(message);
+    process.exit(code);
+}
+/** Convenience function for `example... [done. / error]` */
+export 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;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@axium/server",
-	"version": "0.0.2",
+	"version": "0.0.3",
 	"author": "James Prevett <axium@jamespre.dev> (https://jamespre.dev)",
 	"funding": {
 		"type": "individual",
@@ -18,7 +18,8 @@
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"files": [
-		"dist"
+		"dist",
+		"web"
 	],
 	"bin": {
 		"axium": "dist/cli.js"
@@ -34,9 +35,9 @@
 		"@auth/kysely-adapter": "^1.8.0",
 		"@types/pg": "^8.11.11",
 		"bcryptjs": "^3.0.2",
-		"chalk": "^5.4.1",
 		"commander": "^13.1.0",
 		"kysely": "^0.27.5",
+		"logzen": "^0.6.2",
 		"pg": "^8.14.1",
 		"utilium": "^2.2.3"
 	},

package/web/app.html

@@ -0,0 +1,15 @@
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<link rel="icon" href="%sveltekit.assets%/favicon.svg" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		<meta name="color-scheme" content="dark light" />
+		<link rel="stylesheet" href="/axium.css" />
+		%sveltekit.head%
+	</head>
+
+	<body>
+		<div style="display: contents">%sveltekit.body%</div>
+	</body>
+</html>

package/web/auth.ts

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

package/web/hooks.server.ts

@@ -0,0 +1 @@
+export { handle } from './auth.js';

package/web/lib/Icon.svelte

@@ -0,0 +1,42 @@
+<script lang="ts">
+	import { onMount } from 'svelte';
+
+	const { id, style = 'solid' } = $props();
+
+	const href = `https://site-assets.fontawesome.com/releases/v6.7.2/svgs/${style}/${id}.svg`;
+
+	let content = $state('');
+
+	// Fetch and inline the SVG content on component mount
+	onMount(async () => {
+		const res = await fetch(href);
+
+		if (!res.ok) {
+			console.error('Failed to fetch icon:', res.statusText);
+			return;
+		}
+
+		const text = await res.text();
+
+		const doc = new DOMParser().parseFromString(text, 'image/svg+xml');
+		const errorNode = doc.querySelector('parsererror');
+
+		if (errorNode || doc.documentElement?.nodeName != 'svg') {
+			console.error('Invalid SVG');
+			return;
+		}
+
+		content = text;
+	});
+</script>
+
+<span>{@html content}</span>
+
+<style>
+	span {
+		width: 1em;
+		height: 1em;
+		display: inline-block;
+		fill: #bbb;
+	}
+</style>

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

@@ -0,0 +1,14 @@
+import { redirect } from '@sveltejs/kit';
+import { adapter } from '../../src/auth.js';
+import type { PageServerLoadEvent } from './$types';
+
+export async function load(event: PageServerLoadEvent) {
+	const session = await event.locals.auth();
+
+	if (!session) redirect(307, '/auth/signin');
+	if (!session.user.name) redirect(307, '/edit/name');
+
+	const user = await adapter.getUserByEmail(session.user.email);
+
+	return { session, user };
+}

package/web/routes/+page.svelte

@@ -0,0 +1,99 @@
+<script lang="ts">
+	import { page } from '$app/state';
+	import Icon from '$lib/Icon.svelte';
+	import { getUserImage } from '@axium/core';
+
+	const { user } = page.data;
+
+	const image = getUserImage(user);
+</script>
+
+<svelte:head>
+	<title>Axium Account</title>
+</svelte:head>
+
+<div id="content">
+	<img id="pfp" src={image} alt="User profile" />
+	<p id="greeting">Welcome, {user.name}</p>
+	<div class="main">
+		<div>
+			<p>Name</p>
+			<p>{user.name}</p>
+			<a href="/edit/name"><Icon id="chevron-right" /></a>
+		</div>
+		<div>
+			<p>Email</p>
+			<p>{user.email}</p>
+			<a href="/edit/email"><Icon id="chevron-right" /></a>
+		</div>
+		<div>
+			<p>User ID <dfn title="This is your UUID."><Icon id="circle-info" style="regular" /></dfn></p>
+			<p>{user.id}</p>
+		</div>
+		<a id="signout" href="/auth/signout"><button>Sign out</button></a>
+	</div>
+</div>
+
+<style>
+	#content {
+		display: flex;
+		align-items: center;
+		flex-direction: column;
+	}
+
+	#pfp {
+		width: 100px;
+		height: 100px;
+		border-radius: 50%;
+		border: 1px solid #8888;
+		margin: 3em auto 2em;
+	}
+
+	#greeting {
+		font-size: 2em;
+		margin-bottom: 1em;
+	}
+
+	.main {
+		width: 50%;
+		padding-top: 4em;
+
+		> div:has(+ div) {
+			border-bottom: 1px solid #8888;
+		}
+	}
+
+	.main > div {
+		display: grid;
+		grid-template-columns: 10em 1fr 2em;
+		align-items: center;
+		width: 100%;
+		gap: 1em;
+		text-wrap: nowrap;
+		padding-bottom: 1em;
+
+		> :first-child {
+			margin: 0 5em 0 1em;
+			color: #bbbb;
+			font-size: 0.9em;
+			grid-column: 1;
+		}
+
+		> :nth-child(2) {
+			margin: 0;
+			grid-column: 2;
+		}
+
+		> a:last-child {
+			margin: 0;
+			display: inline;
+			grid-column: 3;
+			font-size: 0.75em;
+			cursor: pointer;
+		}
+	}
+
+	#signout {
+		margin-top: 2em;
+	}
+</style>

package/web/routes/edit/email/+page.server.ts

@@ -0,0 +1,35 @@
+import { fail, redirect, type Actions } from '@sveltejs/kit';
+import { adapter } from '../../../../src/auth';
+import * as z from 'zod';
+import type { PageServerLoadEvent } from './$types';
+
+export async function load(event: PageServerLoadEvent) {
+	const session = await event.locals.auth();
+	if (!session) redirect(307, '/auth/signin');
+	return { session };
+}
+
+export const actions = {
+	async default(event) {
+		const session = await event.locals.auth();
+
+		const rawEmail = (await event.request.formData()).get('email');
+		const { data: email, success, error } = z.string().email().safeParse(rawEmail);
+
+		if (!success)
+			return fail(400, {
+				email,
+				error: error.flatten().formErrors[0] || Object.values(error.flatten().fieldErrors).flat()[0],
+			});
+
+		const user = await adapter.getUserByEmail(session.user.email);
+		if (!user) return fail(500, { email, error: 'User does not exist' });
+
+		try {
+			await adapter.updateUser({ id: user.id, email, image: user.image });
+		} catch (error: any) {
+			return fail(400, { email, error: typeof error === 'string' ? error : error.message });
+		}
+		redirect(303, '/');
+	},
+} satisfies Actions;

package/web/routes/edit/email/+page.svelte

@@ -0,0 +1,25 @@
+<script lang="ts">
+	import { enhance } from '$app/forms';
+	import { page } from '$app/state';
+	const { user } = page.data.session;
+	let { form } = $props();
+</script>
+
+<svelte:head>
+	<title>Edit Email</title>
+</svelte:head>
+
+<div>
+	<form method="POST" class="main" use:enhance>
+		{#if form?.error}
+			<div class="error">
+				{typeof form.error === 'string' ? form.error : JSON.stringify(form.error)}
+			</div>
+		{/if}
+		<div>
+			<label for="email">Email Address</label>
+			<input name="email" type="email" value={form?.email || user.email || ''} required />
+		</div>
+		<button type="submit">Continue</button>
+	</form>
+</div>

package/web/routes/edit/name/+page.server.ts

@@ -0,0 +1,35 @@
+import { Name } from '@axium/core/schemas';
+import { fail, redirect, type Actions } from '@sveltejs/kit';
+import { adapter } from '../../../../src/auth';
+import type { PageServerLoadEvent } from './$types';
+
+export async function load(event: PageServerLoadEvent) {
+	const session = await event.locals.auth();
+	if (!session) redirect(307, '/auth/signin');
+	return { session };
+}
+
+export const actions = {
+	async default(event) {
+		const session = await event.locals.auth();
+
+		const rawName = (await event.request.formData()).get('name');
+		const { data: name, success, error } = Name.safeParse(rawName);
+
+		if (!success)
+			return fail(400, {
+				name,
+				error: error.flatten().formErrors[0] || Object.values(error.flatten().fieldErrors).flat()[0],
+			});
+
+		const user = await adapter.getUserByEmail(session.user.email);
+		if (!user) return fail(500, { name, error: 'User does not exist' });
+
+		try {
+			await adapter.updateUser({ id: user.id, name, image: user.image });
+		} catch (error: any) {
+			return fail(400, { name, error: typeof error === 'string' ? error : error.message });
+		}
+		redirect(303, '/');
+	},
+} satisfies Actions;

package/web/routes/edit/name/+page.svelte

@@ -0,0 +1,25 @@
+<script lang="ts">
+	import { enhance } from '$app/forms';
+	import { page } from '$app/state';
+	const { user } = page.data.session;
+	let { form } = $props();
+</script>
+
+<svelte:head>
+	<title>Edit Name</title>
+</svelte:head>
+
+<div>
+	<form method="POST" class="main" use:enhance>
+		{#if form?.error}
+			<div class="error">
+				{typeof form.error === 'string' ? form.error : JSON.stringify(form.error)}
+			</div>
+		{/if}
+		<div>
+			<label for="name">What do you want to be called?</label>
+			<input name="name" type="text" value={form?.name || user.name || ''} required />
+		</div>
+		<button type="submit">Continue</button>
+	</form>
+</div>

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

@@ -0,0 +1,33 @@
+import { Registration } from '@axium/core/schemas';
+import { fail, redirect } from '@sveltejs/kit';
+import * as auth from '../../../src/auth.js';
+import * as config from '../../../src/config.js';
+import type { Actions } from './$types';
+
+export function load() {
+	if (!config.auth.credentials) return redirect(307, '/auth/signin');
+}
+
+export const actions = {
+	async default(event) {
+		const { data, success, error } = Registration.safeParse(Object.fromEntries(await event.request.formData()));
+
+		if (!success)
+			return fail(400, {
+				...data,
+				error: error.flatten().formErrors[0] || Object.values(error.flatten().fieldErrors).flat()[0],
+			});
+
+		try {
+			const { session } = await auth.register(data);
+			event.cookies.set('session', session.sessionToken, {
+				path: '/',
+				expires: session.expires,
+				httpOnly: true,
+			});
+			return { ...data, success: true, data: session.sessionToken };
+		} catch (error: any) {
+			return fail(400, { ...data, error: typeof error === 'string' ? error : error.message });
+		}
+	},
+} satisfies Actions;

package/web/routes/signup/+page.svelte

@@ -0,0 +1,27 @@
+<script lang="ts">
+	import { enhance } from '$app/forms';
+	let { form } = $props();
+</script>
+
+<div>
+	<form method="POST" class="main" use:enhance>
+		{#if form?.error}
+			<div class="error">
+				{typeof form.error === 'string' ? form.error : JSON.stringify(form.error)}
+			</div>
+		{/if}
+		<div>
+			<label for="name">Display Name</label>
+			<input name="name" type="text" value={form?.name || ''} required />
+		</div>
+		<div>
+			<label for="email">Email</label>
+			<input name="email" type="email" value={form?.email || ''} required />
+		</div>
+		<div>
+			<label for="password">Password</label>
+			<input name="password" type="password" />
+		</div>
+		<button type="submit">Register</button>
+	</form>
+</div>

package/web/static/axium.css

@@ -0,0 +1,67 @@
+body {
+	position: fixed;
+	inset: 0;
+	font-family: sans-serif;
+	font-size: 16px;
+	background-color: #222;
+	color: #bbb;
+	accent-color: #bbb;
+}
+
+.main {
+	padding: 2em;
+	border-radius: 1em;
+	background-color: #111;
+	display: flex;
+	flex-direction: column;
+	gap: 1em;
+}
+
+div:has(form.main) {
+	position: absolute;
+	inset: 0;
+	display: flex;
+	justify-content: center;
+	align-items: center;
+}
+
+form.main {
+	width: max-content;
+	height: max-content;
+}
+
+form {
+	div {
+		display: flex;
+		flex-direction: column;
+		gap: 0;
+	}
+}
+
+input,
+button {
+	border-radius: 0.5em;
+	border: 1px solid #aaa;
+	background-color: #222;
+}
+
+input {
+	padding: 0.5em 1em;
+	outline: none;
+}
+
+button {
+	padding: 0.5em 1em;
+	cursor: pointer;
+}
+
+button:hover {
+	background-color: #334;
+}
+
+.error {
+	padding: 1em;
+	border-radius: 0.5em;
+	background-color: #733;
+	color: #ccc;
+}

package/web/tsconfig.json

@@ -0,0 +1,7 @@
+{
+	"extends": "../.svelte-kit/tsconfig.json",
+	"compilerOptions": {
+		"target": "ES2021"
+	},
+	"include": ["**/*.ts", "**/*.svelte"]
+}