@axium/server 0.24.0 → 0.25.0

package/dist/requests.js

@@ -1,5 +1,5 @@
 import { userProtectedFields, userPublicFields } from '@axium/core/user';
-import { serialize as serializeCookie } from 'cookie';
+import * as cookie from 'cookie';
 import { pick } from 'utilium';
 import * as z from 'zod';
 import { createSession } from './auth.js';
@@ -29,11 +29,11 @@ export function json(data, init) {
     }
     return response;
 }
-export async function parseBody(event, schema) {
-    const contentType = event.request.headers.get('content-type');
+export async function parseBody(request, schema) {
+    const contentType = request.headers.get('content-type');
     if (!contentType || !contentType.includes('application/json'))
         error(415, 'Invalid content type');
-    const body = await event.request.json().catch(() => error(415, 'Invalid JSON'));
+    const body = await request.json().catch(() => error(415, 'Invalid JSON'));
     try {
         return schema.parse(body);
     }
@@ -41,18 +41,18 @@ export async function parseBody(event, schema) {
         error(400, e instanceof z.core.$ZodError ? z.prettifyError(e) : 'invalid body');
     }
 }
-export function getToken(event, sensitive = false) {
-    const header_token = event.request.headers.get('Authorization')?.replace('Bearer ', '');
+export function getToken(request, sensitive = false) {
+    const header_token = request.headers.get('Authorization')?.replace('Bearer ', '');
     if (header_token)
         return header_token;
     if (config.debug || !config.auth.header_only) {
-        return event.cookies.get(sensitive ? 'elevated_token' : 'session_token');
+        return cookie.parse(request.headers.get('cookie') || '')[sensitive ? 'elevated_token' : 'session_token'];
     }
 }
 export async function createSessionData(userId, elevated = false) {
     const { token, expires } = await createSession(userId, elevated);
     const response = json({ userId, token: elevated ? '[[redacted:elevated]]' : token }, { status: 201 });
-    const cookies = serializeCookie(elevated ? 'elevated_token' : 'session_token', token, {
+    const cookies = cookie.serialize(elevated ? 'elevated_token' : 'session_token', token, {
         httpOnly: true,
         path: '/',
         expires,
@@ -72,18 +72,18 @@ export function withError(text, code = 500) {
         error(code, text + (config.debug && e.message ? `: ${e.message}` : ''));
     };
 }
-export async function handleAPIRequest(event, route) {
-    const method = event.request.method;
+export async function handleAPIRequest(request, params, route) {
+    const method = request.method;
     const _warnings = [];
-    if (route.api && !event.request.headers.get('Accept')?.includes('application/json')) {
+    if (route.api && !request.headers.get('Accept')?.includes('application/json')) {
         _warnings.push('Only application/json is supported');
-        event.request.headers.set('Accept', 'application/json');
+        request.headers.set('Accept', 'application/json');
     }
     for (const [key, type] of Object.entries(route.params || {})) {
         if (!type)
             continue;
         try {
-            event.params[key] = type.parse(event.params[key]);
+            params[key] = type.parse(params[key]);
         }
         catch (e) {
             error(400, `Invalid parameter: ${e instanceof z.core.$ZodError ? z.prettifyError(e) : '<unknown error>'}`);
@@ -91,7 +91,7 @@ export async function handleAPIRequest(event, route) {
     }
     if (typeof route[method] != 'function')
         error(405, `Method ${method} not allowed for ${route.path}`);
-    const result = await route[method](event);
+    const result = await route[method].call(route, request, params);
     if (result instanceof Response)
         return result;
     if (typeof result == 'object' || typeof result == 'function') {

package/dist/routes.d.ts

@@ -1,10 +1,9 @@
 import type { RequestMethod } from '@axium/core/requests';
 import type { Component } from 'svelte';
 import type z from 'zod';
-import type { RequestEvent } from './requests.js';
 type _Params = Partial<Record<string, string>>;
-type MaybePromise<T> = T | Promise<T>;
-export type EndpointHandlers<Params extends _Params = _Params> = Partial<Record<RequestMethod, (event: RequestEvent<Params>) => MaybePromise<object | Response>>>;
+export type MaybePromise<T> = T | Promise<T>;
+export type EndpointHandlers<Params extends _Params = _Params, This = unknown> = Partial<Record<RequestMethod, (this: This, request: Request, params: Params) => MaybePromise<object | Response>>>;
 export type RouteParamOptions = z.ZodType;
 export interface CommonRouteOptions<Params extends _Params = _Params> {
     path: string;
@@ -15,11 +14,11 @@ export interface CommonRouteOptions<Params extends _Params = _Params> {
 /**
  * A route with server-side handlers for different HTTP methods.
  */
-export interface ServerRouteOptions<Params extends _Params = _Params> extends CommonRouteOptions<Params>, EndpointHandlers<Params> {
+export interface ServerRouteOptions<Params extends _Params = _Params> extends CommonRouteOptions<Params>, EndpointHandlers<Params, RouteCommon> {
     api?: boolean;
 }
 export interface WebRouteOptions extends CommonRouteOptions {
-    load?(event: RequestEvent): object | Promise<object>;
+    load?(request: Request): object | Promise<object>;
     /** the Svelte page */
     page?: Component;
 }
@@ -34,7 +33,7 @@ export interface ServerRoute extends RouteCommon, EndpointHandlers {
 }
 export interface WebRoute extends RouteCommon {
     server: false;
-    load?(event: RequestEvent): object | Promise<object>;
+    load?(request: Request): object | Promise<object>;
     page: Component;
 }
 export type Route = ServerRoute | WebRoute;
@@ -50,8 +49,5 @@ export declare function addRoute(opt: RouteOptions): void;
  * Resolve a request URL into a route.
  * This handles parsing of parameters in the URL.
  */
-export declare function resolveRoute(event: {
-    url: URL;
-    params?: object;
-}): Route | undefined;
+export declare function resolveRoute(url: URL): [Route, params: object] | void;
 export {};

package/dist/routes.js

@@ -25,10 +25,10 @@ export function addRoute(opt) {
  * Resolve a request URL into a route.
  * This handles parsing of parameters in the URL.
  */
-export function resolveRoute(event) {
-    const { pathname } = event.url;
+export function resolveRoute(url) {
+    const { pathname } = url;
     if (routes.has(pathname) && !pathname.split('/').some(p => p.startsWith(':')))
-        return routes.get(pathname);
+        return [routes.get(pathname), {}];
     // Otherwise we must have a parameterized route
     _routes: for (const route of routes.values()) {
         const params = {};
@@ -50,7 +50,6 @@ export function resolveRoute(event) {
         // we didn't find a match, since an exact match would have been found already
         if (pathParts.length || !Object.keys(params).length)
             continue;
-        event.params = params;
-        return route;
+        return [route, params];
     }
 }

package/dist/serve.d.ts

@@ -1,12 +1,13 @@
-import type { Server } from 'node:http';
 import '@axium/server/api/index';
+import type { Server } from 'node:http';
 export interface ServeOptions {
     secure: boolean;
     ssl_key: string;
     ssl_cert: string;
     build: string;
+    multiBuild: boolean;
 }
-export declare function serveSvelteKit(opt: Partial<ServeOptions>): Promise<Server>;
+export declare function serve(opt: Partial<ServeOptions>): Promise<Server>;
 /**
  * Perform initial setup for when the server is serving web pages.
  */

package/dist/serve.js

@@ -1,19 +1,171 @@
-import { readFileSync } from 'node:fs';
-import { createServer } from 'node:http';
-import { createServer as createSecureServer } from 'node:https';
-import config from './config.js';
 import '@axium/server/api/index';
-import { loadDefaultConfigs } from '@axium/server/config';
+import { loadDefaultConfigs, reloadConfigs } from '@axium/server/config';
 import { clean, connect, database } from '@axium/server/database';
-import { dirs, logger, output } from '@axium/server/io';
+import { _debugOutput, dirs, logger, output } from '@axium/server/io';
 import { allLogLevels } from 'logzen';
-import { createWriteStream } from 'node:fs';
+import { createWriteStream, readFileSync } from 'node:fs';
+import { createServer, ServerResponse } from 'node:http';
+import { createServer as createSecureServer } from 'node:https';
 import { join } from 'node:path/posix';
-export async function serveSvelteKit(opt) {
-    const { handler } = await import(opt.build || config.web.build);
+import { styleText } from 'node:util';
+import { appDisabledContent, apps } from './apps.js';
+import config from './config.js';
+import { convertFromResponse, convertToRequest } from './internal_requests.js';
+import { plugins } from './plugins.js';
+import { error, handleAPIRequest, handleResponseError, json, noCacheHeaders } from './requests.js';
+import { resolveRoute } from './routes.js';
+const template = readFileSync(join(import.meta.dirname, '../template.html'), 'utf-8');
+function fillSvelteKitTemplate({ head, body }, env = {}, nonce = '') {
+    return (template
+        .replaceAll('%sveltekit.head%', head)
+        .replaceAll('%sveltekit.body%', body)
+        .replaceAll('%sveltekit.assets%', '')
+        // Unused for now.
+        .replaceAll('%sveltekit.nonce%', nonce)
+        .replace(/%sveltekit\.env\.([^%]+)%/g, (_match, key) => env[key] ?? ''));
+}
+async function handleRequestDefault(req) {
+    const url = new URL(req.url);
+    const [route, params] = resolveRoute(url) ?? [];
+    if (!route && url.pathname === '/' && config.debug_home)
+        return new Response(null, { status: 303, headers: { Location: '/_axium/default' } });
+    if (config.debug)
+        console.log(styleText('blueBright', req.method.padEnd(7)), route ? route.path : url.pathname);
+    if (!route) {
+        // Check to see if this is for an app that is disabled.
+        const maybeApp = url.pathname.split('/')[1];
+        if (apps.has(maybeApp) && config.apps.disabled.includes(maybeApp)) {
+            const body = fillSvelteKitTemplate(appDisabledContent);
+            return new Response(body, { headers: noCacheHeaders, status: 503 });
+        }
+        return new Response('Not Found', { status: 404 });
+    }
+    if (route.server == true) {
+        if (route.api)
+            return await handleAPIRequest(req, params, route).catch(handleResponseError);
+        const run = route[req.method];
+        if (typeof run !== 'function') {
+            error(405, `Method ${req.method} not allowed for ${route.path}`);
+        }
+        try {
+            const result = await run(req, params);
+            if (result instanceof Response)
+                return result;
+            return json(result);
+        }
+        catch (e) {
+            return handleResponseError(e);
+        }
+    }
+    /* const data = await route.load?.(req);
+
+    const body = fillSvelteKitTemplate(render(route.page, { props: { data } }));
+
+    return new Response(body, {
+        headers: config.web.disable_cache ? noCacheHeaders : {},
+        status: 200,
+    }); */
+    return json({ message: 'Not Implemented' }, { status: 501 });
+}
+const kNext = Symbol('next');
+function __next(error) {
+    throw { [kNext]: error };
+}
+async function _getMultiBuildHandler() {
+    const handlers = [];
+    for (const plugin of plugins.values()) {
+        if (!plugin.http_handler)
+            continue;
+        try {
+            const { handler } = await import(join(plugin.dirname, plugin.http_handler));
+            handlers.push(handler);
+            output.debug(`Loaded plugin handler: ${plugin.name}`);
+        }
+        catch (e) {
+            output.warn(`Failed to load plugin HTTP handler for ${plugin.name} ${_debugOutput ? ': ' + (e instanceof Error ? e.message : e) : ''}`);
+        }
+    }
+    // @ts-expect-error 7016 - it is plain JS
+    const { handler: handleFrontendRequest } = await import('../build/handler.js');
+    handlers.push(handleFrontendRequest);
+    function handle(incoming, response) {
+        for (const handler of handlers) {
+            const maybeResponse = new ServerResponse(incoming);
+            try {
+                handler(incoming, maybeResponse, __next);
+            }
+            catch (e) {
+                if (!e || !(kNext in e)) {
+                    response.statusCode = 500;
+                    response.end('Internal Server Error');
+                    console.error(e);
+                    return;
+                }
+                console.debug(`next@${handler.name} (${e[kNext]})`);
+            }
+            if (maybeResponse.statusCode != 404) {
+                response.setHeaders(new Map(Object.entries(maybeResponse.getHeaders())));
+            }
+        }
+        const req = convertToRequest(incoming);
+        void handleRequestDefault(req).then(res => convertFromResponse(response, res));
+    }
+    return handle;
+}
+async function _runRoute(run, request, params) {
+    try {
+        const result = await run(request, params);
+        if (result instanceof Response)
+            return result;
+        return json(result);
+    }
+    catch (e) {
+        return handleResponseError(e);
+    }
+}
+async function _getLinkedBuildHandler(buildPath = '../build/handler.js') {
+    const { handler: handleFrontendRequest } = await import(buildPath);
+    return function handle(req, res) {
+        const url = new URL(req.url, config.auth.origin);
+        const [route, params = {}] = resolveRoute(url) ?? [];
+        if (!route && url.pathname === '/' && config.debug_home) {
+            res.writeHead(303, { Location: '/_axium/default' }).end();
+            return;
+        }
+        if (config.debug)
+            console.log(styleText('blueBright', req.method.padEnd(7)), route ? route.path : url.pathname);
+        if (route && route.server == true) {
+            const request = convertToRequest(req);
+            if (route.api) {
+                void handleAPIRequest(request, params, route)
+                    .catch(handleResponseError)
+                    .then(response => convertFromResponse(res, response));
+                return;
+            }
+            const run = route[request.method]?.bind(route);
+            if (typeof run !== 'function') {
+                res.writeHead(405).end(`Method ${request.method} not allowed for ${route.path}`);
+                return;
+            }
+            void _runRoute(run, request, params).then(response => convertFromResponse(res, response));
+            return;
+        }
+        // Check to see if this is for an app that is disabled.
+        const maybeApp = url.pathname.split('/')[1];
+        if (apps.has(maybeApp) && config.apps.disabled.includes(maybeApp)) {
+            const body = fillSvelteKitTemplate(appDisabledContent);
+            res.writeHead(503, noCacheHeaders).end(body);
+            return;
+        }
+        handleFrontendRequest(req, res);
+        return;
+    };
+}
+export async function serve(opt) {
+    const handle = await _getLinkedBuildHandler(opt.build);
     if (!opt.secure && !config.web.secure)
-        return createServer(handler);
-    return createSecureServer({ key: readFileSync(opt.ssl_key || config.web.ssl_key), cert: readFileSync(opt.ssl_cert || config.web.ssl_cert) }, handler);
+        return createServer(handle);
+    return createSecureServer({ key: readFileSync(opt.ssl_key || config.web.ssl_key), cert: readFileSync(opt.ssl_cert || config.web.ssl_cert) }, handle);
 }
 /**
  * Perform initial setup for when the server is serving web pages.
@@ -26,7 +178,7 @@ export async function init() {
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
     process.on('beforeExit', () => database.destroy());
     process.on('SIGHUP', () => {
-        output.info('Reloading configuration.');
-        void loadDefaultConfigs();
+        output.info('Reloading configuration due to SIGHUP.');
+        void reloadConfigs();
     });
 }

package/dist/state.js

@@ -1,7 +1,8 @@
 import { styleText } from 'node:util';
 const sym = Symbol.for('Axium:state');
 globalThis[sym] ||= Object.create({ _errored: false });
-let _doWarnings = false;
+const { SHOW_DUPLICATE_STATE } = process.env;
+let _doWarnings = SHOW_DUPLICATE_STATE ? ['1', 'true', 'y', 'yes'].includes(SHOW_DUPLICATE_STATE.toLowerCase()) : false;
 export function _duplicateStateWarnings(value) {
     _doWarnings = value;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@axium/server",
-	"version": "0.24.0",
-	"author": "James Prevett <axium@jamespre.dev> (https://jamespre.dev)",
+	"version": "0.25.0",
+	"author": "James Prevett <axium@jamespre.dev>",
 	"funding": {
 		"type": "individual",
 		"url": "https://github.com/sponsors/james-pre"
@@ -33,7 +33,8 @@
 		"dist",
 		"routes",
 		"svelte.config.js",
-		"web",
+		"web.tsconfig.json",
+		"template.html",
 		"vite.config.js",
 		"axiumd.service"
 	],
@@ -45,8 +46,8 @@
 		"clean": "rm -rf build .svelte-kit node_modules/{.vite,.vite-temp}"
 	},
 	"peerDependencies": {
-		"@axium/client": ">=0.4.0",
-		"@axium/core": ">=0.7.0",
+		"@axium/client": ">=0.5.0",
+		"@axium/core": ">=0.8.0",
 		"kysely": "^0.28.0",
 		"utilium": "^2.3.8",
 		"zod": "^4.0.5"

package/routes/account/+page.svelte

@@ -1,16 +1,8 @@
 <script lang="ts">
-	import {
-		createPasskey,
-		deletePasskey,
-		deleteUser,
-		logout,
-		logoutAll,
-		sendVerificationEmail,
-		updatePasskey,
-		updateUser,
-	} from '@axium/client/user';
+	import { ClipboardCopy, FormDialog, Icon, Logout, Preferences, SessionList } from '@axium/client/components';
+	import '@axium/client/styles/account';
+	import { createPasskey, deletePasskey, deleteUser, sendVerificationEmail, updatePasskey, updateUser } from '@axium/client/user';
 	import { getUserImage } from '@axium/core/user';
-	import { ClipboardCopy, FormDialog, Icon, Logout, Preferences } from '@axium/client/components';
 	import type { PageProps } from './$types';
 
 	const { data }: PageProps = $props();
@@ -31,7 +23,7 @@
 </script>
 
 <svelte:head>
-	<title>Account</title>
+	<title>Your Account</title>
 </svelte:head>
 
 {#snippet action(name: string, i: string = 'pen')}
@@ -159,45 +151,7 @@
 
 	<div class="section main">
 		<h3>Sessions</h3>
-		{#each sessions as session}
-			<div class="item session">
-				<p>
-					{session.id.slice(0, 4)}...{session.id.slice(-4)}
-					{#if session.id == currentSession.id}
-						<span class="current">Current</span>
-					{/if}
-					{#if session.elevated}
-						<span class="elevated">Elevated</span>
-					{/if}
-				</p>
-				<p>Created {session.created.toLocaleString()}</p>
-				<p>Expires {session.expires.toLocaleString()}</p>
-				{@render action('logout#' + session.id, 'right-from-bracket')}
-			</div>
-			<FormDialog
-				bind:dialog={dialogs['logout#' + session.id]}
-				submit={async () => {
-					await logout(user.id, session.id);
-					dialogs['logout#' + session.id].remove();
-					sessions.splice(sessions.indexOf(session), 1);
-					if (session.id == currentSession.id) window.location.href = '/';
-				}}
-				submitText="Logout"
-			>
-				<p>Are you sure you want to log out this session?</p>
-			</FormDialog>
-		{/each}
-		<span>
-			<button onclick={() => dialogs.logout_all.showModal()} class="danger">Logout All</button>
-		</span>
-		<FormDialog
-			bind:dialog={dialogs['logout_all']}
-			submit={() => logoutAll(user.id).then(() => (window.location.href = '/'))}
-			submitText="Logout All Sessions"
-			submitDanger
-		>
-			<p>Are you sure you want to log out all sessions?</p>
-		</FormDialog>
+		<SessionList {sessions} {currentSession} {user} redirectAfterLogoutAll />
 	</div>
 
 	<div class="section main">
@@ -233,62 +187,4 @@
 	.signout {
 		margin-top: 2em;
 	}
-
-	.section {
-		width: 50%;
-		padding-top: 4em;
-
-		/* This is causing duplicate separators when removing sessions/passkeys
-		> div:has(+ div) {
-			border-bottom: 1px solid #8888;
-		}
-		*/
-	}
-
-	.section .item {
-		display: grid;
-		align-items: center;
-		width: 100%;
-		gap: 1em;
-		text-wrap: nowrap;
-		border-top: 1px solid #8888;
-		padding-bottom: 1em;
-	}
-
-	.info {
-		grid-template-columns: 10em 1fr 2em;
-
-		> :first-child {
-			margin-left: 1em;
-		}
-
-		> :nth-child(2) {
-			text-overflow: ellipsis;
-			overflow: hidden;
-		}
-	}
-
-	.passkey {
-		grid-template-columns: 1em 1em 1fr 1fr 1em 1em;
-
-		dfn:not(.disabled) {
-			cursor: help;
-		}
-	}
-
-	.session {
-		grid-template-columns: 1fr 1fr 1fr 1em;
-
-		.current {
-			border-radius: 2em;
-			padding: 0 0.5em;
-			background-color: #337;
-		}
-
-		.elevated {
-			border-radius: 2em;
-			padding: 0 0.5em;
-			background-color: #733;
-		}
-	}
 </style>

package/routes/admin/+layout.svelte

@@ -0,0 +1,56 @@
+<script lang="ts">
+	import { Icon } from '@axium/client/components';
+	import { capitalize } from 'utilium';
+
+	let { children, data } = $props();
+</script>
+
+<div id="admin-container">
+	<div class="sidebar">
+		{#each data.tabs as { href, name, icon: i, active }}
+			<a {href} class={['item', 'icon-text', active && 'active']}><Icon {i} /> {capitalize(name)}</a>
+		{/each}
+	</div>
+
+	<div id="admin-content">
+		{@render children()}
+	</div>
+</div>
+
+<style>
+	#admin-container {
+		display: grid;
+		grid-template-columns: 15em 1fr;
+		height: 100%;
+	}
+
+	.sidebar {
+		grid-column: 1;
+		width: 100%;
+		display: inline-flex;
+		flex-direction: column;
+		gap: 0.5em;
+		padding-left: 1em;
+	}
+
+	.item {
+		padding: 0.3em 0.5em;
+		border-radius: 0.25em 1em 1em 0.25em;
+	}
+
+	.item:hover {
+		background-color: var(--bg-accent);
+		cursor: pointer;
+	}
+
+	.item.active {
+		background-color: var(--bg-accent);
+	}
+
+	#admin-content {
+		grid-column: 2;
+		padding: 1em;
+		overflow-x: hidden;
+		overflow-y: scroll;
+	}
+</style>

package/routes/admin/+layout.ts

@@ -0,0 +1,29 @@
+import { getCurrentSession } from '@axium/client/user';
+import type { Session, User } from '@axium/core';
+import type { LayoutLoadEvent, LayoutRouteId } from './$types';
+
+export const ssr = false;
+
+export async function load({
+	parent,
+	route,
+}: Omit<LayoutLoadEvent, 'parent'> & { parent?(): Promise<{ session?: Session & { user: User } }> }) {
+	let { session } = (await parent?.()) ?? { session: null };
+
+	const tabs = [
+		{ name: 'dashboard', href: '/admin', icon: 'gauge', active: route.id.endsWith('/admin') },
+		{
+			name: 'users',
+			href: '/admin/users',
+			icon: 'user-group',
+			active: route.id.endsWith('/admin/users') || route.id.endsWith('/admin/users/[id]'),
+		},
+		{ name: 'configuration', href: '/admin/config', icon: 'sliders', active: route.id.endsWith('/admin/config') },
+		{ name: 'plugins', href: '/admin/plugins', icon: 'puzzle-piece-simple', active: route.id.endsWith('/admin/plugins') },
+		{ name: 'audit log', href: '/admin/audit', icon: 'file-shield', active: route.id.endsWith('/admin/audit') },
+	] satisfies { name: string; href: LayoutRouteId; icon: string; active: boolean }[];
+
+	session ||= await getCurrentSession().catch(() => null);
+
+	return { session, tabs };
+}

package/routes/admin/+page.svelte

@@ -0,0 +1,39 @@
+<script>
+	import { Severity } from '@axium/core';
+
+	const { data } = $props();
+</script>
+
+<svelte:head>
+	<title>Admin — Dashboard</title>
+</svelte:head>
+
+<h2>Administration</h2>
+
+<p>Axium Server version {data.version}</p>
+
+<h3><a href="/admin/users">Users</a></h3>
+
+<p>{data.users} users, {data.sessions} sessions, {data.passkeys} passkeys.</p>
+
+<h3><a href="/admin/config">Configuration</a></h3>
+
+<p>{data.configFiles} files loaded.</p>
+
+<h3><a href="/admin/plugins">Plugins</a></h3>
+
+<p>{data.plugins} plugins loaded.</p>
+
+<h3><a href="/admin/audit">Audit Log</a></h3>
+
+<p>
+	{Object.entries(data.auditEvents)
+		.map(([severity, count]) => `${count} ${Severity[severity].toUpperCase()} events`)
+		.join(', ')}.
+</p>
+
+<style>
+	h3 {
+		text-decoration: underline;
+	}
+</style>

package/routes/admin/+page.ts

@@ -0,0 +1,7 @@
+import { fetchAPI } from '@axium/client/requests';
+
+export const ssr = false;
+
+export async function load() {
+	return await fetchAPI('GET', 'admin/summary');
+}