@axium/core 0.11.0 → 0.12.1

package/dist/access.d.ts

@@ -2,58 +2,16 @@ import * as z from 'zod';
 import type { User } from './user.js';
 export interface AccessControl {
     itemId: string;
-    userId: string;
+    userId?: string | null;
+    role?: string | null;
     user?: User;
     createdAt: Date;
-    permission: Permission;
 }
-declare const _Permission: {
-    readonly None: 0;
-    readonly Read: 1;
-    readonly Comment: 2;
-    readonly Edit: 3;
-    readonly Manage: 5;
-};
-export declare const Permission: z.ZodEnum<{
-    readonly None: 0;
-    readonly Read: 1;
-    readonly Comment: 2;
-    readonly Edit: 3;
-    readonly Manage: 5;
-}> & {
-    readonly None: 0;
-    readonly Read: 1;
-    readonly Comment: 2;
-    readonly Edit: 3;
-    readonly Manage: 5;
-};
-export type Permission = (typeof _Permission)[keyof typeof _Permission];
-export declare const permissionNames: {
-    0: string;
-    1: string;
-    2: string;
-    3: string;
-    5: string;
-};
+export declare function pickPermissions<T extends AccessControl & object>(ac: T): Omit<T, 'itemId' | 'userId' | 'role' | 'user' | 'createdAt'>;
 export interface AccessControllable {
     userId: string;
-    publicPermission: Permission;
     acl?: AccessControl[];
 }
-export declare const AccessMap: z.ZodRecord<z.ZodUnion<readonly [z.ZodUUID, z.ZodLiteral<"public">]>, z.ZodEnum<{
-    readonly None: 0;
-    readonly Read: 1;
-    readonly Comment: 2;
-    readonly Edit: 3;
-    readonly Manage: 5;
-}> & {
-    readonly None: 0;
-    readonly Read: 1;
-    readonly Comment: 2;
-    readonly Edit: 3;
-    readonly Manage: 5;
-}>;
+export declare const AccessMap: z.ZodRecord<z.ZodUnion<readonly [z.ZodUUID, z.ZodTemplateLiteral<`@${string}`>, z.ZodTemplateLiteral<`#${string}`>, z.ZodLiteral<"public">]>, z.ZodAny>;
 export interface AccessMap extends z.infer<typeof AccessMap> {
 }
-export declare function hasPermission(item: AccessControllable, userId: string | undefined, permission: Permission): boolean;
-export {};

package/dist/access.js

@@ -1,29 +1,6 @@
 import * as z from 'zod';
-const _Permission = {
-    None: 0,
-    Read: 1,
-    Comment: 2,
-    Edit: 3,
-    Manage: 5,
-};
-export const Permission = Object.assign(z.enum(_Permission), _Permission);
-export const permissionNames = {
-    [Permission.None]: 'No Permissions',
-    [Permission.Read]: 'Reader',
-    [Permission.Comment]: 'Commenter',
-    [Permission.Edit]: 'Editor',
-    [Permission.Manage]: 'Manager',
-};
-export const AccessMap = z.record(z.union([z.uuid(), z.literal('public')]), Permission);
-export function hasPermission(item, userId, permission) {
-    if (item.publicPermission >= permission)
-        return true;
-    if (!userId)
-        return false;
-    if (item.userId == userId)
-        return true;
-    const entry = item.acl?.find(entry => entry.userId == userId);
-    if (!entry)
-        return false;
-    return entry.permission >= permission;
+import { omit } from 'utilium';
+export function pickPermissions(ac) {
+    return omit(ac, ['itemId', 'userId', 'role', 'user', 'createdAt']);
 }
+export const AccessMap = z.record(z.union([z.uuid(), z.templateLiteral(['@', z.string()]), z.templateLiteral(['#', z.string()]), z.literal('public')]), z.any());

package/dist/index.d.ts

@@ -3,7 +3,9 @@ export * from './api.js';
 export * from './apps.js';
 export * from './audit.js';
 export * from './auth.js';
+export * from './format.js';
 export * as icons from './icons.js';
+export * from './parse.js';
 export * from './passkeys.js';
 export * from './plugins.js';
 export * from './preferences.js';

package/dist/index.js

@@ -3,7 +3,9 @@ export * from './api.js';
 export * from './apps.js';
 export * from './audit.js';
 export * from './auth.js';
+export * from './format.js';
 export * as icons from './icons.js';
+export * from './parse.js';
 export * from './passkeys.js';
 export * from './plugins.js';
 export * from './preferences.js';

package/dist/node/io.js

@@ -89,20 +89,32 @@ io.useProgress({
         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) {
+    error(...message) {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
             const _ = __addDisposableResource(env_1, handleProgress(), false);
-            console.error(message.startsWith('\x1b') ? message : styleText('red', message));
+            console.error(...maybeStyle('red', message));
         }
         catch (e_1) {
             env_1.error = e_1;
@@ -112,11 +124,11 @@ io.useOutput({
             __disposeResources(env_1);
         }
     },
-    warn(message) {
+    warn(...message) {
         const env_2 = { stack: [], error: void 0, hasError: false };
         try {
             const _ = __addDisposableResource(env_2, handleProgress(), false);
-            console.warn(message.startsWith('\x1b') ? message : styleText('yellow', message));
+            console.warn(...maybeStyle('yellow', message));
         }
         catch (e_2) {
             env_2.error = e_2;
@@ -126,11 +138,11 @@ io.useOutput({
             __disposeResources(env_2);
         }
     },
-    info(message) {
+    info(...message) {
         const env_3 = { stack: [], error: void 0, hasError: false };
         try {
             const _ = __addDisposableResource(env_3, handleProgress(), false);
-            console.info(message.startsWith('\x1b') ? message : styleText('blue', message));
+            console.info(...maybeStyle('blue', message));
         }
         catch (e_3) {
             env_3.error = e_3;
@@ -140,11 +152,11 @@ io.useOutput({
             __disposeResources(env_3);
         }
     },
-    log(message) {
+    log(...message) {
         const env_4 = { stack: [], error: void 0, hasError: false };
         try {
             const _ = __addDisposableResource(env_4, handleProgress(), false);
-            console.log(message);
+            console.log(...message);
         }
         catch (e_4) {
             env_4.error = e_4;
@@ -154,13 +166,13 @@ io.useOutput({
             __disposeResources(env_4);
         }
     },
-    debug(message) {
+    debug(...message) {
         const env_5 = { stack: [], error: void 0, hasError: false };
         try {
             if (!io._debugOutput)
                 return;
             const _ = __addDisposableResource(env_5, handleProgress(), false);
-            console.debug(message.startsWith('\x1b') ? message : styleText('gray', message));
+            console.debug(...maybeStyle('gray', message));
         }
         catch (e_5) {
             env_5.error = e_5;

package/dist/node/plugins.d.ts

@@ -1,3 +1,3 @@
 import { type PluginInternal } from '@axium/core/plugins';
 export declare function pluginText(plugin: PluginInternal): Generator<string>;
-export declare function loadPlugin<const T extends 'client' | 'server'>(mode: T, specifier: string, _loadedBy: string, safeMode?: boolean): Promise<void>;
+export declare function loadPlugin<const T extends 'client' | 'server'>(mode: T, specifier: string, _loadedBy: string, safeMode?: boolean): Promise<PluginInternal | void>;

package/dist/node/plugins.js

@@ -53,15 +53,20 @@ export async function loadPlugin(mode, specifier, _loadedBy, safeMode = false) {
         if (!plugin[mode])
             throw `Plugin does not support running ${mode}-side`;
         if (!safeMode) {
-            if (plugin.cli)
-                await import(resolve(plugin.dirname, plugin.cli));
+            if (plugin[mode].cli)
+                await import(resolve(plugin.dirname, plugin[mode].cli));
             if (mode == 'client') {
                 if (plugin.client.hooks)
                     Object.assign(plugin, { _client: await import(resolve(plugin.dirname, plugin.client.hooks)) });
             }
             if (mode == 'server') {
-                if (plugin.server.hooks)
-                    Object.assign(plugin, { _hooks: await import(resolve(plugin.dirname, plugin.server.hooks)) });
+                const cfg = plugin.server;
+                if (cfg.hooks)
+                    Object.assign(plugin, { _hooks: await import(resolve(plugin.dirname, cfg.hooks)) });
+                if (cfg.db) {
+                    const dbSchema = await import(resolve(plugin.dirname, cfg.db), { with: { type: 'json' } });
+                    Object.assign(plugin, { _db: dbSchema.default });
+                }
             }
         }
         Object.freeze(plugin);
@@ -77,6 +82,7 @@ export async function loadPlugin(mode, specifier, _loadedBy, safeMode = false) {
         }
         plugins.set(plugin.name, plugin);
         io.debug(`Loaded plugin: ${plugin.name} ${plugin.version}`);
+        return plugin;
     }
     catch (e) {
         io.warn(`Failed to load plugin from ${specifier}: ${e ? (e instanceof Error ? e.message : e.toString()) : e}`);

package/dist/parse.d.ts

@@ -0,0 +1 @@
+export declare function parseByteSize(input: string): number | null;

package/dist/parse.js

@@ -0,0 +1,19 @@
+const byteSizePattern = /^(?<size>\d+(?:\.\d+)?)\s*(?<unit>\w*)$/i;
+const units = ['', 'K', 'M', 'G', 'T', 'P', 'E'];
+export function parseByteSize(input) {
+    const match = byteSizePattern.exec(input.trim());
+    if (!match)
+        return null;
+    const size = parseFloat(match.groups.size);
+    if (!Number.isFinite(size))
+        return null;
+    let unit = match.groups.unit.toUpperCase();
+    if (unit.at(-1) == 'B')
+        unit = unit.slice(0, -1);
+    if (unit.at(-1) == 'I')
+        unit = unit.slice(0, -1);
+    const unitIndex = units.indexOf(unit);
+    if (unitIndex === -1)
+        return null;
+    return Math.round(size * Math.pow(1024, unitIndex));
+}

package/dist/plugins.d.ts

@@ -12,26 +12,32 @@ export declare const Plugin: z.ZodObject<{
     client: z.ZodOptional<z.ZodObject<{
         cli: z.ZodOptional<z.ZodString>;
         hooks: z.ZodOptional<z.ZodString>;
+        integrations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     }, z.core.$strip>>;
     server: z.ZodOptional<z.ZodObject<{
+        cli: z.ZodOptional<z.ZodString>;
         hooks: z.ZodOptional<z.ZodString>;
+        integrations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         http_handler: z.ZodOptional<z.ZodString>;
         routes: z.ZodOptional<z.ZodString>;
-        cli: z.ZodOptional<z.ZodString>;
+        db: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$loose>;
 export type Plugin = z.infer<typeof Plugin>;
-export interface PluginInternal extends Plugin {
-    readonly path: string;
-    readonly dirname: string;
-    readonly specifier: string;
-    readonly _loadedBy: string;
-    readonly cli?: string;
+export interface PluginInfo {
+    path: string;
+    dirname: string;
+    specifier: string;
+    _loadedBy: string;
+    cli?: string;
     /** @internal */
-    readonly _hooks?: ServerHooks;
+    _hooks?: ServerHooks;
     /** @internal */
-    readonly _client?: ClientHooks;
-    readonly isServer: boolean;
+    _client?: ClientHooks;
+    isServer: boolean;
+    _db?: any;
+}
+export interface PluginInternal extends Plugin, Readonly<PluginInfo> {
 }
 export declare const plugins: Map<string, PluginInternal>;
 /**
@@ -40,9 +46,7 @@ export declare const plugins: Map<string, PluginInternal>;
 export declare function _findPlugin(search: string): PluginInternal;
 export declare const PluginServerHooks: z.ZodObject<{
     statusText: z.ZodOptional<z.ZodCustom<z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<readonly [], null>, z.ZodString>, z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<readonly [], null>, z.ZodString>>>;
-    db_init: z.ZodOptional<z.ZodCustom<(...args: any[]) => any, (...args: any[]) => any>>;
     remove: z.ZodOptional<z.ZodCustom<(...args: any[]) => any, (...args: any[]) => any>>;
-    db_wipe: z.ZodOptional<z.ZodCustom<(...args: any[]) => any, (...args: any[]) => any>>;
     clean: z.ZodOptional<z.ZodCustom<(...args: any[]) => any, (...args: any[]) => any>>;
 }, z.core.$strip>;
 interface _InitOptions {
@@ -52,16 +56,13 @@ interface _InitOptions {
 }
 export interface ServerHooks {
     statusText?(): string | Promise<string>;
-    db_init?: (opt: _InitOptions) => void | Promise<void>;
     remove?: (opt: {
         force?: boolean;
     }) => void | Promise<void>;
-    db_wipe?: (opt: {
-        force?: boolean;
-    }) => void | Promise<void>;
     clean?: (opt: Partial<_InitOptions>) => void | Promise<void>;
 }
 export interface ClientHooks {
     run(): void | Promise<void>;
 }
+export declare function runIntegrations(): Promise<void>;
 export {};

package/dist/plugins.js

@@ -1,30 +1,27 @@
 import * as z from 'zod';
 import { zAsyncFunction } from './schemas.js';
 import { App } from './apps.js';
+import { debug, warn } from './io.js';
+const PluginCommon = z.object({
+    /** CLI mixin path */
+    cli: z.string().optional(),
+    /** The path to the hooks script */
+    hooks: z.string().optional(),
+    /** A map of plugin names to paths */
+    integrations: z.record(z.string(), z.string()).optional(),
+});
 export const Plugin = z.looseObject({
     name: z.string(),
     version: z.string(),
     description: z.string().optional(),
     apps: z.array(App).optional(),
-    client: z
-        .object({
-        /** CLI mixin path */
-        cli: z.string().optional(),
-        /** The path to the hooks script */
-        hooks: z.string().optional(),
-    })
-        .optional(),
-    server: z
-        .object({
-        /** The path to the hooks script */
-        hooks: z.string().optional(),
+    client: PluginCommon.extend({}).optional(),
+    server: PluginCommon.extend({
         http_handler: z.string().optional(),
         /** The path to the HTTP handler used by the server */
         routes: z.string().optional(),
-        /** CLI mixin path */
-        cli: z.string().optional(),
-    })
-        .optional(),
+        db: z.string().optional(),
+    }).optional(),
 });
 export const plugins = new Map();
 /**
@@ -39,8 +36,22 @@ export function _findPlugin(search) {
 const fn = z.custom(data => typeof data === 'function');
 export const PluginServerHooks = z.object({
     statusText: zAsyncFunction(z.function({ input: [], output: z.string() })).optional(),
-    db_init: fn.optional(),
     remove: fn.optional(),
-    db_wipe: fn.optional(),
     clean: fn.optional(),
 });
+export async function runIntegrations() {
+    for (const [pluginName, plugin] of plugins) {
+        const { integrations } = plugin[plugin.isServer ? 'server' : 'client'];
+        if (!integrations)
+            continue;
+        for (const [name, path] of Object.entries(integrations)) {
+            if (!plugins.has(name))
+                continue;
+            debug(`Running ${pluginName} integration with ${name}`);
+            await import(path).catch(e => {
+                const text = e instanceof Error ? e.stack : String(e);
+                warn(`Failed to load ${pluginName} integration with ${name}:\n\t${text}`);
+            });
+        }
+    }
+}

package/package.json

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