@axium/core 0.22.2 → 0.24.0

package/dist/access.d.ts

@@ -1,5 +1,6 @@
-import * as z from 'zod';
 import { type Omit } from 'utilium';
+import * as z from 'zod';
+import { UserPublic } from './user.js';
 export declare const AccessControl: z.ZodObject<{
     itemId: z.ZodUUID;
     userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
@@ -25,19 +26,37 @@ export declare const AccessControl: z.ZodObject<{
 export interface AccessControl extends z.infer<typeof AccessControl> {
 }
 export declare function getTarget(ac: AccessControl): AccessTarget;
-export declare function fromTarget(target: AccessTarget): Partial<Pick<AccessControl, 'userId' | 'role' | 'tag'>>;
-export declare function pickPermissions<T extends AccessControl & object>(ac: T): Omit<T, 'itemId' | 'userId' | 'role' | 'tag' | 'user' | 'createdAt'>;
+export declare function fromTarget(target: AccessTarget): Pick<AccessControl, 'userId' | 'role' | 'tag'>;
+export declare function controlMatchesUser(control: AccessControl, user?: Pick<UserPublic, 'id' | 'roles' | 'tags'>): boolean;
+type NonPermKeys = keyof (typeof AccessControl)['shape'];
+export type PickPermissions<T extends AccessControl> = Omit<T, NonPermKeys>;
+export declare function pickPermissions<T extends AccessControl>(ac: T): PickPermissions<T>;
+/**
+ * Check an ACL against a set of permissions.
+ * Returns the set of permissions that are missing.
+ */
+export declare function checkACL<const AC extends AccessControl>(acl: AC[], permissions: Partial<PickPermissions<AC>>): Set<keyof PickPermissions<AC>>;
+/**
+ * Check an ACL against a set of permissions and a user.
+ * Returns the set of permissions that are missing for the user.
+ */
+export declare function checkAndMatchACL<const AC extends AccessControl>(acl: AC[], user: Pick<UserPublic, 'id' | 'roles' | 'tags'>, permissions: Partial<PickPermissions<AC>>): Set<keyof PickPermissions<AC>>;
 export interface AccessControllable {
     id: string;
     userId: string;
     parentId?: string | null;
     acl?: AccessControl[];
 }
-export declare const AccessTarget: z.ZodUnion<readonly [z.ZodUUID, z.ZodTemplateLiteral<`@${string}`>, z.ZodTemplateLiteral<`#${string}`>, z.ZodLiteral<"public">]>;
+export declare const AccessTarget: z.ZodUnion<readonly [z.ZodUUID, z.ZodTemplateLiteral<`@${string}`>, z.ZodTemplateLiteral<`#${string}`>, z.ZodLiteral<null>]>;
+/**
+ * A primitive representation for the target of an access control.
+ *
+ */
 export type AccessTarget = z.infer<typeof AccessTarget>;
 export declare const AccessControlUpdate: z.ZodObject<{
-    target: z.ZodUnion<readonly [z.ZodUUID, z.ZodTemplateLiteral<`@${string}`>, z.ZodTemplateLiteral<`#${string}`>, z.ZodLiteral<"public">]>;
+    target: z.ZodUnion<readonly [z.ZodUUID, z.ZodTemplateLiteral<`@${string}`>, z.ZodTemplateLiteral<`#${string}`>, z.ZodLiteral<null>]>;
     permissions: z.ZodRecord<z.ZodString, z.ZodAny>;
 }, z.core.$strip>;
 export interface AccessControlUpdate extends z.infer<typeof AccessControlUpdate> {
 }
+export {};

package/dist/access.js

@@ -1,6 +1,6 @@
+import { omit } from 'utilium';
 import * as z from 'zod';
 import { UserPublic } from './user.js';
-import { omit } from 'utilium';
 export const AccessControl = z
     .object({
     itemId: z.uuid(),
@@ -18,10 +18,10 @@ export function getTarget(ac) {
         return '@' + ac.role;
     if (ac.tag)
         return '#' + ac.tag;
-    return 'public';
+    return null;
 }
 export function fromTarget(target) {
-    if (target == 'public')
+    if (target == null)
         return { userId: null, role: null, tag: null };
     if (target[0] == '@')
         return { userId: null, role: target.slice(1), tag: null };
@@ -29,14 +29,48 @@ export function fromTarget(target) {
         return { userId: null, role: null, tag: target.slice(1) };
     return { userId: target, role: null, tag: null };
 }
+export function controlMatchesUser(control, user) {
+    if (!control.role && !control.tag && !control.userId)
+        return true;
+    if (!user)
+        return false;
+    return !!(control.userId === user.id ||
+        (control.role && user.roles.includes(control.role)) ||
+        (control.tag && user.tags?.includes(control.tag)));
+}
 export function pickPermissions(ac) {
     return omit(ac, 'itemId', 'userId', 'role', 'tag', 'user', 'createdAt');
 }
+/**
+ * Check an ACL against a set of permissions.
+ * Returns the set of permissions that are missing.
+ */
+export function checkACL(acl, permissions) {
+    const allowed = new Set();
+    const all = new Set(Object.keys(permissions));
+    const entries = Object.entries(permissions);
+    for (const control of acl) {
+        for (const [key, needed] of entries) {
+            const value = control[key];
+            if (value === needed)
+                allowed.add(key);
+        }
+    }
+    return all.difference(allowed);
+}
+/**
+ * Check an ACL against a set of permissions and a user.
+ * Returns the set of permissions that are missing for the user.
+ */
+export function checkAndMatchACL(acl, user, permissions) {
+    const filtered = acl.filter(c => controlMatchesUser(c, user));
+    return checkACL(filtered, permissions);
+}
 export const AccessTarget = z.union([
     z.uuid(),
     z.templateLiteral(['@', z.string()]),
     z.templateLiteral(['#', z.string()]),
-    z.literal('public'),
+    z.literal(null),
 ]);
 export const AccessControlUpdate = z.object({
     target: AccessTarget,

package/dist/api.d.ts

@@ -434,7 +434,7 @@ declare const _API: {
             createdAt: z.ZodCoercedDate<unknown>;
         }, z.core.$catchall<z.ZodBoolean>>>;
         readonly PATCH: [z.ZodObject<{
-            target: z.ZodUnion<readonly [z.ZodUUID, z.ZodTemplateLiteral<`@${string}`>, z.ZodTemplateLiteral<`#${string}`>, z.ZodLiteral<"public">]>;
+            target: z.ZodUnion<readonly [z.ZodUUID, z.ZodTemplateLiteral<`@${string}`>, z.ZodTemplateLiteral<`#${string}`>, z.ZodLiteral<null>]>;
             permissions: z.ZodRecord<z.ZodString, z.ZodAny>;
         }, z.core.$strip>, z.ZodObject<{
             itemId: z.ZodUUID;
@@ -458,7 +458,7 @@ declare const _API: {
             }, z.core.$strip>>>;
             createdAt: z.ZodCoercedDate<unknown>;
         }, z.core.$catchall<z.ZodBoolean>>];
-        readonly PUT: [z.ZodUnion<readonly [z.ZodUUID, z.ZodTemplateLiteral<`@${string}`>, z.ZodTemplateLiteral<`#${string}`>, z.ZodLiteral<"public">]>, z.ZodObject<{
+        readonly PUT: [z.ZodUnion<readonly [z.ZodUUID, z.ZodTemplateLiteral<`@${string}`>, z.ZodTemplateLiteral<`#${string}`>, z.ZodLiteral<null>]>, z.ZodObject<{
             itemId: z.ZodUUID;
             userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
             role: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -480,7 +480,7 @@ declare const _API: {
             }, z.core.$strip>>>;
             createdAt: z.ZodCoercedDate<unknown>;
         }, z.core.$catchall<z.ZodBoolean>>];
-        readonly DELETE: [z.ZodUnion<readonly [z.ZodUUID, z.ZodTemplateLiteral<`@${string}`>, z.ZodTemplateLiteral<`#${string}`>, z.ZodLiteral<"public">]>, z.ZodObject<{
+        readonly DELETE: [z.ZodUnion<readonly [z.ZodUUID, z.ZodTemplateLiteral<`@${string}`>, z.ZodTemplateLiteral<`#${string}`>, z.ZodLiteral<null>]>, z.ZodObject<{
             itemId: z.ZodUUID;
             userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
             role: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -601,9 +601,9 @@ declare const _API: {
                 hooks: z.ZodOptional<z.ZodString>;
                 integrations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             }, z.core.$strip>>;
+            description: z.ZodOptional<z.ZodString>;
             version: z.ZodString;
             cli: z.ZodOptional<z.ZodString>;
-            description: z.ZodOptional<z.ZodString>;
             apps: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
                 name: z.ZodOptional<z.ZodString>;

package/dist/node/index.d.ts

@@ -1,3 +1,2 @@
 export * from './daemon.js';
-export * as io from './io.js';
 export * from './plugins.js';

package/dist/node/index.js

@@ -1,3 +1,2 @@
 export * from './daemon.js';
-export * as io from './io.js';
 export * from './plugins.js';

package/dist/node/plugins.js

@@ -1,4 +1,4 @@
-import * as io from '@axium/core/node/io';
+import * as io from 'ioium/node';
 import { Plugin, plugins } from '@axium/core/plugins';
 import * as fs from 'node:fs';
 import { findPackageJSON } from 'node:module';

package/dist/packages.js

@@ -1,6 +1,6 @@
 import * as z from 'zod';
 import { lt as ltVersion } from 'semver';
-import { warn } from './io.js';
+import { warn } from 'ioium';
 export const PackageVersionInfo = z.object({
     name: z.string(),
     version: z.string(),

package/dist/plugins.js

@@ -1,6 +1,6 @@
 import * as z from 'zod';
 import { App } from './apps.js';
-import { debug, warn } from './io.js';
+import { debug, warn } from 'ioium';
 import { zAsyncFunction } from './schemas.js';
 const fn = z.custom(data => typeof data === 'function');
 export const PluginServerHooks = z.object({

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@axium/core",
-	"version": "0.22.2",
+	"version": "0.24.0",
 	"author": "James Prevett <axium@jamespre.dev>",
 	"funding": {
 		"type": "individual",
@@ -36,6 +36,7 @@
 	},
 	"dependencies": {
 		"@types/semver": "^7.7.1",
+		"ioium": "^0.1.0",
 		"mime": "^4.0.7",
 		"semver": "^7.7.3"
 	}

package/dist/io.d.ts

@@ -1,42 +0,0 @@
-/**
- * Get a human-readable string for a date that also fits into CLIs well (fixed-width)
- */
-export declare function prettyDate(date: Date): string;
-export declare let _debugOutput: boolean;
-/**
- * Enable or disable debug output.
- */
-export declare function _setDebugOutput(enabled: boolean): void;
-export declare let start: (message: string) => void;
-export declare let progress: (value: number, max: number, message?: any) => void;
-export declare let done: () => void;
-export interface ProgressIO {
-    start(message: string): void;
-    progress(value: number, max: number, message?: any): void;
-    done(): void;
-}
-export declare function useProgress(io: ProgressIO): void;
-export declare let debug: (...args: any[]) => void;
-export declare let log: (...args: any[]) => void;
-export declare let info: (...args: any[]) => void;
-export declare let warn: (...args: any[]) => void;
-export declare let error: (...args: any[]) => void;
-export interface ConsoleLike {
-    debug(...args: any[]): void;
-    log(...args: any[]): void;
-    info(...args: any[]): void;
-    warn(...args: any[]): void;
-    error(...args: any[]): void;
-}
-export declare function useOutput(output: ConsoleLike): void;
-/**
- * This is a factory for handling errors when performing operations.
- * The handler will allow the parent scope to continue if certain errors occur,
- * 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,65 +0,0 @@
-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');
-/**
- * Get a human-readable string for a date that also fits into CLIs well (fixed-width)
- */
-export function prettyDate(date) {
-    return `${date.getFullYear()} ${months[date.getMonth()]} ${_2(date.getDate())} ${_2(date.getHours())}:${_2(date.getMinutes())}:${_2(date.getSeconds())}.${date.getMilliseconds().toString().padStart(3, '0')}`;
-}
-export let _debugOutput = false;
-/**
- * Enable or disable debug output.
- */
-export function _setDebugOutput(enabled) {
-    _debugOutput = enabled;
-}
-// I/O for "progressive" actions
-export let start;
-export let progress;
-export let done;
-export function useProgress(io) {
-    start = io.start.bind(io);
-    progress = io.progress.bind(io);
-    done = io.done.bind(io);
-}
-// User-facing messaging
-export let debug = console.debug;
-export let log = console.log;
-export let info = console.info;
-export let warn = console.warn;
-export let error = console.error;
-export function useOutput(output) {
-    debug = output.debug.bind(output);
-    log = output.log.bind(output);
-    info = output.info.bind(output);
-    warn = output.warn.bind(output);
-    error = output.error.bind(output);
-}
-/**
- * This is a factory for handling errors when performing operations.
- * The handler will allow the parent scope to continue if certain errors occur,
- * rather than fatally exiting.
- */
-export function someWarnings(...allowList) {
-    return (error) => {
-        error = typeof error == 'object' && 'message' in error ? error.message : error;
-        for (const [pattern, message = error] of allowList) {
-            if (!pattern.test(error))
-                continue;
-            warn(message);
-            return;
-        }
-        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,16 +0,0 @@
-import type * as z from 'zod';
-export * from '../io.js';
-export declare function setCommandTimeout(value: number): void;
-/**
- * Run a system command with the fancy "Example... done."
- * @internal
- */
-export declare function run(message: string, command: string): Promise<string>;
-/** Yet another convenience function */
-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.
- */
-export declare function readJSON<S extends z.ZodType>(path: string, schema: S): z.infer<S>;
-export declare function writeJSON(path: string, data: any): void;

package/dist/node/io.js

@@ -1,243 +0,0 @@
-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 { exec } from 'node:child_process';
-import { readFileSync, writeFileSync } from 'node:fs';
-import { styleText } from 'node:util';
-import * as io from '../io.js';
-export * from '../io.js';
-let _currentOperation = null, _progress = null;
-function handleProgress() {
-    if (!_currentOperation || !_progress)
-        return {
-            [Symbol.dispose]() {
-                if (!_progress)
-                    _currentOperation = null;
-            },
-        };
-    process.stdout.clearLine(0);
-    process.stdout.cursorTo(0);
-    return {
-        [Symbol.dispose]() {
-            process.stdout.write(_currentOperation + '... ');
-            if (_progress)
-                io.progress(..._progress);
-        },
-    };
-}
-io.useProgress({
-    start(message) {
-        _currentOperation = message;
-        process.stdout.write(message + '... ');
-    },
-    /** @todo implement additional messaging */
-    progress(value, max, message) {
-        _progress = [value, max];
-        value++;
-        process.stdout.clearLine(0);
-        process.stdout.cursorTo(0);
-        process.stdout.write(`${_currentOperation}... ${value.toString().padStart(max.toString().length)}/${max} ${message && value < max ? `(${message})` : ''}`);
-        if (value >= max) {
-            _currentOperation = null;
-            _progress = null;
-            console.log();
-        }
-    },
-    done() {
-        _currentOperation = null;
-        _progress = null;
-        console.log('done.');
-    },
-});
-function* maybeStyle(style, parts) {
-    for (const part of parts) {
-        if (typeof part != 'string')
-            yield part;
-        else if (part.startsWith('\x1b'))
-            yield part;
-        else
-            yield styleText(style, part);
-    }
-}
-io.useOutput({
-    error(...message) {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const _ = __addDisposableResource(env_1, handleProgress(), false);
-            console.error(...maybeStyle('red', message));
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            __disposeResources(env_1);
-        }
-    },
-    warn(...message) {
-        const env_2 = { stack: [], error: void 0, hasError: false };
-        try {
-            const _ = __addDisposableResource(env_2, handleProgress(), false);
-            console.warn(...maybeStyle('yellow', message));
-        }
-        catch (e_2) {
-            env_2.error = e_2;
-            env_2.hasError = true;
-        }
-        finally {
-            __disposeResources(env_2);
-        }
-    },
-    info(...message) {
-        const env_3 = { stack: [], error: void 0, hasError: false };
-        try {
-            const _ = __addDisposableResource(env_3, handleProgress(), false);
-            console.info(...maybeStyle('blue', message));
-        }
-        catch (e_3) {
-            env_3.error = e_3;
-            env_3.hasError = true;
-        }
-        finally {
-            __disposeResources(env_3);
-        }
-    },
-    log(...message) {
-        const env_4 = { stack: [], error: void 0, hasError: false };
-        try {
-            const _ = __addDisposableResource(env_4, handleProgress(), false);
-            console.log(...message);
-        }
-        catch (e_4) {
-            env_4.error = e_4;
-            env_4.hasError = true;
-        }
-        finally {
-            __disposeResources(env_4);
-        }
-    },
-    debug(...message) {
-        const env_5 = { stack: [], error: void 0, hasError: false };
-        try {
-            if (!io._debugOutput)
-                return;
-            const _ = __addDisposableResource(env_5, handleProgress(), false);
-            console.debug(...maybeStyle('gray', message));
-        }
-        catch (e_5) {
-            env_5.error = e_5;
-            env_5.hasError = true;
-        }
-        finally {
-            __disposeResources(env_5);
-        }
-    },
-});
-let timeout = 1000;
-export function setCommandTimeout(value) {
-    timeout = value;
-}
-/**
- * Run a system command with the fancy "Example... done."
- * @internal
- */
-export async function run(message, command) {
-    let stderr;
-    try {
-        io.start(message);
-        const { promise, resolve, reject } = Promise.withResolvers();
-        exec(command, { timeout }, (err, stdout, _stderr) => {
-            stderr = _stderr.startsWith('ERROR:') ? _stderr.slice(6).trim() : _stderr;
-            if (err)
-                reject('[command]');
-            else
-                resolve(stdout);
-        });
-        const value = await promise;
-        io.done();
-        return value;
-    }
-    catch (error) {
-        throw error == '[command]'
-            ? stderr?.slice(0, 100) || 'failed.'
-            : typeof error == 'object' && 'message' in error
-                ? error.message
-                : error;
-    }
-}
-/** 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);
-}
-/**
- *
- * @param defaultValue Returned when the file can't be loaded. If omitted, loading errors will be thrown.
- */
-export function readJSON(path, schema) {
-    try {
-        const data = JSON.parse(readFileSync(path, 'utf-8'));
-        return schema.parse(data);
-    }
-    catch (e) {
-        throw io.errorText(e);
-    }
-}
-export function writeJSON(path, data) {
-    writeFileSync(path, JSON.stringify(data, null, 4).replaceAll(/^( {4})+/g, match => '\t'.repeat(match.length / 4)), 'utf-8');
-}