@axium/storage 0.8.0 → 0.9.0

package/dist/client/api.d.ts

@@ -15,7 +15,7 @@ export declare function downloadItem(fileId: string): Promise<Blob>;
 export declare function updateItemMetadata(fileId: string, metadata: StorageItemUpdate): Promise<StorageItemMetadata>;
 export declare function deleteItem(fileId: string): Promise<StorageItemMetadata>;
 export declare function getUserStorage(userId: string): Promise<UserStorage>;
-export declare function getUserStorageInfo(userId: string): Promise<UserStorageInfo>;
+export declare function getUserStats(userId: string): Promise<UserStorageInfo>;
 export declare function getUserTrash(userId: string): Promise<StorageItemMetadata[]>;
 export declare function itemsSharedWith(userId: string): Promise<StorageItemMetadata[]>;
 export declare function getUserStorageRoot(userId: string): Promise<StorageItemMetadata[]>;

package/dist/client/api.js

@@ -80,12 +80,19 @@ export async function deleteItem(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;
 }
-export async function getUserStorageInfo(userId) {
-    return await fetchAPI('OPTIONS', '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;
 }
 export async function getUserTrash(userId) {
     const result = await fetchAPI('GET', 'users/:id/storage/trash', undefined, userId);

package/dist/client/cli.js

@@ -6,23 +6,61 @@ import { statSync, unlinkSync } from 'node:fs';
 import { stat } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { styleText } from 'node:util';
-import { getUserStorage, getUserStorageInfo, getUserStorageRoot } from './api.js';
+import { colorItem, formatItems } from '../node.js';
+import * as api from './api.js';
 import { config, saveConfig } from './config.js';
-import { walkItems } from './paths.js';
+import { cachePath, getDirectory, resolveItem, setQuiet, syncCache } from './local.js';
 import { computeDelta, doSync, fetchSyncItems } from './sync.js';
-const cli = program.command('files').helpGroup('Plugins:').description('CLI integration for @axium/storage');
+const cli = program
+    .command('files')
+    .helpGroup('Plugins:')
+    .description('CLI integration for @axium/storage')
+    .option('-q, --quiet', 'Suppress output')
+    .hook('preAction', (action) => {
+    const opts = action.optsWithGlobals();
+    if (opts.quiet)
+        setQuiet(true);
+});
 cli.command('usage')
     .description('Show your usage')
     .action(async () => {
-    const { limits, usage } = await getUserStorageInfo(session().userId);
-    console.log(`Items: ${usage.items} ${limits.user_items ? ' / ' + limits.user_items : ''}`);
-    console.log(`Space: ${formatBytes(usage.bytes)} ${limits.user_size ? ' / ' + formatBytes(limits.user_size * 1_000_000) : ''}`);
+    const { limits, itemCount, usedBytes } = await api.getUserStats(session().userId);
+    console.log(`Items: ${itemCount} ${limits.user_items ? ' / ' + limits.user_items : ''}`);
+    console.log(`Space: ${formatBytes(usedBytes)} ${limits.user_size ? ' / ' + formatBytes(limits.user_size * 1_000_000) : ''}`);
 });
 cli.command('ls')
     .alias('list')
     .description('List the contents of a folder')
-    .action(() => {
-    io.error('Not implemented yet.');
+    .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);
+    const { long, humanReadable } = this.optsWithGlobals();
+    const items = await getDirectory(path).catch(io.handleError);
+    if (!long) {
+        console.log(items.map(colorItem).join('\t'));
+        return;
+    }
+    console.log('total ' + items.length);
+    for (const text of formatItems({ items, users, humanReadable }))
+        console.log(text);
+});
+cli.command('mkdir')
+    .description('Create a remote folder')
+    .argument('<path>', 'remote folder path to create')
+    .action(async (path) => {
+    const pathParts = path.split('/');
+    const name = pathParts.pop();
+    const parentPath = pathParts.join('/');
+    const parent = !parentPath ? null : await resolveItem(parentPath).catch(io.handleError);
+    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);
 });
 cli.command('status')
     .option('-v, --verbose', 'Show more details')
@@ -31,26 +69,26 @@ cli.command('status')
     console.log(styleText('bold', `${config.sync.length} synced folder(s):`));
     for (const sync of config.sync) {
         if (opt.refresh)
-            await fetchSyncItems(sync.itemId, sync.name);
-        const delta = computeDelta(sync.itemId, sync.localPath);
+            await fetchSyncItems(sync.item, sync.name);
+        const delta = computeDelta(sync);
         if (opt.verbose) {
-            console.log(styleText('underline', sync.localPath + ':'));
-            if (delta.synced.length == delta.items.length && !delta.localOnly.length) {
+            console.log(styleText('underline', sync.local_path + ':'));
+            if (delta.synced.length == delta.items.length && !delta.local_only.length) {
                 console.log('\t' + styleText('blueBright', 'All files are synced!'));
                 continue;
             }
-            for (const { _path } of delta.localOnly)
+            for (const { _path } of delta.local_only)
                 console.log('\t' + styleText('green', '+ ' + _path));
-            for (const { path } of delta.remoteOnly)
+            for (const { path } of delta.remote_only)
                 console.log('\t' + styleText('red', '- ' + path));
             for (const { path, modifiedAt } of delta.modified) {
-                const outdated = modifiedAt.getTime() > statSync(join(sync.localPath, path)).mtime.getTime();
+                const outdated = modifiedAt.getTime() > statSync(join(sync.local_path, path)).mtime.getTime();
                 console.log('\t' + styleText('yellow', '~ ' + path) + (outdated ? ' (outdated)' : ''));
             }
         }
         else {
-            console.log(sync.localPath + ':', Object.entries(delta)
-                .map(([name, items]) => `${styleText('blueBright', items.length.toString())} ${name}`)
+            console.log(sync.local_path + ':', Object.entries(delta)
+                .map(([name, items]) => `${styleText('blueBright', items.length.toString())} ${name.replaceAll('_', '-')}`)
                 .join(', '));
         }
     }
@@ -62,30 +100,27 @@ cli.command('add')
     .action(async (localPath, remoteName) => {
     localPath = resolve(localPath);
     for (const sync of config.sync) {
-        if (sync.localPath == localPath || localPath.startsWith(sync.localPath + '/'))
+        if (sync.local_path == localPath || localPath.startsWith(sync.local_path + '/'))
             io.exit('This local path is already being synced.');
-        if (sync.remotePath == remoteName || remoteName.startsWith(sync.remotePath + '/'))
+        if (sync.remote_path == remoteName || remoteName.startsWith(sync.remote_path + '/'))
             io.exit('This remote path is already being synced.');
     }
-    const { userId } = session();
     const local = await stat(localPath).catch(e => io.exit(e.toString()));
     if (!local.isDirectory())
         io.exit('Local path is not a directory.');
-    /**
-     * @todo Add an endpoint to fetch directories (maybe with the full paths?)
-     */
-    const allItems = remoteName.includes('/') ? (await getUserStorage(userId)).items : await getUserStorageRoot(userId);
-    const remote = walkItems(remoteName, allItems);
+    const remote = await resolveItem(remoteName);
     if (!remote)
         io.exit('Could not resolve remote path.');
     if (remote.type != 'inode/directory')
         io.exit('Remote path is not a directory.');
     config.sync.push({
         name: remote.name,
-        itemId: remote.id,
-        localPath,
-        lastSynced: new Date(),
-        remotePath: remoteName,
+        item: remote.id,
+        local_path: localPath,
+        last_synced: new Date(),
+        remote_path: remoteName,
+        include_dotfiles: false,
+        exclude: [],
     });
     await fetchSyncItems(remote.id);
     saveConfig();
@@ -97,19 +132,20 @@ cli.command('unsync')
     .argument('<path>', 'local path to the folder to stop syncing')
     .action((localPath) => {
     localPath = resolve(localPath);
-    const index = config.sync.findIndex(sync => sync.localPath == localPath);
+    const index = config.sync.findIndex(sync => sync.local_path == localPath);
     if (index == -1)
         io.exit('This local path is not being synced.');
-    unlinkSync(join(configDir, 'sync', config.sync[index].itemId + '.json'));
+    unlinkSync(join(configDir, 'sync', config.sync[index].item + '.json'));
     config.sync.splice(index, 1);
     saveConfig();
 });
 cli.command('sync')
     .description('Sync files')
-    .addOption(new Option('--delete', 'Delete local/remote files that were deleted remotely/locally')
+    .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')
     .argument('[sync]', 'The name of the Sync to sync')
     .action(async (name, opt) => {
     if (name) {
@@ -122,3 +158,37 @@ cli.command('sync')
         for (const sync of config.sync)
             await doSync(sync, opt);
 });
+const cliCache = cli.command('cache').description('Manage the local cache');
+cliCache
+    .command('clear')
+    .description('Clear the local cache')
+    .action(() => unlinkSync(cachePath));
+cliCache
+    .command('refresh')
+    .description('Force a refresh of the local cache from the server')
+    .action(async () => {
+    await syncCache(true).catch(io.handleError);
+});
+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 () {
+    const opt = this.optsWithGlobals();
+    const data = await syncCache(false).catch(io.handleError);
+    if (opt.json) {
+        console.log(JSON.stringify(data));
+        return;
+    }
+    console.log(`Cache contains ${data.items.length} items and ${Object.keys(data.users).length} users.`);
+    if (opt.quiet || !opt.verbose)
+        return;
+    console.log(styleText('bold', 'Items:'));
+    for (const text of formatItems({ ...data, humanReadable: true }))
+        console.log(text);
+    console.log(styleText('bold', 'Users:'));
+    for (const user of Object.values(data.users)) {
+        console.log(user.name, `<${user.email}>`, styleText('dim', `(${user.id})`));
+    }
+});

package/dist/client/config.d.ts

@@ -2,11 +2,13 @@ import * as z from 'zod';
 declare const ClientStorageConfig: z.ZodObject<{
     sync: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
-        itemId: z.ZodUUID;
-        localPath: z.ZodString;
-        lastSynced: z.ZodCoercedDate<unknown>;
-        remotePath: z.ZodString;
-    }, z.core.$strip>>;
+        item: z.ZodUUID;
+        local_path: z.ZodString;
+        last_synced: z.ZodCoercedDate<unknown>;
+        remote_path: z.ZodString;
+        include_dotfiles: z.ZodDefault<z.ZodBoolean>;
+        exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>;
 }, z.core.$loose>;
 export interface ClientStorageConfig extends z.infer<typeof ClientStorageConfig> {
 }

package/dist/client/config.js

@@ -1,6 +1,5 @@
 import { configDir } from '@axium/client/cli/config';
-import { debug, writeJSON } from '@axium/core/node/io';
-import { readFileSync } from 'node:fs';
+import { debug, readJSON, writeJSON } from '@axium/core/node/io';
 import { join } from 'node:path/posix';
 import * as z from 'zod';
 import { Sync } from './sync.js';
@@ -10,10 +9,10 @@ const ClientStorageConfig = z.looseObject({
 const configPath = join(configDir, 'storage.json');
 export let config = { sync: [] };
 try {
-    config = ClientStorageConfig.parse(JSON.parse(readFileSync(configPath, 'utf-8')));
+    config = readJSON(configPath, ClientStorageConfig);
 }
 catch (e) {
-    debug('Could not load @axium/storage config: ' + (e instanceof z.core.$ZodError ? z.prettifyError(e) : e.message));
+    debug('Could not load @axium/storage config: ' + e);
 }
 export function saveConfig() {
     writeJSON(configPath, config);

package/dist/client/hooks.js

@@ -2,5 +2,5 @@ import { config } from './config.js';
 import { doSync } from './sync.js';
 export async function run() {
     for (const sync of config.sync)
-        await doSync(sync, { delete: 'none', dryRun: false });
+        await doSync(sync, { delete: 'none', dryRun: false, verbose: true });
 }

package/dist/client/local.d.ts

@@ -0,0 +1,58 @@
+import { UserPublic } from '@axium/core';
+import * as z from 'zod';
+import { StorageItemMetadata } from '../common.js';
+export declare function setQuiet(enabled: boolean): void;
+export declare function walkItems(path: string, items: StorageItemMetadata[]): StorageItemMetadata | null;
+declare const StorageCache: 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>;
+        publicPermission: 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;
+        };
+        size: z.ZodInt;
+        trashedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+        type: z.ZodString;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+    users: z.ZodRecord<z.ZodUUID, z.ZodObject<{
+        id: z.ZodUUID;
+        name: z.ZodString;
+        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>>;
+        roles: z.ZodArray<z.ZodString>;
+        registeredAt: z.ZodCoercedDate<unknown>;
+        isAdmin: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+interface StorageCache extends z.infer<typeof StorageCache> {
+    users: Record<string, UserPublic>;
+}
+export declare const cachePath: string;
+export declare let cachedData: StorageCache | null;
+/**
+ * @param force true => always refresh, false => never refresh, null (default) => refresh if outdated
+ */
+export declare function syncCache(force?: boolean | null): Promise<StorageCache>;
+export declare function resolveItem(path: string): Promise<StorageItemMetadata | null>;
+export declare function getDirectory(path: string): Promise<StorageItemMetadata[]>;
+export {};

package/dist/client/local.js

@@ -0,0 +1,90 @@
+import { cacheDir, session } from '@axium/client/cli/config';
+import { userInfo } from '@axium/client/user';
+import { UserPublic } from '@axium/core';
+import * as io from '@axium/core/node/io';
+import { ENOENT, ENOTDIR } from 'node:constants';
+import { stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import * as z from 'zod';
+import { StorageItemMetadata } from '../common.js';
+import { getUserStats, getUserStorage } from './api.js';
+let quiet = false;
+export function setQuiet(enabled) {
+    quiet = enabled;
+}
+export function walkItems(path, items) {
+    const resolved = [];
+    let currentItem = null, currentParentId = null;
+    const target = path.split('/').filter(p => p);
+    for (const part of target) {
+        for (const item of items) {
+            if (item.parentId != currentParentId || item.name != part)
+                continue;
+            currentItem = item;
+            currentParentId = item.id;
+            resolved.push(part);
+            break;
+        }
+    }
+    return currentItem;
+}
+const StorageCache = z.object({
+    items: StorageItemMetadata.array(),
+    users: z.record(z.uuid(), UserPublic),
+});
+export const cachePath = join(cacheDir, 'storage.json');
+export let cachedData = null;
+/**
+ * @param force true => always refresh, false => never refresh, null (default) => refresh if outdated
+ */
+export async function syncCache(force = null) {
+    if (cachedData)
+        return cachedData;
+    const cacheUpdated = await stat(cachePath)
+        .then(stats => stats.mtimeMs)
+        .catch(() => 0);
+    const { userId } = session();
+    let { lastModified, lastTrashed } = await getUserStats(userId);
+    lastTrashed ??= new Date(0);
+    if ((force || cacheUpdated < lastModified.getTime() || cacheUpdated < lastTrashed.getTime()) && force !== false) {
+        if (!quiet)
+            io.start('Updating and loading item metadata');
+        try {
+            const { items } = await getUserStorage(userId);
+            const users = {};
+            for (const item of items) {
+                users[item.userId] ||= await userInfo(item.userId);
+            }
+            cachedData = { items, users };
+            io.writeJSON(cachePath, cachedData);
+            if (!quiet)
+                io.done();
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            if (quiet)
+                io.exit('Failed to update item metadata: ' + message);
+            else
+                io.exit(message);
+        }
+    }
+    else {
+        cachedData = io.readJSON(cachePath, StorageCache);
+    }
+    return cachedData;
+}
+export async function resolveItem(path) {
+    const { items } = await syncCache();
+    return walkItems(path, items);
+}
+export async function getDirectory(path) {
+    const { items } = await syncCache();
+    if (path == '/' || path == '')
+        return items.filter(item => item.parentId === null);
+    const dir = walkItems(path, items);
+    if (!dir)
+        throw ENOENT;
+    if (dir.type != 'inode/directory')
+        throw ENOTDIR;
+    return items.filter(item => item.parentId === dir.id);
+}

package/dist/client/sync.d.ts

@@ -11,11 +11,13 @@ import '../polyfills.js';
  */
 export declare const Sync: z.ZodObject<{
     name: z.ZodString;
-    itemId: z.ZodUUID;
-    localPath: z.ZodString;
-    lastSynced: z.ZodCoercedDate<unknown>;
-    remotePath: z.ZodString;
-}, z.core.$strip>;
+    item: z.ZodUUID;
+    local_path: z.ZodString;
+    last_synced: z.ZodCoercedDate<unknown>;
+    remote_path: z.ZodString;
+    include_dotfiles: z.ZodDefault<z.ZodBoolean>;
+    exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
 export interface Sync extends z.infer<typeof Sync> {
 }
 /** Local metadata about a storage item to sync */
@@ -37,19 +39,29 @@ export interface ItemMetadata {
 export interface Delta {
     synced: LocalItem[];
     modified: LocalItem[];
-    remoteOnly: LocalItem[];
+    remote_only: LocalItem[];
     items: LocalItem[];
     _items: Map<string, LocalItem>;
-    localOnly: (fs.Dirent<string> & {
+    local_only: (fs.Dirent<string> & {
         _path: string;
     })[];
 }
 /**
  * Computes the changes between the local and remote, in the direction of the remote.
  */
-export declare function computeDelta(id: string, localPath: string): Delta;
+export declare function computeDelta(sync: Sync): Delta;
+/**
+ * A helper to run an action on an array, with support for dry-runs and displaying a progress counter or listing each item.
+ */
+export declare function applyAction<T>(opt: {
+    dryRun: boolean;
+    verbose: boolean;
+}, items: T[], label: (item: T) => string, action: (item: T) => Promise<void | string> | void | string): Promise<void>;
 export interface SyncOptions {
     delete: 'local' | 'remote' | 'none';
     dryRun: boolean;
+    verbose: boolean;
+}
+export interface SyncStats {
 }
-export declare function doSync(sync: Sync, opt: SyncOptions): Promise<void>;
+export declare function doSync(sync: Sync, opt: SyncOptions): Promise<SyncStats>;

package/dist/client/sync.js

@@ -1,14 +1,14 @@
 import { configDir, saveConfig } from '@axium/client/cli/config';
 import { fetchAPI } from '@axium/client/requests';
 import * as io from '@axium/core/node/io';
+import mime from 'mime';
 import { createHash } from 'node:crypto';
 import * as fs from 'node:fs';
-import { dirname, join, relative } from 'node:path';
+import { basename, dirname, join, matchesGlob, relative } from 'node:path';
 import { pick } from 'utilium';
 import * as z from 'zod';
 import '../polyfills.js';
 import { deleteItem, downloadItem, updateItem, uploadItem } from './api.js';
-import mime from 'mime';
 /**
  * A Sync is a storage item that has been selected for synchronization by the user.
  * Importantly, it is *only* the "top-level" item.
@@ -17,12 +17,14 @@ import mime from 'mime';
  * `Sync`s are client-side in nature, the server does not care about them.
  * (we could do something fancy server-side at a later date)
  */
-export const Sync = z.object({
+export const Sync = z.looseObject({
     name: z.string(),
-    itemId: z.uuid(),
-    localPath: z.string(),
-    lastSynced: z.coerce.date(),
-    remotePath: z.string(),
+    item: z.uuid(),
+    local_path: z.string(),
+    last_synced: z.coerce.date(),
+    remote_path: z.string(),
+    include_dotfiles: z.boolean().default(false),
+    exclude: z.string().array().default([]),
 });
 /** Local metadata about a storage item to sync */
 export const LocalItem = z.object({
@@ -46,11 +48,7 @@ export async function fetchSyncItems(id, folderName) {
     }
 }
 export function getItems(id) {
-    const items = JSON.parse(fs.readFileSync(join(configDir, 'sync', id + '.json'), 'utf-8'));
-    const { error, data } = LocalItem.array().safeParse(items);
-    if (error)
-        throw z.prettifyError(error);
-    return data;
+    return io.readJSON(join(configDir, 'sync', id + '.json'), LocalItem.array());
 }
 export function setItems(id, items) {
     fs.mkdirSync(join(configDir, 'sync'), { recursive: true });
@@ -59,16 +57,19 @@ export function setItems(id, items) {
 /**
  * Computes the changes between the local and remote, in the direction of the remote.
  */
-export function computeDelta(id, localPath) {
-    const items = new Map(getItems(id).map(i => [i.path, i]));
+export function computeDelta(sync) {
+    const items = new Map(getItems(sync.item).map(i => [i.path, i]));
     const itemsSet = new Set(items.keys());
-    const files = new Map(fs.readdirSync(localPath, { recursive: true, encoding: 'utf8', withFileTypes: true }).map(d => {
-        const _path = relative(localPath, join(d.parentPath, d.name));
+    const files = new Map(fs
+        .readdirSync(sync.local_path, { recursive: true, encoding: 'utf8', withFileTypes: true })
+        .map(d => {
+        const _path = relative(sync.local_path, join(d.parentPath, d.name));
         return [_path, Object.assign(d, { _path })];
-    }));
+    })
+        .filter(([p]) => (sync.include_dotfiles || basename(p)[0] != '.') && !sync.exclude.some(glob => matchesGlob(p, glob))));
     const synced = itemsSet.intersection(files);
     const modified = new Set(synced.keys().filter(path => {
-        const full = join(localPath, path);
+        const full = join(sync.local_path, path);
         const hash = fs.statSync(full).isDirectory() ? null : createHash('BLAKE2b512').update(fs.readFileSync(full)).digest().toHex();
         return hash != items.get(path)?.hash;
     }));
@@ -77,129 +78,119 @@ export function computeDelta(id, localPath) {
         items: Array.from(items.values()),
         synced: Array.from(synced.difference(modified)).map(p => items.get(p)),
         modified: Array.from(modified).map(p => items.get(p)),
-        localOnly: Array.from(new Set(files.keys()).difference(items)).map(p => files.get(p)),
-        remoteOnly: Array.from(itemsSet.difference(files)).map(p => items.get(p)),
+        local_only: Array.from(new Set(files.keys()).difference(items)).map(p => files.get(p)),
+        remote_only: Array.from(itemsSet.difference(files)).map(p => items.get(p)),
     };
     Object.defineProperty(delta, '_items', { enumerable: false });
     return delta;
 }
-export async function doSync(sync, opt) {
-    await fetchSyncItems(sync.itemId, sync.name);
-    const delta = computeDelta(sync.itemId, sync.localPath);
-    const { _items } = delta;
-    if (opt.delete == 'local')
-        delta.localOnly.reverse(); // so directories come after
-    for (const dirent of delta.localOnly) {
-        if (opt.delete == 'local') {
-            io.start('Deleting ' + dirent._path);
-            try {
-                if (opt.dryRun)
+/**
+ * A helper to run an action on an array, with support for dry-runs and displaying a progress counter or listing each item.
+ */
+export async function applyAction(opt, items, label, action) {
+    for (const [i, item] of items.entries()) {
+        opt.verbose ? io.start(label(item)) : io.progress(i, items.length, label(item));
+        try {
+            let result = undefined;
+            if (opt.dryRun) {
+                if (opt.verbose)
                     process.stdout.write('(dry run) ');
-                else {
-                    fs.unlinkSync(join(sync.localPath, dirent._path));
-                    _items.delete(dirent._path);
-                }
-                io.done();
             }
-            catch (e) {
-                io.error(e.message);
+            else {
+                result = await action(item);
             }
-            continue;
+            if (opt.verbose)
+                result ? io.log(result) : io.done();
+        }
+        catch (e) {
+            io.error(e.message);
+            throw e;
+        }
+    }
+}
+export async function doSync(sync, opt) {
+    const stats = {};
+    await fetchSyncItems(sync.item, sync.name);
+    const delta = computeDelta(sync);
+    const { _items } = delta;
+    if (!delta.local_only.length) {
+        // Nothing
+    }
+    else if (opt.delete == 'local') {
+        delta.local_only.reverse(); // so directories come after
+        if (!opt.verbose)
+            io.start('Deleting local items');
+    }
+    else if (!opt.verbose)
+        io.start('Uploading local items');
+    await applyAction(opt, delta.local_only, dirent => (!opt.verbose ? '' : opt.delete == 'local' ? 'Deleting local ' : 'Uploading ') + dirent._path, async (dirent) => {
+        if (opt.delete == 'local') {
+            fs.unlinkSync(join(sync.local_path, dirent._path));
+            _items.delete(dirent._path);
+            return;
         }
         const uploadOpts = {
-            parentId: dirname(dirent._path) == '.' ? sync.itemId : _items.get(dirname(dirent._path))?.id,
+            parentId: dirname(dirent._path) == '.' ? sync.item : _items.get(dirname(dirent._path))?.id,
             name: dirent.name,
         };
-        io.start('Uploading ' + dirent._path);
-        try {
-            if (opt.dryRun)
-                process.stdout.write('(dry run) ');
-            else if (dirent.isDirectory()) {
-                const dir = await uploadItem(new Blob([], { type: 'inode/directory' }), uploadOpts);
-                _items.set(dirent._path, Object.assign(pick(dir, 'id', 'modifiedAt'), { path: dirent._path, hash: null }));
-            }
-            else {
-                const type = mime.getType(dirent._path) || 'application/octet-stream';
-                const content = fs.readFileSync(join(sync.localPath, dirent._path));
-                const file = await uploadItem(new Blob([content], { type }), uploadOpts);
-                _items.set(dirent._path, Object.assign(pick(file, 'id', 'modifiedAt', 'hash'), { path: dirent._path }));
-            }
-            io.done();
+        if (dirent.isDirectory()) {
+            const dir = await uploadItem(new Blob([], { type: 'inode/directory' }), uploadOpts);
+            _items.set(dirent._path, Object.assign(pick(dir, 'id', 'modifiedAt'), { path: dirent._path, hash: null }));
         }
-        catch (e) {
-            io.error(e.message);
+        else {
+            const type = mime.getType(dirent._path) || 'application/octet-stream';
+            const content = fs.readFileSync(join(sync.local_path, dirent._path));
+            const file = await uploadItem(new Blob([content], { type }), uploadOpts);
+            _items.set(dirent._path, Object.assign(pick(file, 'id', 'modifiedAt', 'hash'), { path: dirent._path }));
         }
+    });
+    if (!delta.remote_only.length) {
+        // Nothing
+    }
+    else if (opt.delete == 'remote') {
+        delta.remote_only.reverse();
+        if (!opt.verbose)
+            io.start('Deleting remote items');
     }
-    if (opt.delete == 'remote')
-        delta.remoteOnly.reverse();
-    for (const item of delta.remoteOnly) {
+    else if (!opt.verbose)
+        io.start('Downloading remote items');
+    await applyAction(opt, delta.remote_only, item => (!opt.verbose ? '' : opt.delete == 'remote' ? 'Deleting remote ' : 'Downloading ') + item.path, async (item) => {
         if (opt.delete == 'remote') {
-            io.start('Deleting ' + item.path);
-            try {
-                if (opt.dryRun)
-                    process.stdout.write('(dry run) ');
-                else {
-                    await deleteItem(item.id);
-                    _items.delete(item.path);
-                }
-                io.done();
-            }
-            catch (e) {
-                io.error(e.message);
-            }
-            continue;
+            await deleteItem(item.id);
+            _items.delete(item.path);
+            return;
         }
-        io.start('Downloading ' + item.path);
-        try {
-            const fullPath = join(sync.localPath, item.path);
-            if (opt.dryRun)
-                process.stdout.write('(dry run) ');
-            else if (!item.hash) {
-                fs.mkdirSync(fullPath, { recursive: true });
-            }
-            else {
-                const blob = await downloadItem(item.id);
-                const content = await blob.bytes();
-                fs.writeFileSync(fullPath, content);
-            }
-            io.done();
+        const fullPath = join(sync.local_path, item.path);
+        if (!item.hash) {
+            fs.mkdirSync(fullPath, { recursive: true });
         }
-        catch (e) {
-            io.error(e.message);
+        else {
+            const blob = await downloadItem(item.id);
+            const content = await blob.bytes();
+            fs.writeFileSync(fullPath, content);
         }
-    }
-    for (const item of delta.modified) {
-        io.start('Updating ' + item.path);
-        try {
-            const content = fs.readFileSync(join(sync.localPath, item.path));
-            const type = mime.getType(item.path) || 'application/octet-stream';
-            if (item.modifiedAt.getTime() > fs.statSync(join(sync.localPath, item.path)).mtime.getTime()) {
-                if (opt.dryRun)
-                    process.stdout.write('(dry run) ');
-                else {
-                    const blob = await downloadItem(item.id);
-                    const content = await blob.bytes();
-                    fs.writeFileSync(join(sync.localPath, item.path), content);
-                }
-                console.log('server.');
-            }
-            else {
-                if (opt.dryRun)
-                    process.stdout.write('(dry run) ');
-                else {
-                    const updated = await updateItem(item.id, new Blob([content], { type }));
-                    _items.set(item.path, Object.assign(pick(updated, 'id', 'modifiedAt', 'hash'), { path: item.path }));
-                }
-                console.log('local.');
-            }
+    });
+    if (!opt.verbose && delta.modified.length)
+        io.start('Syncing modified items');
+    await applyAction(opt, delta.modified, item => (opt.verbose ? 'Updating ' : '') + item.path, async (item) => {
+        if (item.modifiedAt.getTime() > fs.statSync(join(sync.local_path, item.path)).mtime.getTime()) {
+            const blob = await downloadItem(item.id);
+            const content = await blob.bytes();
+            fs.writeFileSync(join(sync.local_path, item.path), content);
+            return 'server.';
         }
-        catch (e) {
-            io.error(e.message);
+        else {
+            const type = mime.getType(item.path) || 'application/octet-stream';
+            const content = fs.readFileSync(join(sync.local_path, item.path));
+            const updated = await updateItem(item.id, new Blob([content], { type }));
+            _items.set(item.path, Object.assign(pick(updated, 'id', 'modifiedAt', 'hash'), { path: item.path }));
+            return 'local.';
         }
-    }
+    });
     if (opt.dryRun)
-        return;
-    setItems(sync.itemId, Array.from(_items.values()));
-    sync.lastSynced = new Date();
+        return stats;
+    setItems(sync.item, Array.from(_items.values()));
+    sync.last_synced = new Date();
     saveConfig();
+    return stats;
 }

package/dist/common.d.ts

@@ -64,13 +64,14 @@ export interface StorageLimits {
     /** The maximum storage size per user in MB */
     user_size: number;
 }
-export interface StorageUsage {
-    bytes: number;
-    items: number;
+export interface StorageStats {
+    usedBytes: number;
+    itemCount: number;
+    lastModified: Date;
+    lastTrashed: Date | null;
 }
-export interface UserStorageInfo {
+export interface UserStorageInfo extends StorageStats {
     limits: StorageLimits;
-    usage: StorageUsage;
 }
 export interface UserStorage extends UserStorageInfo {
     items: StorageItemMetadata[];
@@ -82,24 +83,50 @@ export declare const StorageItemUpdate: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     owner: z.ZodOptional<z.ZodUUID>;
     trash: z.ZodOptional<z.ZodBoolean>;
-    publicPermission: z.ZodOptional<z.ZodNumber>;
+    publicPermission: z.ZodOptional<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;
+    }>;
 }, z.core.$strip>;
 export type StorageItemUpdate = z.infer<typeof StorageItemUpdate>;
-export interface StorageItemMetadata<T extends Record<string, unknown> = Record<string, unknown>> {
-    createdAt: Date;
-    dataURL: string;
-    /** The hash of the file, or null if it is a directory */
-    hash: string | null;
-    id: string;
-    immutable: boolean;
-    modifiedAt: Date;
-    name: string;
-    userId: string;
-    parentId: string | null;
-    publicPermission: number;
-    size: number;
-    trashedAt: Date | null;
-    type: string;
+export declare const StorageItemMetadata: 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>;
+    publicPermission: 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;
+    };
+    size: z.ZodInt;
+    trashedAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
+    type: z.ZodString;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export interface StorageItemMetadata<T extends Record<string, unknown> = Record<string, unknown>> extends z.infer<typeof StorageItemMetadata> {
     metadata: T;
 }
 /**
@@ -121,7 +148,19 @@ export declare const StorageBatchUpdate: z.ZodObject<{
         name: z.ZodOptional<z.ZodString>;
         owner: z.ZodOptional<z.ZodUUID>;
         trash: z.ZodOptional<z.ZodBoolean>;
-        publicPermission: z.ZodOptional<z.ZodNumber>;
+        publicPermission: z.ZodOptional<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;
+        }>;
     }, z.core.$strip>>;
     content: z.ZodRecord<z.ZodUUID, z.ZodObject<{
         offset: z.ZodInt;

package/dist/common.js

@@ -1,3 +1,4 @@
+import { Permission } from '@axium/core/access';
 import * as z from 'zod';
 export const syncProtocolVersion = 0;
 /**
@@ -8,9 +9,26 @@ export const StorageItemUpdate = z
     name: z.string(),
     owner: z.uuid(),
     trash: z.boolean(),
-    publicPermission: z.number().min(0).max(5),
+    publicPermission: Permission,
 })
     .partial();
+export const StorageItemMetadata = z.object({
+    createdAt: z.coerce.date(),
+    dataURL: z.string(),
+    /** The hash of the file, or null if it is a directory */
+    hash: z.string().nullish(),
+    id: z.uuid(),
+    immutable: z.boolean(),
+    modifiedAt: z.coerce.date(),
+    name: z.string(),
+    userId: z.uuid(),
+    parentId: z.uuid().nullable(),
+    publicPermission: Permission,
+    size: z.int().nonnegative(),
+    trashedAt: z.coerce.date().nullable(),
+    type: z.string(),
+    metadata: z.record(z.string(), z.unknown()),
+});
 /**
  * Formats:
  *

package/dist/node.d.ts

@@ -0,0 +1,13 @@
+import type { StorageItemMetadata } from './common.js';
+export declare function colorItem(item: StorageItemMetadata): string;
+interface FormatItemsConfig {
+    items: (StorageItemMetadata & {
+        __size?: string;
+    })[];
+    users: Record<string, {
+        name: string;
+    }>;
+    humanReadable: boolean;
+}
+export declare function formatItems({ items, users, humanReadable }: FormatItemsConfig): Generator<string>;
+export {};

package/dist/node.js

@@ -0,0 +1,52 @@
+import { formatBytes } from '@axium/core/format';
+import { styleText } from 'node:util';
+const executables = ['application/x-pie-executable', 'application/x-sharedlib', 'application/vnd.microsoft.portable-executable'];
+const archives = [
+    'application/gzip',
+    'application/vnd.rar',
+    'application/x-7z-compressed',
+    'application/x-bzip',
+    'application/x-bzip2',
+    'application/x-tar',
+    'application/x-xz',
+    'application/zip',
+];
+export function colorItem(item) {
+    const { type, name } = item;
+    if (type === 'inode/directory')
+        return styleText('blue', name);
+    if (type.startsWith('image/') || type.startsWith('video/'))
+        return styleText('magenta', name);
+    if (type.startsWith('audio/'))
+        return styleText('cyan', name);
+    if (executables.includes(type))
+        return styleText('green', name);
+    if (archives.includes(type))
+        return styleText('red', name);
+    return name;
+}
+const publicPermString = ['---', 'r--', 'r-x', 'rwx', 'rwx', 'rwx'];
+const __formatter = new Intl.DateTimeFormat('en-US', {
+    year: 'numeric',
+    month: 'short',
+    day: '2-digit',
+    hour12: false,
+    hour: '2-digit',
+    minute: '2-digit',
+});
+const formatDate = __formatter.format.bind(__formatter);
+export function* formatItems({ items, users, humanReadable }) {
+    let sizeWidth = 0, nameWidth = 0;
+    for (const item of items) {
+        item.__size = item.type == 'inode/directory' ? '-' : humanReadable ? formatBytes(item.size) : item.size.toString();
+        sizeWidth = Math.max(sizeWidth, item.__size.length);
+        nameWidth = Math.max(nameWidth, users[item.userId].name.length);
+    }
+    for (const item of items) {
+        const owner = users[item.userId].name;
+        const type = item.type == 'inode/directory' ? 'd' : '-';
+        const ownerPerm = `r${item.immutable ? '-' : 'w'}x`;
+        const publicPerm = publicPermString[item.publicPermission];
+        yield `${type}${ownerPerm}${ownerPerm}${publicPerm}. ${owner.padEnd(nameWidth)} ${item.__size.padStart(sizeWidth)} ${formatDate(item.modifiedAt)} ${colorItem(item)}`;
+    }
+}

package/dist/server/api.js

@@ -9,7 +9,7 @@ import * as z from 'zod';
 import { batchFormatVersion, StorageItemUpdate, syncProtocolVersion } from '../common.js';
 import '../polyfills.js';
 import { getLimits } from './config.js';
-import { currentUsage, deleteRecursive, getRecursive, parseItem } from './db.js';
+import { getUserStats, deleteRecursive, getRecursive, parseItem } from './db.js';
 addRoute({
     path: '/api/storage',
     OPTIONS() {
@@ -106,20 +106,20 @@ addRoute({
             error(503, 'User storage is disabled');
         const userId = params.id;
         await checkAuthForUser(request, userId);
-        const [usage, limits] = await Promise.all([currentUsage(userId), getLimits(userId)]).catch(withError('Could not fetch data'));
-        return { usage, limits };
+        const [stats, limits] = await Promise.all([getUserStats(userId), getLimits(userId)]).catch(withError('Could not fetch data'));
+        return Object.assign(stats, { limits });
     },
     async GET(request, params) {
         if (!config.storage.enabled)
             error(503, 'User storage is disabled');
         const userId = params.id;
         await checkAuthForUser(request, userId);
-        const [items, usage, limits] = await Promise.all([
+        const [items, stats, limits] = await Promise.all([
             database.selectFrom('storage').where('userId', '=', userId).where('trashedAt', 'is', null).selectAll().execute(),
-            currentUsage(userId),
+            getUserStats(userId),
             getLimits(userId),
         ]).catch(withError('Could not fetch data'));
-        return { usage, limits, items: items.map(parseItem) };
+        return Object.assign(stats, { limits, items: items.map(parseItem) });
     },
 });
 addRoute({

package/dist/server/batch.js

@@ -13,7 +13,7 @@ import { join } from 'node:path/posix';
 import * as z from 'zod';
 import { StorageBatchUpdate } from '../common.js';
 import { getLimits } from './config.js';
-import { currentUsage, getRecursiveIds, parseItem } from './db.js';
+import { getUserStats, getRecursiveIds, parseItem } from './db.js';
 addRoute({
     path: '/api/storage/batch',
     async POST(req) {
@@ -27,7 +27,7 @@ addRoute({
         const { userId, user } = await getSessionAndUser(token).catch(withError('Invalid session token', 401));
         if (user.isSuspended)
             error(403, 'User is suspended');
-        const [usage, limits] = await Promise.all([currentUsage(userId), getLimits(userId)]).catch(withError('Could not fetch usage and/or limits'));
+        const [usage, limits] = await Promise.all([getUserStats(userId), getLimits(userId)]).catch(withError('Could not fetch usage and/or limits'));
         const batchHeaderSize = Number(req.headers.get('x-batch-header-size'));
         if (!Number.isSafeInteger(batchHeaderSize) || batchHeaderSize < 2)
             error(400, 'Invalid or missing header, X-Batch-Header-Size');
@@ -92,7 +92,7 @@ addRoute({
                 continue;
             error(403, 'Missing permission for item: ' + item.id);
         }
-        if (limits.user_size && (usage.bytes + size - items.reduce((sum, item) => sum + item.size, 0)) / 1_000_000 >= limits.user_size)
+        if (limits.user_size && (usage.usedBytes + size - items.reduce((sum, item) => sum + item.size, 0)) / 1_000_000 >= limits.user_size)
             error(413, 'Not enough space');
         const tx = await database.startTransaction().execute();
         const results = new Map();

package/dist/server/db.d.ts

@@ -1,7 +1,8 @@
 import { type Schema } from '@axium/server/database';
 import type { Generated, Selectable } from 'kysely';
-import type { StorageItemMetadata, StorageUsage } from '../common.js';
+import type { StorageItemMetadata, StorageStats } from '../common.js';
 import '../polyfills.js';
+import type { Permission } from '@axium/core';
 declare module '@axium/server/database' {
     interface Schema {
         storage: {
@@ -16,7 +17,7 @@ declare module '@axium/server/database' {
             trashedAt: Date | null;
             type: string;
             userId: string;
-            publicPermission: Generated<number>;
+            publicPermission: Generated<Permission>;
             metadata: Generated<Record<string, unknown>>;
         };
     }
@@ -36,7 +37,7 @@ export declare function parseItem<T extends SelectedItem>(item: T): Omit<T, keyo
 /**
  * Returns the current usage of the storage for a user in bytes.
  */
-export declare function currentUsage(userId: string): Promise<StorageUsage>;
+export declare function getUserStats(userId: string): Promise<StorageStats>;
 export declare function get(itemId: string): Promise<StorageItemMetadata>;
 export declare function getRecursive(this: {
     path: string;

package/dist/server/db.js

@@ -29,15 +29,19 @@ export function parseItem(item) {
 /**
  * Returns the current usage of the storage for a user in bytes.
  */
-export async function currentUsage(userId) {
+export async function getUserStats(userId) {
     const result = await database
         .selectFrom('storage')
         .where('userId', '=', userId)
-        .select(eb => eb.fn.countAll().as('items'))
-        .select(eb => eb.fn.sum('size').as('bytes'))
+        .select(eb => [
+        eb.fn.countAll().as('itemCount'),
+        eb.fn.sum('size').as('usedBytes'),
+        eb.fn.max('modifiedAt').as('lastModified'),
+        eb.fn.max('trashedAt').as('lastTrashed'),
+    ])
         .executeTakeFirstOrThrow();
-    result.bytes = Number(result.bytes || 0);
-    result.items = Number(result.items);
+    result.usedBytes = Number(result.usedBytes || 0);
+    result.itemCount = Number(result.itemCount);
     return result;
 }
 export async function get(itemId) {

package/dist/server/raw.js

@@ -11,7 +11,7 @@ import { join } from 'node:path/posix';
 import * as z from 'zod';
 import '../polyfills.js';
 import { defaultCASMime, getLimits } from './config.js';
-import { currentUsage, parseItem } from './db.js';
+import { getUserStats, parseItem } from './db.js';
 addRoute({
     path: '/raw/storage',
     async PUT(request) {
@@ -21,7 +21,7 @@ addRoute({
         if (!token)
             error(401, 'Missing session token');
         const { userId } = await getSessionAndUser(token).catch(withError('Invalid session token', 401));
-        const [usage, limits] = await Promise.all([currentUsage(userId), getLimits(userId)]).catch(withError('Could not fetch usage and/or limits'));
+        const [usage, limits] = await Promise.all([getUserStats(userId), getLimits(userId)]).catch(withError('Could not fetch usage and/or limits'));
         const name = request.headers.get('x-name');
         if (!name)
             error(400, 'Missing name header');
@@ -39,9 +39,9 @@ addRoute({
         const size = Number(request.headers.get('content-length'));
         if (Number.isNaN(size))
             error(411, 'Missing or invalid content length header');
-        if (limits.user_items && usage.items >= limits.user_items)
+        if (limits.user_items && usage.itemCount >= limits.user_items)
             error(409, 'Too many items');
-        if (limits.user_size && (usage.bytes + size) / 1_000_000 >= limits.user_size)
+        if (limits.user_size && (usage.usedBytes + size) / 1_000_000 >= limits.user_size)
             error(413, 'Not enough space');
         if (limits.item_size && size > limits.item_size * 1_000_000)
             error(413, 'File size exceeds maximum size');
@@ -132,8 +132,8 @@ addRoute({
         const size = Number(request.headers.get('content-length'));
         if (Number.isNaN(size))
             error(411, 'Missing or invalid content length header');
-        const [usage, limits] = await Promise.all([currentUsage(item.userId), getLimits(item.userId)]).catch(withError('Could not fetch usage and/or limits'));
-        if (limits.user_size && (usage.bytes + size - item.size) / 1_000_000 >= limits.user_size)
+        const [usage, limits] = await Promise.all([getUserStats(item.userId), getLimits(item.userId)]).catch(withError('Could not fetch usage and/or limits'));
+        if (limits.user_size && (usage.usedBytes + size - item.size) / 1_000_000 >= limits.user_size)
             error(413, 'Not enough space');
         if (limits.item_size && size > limits.item_size * 1_000_000)
             error(413, 'File size exceeds maximum size');

package/lib/Usage.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
 	import { formatBytes } from '@axium/core/format';
 	import { NumberBar } from '@axium/client/components';
-	import { getUserStorageInfo } from '@axium/storage/client';
+	import { getUserStats } from '@axium/storage/client';
 	import type { UserStorageInfo } from '@axium/storage/common';
 
 	const { userId, info }: { userId?: string; info?: UserStorageInfo } = $props();
@@ -10,13 +10,13 @@
 {#if !info && !userId}
 	<p>Log in to see storage usage.</p>
 {:else}
-	{#await info || getUserStorageInfo(userId!) then info}
+	{#await info || getUserStats(userId!) then info}
 		<p>
 			<a href="/files/usage">
 				<NumberBar
 					max={info.limits.user_size && info.limits.user_size * 1_000_000}
-					value={info.usage.bytes}
-					text="Using {formatBytes(info.usage.bytes)} {!info.limits.user_size
+					value={info.usedBytes}
+					text="Using {formatBytes(info.usedBytes)} {!info.limits.user_size
 						? ''
 						: 'of ' + formatBytes(info.limits.user_size * 1_000_000)}"
 				/>

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@axium/storage",
-	"version": "0.8.0",
+	"version": "0.9.0",
 	"author": "James Prevett <axium@jamespre.dev>",
 	"description": "User file storage for Axium",
 	"funding": {
@@ -39,7 +39,7 @@
 	},
 	"peerDependencies": {
 		"@axium/client": ">=0.6.0",
-		"@axium/core": ">=0.9.0",
+		"@axium/core": ">=0.10.0",
 		"@axium/server": ">=0.26.0",
 		"@sveltejs/kit": "^2.27.3",
 		"utilium": "^2.3.8"

package/routes/files/usage/+page.svelte

@@ -8,12 +8,10 @@
 	const { limits } = data.info;
 
 	let items = $state(data.info.items.filter(i => i.type != 'inode/directory').sort((a, b) => Math.sign(b.size - a.size)));
-	const usage = $state(data.info.usage);
+	const usedBytes = $state(data.info.usedBytes);
 
 	let dialogs = $state<Record<string, HTMLDialogElement>>({});
-	let barText = $derived(
-		`Using ${formatBytes(usage?.bytes)} ${limits.user_size ? 'of ' + formatBytes(limits.user_size * 1_000_000) : ''}`
-	);
+	let barText = $derived(`Using ${formatBytes(usedBytes)} ${limits.user_size ? 'of ' + formatBytes(limits.user_size * 1_000_000) : ''}`);
 </script>
 
 <svelte:head>
@@ -28,6 +26,6 @@
 
 <h2>Storage Usage</h2>
 
-<p><NumberBar max={limits.user_size * 1_000_000} value={usage?.bytes} text={barText} /></p>
+<p><NumberBar max={limits.user_size * 1_000_000} value={usedBytes} text={barText} /></p>
 
 <StorageList bind:items emptyText="You have not uploaded any files yet." />

package/dist/client/paths.d.ts

@@ -1,2 +0,0 @@
-import type { StorageItemMetadata } from '../common.js';
-export declare function walkItems(path: string, items: StorageItemMetadata[]): StorageItemMetadata | null;

package/dist/client/paths.js

@@ -1,16 +0,0 @@
-export function walkItems(path, items) {
-    const resolved = [];
-    let currentItem = null, currentParentId = null;
-    const target = path.split('/').filter(p => p);
-    for (const part of target) {
-        for (const item of items) {
-            if (item.parentId != currentParentId || item.name != part)
-                continue;
-            currentItem = item;
-            currentParentId = item.id;
-            resolved.push(part);
-            break;
-        }
-    }
-    return currentItem;
-}