@axium/core 0.13.0 → 0.15.0

package/dist/api.d.ts

@@ -5,8 +5,9 @@ import type { AccessControl, AccessMap } from './access.js';
 import type { App } from './apps.js';
 import type { AuditEvent, AuditFilter, Severity } from './audit.js';
 import type { NewSessionResponse, Session, Verification } from './auth.js';
+import type { PackageVersionInfo } from './packages.js';
 import type { Passkey, PasskeyAuthenticationResponse, PasskeyChangeable, PasskeyRegistration } from './passkeys.js';
-import type { PluginInternal, PluginVersionInfo } from './plugins.js';
+import type { PluginInternal } from './plugins.js';
 import type { RequestMethod } from './requests.js';
 import type { LogoutSessions, User, UserAuthOptions, UserChangeable, UserInternal, UserPublic, UserRegistration } from './user.js';
 export interface AdminSummary {
@@ -16,7 +17,7 @@ export interface AdminSummary {
     auditEvents: Record<keyof typeof Severity, number>;
     configFiles: number;
     plugins: number;
-    version: string;
+    versions: Record<'core' | 'server' | 'client', PackageVersionInfo>;
 }
 /**
  * Types for all API endpoints
@@ -25,12 +26,11 @@ export interface AdminSummary {
 export interface $API {
     metadata: {
         GET: {
-            version: string;
+            versions: PackageVersionInfo[];
             routes: Record<string, {
                 params: Record<string, string | null>;
                 methods: string[];
             }>;
-            plugins: Record<string, string>;
         };
     };
     apps: {
@@ -116,7 +116,7 @@ export interface $API {
         };
     };
     'admin/plugins': {
-        GET: (Omit<PluginInternal, '_hooks' | '_client'> & PluginVersionInfo)[];
+        GET: (Omit<PluginInternal, '_hooks' | '_client'> & PackageVersionInfo)[];
     };
     'admin/audit/events': {
         OPTIONS: {

package/dist/io.d.ts

@@ -35,6 +35,7 @@ export declare function useOutput(output: ConsoleLike): void;
  * rather than fatally exiting.
  */
 export declare function someWarnings(...allowList: [RegExp, string?][]): (error: string | Error) => void;
+export declare function errorText(error: unknown): string;
 /** @hidden @internal for Logzen */
 export declare const constructor: {
     name: string;

package/dist/io.js

@@ -1,3 +1,4 @@
+import { $ZodError, prettifyError } from 'zod/v4/core';
 const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
 // Shortcut to convert to 2-digit. Mostly used to make the line shorter.
 const _2 = (v) => v.toString().padStart(2, '0');
@@ -53,5 +54,12 @@ export function someWarnings(...allowList) {
         throw error;
     };
 }
+export function errorText(error) {
+    if (error instanceof $ZodError)
+        return prettifyError(error);
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
 /** @hidden @internal for Logzen */
 export const constructor = { name: 'Console' };

package/dist/node/io.d.ts

@@ -1,4 +1,4 @@
-import * as z from 'zod';
+import type * as z from 'zod';
 export * from '../io.js';
 export declare function setCommandTimeout(value: number): void;
 /**
@@ -7,8 +7,7 @@ export declare function setCommandTimeout(value: number): void;
  */
 export declare function run(message: string, command: string): Promise<string>;
 /** Yet another convenience function */
-export declare function exit(message: string | Error, code?: number): never;
-export declare function handleError(e: number | string | Error): never;
+export declare function exit(message: unknown, code?: number): never;
 /**
  *
  * @param defaultValue Returned when the file can't be loaded. If omitted, loading errors will be thrown.

package/dist/node/io.js

@@ -51,10 +51,9 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { exec } from 'node:child_process';
-import { writeFileSync, readFileSync } from 'node:fs';
+import { readFileSync, writeFileSync } from 'node:fs';
 import { styleText } from 'node:util';
 import * as io from '../io.js';
-import * as z from 'zod';
 export * from '../io.js';
 let _currentOperation = null, _progress = null;
 function handleProgress() {
@@ -217,17 +216,15 @@ export async function run(message, command) {
 }
 /** Yet another convenience function */
 export function exit(message, code = 1) {
+    if (typeof message == 'number') {
+        code = message;
+        message = 'Unknown error!';
+    }
     if (message instanceof Error)
         message = message.message;
     io.error(message);
     process.exit(code);
 }
-export function handleError(e) {
-    if (typeof e == 'number')
-        process.exit(e);
-    else
-        exit(e);
-}
 /**
  *
  * @param defaultValue Returned when the file can't be loaded. If omitted, loading errors will be thrown.
@@ -238,7 +235,7 @@ export function readJSON(path, schema) {
         return schema.parse(data);
     }
     catch (e) {
-        throw e instanceof z.core.$ZodError ? z.prettifyError(e) : e instanceof Error ? e.message : e;
+        throw io.errorText(e);
     }
 }
 export function writeJSON(path, data) {

package/dist/node/plugins.js

@@ -1,11 +1,11 @@
 import * as io from '@axium/core/node/io';
 import { Plugin, plugins } from '@axium/core/plugins';
 import * as fs from 'node:fs';
-import { dirname, join, resolve } from 'node:path/posix';
-import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path/posix';
 import { styleText } from 'node:util';
-import * as z from 'zod';
+import { _throw } from 'utilium';
 import { apps } from '../apps.js';
+import { locatePackage } from '../packages.js';
 export function* pluginText(plugin) {
     yield styleText('whiteBright', plugin.name);
     yield `Version: ${plugin.version}`;
@@ -19,24 +19,9 @@ export function* pluginText(plugin) {
         yield `Hooks: ${plugin._client ? styleText(['dim', 'bold'], `(${Object.keys(plugin._client).length}) `) + Object.keys(plugin._client).join(', ') : plugin.client.hooks || styleText('dim', '(none)')}`;
     }
 }
-function _locatePlugin(specifier, loadedBy) {
-    if (specifier[0] == '/' || ['.', '..'].includes(specifier.split('/')[0])) {
-        const path = resolve(dirname(loadedBy), specifier);
-        const stats = fs.statSync(path);
-        if (stats.isFile())
-            return path;
-        if (!stats.isDirectory())
-            throw new Error('Can not resolve plugin path: ' + path);
-        return join(path, 'package.json');
-    }
-    let packageDir = dirname(fileURLToPath(import.meta.resolve(specifier)));
-    for (; !fs.existsSync(join(packageDir, 'package.json')); packageDir = dirname(packageDir))
-        ;
-    return join(packageDir, 'package.json');
-}
 export async function loadPlugin(mode, specifier, loadedBy, safeMode = false) {
     try {
-        const path = _locatePlugin(specifier, loadedBy);
+        const path = locatePackage(specifier, loadedBy);
         io.debug(`Loading plugin at ${path} (from ${loadedBy})`);
         let imported;
         try {
@@ -47,9 +32,14 @@ export async function loadPlugin(mode, specifier, loadedBy, safeMode = false) {
         }
         if ('axium' in imported)
             Object.assign(imported, imported.axium); // support axium field in package.json
-        const plugin = Object.assign(await Plugin.parseAsync(imported).catch(e => {
-            throw e instanceof z.core.$ZodError ? z.prettifyError(e) : e;
-        }), { path, specifier, loadedBy, dirname: dirname(path), cli: imported[mode]?.cli, isServer: mode === 'server' });
+        const plugin = Object.assign(await Plugin.parseAsync(imported).catch(e => _throw(io.errorText(e))), {
+            path,
+            specifier,
+            loadedBy,
+            dirname: dirname(path),
+            cli: imported[mode]?.cli,
+            isServer: mode === 'server',
+        });
         if (!plugin[mode])
             throw `Plugin does not support running ${mode}-side`;
         if (!safeMode) {

package/dist/packages.d.ts

@@ -0,0 +1,12 @@
+export declare function locatePackage(specifier: string, loadedBy: string): string;
+export interface PackageVersionInfo {
+    name: string;
+    version: string;
+    latest: string | null;
+}
+export declare function setPackageCacheTTL(seconds: number): void;
+/**
+ * @param name Package name
+ * @param version The current/installed version
+ */
+export declare function getVersionInfo(specifier: string, from?: string): Promise<PackageVersionInfo>;

package/dist/packages.js

@@ -0,0 +1,51 @@
+import * as fs from 'node:fs';
+import { dirname, join, resolve } from 'node:path/posix';
+import { fileURLToPath } from 'node:url';
+import { lt as ltVersion } from 'semver';
+import { warn } from './io.js';
+function isRelative(specifier) {
+    return specifier[0] == '/' || ['.', '..'].includes(specifier.split('/')[0]);
+}
+export function locatePackage(specifier, loadedBy) {
+    if (isRelative(specifier)) {
+        const path = resolve(dirname(loadedBy), specifier);
+        const stats = fs.statSync(path);
+        if (stats.isFile())
+            return path;
+        if (!stats.isDirectory())
+            throw new Error('Can not resolve package path: ' + path);
+        return join(path, 'package.json');
+    }
+    let packageDir = dirname(fileURLToPath(import.meta.resolve(specifier)));
+    for (; !fs.existsSync(join(packageDir, 'package.json')); packageDir = dirname(packageDir))
+        ;
+    return join(packageDir, 'package.json');
+}
+let cacheTTL = 1000 * 60 * 60;
+export function setPackageCacheTTL(seconds) {
+    cacheTTL = seconds * 1000;
+}
+const cache = new Map();
+/**
+ * @param name Package name
+ * @param version The current/installed version
+ */
+export async function getVersionInfo(specifier, from = import.meta.filename) {
+    const path = locatePackage(specifier, from);
+    const { version, name } = JSON.parse(fs.readFileSync(path, 'utf8'));
+    const info = { name, version, latest: null };
+    if (isRelative(specifier))
+        return info;
+    const cached = cache.get(specifier);
+    const useCache = cached && Date.now() - cached.timestamp < cacheTTL;
+    try {
+        const pkg = useCache ? cached.data : await fetch('https://registry.npmjs.org/' + specifier).then(res => res.json());
+        if (!useCache)
+            cache.set(specifier, { timestamp: Date.now(), data: pkg });
+        info.latest = pkg['dist-tags']?.latest || Object.keys(pkg.versions).sort((a, b) => (ltVersion(a, b) ? 1 : -1))[0];
+    }
+    catch (e) {
+        warn(`Failed to fetch version info for package ${name}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    return info;
+}

package/dist/plugins.d.ts

@@ -67,8 +67,4 @@ export interface ClientHooks {
     run(): void | Promise<void>;
 }
 export declare function runIntegrations(): Promise<void>;
-export interface PluginVersionInfo {
-    latest: string | null;
-}
-export declare function getVersionInfo(plugin: PluginInternal): Promise<PluginVersionInfo>;
 export {};

package/dist/plugins.js

@@ -1,8 +1,7 @@
 import * as z from 'zod';
-import { zAsyncFunction } from './schemas.js';
 import { App } from './apps.js';
-import { debug, info, warn } from './io.js';
-import { lt as ltVersion } from 'semver';
+import { debug, warn } from './io.js';
+import { zAsyncFunction } from './schemas.js';
 const PluginCommon = z.object({
     /** CLI mixin path */
     cli: z.string().optional(),
@@ -58,17 +57,3 @@ export async function runIntegrations() {
         }
     }
 }
-export async function getVersionInfo(plugin) {
-    if (!plugin.update_checks)
-        return { latest: null };
-    try {
-        const res = await fetch('https://registry.npmjs.org/' + plugin.name);
-        const pkg = await res.json();
-        const latest = pkg['dist-tags']?.latest || Object.keys(pkg.versions).sort((a, b) => (ltVersion(a, b) ? 1 : -1))[0];
-        return { latest };
-    }
-    catch (e) {
-        warn(`Failed to fetch version info for plugin ${plugin.name}: ${e instanceof Error ? e.message : String(e)}`);
-        return { latest: null };
-    }
-}

package/dist/preferences.d.ts

@@ -6,18 +6,17 @@ type ZodPrefComposite = ZodPrefPrimitive | z.ZodNullable<ZodPrefPrimitive> | z.Z
 /** @internal Used so we can narrow using `type` and get access to type-specific properties (e.g. `ZodNumber.minValue`) */
 export type ZodPref = ZodPrefComposite | z.ZodObject<Readonly<Record<string, ZodPrefComposite>>>;
 /**
- * Interface for the user preferences schema shape.
- * Modify with `declare module ...`.
+ * @internal
  */
-export interface PreferenceSchemas {
+export declare let Preferences: z.ZodObject<{
     debug: z.ZodBoolean;
-}
-export type PreferenceName = keyof PreferenceSchemas & string;
+}, z.core.$strip>;
 /**
- * @internal
+ * Interface for the user preferences schema shape.
+ * Modify with `declare module ...`.
  */
-export declare const preferenceSchemas: PreferenceSchemas;
-export type Preferences = z.infer<z.ZodObject<Readonly<PreferenceSchemas>>>;
+export interface Preferences extends z.infer<typeof Preferences> {
+}
 /**
  * @internal
  */
@@ -26,14 +25,14 @@ export declare const preferenceDefaults: Preferences;
  * @internal
  * @todo Implement proper localization
  */
-export declare const preferenceLabels: Record<PreferenceName, string>;
-export declare const preferenceDescriptions: Partial<Record<PreferenceName, string>>;
-export interface PreferenceInit<T extends PreferenceName = PreferenceName> {
+export declare const preferenceLabels: Record<keyof Preferences, string>;
+export declare const preferenceDescriptions: Partial<Record<keyof Preferences, string>>;
+export interface PreferenceInit<T extends keyof Preferences = keyof Preferences, S extends ZodPref = ZodPref> {
     name: T;
-    schema: PreferenceSchemas[T] & ZodPref;
-    initial: z.infer<PreferenceSchemas[T] & ZodPref>;
+    schema: S;
+    initial: z.infer<S> & Preferences[T];
     label: string;
     descriptions?: string;
 }
-export declare function addPreference<T extends PreferenceName = PreferenceName>(init: PreferenceInit<T>): void;
+export declare function addPreference<T extends keyof Preferences = keyof Preferences>(init: PreferenceInit<T>): void;
 export {};

package/dist/preferences.js

@@ -2,9 +2,9 @@ import * as z from 'zod';
 /**
  * @internal
  */
-export const preferenceSchemas = {
+export let Preferences = z.object({
     debug: z.boolean(),
-};
+});
 /**
  * @internal
  */
@@ -20,7 +20,7 @@ export const preferenceLabels = {
 };
 export const preferenceDescriptions = {};
 export function addPreference(init) {
-    preferenceSchemas[init.name] = init.schema;
+    Preferences = z.object({ ...Preferences.shape, [init.name]: init.schema });
     preferenceDefaults[init.name] = init.initial;
     preferenceLabels[init.name] = init.label;
     preferenceDescriptions[init.name] = init.descriptions;

package/dist/user.d.ts

@@ -1,18 +1,18 @@
 import * as z from 'zod';
-import type { Preferences } from './preferences.js';
 export declare const User: z.ZodObject<{
     id: z.ZodUUID;
     name: z.ZodString;
     email: z.ZodEmail;
     emailVerified: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
     image: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
-    preferences: z.ZodRecord<z.ZodString, z.ZodAny>;
+    preferences: z.ZodObject<{
+        debug: z.ZodBoolean;
+    }, z.core.$strip>;
     roles: z.ZodArray<z.ZodString>;
     registeredAt: z.ZodCoercedDate<unknown>;
     isAdmin: z.ZodBoolean;
 }, z.core.$strip>;
 export interface User extends z.infer<typeof User> {
-    preferences: Preferences;
 }
 export interface UserInternal extends User {
     isSuspended: boolean;
@@ -26,7 +26,9 @@ export declare const UserPublic: z.ZodObject<{
     email: z.ZodOptional<z.ZodEmail>;
     emailVerified: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodDate>>>;
     image: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
-    preferences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    preferences: z.ZodOptional<z.ZodObject<{
+        debug: z.ZodBoolean;
+    }, z.core.$strip>>;
     roles: z.ZodArray<z.ZodString>;
     registeredAt: z.ZodCoercedDate<unknown>;
     isAdmin: z.ZodOptional<z.ZodBoolean>;
@@ -37,11 +39,12 @@ export declare const userProtectedFields: ["email", "emailVerified", "preference
 export declare const UserChangeable: z.ZodObject<{
     email: z.ZodOptional<z.ZodEmail>;
     name: z.ZodOptional<z.ZodString>;
+    preferences: z.ZodOptional<z.ZodObject<{
+        debug: z.ZodBoolean;
+    }, z.core.$strip>>;
     image: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodURL>>>;
-    preferences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
 }, z.core.$strip>;
 export interface UserChangeable extends z.infer<typeof UserChangeable> {
-    preferences?: Preferences;
 }
 export declare function getUserImage(user: Partial<User>): string;
 export declare const UserRegistration: z.ZodObject<{

package/dist/user.js

@@ -1,4 +1,5 @@
 import * as z from 'zod';
+import { Preferences } from './preferences.js';
 import { PasskeyRegistration } from './passkeys.js';
 import { colorHash } from './color.js';
 export const User = z.object({
@@ -7,7 +8,7 @@ export const User = z.object({
     email: z.email(),
     emailVerified: z.date().nullish(),
     image: z.url().nullish(),
-    preferences: z.record(z.string(), z.any()),
+    preferences: Preferences,
     roles: z.array(z.string()),
     registeredAt: z.coerce.date(),
     isAdmin: z.boolean(),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@axium/core",
-	"version": "0.13.0",
+	"version": "0.15.0",
 	"author": "James Prevett <axium@jamespre.dev>",
 	"funding": {
 		"type": "individual",