@axium/storage 0.11.2 → 0.13.0

package/db.json

@@ -28,6 +28,9 @@
 						"itemId": { "type": "uuid", "required": true, "primary": true, "references": "storage.id", "onDelete": "cascade" },
 						"createdAt": { "type": "timestamptz", "required": true, "default": "now()" },
 						"permission": { "type": "integer", "required": true, "check": "permission >= 0 AND permission <= 5" }
+					},
+					"constraints": {
+						"PK_acl_storage": { "type": "primary_key", "on": ["userId", "itemId"] }
 					}
 				}
 			},

package/dist/client/api.d.ts

@@ -1,5 +1,4 @@
 import type { StorageItemMetadata, StorageItemUpdate, UserStorage, UserStorageInfo } from '../common.js';
-export declare function parseItem(result: StorageItemMetadata): StorageItemMetadata;
 export interface UploadOptions {
     parentId?: string;
     name?: string;
@@ -7,9 +6,7 @@ export interface UploadOptions {
 export declare function uploadItem(file: Blob | File, opt?: UploadOptions): Promise<StorageItemMetadata>;
 export declare function updateItem(fileId: string, data: Blob): Promise<StorageItemMetadata>;
 export declare function getItemMetadata(fileId: string): Promise<StorageItemMetadata>;
-/**
- * Gets the metadata for all items in a directory.
- */
+/** Gets the metadata for all items in a directory. */
 export declare function getDirectoryMetadata(parentId: string): Promise<StorageItemMetadata[]>;
 export declare function downloadItem(fileId: string): Promise<Blob>;
 export declare function updateItemMetadata(fileId: string, metadata: StorageItemUpdate): Promise<StorageItemMetadata>;

package/dist/client/api.js

@@ -20,16 +20,8 @@ async function _upload(method, url, data, extraHeaders = {}) {
     const json = await response.json().catch(() => ({ message: 'Unknown server error (invalid JSON response)' }));
     if (!response.ok)
         throw new Error(json.message);
-    json.modifiedAt = new Date(json.modifiedAt);
     return json;
 }
-export function parseItem(result) {
-    result.createdAt = new Date(result.createdAt);
-    result.modifiedAt = new Date(result.modifiedAt);
-    if (result.trashedAt)
-        result.trashedAt = new Date(result.trashedAt);
-    return result;
-}
 function rawStorage(fileId) {
     const raw = '/raw/storage' + (fileId ? '/' + fileId : '');
     if (prefix[0] == '/')
@@ -44,23 +36,17 @@ export async function uploadItem(file, opt = {}) {
         headers['x-parent'] = opt.parentId;
     if (opt.name)
         headers['x-name'] = opt.name;
-    return parseItem(await _upload('PUT', rawStorage(), file, headers));
+    return await _upload('PUT', rawStorage(), file, headers);
 }
 export async function updateItem(fileId, data) {
-    return parseItem(await _upload('POST', rawStorage(fileId), data));
+    return await _upload('POST', rawStorage(fileId), data);
 }
 export async function getItemMetadata(fileId) {
-    const result = await fetchAPI('GET', 'storage/item/:id', undefined, fileId);
-    return parseItem(result);
+    return await fetchAPI('GET', 'storage/item/:id', undefined, fileId);
 }
-/**
- * Gets the metadata for all items in a directory.
- */
+/** Gets the metadata for all items in a directory. */
 export async function getDirectoryMetadata(parentId) {
-    const result = await fetchAPI('GET', 'storage/directory/:id', undefined, parentId);
-    for (const item of result)
-        parseItem(item);
-    return result;
+    return await fetchAPI('GET', 'storage/directory/:id', undefined, parentId);
 }
 export async function downloadItem(fileId) {
     const response = await fetch(rawStorage(fileId), {
@@ -71,44 +57,23 @@ export async function downloadItem(fileId) {
     return await response.blob();
 }
 export async function updateItemMetadata(fileId, metadata) {
-    const result = await fetchAPI('PATCH', 'storage/item/:id', metadata, fileId);
-    return parseItem(result);
+    return await fetchAPI('PATCH', 'storage/item/:id', metadata, fileId);
 }
 export async function deleteItem(fileId) {
-    const result = await fetchAPI('DELETE', 'storage/item/:id', undefined, fileId);
-    return parseItem(result);
+    return await fetchAPI('DELETE', 'storage/item/:id', undefined, fileId);
 }
 export async function getUserStorage(userId) {
-    const result = await fetchAPI('GET', 'users/:id/storage', undefined, userId);
-    result.lastModified = new Date(result.lastModified);
-    if (result.lastTrashed)
-        result.lastTrashed = new Date(result.lastTrashed);
-    for (const item of result.items)
-        parseItem(item);
-    return result;
+    return await fetchAPI('GET', 'users/:id/storage', undefined, userId);
 }
 export async function getUserStats(userId) {
-    const result = await fetchAPI('OPTIONS', 'users/:id/storage', undefined, userId);
-    result.lastModified = new Date(result.lastModified);
-    if (result.lastTrashed)
-        result.lastTrashed = new Date(result.lastTrashed);
-    return result;
+    return await fetchAPI('OPTIONS', 'users/:id/storage', undefined, userId);
 }
 export async function getUserTrash(userId) {
-    const result = await fetchAPI('GET', 'users/:id/storage/trash', undefined, userId);
-    for (const item of result)
-        parseItem(item);
-    return result;
+    return await fetchAPI('GET', 'users/:id/storage/trash', undefined, userId);
 }
 export async function itemsSharedWith(userId) {
-    const result = await fetchAPI('GET', 'users/:id/storage/shared', undefined, userId);
-    for (const item of result)
-        parseItem(item);
-    return result;
+    return await fetchAPI('GET', 'users/:id/storage/shared', undefined, userId);
 }
 export async function getUserStorageRoot(userId) {
-    const result = await fetchAPI('GET', 'users/:id/storage/root', undefined, userId);
-    for (const item of result)
-        parseItem(item);
-    return result;
+    return await fetchAPI('GET', 'users/:id/storage/root', undefined, userId);
 }

package/dist/client/cli.js

@@ -16,7 +16,7 @@ const cli = program
     .helpGroup('Plugins:')
     .description('CLI integration for @axium/storage')
     .option('-q, --quiet', 'Suppress output')
-    .hook('preAction', (action) => {
+    .hook('preAction', action => {
     const opts = action.optsWithGlobals();
     if (opts.quiet)
         setQuiet(true);
@@ -33,11 +33,11 @@ cli.command('ls')
     .description('List the contents of a folder')
     .argument('<path>', 'remote folder path')
     .option('-l, --long', 'Show more details')
-    .option('-h, --human-readable', 'Show sizes in human readable format')
-    .action(async function (path) {
-    const { users } = await syncCache().catch(io.handleError);
+    .option('-h, --human-readable', 'Show sizes in human readable format', false)
+    .action(async function axium_files_ls(path) {
+    const { users } = await syncCache().catch(io.exit);
     const { long, humanReadable } = this.optsWithGlobals();
-    const items = await getDirectory(path).catch(io.handleError);
+    const items = await getDirectory(path).catch(io.exit);
     if (!long) {
         console.log(items.map(colorItem).join('\t'));
         return;
@@ -53,14 +53,14 @@ cli.command('mkdir')
     const pathParts = path.split('/');
     const name = pathParts.pop();
     const parentPath = pathParts.join('/');
-    const parent = !parentPath ? null : await resolveItem(parentPath).catch(io.handleError);
+    const parent = !parentPath ? null : await resolveItem(parentPath).catch(io.exit);
     if (parent) {
         if (!parent)
             io.exit('Could not resolve parent folder.');
         if (parent.type != 'inode/directory')
             io.exit('Parent path is not a directory.');
     }
-    await api.uploadItem(new Blob([], { type: 'inode/directory' }), { parentId: parent?.id, name }).catch(io.handleError);
+    await api.uploadItem(new Blob([], { type: 'inode/directory' }), { parentId: parent?.id, name }).catch(io.exit);
 });
 cli.command('status')
     .option('-v, --verbose', 'Show more details')
@@ -144,8 +144,8 @@ cli.command('sync')
     .addOption(new Option('--delete <mode>', 'Delete local/remote files that were deleted remotely/locally')
     .choices(['local', 'remote', 'none'])
     .default('none'))
-    .option('-d, --dry-run', 'Show what would be done, but do not make any changes')
-    .option('-v, --verbose', 'Show more details')
+    .option('-d, --dry-run', 'Show what would be done, but do not make any changes', false)
+    .option('-v, --verbose', 'Show more details', false)
     .argument('[sync]', 'The name of the Sync to sync')
     .action(async (name, opt) => {
     if (name) {
@@ -167,16 +167,16 @@ cliCache
     .command('refresh')
     .description('Force a refresh of the local cache from the server')
     .action(async () => {
-    await syncCache(true).catch(io.handleError);
+    await syncCache(true).catch(io.exit);
 });
 cliCache
     .command('dump')
     .description('Dump the local cache')
     .option('-v, --verbose', 'Show more details')
     .addOption(new Option('-j, --json', 'Output as JSON').conflicts(['verbose', 'quiet']))
-    .action(async function () {
+    .action(async function axium_files_cache_dump() {
     const opt = this.optsWithGlobals();
-    const data = await syncCache(false).catch(io.handleError);
+    const data = await syncCache(false).catch(io.exit);
     if (opt.json) {
         console.log(JSON.stringify(data));
         return;

package/dist/client/local.d.ts

@@ -23,12 +23,16 @@ declare const StorageCache: z.ZodObject<{
         id: z.ZodUUID;
         name: z.ZodString;
         email: z.ZodOptional<z.ZodEmail>;
-        emailVerified: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodDate>>>;
+        emailVerified: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>>;
         image: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
-        preferences: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        preferences: z.ZodOptional<z.ZodLazy<z.ZodObject<{
+            debug: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>>;
         roles: z.ZodArray<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
         registeredAt: z.ZodCoercedDate<unknown>;
         isAdmin: z.ZodOptional<z.ZodBoolean>;
+        isSuspended: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 interface StorageCache extends z.infer<typeof StorageCache> {

package/dist/client/local.js

@@ -61,11 +61,10 @@ export async function syncCache(force = null) {
                 io.done();
         }
         catch (e) {
-            const message = e instanceof Error ? e.message : String(e);
             if (quiet)
-                io.exit('Failed to update item metadata: ' + message);
+                io.exit('Failed to update item metadata: ' + io.errorText(e));
             else
-                io.exit(message);
+                io.exit(e);
         }
     }
     else {

package/dist/client/sync.js

@@ -44,7 +44,7 @@ export async function fetchSyncItems(id, folderName) {
         return localItems;
     }
     catch (e) {
-        io.exit(e.message);
+        io.exit(e);
     }
 }
 export function getItems(id) {

package/dist/common.d.ts

@@ -1,80 +1,15 @@
 import * as z from 'zod';
-declare module '@axium/core/api' {
-    interface $API {
-        'users/:id/storage': {
-            OPTIONS: UserStorageInfo;
-            GET: UserStorage;
-        };
-        'users/:id/storage/root': {
-            GET: StorageItemMetadata[];
-        };
-        'users/:id/storage/trash': {
-            GET: StorageItemMetadata[];
-        };
-        'users/:id/storage/shared': {
-            GET: StorageItemMetadata[];
-        };
-        storage: {
-            OPTIONS: StoragePublicConfig & {
-                syncProtocolVersion: number;
-                batchFormatVersion: number;
-            };
-        };
-        'storage/batch': {
-            POST: [StorageBatchUpdate[], StorageItemMetadata[]];
-        };
-        'storage/item/:id': {
-            GET: StorageItemMetadata;
-            DELETE: StorageItemMetadata;
-            PATCH: [z.input<typeof StorageItemUpdate>, StorageItemMetadata];
-        };
-        'storage/directory/:id': {
-            GET: StorageItemMetadata[];
-        };
-        'storage/directory/:id/recursive': {
-            GET: (StorageItemMetadata & {
-                path: string;
-            })[];
-        };
-    }
-}
-export interface StoragePublicConfig {
-    /** Configuration for batch updates */
-    batch: {
-        /** Whether to enable sending multiple files per request */
-        enabled: boolean;
-        /** Maximum number of items that can be included in a single batch update */
-        max_items: number;
-        /** Maximum size in KiB per item */
-        max_item_size: number;
-    };
-    /** Whether to split files larger than `max_transfer_size` into multiple chunks */
-    chunk: boolean;
-    /** Maximum size in MiB per transfer/request */
-    max_transfer_size: number;
-    /** Maximum number of chunks */
-    max_chunks: number;
-}
-export declare const syncProtocolVersion = 0;
-export interface StorageLimits {
-    /** The maximum size per item in MB */
-    item_size: number;
-    /** Maximum number of items per user */
-    user_items: number;
-    /** The maximum storage size per user in MB */
-    user_size: number;
-}
-export interface StorageStats {
-    usedBytes: number;
-    itemCount: number;
-    lastModified: Date;
-    lastTrashed: Date | null;
-}
-export interface UserStorageInfo extends StorageStats {
-    limits: StorageLimits;
-}
-export interface UserStorage extends UserStorageInfo {
-    items: StorageItemMetadata[];
+export declare const StoragePublicConfig: z.ZodObject<{
+    batch: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        max_items: z.ZodNumber;
+        max_item_size: z.ZodNumber;
+    }, z.core.$strip>;
+    chunk: z.ZodBoolean;
+    max_transfer_size: z.ZodNumber;
+    max_chunks: z.ZodNumber;
+}, z.core.$strip>;
+export interface StoragePublicConfig extends z.infer<typeof StoragePublicConfig> {
 }
 /**
  * An update to file metadata.
@@ -103,6 +38,63 @@ export declare const StorageItemMetadata: z.ZodObject<{
 export interface StorageItemMetadata<T extends Record<string, unknown> = Record<string, unknown>> extends z.infer<typeof StorageItemMetadata> {
     metadata: T;
 }
+export declare const syncProtocolVersion = 0;
+export declare const StorageLimits: z.ZodObject<{
+    item_size: z.ZodNumber;
+    user_items: z.ZodNumber;
+    user_size: z.ZodNumber;
+}, z.core.$strip>;
+export interface StorageLimits extends z.infer<typeof StorageLimits> {
+}
+export declare const StorageStats: z.ZodObject<{
+    usedBytes: z.ZodNumber;
+    itemCount: z.ZodNumber;
+    lastModified: z.ZodCoercedDate<unknown>;
+    lastTrashed: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+export interface StorageStats extends z.infer<typeof StorageStats> {
+}
+export declare const UserStorageInfo: z.ZodObject<{
+    limits: z.ZodObject<{
+        item_size: z.ZodNumber;
+        user_items: z.ZodNumber;
+        user_size: z.ZodNumber;
+    }, z.core.$strip>;
+    usedBytes: z.ZodNumber;
+    itemCount: z.ZodNumber;
+    lastModified: z.ZodCoercedDate<unknown>;
+    lastTrashed: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+export interface UserStorageInfo extends z.infer<typeof UserStorageInfo> {
+}
+export declare const UserStorage: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        createdAt: z.ZodCoercedDate<unknown>;
+        dataURL: z.ZodString;
+        hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        id: z.ZodUUID;
+        immutable: z.ZodBoolean;
+        modifiedAt: z.ZodCoercedDate<unknown>;
+        name: z.ZodString;
+        userId: z.ZodUUID;
+        parentId: z.ZodNullable<z.ZodUUID>;
+        size: z.ZodInt;
+        trashedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+        type: z.ZodString;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+    limits: z.ZodObject<{
+        item_size: z.ZodNumber;
+        user_items: z.ZodNumber;
+        user_size: z.ZodNumber;
+    }, z.core.$strip>;
+    usedBytes: z.ZodNumber;
+    itemCount: z.ZodNumber;
+    lastModified: z.ZodCoercedDate<unknown>;
+    lastTrashed: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+export interface UserStorage extends z.infer<typeof UserStorage> {
+}
 /**
  * Formats:
  *
@@ -130,3 +122,229 @@ export declare const StorageBatchUpdate: z.ZodObject<{
 }, z.core.$strip>;
 export interface StorageBatchUpdate extends z.infer<typeof StorageBatchUpdate> {
 }
+declare const StorageAPI: {
+    readonly 'users/:id/storage': {
+        readonly OPTIONS: z.ZodObject<{
+            limits: z.ZodObject<{
+                item_size: z.ZodNumber;
+                user_items: z.ZodNumber;
+                user_size: z.ZodNumber;
+            }, z.core.$strip>;
+            usedBytes: z.ZodNumber;
+            itemCount: z.ZodNumber;
+            lastModified: z.ZodCoercedDate<unknown>;
+            lastTrashed: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+        }, z.core.$strip>;
+        readonly GET: z.ZodObject<{
+            items: z.ZodArray<z.ZodObject<{
+                createdAt: z.ZodCoercedDate<unknown>;
+                dataURL: z.ZodString;
+                hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                id: z.ZodUUID;
+                immutable: z.ZodBoolean;
+                modifiedAt: z.ZodCoercedDate<unknown>;
+                name: z.ZodString;
+                userId: z.ZodUUID;
+                parentId: z.ZodNullable<z.ZodUUID>;
+                size: z.ZodInt;
+                trashedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+                type: z.ZodString;
+                metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>>;
+            limits: z.ZodObject<{
+                item_size: z.ZodNumber;
+                user_items: z.ZodNumber;
+                user_size: z.ZodNumber;
+            }, z.core.$strip>;
+            usedBytes: z.ZodNumber;
+            itemCount: z.ZodNumber;
+            lastModified: z.ZodCoercedDate<unknown>;
+            lastTrashed: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+        }, z.core.$strip>;
+    };
+    readonly 'users/:id/storage/root': {
+        readonly GET: z.ZodArray<z.ZodObject<{
+            createdAt: z.ZodCoercedDate<unknown>;
+            dataURL: z.ZodString;
+            hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            id: z.ZodUUID;
+            immutable: z.ZodBoolean;
+            modifiedAt: z.ZodCoercedDate<unknown>;
+            name: z.ZodString;
+            userId: z.ZodUUID;
+            parentId: z.ZodNullable<z.ZodUUID>;
+            size: z.ZodInt;
+            trashedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+            type: z.ZodString;
+            metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>;
+    };
+    readonly 'users/:id/storage/trash': {
+        readonly GET: z.ZodArray<z.ZodObject<{
+            createdAt: z.ZodCoercedDate<unknown>;
+            dataURL: z.ZodString;
+            hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            id: z.ZodUUID;
+            immutable: z.ZodBoolean;
+            modifiedAt: z.ZodCoercedDate<unknown>;
+            name: z.ZodString;
+            userId: z.ZodUUID;
+            parentId: z.ZodNullable<z.ZodUUID>;
+            size: z.ZodInt;
+            trashedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+            type: z.ZodString;
+            metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>;
+    };
+    readonly 'users/:id/storage/shared': {
+        readonly GET: z.ZodArray<z.ZodObject<{
+            createdAt: z.ZodCoercedDate<unknown>;
+            dataURL: z.ZodString;
+            hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            id: z.ZodUUID;
+            immutable: z.ZodBoolean;
+            modifiedAt: z.ZodCoercedDate<unknown>;
+            name: z.ZodString;
+            userId: z.ZodUUID;
+            parentId: z.ZodNullable<z.ZodUUID>;
+            size: z.ZodInt;
+            trashedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+            type: z.ZodString;
+            metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>;
+    };
+    readonly storage: {
+        readonly OPTIONS: z.ZodObject<{
+            batch: z.ZodObject<{
+                enabled: z.ZodBoolean;
+                max_items: z.ZodNumber;
+                max_item_size: z.ZodNumber;
+            }, z.core.$strip>;
+            chunk: z.ZodBoolean;
+            max_transfer_size: z.ZodNumber;
+            max_chunks: z.ZodNumber;
+            syncProtocolVersion: z.ZodNumber;
+            batchFormatVersion: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly 'storage/batch': {
+        readonly POST: readonly [z.ZodArray<z.ZodObject<{
+            deleted: z.ZodArray<z.ZodUUID>;
+            metadata: z.ZodRecord<z.ZodUUID, z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                owner: z.ZodOptional<z.ZodUUID>;
+                trash: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            content: z.ZodRecord<z.ZodUUID, z.ZodObject<{
+                offset: z.ZodInt;
+                size: z.ZodInt;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>, z.ZodArray<z.ZodObject<{
+            createdAt: z.ZodCoercedDate<unknown>;
+            dataURL: z.ZodString;
+            hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            id: z.ZodUUID;
+            immutable: z.ZodBoolean;
+            modifiedAt: z.ZodCoercedDate<unknown>;
+            name: z.ZodString;
+            userId: z.ZodUUID;
+            parentId: z.ZodNullable<z.ZodUUID>;
+            size: z.ZodInt;
+            trashedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+            type: z.ZodString;
+            metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>];
+    };
+    readonly 'storage/item/:id': {
+        readonly GET: z.ZodObject<{
+            createdAt: z.ZodCoercedDate<unknown>;
+            dataURL: z.ZodString;
+            hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            id: z.ZodUUID;
+            immutable: z.ZodBoolean;
+            modifiedAt: z.ZodCoercedDate<unknown>;
+            name: z.ZodString;
+            userId: z.ZodUUID;
+            parentId: z.ZodNullable<z.ZodUUID>;
+            size: z.ZodInt;
+            trashedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+            type: z.ZodString;
+            metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>;
+        readonly DELETE: z.ZodObject<{
+            createdAt: z.ZodCoercedDate<unknown>;
+            dataURL: z.ZodString;
+            hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            id: z.ZodUUID;
+            immutable: z.ZodBoolean;
+            modifiedAt: z.ZodCoercedDate<unknown>;
+            name: z.ZodString;
+            userId: z.ZodUUID;
+            parentId: z.ZodNullable<z.ZodUUID>;
+            size: z.ZodInt;
+            trashedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+            type: z.ZodString;
+            metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>;
+        readonly PATCH: readonly [z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            owner: z.ZodOptional<z.ZodUUID>;
+            trash: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            createdAt: z.ZodCoercedDate<unknown>;
+            dataURL: z.ZodString;
+            hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            id: z.ZodUUID;
+            immutable: z.ZodBoolean;
+            modifiedAt: z.ZodCoercedDate<unknown>;
+            name: z.ZodString;
+            userId: z.ZodUUID;
+            parentId: z.ZodNullable<z.ZodUUID>;
+            size: z.ZodInt;
+            trashedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+            type: z.ZodString;
+            metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>];
+    };
+    readonly 'storage/directory/:id': {
+        readonly GET: z.ZodArray<z.ZodObject<{
+            createdAt: z.ZodCoercedDate<unknown>;
+            dataURL: z.ZodString;
+            hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            id: z.ZodUUID;
+            immutable: z.ZodBoolean;
+            modifiedAt: z.ZodCoercedDate<unknown>;
+            name: z.ZodString;
+            userId: z.ZodUUID;
+            parentId: z.ZodNullable<z.ZodUUID>;
+            size: z.ZodInt;
+            trashedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+            type: z.ZodString;
+            metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>;
+    };
+    readonly 'storage/directory/:id/recursive': {
+        readonly GET: z.ZodArray<z.ZodObject<{
+            createdAt: z.ZodCoercedDate<unknown>;
+            dataURL: z.ZodString;
+            hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            id: z.ZodUUID;
+            immutable: z.ZodBoolean;
+            modifiedAt: z.ZodCoercedDate<unknown>;
+            name: z.ZodString;
+            userId: z.ZodUUID;
+            parentId: z.ZodNullable<z.ZodUUID>;
+            size: z.ZodInt;
+            trashedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+            type: z.ZodString;
+            metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            path: z.ZodString;
+        }, z.core.$strip>>;
+    };
+};
+type StorageAPI = typeof StorageAPI;
+declare module '@axium/core/api' {
+    interface $API extends StorageAPI {
+    }
+}
+export {};

package/dist/common.js

@@ -1,5 +1,22 @@
+import { $API } from '@axium/core';
 import * as z from 'zod';
-export const syncProtocolVersion = 0;
+export const StoragePublicConfig = z.object({
+    /** Configuration for batch updates */
+    batch: z.object({
+        /** Whether to enable sending multiple files per request */
+        enabled: z.boolean(),
+        /** Maximum number of items that can be included in a single batch update */
+        max_items: z.number(),
+        /** Maximum size in KiB per item */
+        max_item_size: z.number(),
+    }),
+    /** Whether to split files larger than `max_transfer_size` into multiple chunks */
+    chunk: z.boolean(),
+    /** Maximum size in MiB per transfer/request */
+    max_transfer_size: z.number(),
+    /** Maximum number of chunks */
+    max_chunks: z.number(),
+});
 /**
  * An update to file metadata.
  */
@@ -26,6 +43,29 @@ export const StorageItemMetadata = z.object({
     type: z.string(),
     metadata: z.record(z.string(), z.unknown()),
 });
+export const syncProtocolVersion = 0;
+export const StorageLimits = z.object({
+    /** The maximum size per item in MB */
+    item_size: z.number(),
+    /** Maximum number of items per user */
+    user_items: z.number(),
+    /** The maximum storage size per user in MB */
+    user_size: z.number(),
+});
+export const StorageStats = z.object({
+    usedBytes: z.number().nonnegative(),
+    itemCount: z.number().nonnegative(),
+    lastModified: z.coerce.date(),
+    lastTrashed: z.coerce.date().nullable(),
+});
+export const UserStorageInfo = z.object({
+    ...StorageStats.shape,
+    limits: StorageLimits,
+});
+export const UserStorage = z.object({
+    ...UserStorageInfo.shape,
+    items: StorageItemMetadata.array(),
+});
 /**
  * Formats:
  *
@@ -45,3 +85,39 @@ export const StorageBatchUpdate = z.object({
     metadata: z.record(z.uuid(), StorageItemUpdate),
     content: z.record(z.uuid(), BatchedContentChange),
 });
+const StorageAPI = {
+    'users/:id/storage': {
+        OPTIONS: UserStorageInfo,
+        GET: UserStorage,
+    },
+    'users/:id/storage/root': {
+        GET: StorageItemMetadata.array(),
+    },
+    'users/:id/storage/trash': {
+        GET: StorageItemMetadata.array(),
+    },
+    'users/:id/storage/shared': {
+        GET: StorageItemMetadata.array(),
+    },
+    storage: {
+        OPTIONS: StoragePublicConfig.extend({
+            syncProtocolVersion: z.number(),
+            batchFormatVersion: z.number(),
+        }),
+    },
+    'storage/batch': {
+        POST: [StorageBatchUpdate.array(), StorageItemMetadata.array()],
+    },
+    'storage/item/:id': {
+        GET: StorageItemMetadata,
+        DELETE: StorageItemMetadata,
+        PATCH: [StorageItemUpdate, StorageItemMetadata],
+    },
+    'storage/directory/:id': {
+        GET: StorageItemMetadata.array(),
+    },
+    'storage/directory/:id/recursive': {
+        GET: StorageItemMetadata.extend({ path: z.string() }).array(),
+    },
+};
+Object.assign($API, StorageAPI);

package/dist/server/cli.js

@@ -27,7 +27,7 @@ cli.command('query')
     .addOption(new Option('-u, --user <user>', 'Filter by user UUID or email').argParser(lookupUser))
     .option('-m, --min-size <size>', 'Filter by minimum size', _byteSize('Invalid minimum size.'))
     .option('-M, --max-size <size>', 'Filter by maximum size', _byteSize('Invalid maximum size.'))
-    .addOption(new Option('--size', 'Filter by exact size').conflicts(['minSize', 'maxSize']).argParser(_byteSize('Invalid size.')))
+    .addOption(new Option('--size <size>', 'Filter by exact size').conflicts(['minSize', 'maxSize']).argParser(_byteSize('Invalid size.')))
     .option('-l, --limit <n>', 'Limit the number of results', (v) => z.coerce.number().int().min(1).max(1000).parse(v), 100)
     .option('-j, --json', 'Output results as JSON', false)
     .addOption(new Option('-f, --format <format>', 'How to format output lines').conflicts('json').default('{id} {type} {size} {userId} {name}'))
@@ -63,7 +63,7 @@ cli.command('query')
     if (opt.size !== undefined) {
         query = query.where('size', '=', opt.size);
     }
-    const rawItems = await query.execute().catch(io.handleError);
+    const rawItems = await query.execute().catch(io.exit);
     const items = rawItems.map(parseItem);
     if (!items.length) {
         console.log(styleText(['italic', 'dim'], 'No storage items match the provided filters.'));

package/dist/server/config.d.ts

@@ -1,28 +1,33 @@
-import type { StorageLimits, StoragePublicConfig } from '../common.js';
+import { StorageLimits } from '../common.js';
 import '../polyfills.js';
+import * as z from 'zod';
+declare const StorageConfig: z.ZodObject<{
+    batch: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        max_items: z.ZodNumber;
+        max_item_size: z.ZodNumber;
+    }, z.core.$strip>;
+    chunk: z.ZodBoolean;
+    max_transfer_size: z.ZodNumber;
+    max_chunks: z.ZodNumber;
+    app_enabled: z.ZodBoolean;
+    cas: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        include: z.ZodArray<z.ZodString>;
+        exclude: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    data: z.ZodString;
+    enabled: z.ZodBoolean;
+    limits: z.ZodObject<{
+        item_size: z.ZodNumber;
+        user_items: z.ZodNumber;
+        user_size: z.ZodNumber;
+    }, z.core.$strip>;
+    trash_duration: z.ZodNumber;
+}, z.core.$strip>;
 declare module '@axium/server/config' {
     interface Config {
-        storage: StoragePublicConfig & {
-            /** Whether the files app is enabled. Requires `enabled` */
-            app_enabled: boolean;
-            /** Content Addressable Storage (CAS) configuration */
-            cas: {
-                /** Whether to use CAS */
-                enabled: boolean;
-                /** Mime types to include when determining if CAS should be used */
-                include: string[];
-                /** Mime types to exclude when determining if CAS should be used */
-                exclude: string[];
-            };
-            /** Path to data directory */
-            data: string;
-            /** Whether the storage API endpoints are enabled */
-            enabled: boolean;
-            /** Default limits */
-            limits: StorageLimits;
-            /** How many days files are kept in the trash */
-            trash_duration: number;
-        };
+        storage: z.infer<typeof StorageConfig>;
     }
 }
 export declare const defaultCASMime: RegExp[];
@@ -45,3 +50,4 @@ export type ExternalLimitHandler = (userId?: string) => StorageLimits | Promise<
  */
 export declare function useLimits(handler: ExternalLimitHandler): void;
 export declare function getLimits(userId?: string): Promise<StorageLimits>;
+export {};

package/dist/server/config.js

@@ -1,7 +1,35 @@
 import { Severity } from '@axium/core';
 import { addEvent } from '@axium/server/audit';
-import { addConfigDefaults, config } from '@axium/server/config';
+import { addConfig, addConfigDefaults, config } from '@axium/server/config';
+import { StorageLimits, StoragePublicConfig } from '../common.js';
 import '../polyfills.js';
+import * as z from 'zod';
+const StorageConfig = StoragePublicConfig.safeExtend({
+    /** Whether the files app is enabled. Requires `enabled` */
+    app_enabled: z.boolean(),
+    /** Content Addressable Storage (CAS) configuration */
+    cas: z
+        .object({
+        /** Whether to use CAS */
+        enabled: z.boolean(),
+        /** Mime types to include when determining if CAS should be used */
+        include: z.string().array(),
+        /** Mime types to exclude when determining if CAS should be used */
+        exclude: z.string().array(),
+    })
+        .optional(),
+    /** Path to data directory */
+    data: z.string(),
+    /** Whether the storage API endpoints are enabled */
+    enabled: z.boolean(),
+    /** Default limits */
+    limits: StorageLimits,
+    /** How many days files are kept in the trash */
+    trash_duration: z.number(),
+});
+addConfig({
+    storage: StorageConfig.optional(),
+});
 export const defaultCASMime = [/video\/.*/, /audio\/.*/];
 addConfigDefaults({
     storage: {
@@ -29,8 +57,20 @@ addConfigDefaults({
         trash_duration: 30,
     },
 });
-addEvent({ source: '@axium/storage', name: 'storage_type_mismatch', severity: Severity.Warning, tags: ['mimetype'] });
-addEvent({ source: '@axium/storage', name: 'storage_size_mismatch', severity: Severity.Warning, tags: [] });
+addEvent({
+    source: '@axium/storage',
+    name: 'storage_type_mismatch',
+    severity: Severity.Warning,
+    tags: ['mimetype'],
+    extra: { item: z.string() },
+});
+addEvent({
+    source: '@axium/storage',
+    name: 'storage_size_mismatch',
+    severity: Severity.Warning,
+    tags: [],
+    extra: { item: z.string().nullable() },
+});
 let _getLimits = null;
 /**
  * Define the handler to get limits for a user externally.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@axium/storage",
-	"version": "0.11.2",
+	"version": "0.13.0",
 	"author": "James Prevett <axium@jamespre.dev>",
 	"description": "User file storage for Axium",
 	"funding": {
@@ -39,9 +39,9 @@
 		"build": "tsc"
 	},
 	"peerDependencies": {
-		"@axium/client": ">=0.9.0",
-		"@axium/core": ">=0.12.0",
-		"@axium/server": ">=0.28.0",
+		"@axium/client": ">=0.11.0",
+		"@axium/core": ">=0.17.0",
+		"@axium/server": ">=0.30.0",
 		"@sveltejs/kit": "^2.27.3",
 		"utilium": "^2.3.8"
 	},

package/routes/+layout.ts

@@ -0,0 +1 @@
+import '@axium/storage/common';