@axium/server 0.43.0 → 0.44.0

package/dist/acl.d.ts

@@ -1,7 +1,7 @@
 import type { AccessControl, AccessControllable, AccessTarget, UserInternal } from '@axium/core';
 import type * as kysely from 'kysely';
 import type { WithRequired } from 'utilium';
-import * as db from './database.js';
+import * as db from './db/index.js';
 export interface DBAccessControllable extends Omit<AccessControllable, 'id'> {
     id: string | kysely.Generated<string>;
 }

package/dist/acl.js

@@ -1,6 +1,6 @@
 import { fromTarget } from '@axium/core/access';
 import { jsonArrayFrom } from 'kysely/helpers/postgres';
-import * as db from './database.js';
+import * as db from './db/index.js';
 /** Match ACL entries, optionally selecting for a given user-like object */
 export function match(user) {
     return function (eb) {

package/dist/api/admin.js

@@ -12,7 +12,7 @@ import $pkg from '../../package.json' with { type: 'json' };
 import { audit, events, getEvents } from '../audit.js';
 import { createVerification, requireSession } from '../auth.js';
 import { config } from '../config.js';
-import { count, database as db } from '../database.js';
+import { count, database as db } from '../db/index.js';
 import { error, parseBody, parseSearch, withError } from '../requests.js';
 import { addRoute } from '../routes.js';
 async function assertAdmin(route, req, sensitive = false) {

package/dist/api/images.js

@@ -4,7 +4,7 @@ import sharp from 'sharp';
 import * as z from 'zod';
 import { checkAuthForUser } from '../auth.js';
 import { config } from '../config.js';
-import { database as db } from '../database.js';
+import { database as db } from '../db/index.js';
 import { error, withError } from '../requests.js';
 import { addRoute } from '../routes.js';
 export async function prepareImageUpload(request, cfg, userId) {

package/dist/api/passkeys.js

@@ -2,7 +2,7 @@ import { PasskeyChangeable } from '@axium/core/passkeys';
 import { omit } from 'utilium';
 import * as z from 'zod';
 import { checkAuthForUser, getPasskey } from '../auth.js';
-import { database as db } from '../database.js';
+import { database as db } from '../db/index.js';
 import { error, parseBody, withError } from '../requests.js';
 import { addRoute } from '../routes.js';
 addRoute({

package/dist/api/register.js

@@ -5,7 +5,7 @@ import { encodeUUID } from 'utilium';
 import { audit } from '../audit.js';
 import { createPasskey, getUser } from '../auth.js';
 import config from '../config.js';
-import { database as db } from '../database.js';
+import { database as db } from '../db/index.js';
 import { createSessionData, error, parseBody, withError } from '../requests.js';
 import { addRoute } from '../routes.js';
 // Map of user ID => challenge

package/dist/api/session.js

@@ -1,7 +1,7 @@
 import { omit } from 'utilium';
 import { audit } from '../audit.js';
 import { getSessionAndUser } from '../auth.js';
-import { database as db } from '../database.js';
+import { database as db } from '../db/index.js';
 import { error, getToken, stripUser, withError } from '../requests.js';
 import { addRoute } from '../routes.js';
 addRoute({

package/dist/api/users.js

@@ -6,7 +6,7 @@ import * as z from 'zod';
 import { audit } from '../audit.js';
 import { checkAuthForUser, createPasskey, createVerification, getPasskey, getPasskeysByUserId, getSessions, getUser, requireSession, useVerification, } from '../auth.js';
 import { config } from '../config.js';
-import { database as db } from '../database.js';
+import { database as db } from '../db/index.js';
 import { createSessionData, error, parseBody, stripUser, withError } from '../requests.js';
 import { addRoute } from '../routes.js';
 const challenges = new Map();

package/dist/audit.d.ts

@@ -1,7 +1,7 @@
 import { Severity, type AuditEvent, type AuditFilter } from '@axium/core/audit';
 import type { Insertable, SelectQueryBuilder } from 'kysely';
 import * as z from 'zod';
-import { type Schema } from './database.js';
+import { type Schema } from './db/index.js';
 export declare function styleSeverity(sev: Severity, align?: boolean): string;
 export interface AuditEventInit extends Insertable<Schema['audit_log']> {
 }

package/dist/audit.js

@@ -3,7 +3,7 @@ import { styleText } from 'node:util';
 import { capitalize, omit } from 'utilium';
 import * as z from 'zod';
 import config from './config.js';
-import { database } from './database.js';
+import { database } from './db/index.js';
 import * as io from 'ioium/node';
 const severityFormat = {
     [Severity.Emergency]: ['bgRedBright', 'white', 'underline'],

package/dist/auth.d.ts

@@ -2,7 +2,7 @@ import type { Passkey, Session, UserInternal, VerificationInternal, Verification
 import type { Insertable, Kysely } from 'kysely';
 import { type WithRequired } from 'utilium';
 import * as acl from './acl.js';
-import { type Schema } from './database.js';
+import { type Schema } from './db/index.js';
 export declare function getUser(id: string): Promise<UserInternal>;
 export declare function updateUser({ id, ...user }: WithRequired<Insertable<Schema['users']>, 'id'>): Promise<UserInternal>;
 export interface SessionInternal extends Session {

package/dist/auth.js

@@ -3,7 +3,7 @@ import { randomBytes, randomUUID } from 'node:crypto';
 import { omit } from 'utilium';
 import * as acl from './acl.js';
 import { audit } from './audit.js';
-import { database as db, userFromId } from './database.js';
+import { database as db, userFromId } from './db/index.js';
 import { error, getToken, withError } from './requests.js';
 export async function getUser(id) {
     return await db.selectFrom('users').selectAll().where('id', '=', id).executeTakeFirstOrThrow();
@@ -181,7 +181,7 @@ export async function authSessionForItem(itemType, itemId, permissions, session,
  * This will fetch the item, ACLs, users, and the authenticating session.
  */
 export async function authRequestForItem(request, itemType, itemId, permissions, recursive = false) {
-    let session = null;
+    let session;
     try {
         const token = getToken(request, false);
         if (!token)

package/dist/build.d.ts

@@ -0,0 +1,19 @@
+export interface BuildOptions {
+    /**
+     * If set all of the output from Vite and Svelte/SvelteKit will be shown.
+     * This is usually undesirable.
+     */
+    showGarbageOutput?: boolean;
+    /** Whether to minify the output */
+    minify?: boolean;
+}
+export interface BuildStats {
+    /** Build time in milliseconds */
+    time: number;
+    /** Bundle size in bytes */
+    size: bigint;
+}
+export declare function build(options?: BuildOptions): Promise<{
+    time: number;
+    size: bigint;
+}>;

package/dist/build.js

@@ -0,0 +1,121 @@
+import nodeAdapter from '@sveltejs/adapter-node';
+import { svelte as viteSveltePlugin } from '@sveltejs/vite-plugin-svelte';
+import { exit } from 'ioium/node';
+import { findPackageJSON } from 'node:module';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { build as buildVite } from 'vite';
+import config from './config.js';
+import { pick } from 'utilium';
+const sveltekitPackageJSON = findPackageJSON('@sveltejs/kit', import.meta.url);
+if (!sveltekitPackageJSON)
+    exit('Could not resolve @sveltejs/kit package.', 6);
+const { process_config: processSvelteConfig } = await import(join(sveltekitPackageJSON, '../src/core/config/index.js'));
+const { kit: svelteKitPlugin } = await import(join(sveltekitPackageJSON, '../src/exports/vite/index.js'));
+const svelteConfig = processSvelteConfig({
+    compilerOptions: {
+        runes: true,
+        warningFilter(w) {
+            return !w.code.startsWith('a11y');
+        },
+        experimental: {
+            async: true,
+        },
+    },
+    kit: {
+        adapter: nodeAdapter(),
+        files: {
+            assets: join(fileURLToPath(new URL(import.meta.resolve('@axium/client'))), '../../assets'),
+            appTemplate: join(import.meta.dirname, '../template.html'),
+            routes: config.web.routes,
+            hooks: {
+                universal: '/dev/null',
+                client: join(import.meta.dirname, '../.hooks.js'),
+            },
+        },
+    },
+});
+const vitePluginSvelteOptions = {
+    configFile: false,
+    ...pick(svelteConfig, 'extensions', 'preprocess', 'onwarn', 'compilerOptions'),
+};
+const viteConfig = {
+    configFile: false,
+    appType: 'custom',
+    server: {
+        strictPort: true,
+        port: 443,
+    },
+    plugins: [
+        ...viteSveltePlugin(vitePluginSvelteOptions),
+        ...(await svelteKitPlugin({ svelte_config: svelteConfig })) /*, mkcert({ hosts: ['cloud.jamespre.dev'] }) */,
+    ],
+    ssr: {
+        external: ['@axium/server'],
+    },
+    optimizeDeps: {
+        exclude: [],
+        include: ['@axium/client/components'],
+    },
+    build: {
+        rollupOptions: {
+            external: ['@axium/server'],
+        },
+        cssMinify: false,
+    },
+    logLevel: 'silent',
+};
+// SvelteKit uses a nested call to Vite's `build` that fails if we don't have a vite config file
+// We get around that with a sveltekit patch and this "hidden"/internal global
+const __axiumNestedConfig = {
+    configFile: false,
+    appType: 'custom',
+    plugins: [viteSveltePlugin(vitePluginSvelteOptions), await svelteKitPlugin({ svelte_config: svelteConfig })],
+    logLevel: 'silent',
+    build: {},
+};
+Object.assign(globalThis, { __axiumNestedConfig });
+function write(chunk, encoding, cb) {
+    if (typeof encoding === 'function')
+        cb = encoding;
+    if (cb)
+        cb();
+    return true;
+}
+export async function build(options = {}) {
+    const stdoutWrite = process.stdout.write.bind(process.stdout);
+    const stderrWrite = process.stderr.write.bind(process.stderr);
+    const startTime = performance.now();
+    if (options.showGarbageOutput) {
+        viteConfig.logLevel = 'info';
+        __axiumNestedConfig.logLevel = 'info';
+    }
+    else {
+        Object.assign(process.stdout, { write });
+        Object.assign(process.stderr, { write });
+    }
+    viteConfig.build.minify = options.minify;
+    __axiumNestedConfig.build.minify = options.minify;
+    try {
+        const result = await buildVite(viteConfig);
+        let size = 0n;
+        const outputs = Array.isArray(result) ? result : [result];
+        for (const out of outputs) {
+            if (!out || !('output' in out))
+                continue;
+            for (const chunk of out.output) {
+                size += BigInt(chunk.type === 'chunk' ? chunk.code.length : chunk.source.length);
+            }
+        }
+        return {
+            time: Math.round(performance.now() - startTime),
+            size,
+        };
+    }
+    finally {
+        if (!options.showGarbageOutput) {
+            process.stdout.write = stdoutWrite;
+            process.stderr.write = stderrWrite;
+        }
+    }
+}

package/dist/cli.d.ts

@@ -1,4 +1,5 @@
 import type { UserInternal } from '@axium/core';
+import { Option } from 'commander';
 export declare function userText(user: UserInternal, bold?: boolean): string;
 export declare function lookupUser(lookup: string): Promise<UserInternal>;
 /**
@@ -6,3 +7,12 @@ export declare function lookupUser(lookup: string): Promise<UserInternal>;
  * Only returns whether the array was updated and diff text for what actually changed.
  */
 export declare function diffUpdate(original: string[], add?: string[], remove?: string[]): [updated: boolean, newValue: string[], diffText: string];
+export declare const cliOptions: {
+    check: Option<"--check", undefined, false, undefined, false, undefined>;
+    force: Option<"-f, --force", undefined, false, undefined, false, undefined>;
+    global: Option<"-g, --global", undefined, false, undefined, false, undefined>;
+    timeout: Option<"-t, --timeout <ms>", undefined, 1000, void, false, undefined>;
+};
+declare const rl: import("node:readline/promises").Interface;
+export { rl };
+export declare function rlConfirm(question?: string): Promise<void>;

package/dist/cli.js

@@ -1,8 +1,61 @@
-// Supporting code for the CLI. The CLI entry point is main.ts
+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 * as io from 'ioium/node';
 import { styleText } from 'node:util';
 import * as z from 'zod';
-import * as db from './database.js';
+import * as db from './db/index.js';
+import { Option } from 'commander';
+import { createInterface } from 'node:readline/promises';
 export function userText(user, bold = false) {
     const text = `${user.name} <${user.email}> (${user.id})`;
     return bold ? styleText('bold', text) : text;
@@ -45,3 +98,39 @@ export function diffUpdate(original, add, remove) {
         });
     return [!!diffs.length, original, diffs.join(', ')];
 }
+// Options shared by multiple (sub)commands
+export const cliOptions = {
+    check: new Option('--check', 'check the database schema after initialization').default(false),
+    force: new Option('-f, --force', 'force the operation').default(false),
+    global: new Option('-g, --global', 'apply the operation globally').default(false),
+    timeout: new Option('-t, --timeout <ms>', 'how long to wait for commands to complete.').default(1000).argParser(value => {
+        const timeout = parseInt(value);
+        if (!Number.isSafeInteger(timeout) || timeout < 0)
+            io.warn('Invalid timeout value, using default.');
+        io.setCommandTimeout(timeout);
+    }),
+};
+export { rl };
+export async function rlConfirm(question = 'Is this ok') {
+    const { data, error } = z
+        .stringbool()
+        .default(false)
+        .safeParse(await rl.question(question + ' [y/N]: ').catch(() => io.exit('Aborted.')));
+    if (error || !data)
+        io.exit('Aborted.');
+}
+var rl;
+const env_1 = { stack: [], error: void 0, hasError: false };
+try {
+    rl = __addDisposableResource(env_1, createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    }), false);
+}
+catch (e_1) {
+    env_1.error = e_1;
+    env_1.hasError = true;
+}
+finally {
+    __disposeResources(env_1);
+}

package/dist/db/cli.d.ts

@@ -0,0 +1 @@
+export declare function dbInitTables(): Promise<void>;