@axium/storage 0.12.0 → 0.13.1

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/local.d.ts

@@ -23,14 +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.ZodObject<{
-            debug: z.ZodBoolean;
-        }, z.core.$strip>>;
+        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/common.d.ts

@@ -1,75 +1,4 @@
 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 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> {
-}
-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 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[];
-}
 /**
  * An update to file metadata.
  */
@@ -97,6 +26,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:
  *
@@ -124,3 +110,270 @@ export declare const StorageBatchUpdate: z.ZodObject<{
 }, z.core.$strip>;
 export interface StorageBatchUpdate extends z.infer<typeof StorageBatchUpdate> {
 }
+export declare const StoragePublicConfig: z.ZodObject<{
+    batch: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        max_items: z.ZodInt;
+        max_item_size: z.ZodInt;
+    }, z.core.$strip>;
+    chunk: z.ZodBoolean;
+    max_transfer_size: z.ZodInt;
+    max_chunks: z.ZodInt;
+}, z.core.$strip>;
+export interface StoragePublicConfig extends z.infer<typeof StoragePublicConfig> {
+}
+export declare const StorageConfig: z.ZodObject<{
+    batch: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        max_items: z.ZodInt;
+        max_item_size: z.ZodInt;
+    }, z.core.$strip>;
+    chunk: z.ZodBoolean;
+    max_transfer_size: z.ZodInt;
+    max_chunks: z.ZodInt;
+    app_enabled: z.ZodBoolean;
+    cas: z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        exclude: z.ZodOptional<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/core/plugins' {
+    interface $PluginConfigs {
+        '@axium/storage': z.infer<typeof StorageConfig>;
+    }
+}
+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.ZodInt;
+                max_item_size: z.ZodInt;
+            }, z.core.$strip>;
+            chunk: z.ZodBoolean;
+            max_transfer_size: z.ZodInt;
+            max_chunks: z.ZodInt;
+            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,30 +1,5 @@
+import { $API, setServerConfig } from '@axium/core';
 import * as z from 'zod';
-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(),
-});
-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(),
-});
 /**
  * An update to file metadata.
  */
@@ -51,6 +26,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:
  *
@@ -70,3 +68,80 @@ export const StorageBatchUpdate = z.object({
     metadata: z.record(z.uuid(), StorageItemUpdate),
     content: z.record(z.uuid(), BatchedContentChange),
 });
+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.int().positive(),
+        /** Maximum size in KiB per item */
+        max_item_size: z.int().positive(),
+    }),
+    /** 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.int().positive(),
+    /** Maximum number of chunks */
+    max_chunks: z.int().positive(),
+});
+export 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(),
+    })
+        .partial(),
+    /** 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(),
+});
+setServerConfig('@axium/storage', StorageConfig);
+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/api.js

@@ -1,5 +1,5 @@
+import { getConfig } from '@axium/core';
 import { checkAuthForItem, checkAuthForUser } from '@axium/server/auth';
-import { config } from '@axium/server/config';
 import { database } from '@axium/server/database';
 import { error, parseBody, withError } from '@axium/server/requests';
 import { addRoute } from '@axium/server/routes';
@@ -13,7 +13,7 @@ addRoute({
     path: '/api/storage',
     OPTIONS() {
         return {
-            ...pick(config.storage, 'batch', 'chunk', 'max_chunks', 'max_transfer_size'),
+            ...pick(getConfig('@axium/storage'), 'batch', 'chunk', 'max_chunks', 'max_transfer_size'),
             syncProtocolVersion,
             batchFormatVersion,
         };
@@ -23,13 +23,13 @@ addRoute({
     path: '/api/storage/item/:id',
     params: { id: z.uuid() },
     async GET(request, { id: itemId }) {
-        if (!config.storage.enabled)
+        if (!getConfig('@axium/storage').enabled)
             error(503, 'User storage is disabled');
         const { item } = await checkAuthForItem(request, 'storage', itemId, { read: true });
         return parseItem(item);
     },
     async PATCH(request, { id: itemId }) {
-        if (!config.storage.enabled)
+        if (!getConfig('@axium/storage').enabled)
             error(503, 'User storage is disabled');
         const body = await parseBody(request, StorageItemUpdate);
         await checkAuthForItem(request, 'storage', itemId, { manage: true });
@@ -51,7 +51,7 @@ addRoute({
             .catch(withError('Could not update item')));
     },
     async DELETE(request, { id: itemId }) {
-        if (!config.storage.enabled)
+        if (!getConfig('@axium/storage').enabled)
             error(503, 'User storage is disabled');
         const auth = await checkAuthForItem(request, 'storage', itemId, { manage: true });
         const item = parseItem(auth.item);
@@ -63,7 +63,7 @@ addRoute({
     path: '/api/storage/directory/:id',
     params: { id: z.uuid() },
     async GET(request, { id: itemId }) {
-        if (!config.storage.enabled)
+        if (!getConfig('@axium/storage').enabled)
             error(503, 'User storage is disabled');
         const { item } = await checkAuthForItem(request, 'storage', itemId, { read: true });
         if (item.type != 'inode/directory')
@@ -81,7 +81,7 @@ addRoute({
     path: '/api/storage/directory/:id/recursive',
     params: { id: z.uuid() },
     async GET(request, { id: itemId }) {
-        if (!config.storage.enabled)
+        if (!getConfig('@axium/storage').enabled)
             error(503, 'User storage is disabled');
         const { item } = await checkAuthForItem(request, 'storage', itemId, { read: true });
         if (item.type != 'inode/directory')
@@ -94,14 +94,14 @@ addRoute({
     path: '/api/users/:id/storage',
     params: { id: z.uuid() },
     async OPTIONS(request, { id: userId }) {
-        if (!config.storage.enabled)
+        if (!getConfig('@axium/storage').enabled)
             error(503, 'User storage is disabled');
         await checkAuthForUser(request, userId);
         const [stats, limits] = await Promise.all([getUserStats(userId), getLimits(userId)]).catch(withError('Could not fetch data'));
         return Object.assign(stats, { limits });
     },
     async GET(request, { id: userId }) {
-        if (!config.storage.enabled)
+        if (!getConfig('@axium/storage').enabled)
             error(503, 'User storage is disabled');
         await checkAuthForUser(request, userId);
         const [items, stats, limits] = await Promise.all([
@@ -116,7 +116,7 @@ addRoute({
     path: '/api/users/:id/storage/root',
     params: { id: z.uuid() },
     async GET(request, { id: userId }) {
-        if (!config.storage.enabled)
+        if (!getConfig('@axium/storage').enabled)
             error(503, 'User storage is disabled');
         await checkAuthForUser(request, userId);
         const items = await database
@@ -148,7 +148,7 @@ addRoute({
     path: '/api/users/:id/storage/shared',
     params: { id: z.uuid() },
     async GET(request, { id: userId }) {
-        if (!config.storage.enabled)
+        if (!getConfig('@axium/storage').enabled)
             error(503, 'User storage is disabled');
         const { user } = await checkAuthForUser(request, userId);
         const items = await database
@@ -166,7 +166,7 @@ addRoute({
     path: '/api/users/:id/storage/trash',
     params: { id: z.uuid() },
     async GET(request, { id: userId }) {
-        if (!config.storage.enabled)
+        if (!getConfig('@axium/storage').enabled)
             error(503, 'User storage is disabled');
         await checkAuthForUser(request, userId);
         const items = await database

package/dist/server/batch.js

@@ -1,7 +1,7 @@
+import { getConfig } from '@axium/core';
 import * as acl from '@axium/server/acl';
 import { audit } from '@axium/server/audit';
 import { requireSession } from '@axium/server/auth';
-import config from '@axium/server/config';
 import { database } from '@axium/server/database';
 import { withError } from '@axium/server/requests';
 import { addRoute } from '@axium/server/routes';
@@ -16,9 +16,9 @@ import { getRecursiveIds, getUserStats, parseItem } from './db.js';
 addRoute({
     path: '/api/storage/batch',
     async POST(req) {
-        if (!config.storage.enabled)
+        if (!getConfig('@axium/storage').enabled)
             error(503, 'User storage is disabled');
-        if (!config.storage.batch.enabled)
+        if (!getConfig('@axium/storage').batch.enabled)
             error(503, 'Batch updates are disabled');
         const { userId, user } = await requireSession(req);
         const [usage, limits] = await Promise.all([getUserStats(userId), getLimits(userId)]).catch(withError('Could not fetch usage and/or limits'));
@@ -91,14 +91,14 @@ addRoute({
                     .set({ size, modifiedAt: new Date(), hash })
                     .returningAll()
                     .executeTakeFirstOrThrow();
-                writeFileSync(join(config.storage.data, result.id), content);
+                writeFileSync(join(getConfig('@axium/storage').data, result.id), content);
                 await tx.commit().execute();
                 results.set(itemId, parseItem(result));
             }
             const toDelete = await Array.fromAsync(getRecursiveIds(...header.deleted)).catch(withError('Could not get items to delete', 500));
             const deleted = await tx.deleteFrom('storage').where('id', 'in', header.deleted).returningAll().execute();
             for (const id of toDelete)
-                unlinkSync(join(config.storage.data, id));
+                unlinkSync(join(getConfig('@axium/storage').data, id));
             for (const item of deleted)
                 results.set(item.id, parseItem(item));
             for (const [itemId, update] of Object.entries(header.metadata)) {

package/dist/server/config.d.ts

@@ -1,35 +1,5 @@
-import { StorageLimits } from '../common.js';
+import type { 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: z.infer<typeof StorageConfig>;
-    }
-}
 export declare const defaultCASMime: RegExp[];
 declare module '@axium/server/audit' {
     interface $EventTypes {
@@ -50,4 +20,3 @@ 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,62 +1,8 @@
-import { Severity } from '@axium/core';
+import { getConfig, Severity } from '@axium/core';
 import { addEvent } from '@axium/server/audit';
-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(),
-});
+import '../polyfills.js';
 export const defaultCASMime = [/video\/.*/, /audio\/.*/];
-addConfigDefaults({
-    storage: {
-        app_enabled: true,
-        batch: {
-            enabled: false,
-            max_items: 100,
-            max_item_size: 100,
-        },
-        cas: {
-            enabled: true,
-            include: [],
-            exclude: [],
-        },
-        chunk: false,
-        data: '/srv/axium/storage',
-        enabled: true,
-        limits: {
-            user_size: 1000,
-            item_size: 100,
-            user_items: 10_000,
-        },
-        max_chunks: 10,
-        max_transfer_size: 100,
-        trash_duration: 30,
-    },
-});
 addEvent({
     source: '@axium/storage',
     name: 'storage_type_mismatch',
@@ -83,6 +29,6 @@ export async function getLimits(userId) {
         return await _getLimits(userId);
     }
     catch {
-        return config.storage.limits;
+        return getConfig('@axium/storage').limits;
     }
 }

package/dist/server/db.js

@@ -1,4 +1,4 @@
-import { config } from '@axium/server/config';
+import { getConfig } from '@axium/core';
 import { database } from '@axium/server/database';
 import { withError } from '@axium/server/requests';
 import { unlinkSync } from 'node:fs';
@@ -62,5 +62,5 @@ export async function deleteRecursive(deleteSelf, ...itemId) {
         toDelete.push(...itemId);
     await database.deleteFrom('storage').where('id', '=', itemId).returningAll().execute().catch(withError('Could not delete item'));
     for (const id of toDelete)
-        unlinkSync(join(config.storage.data, id));
+        unlinkSync(join(getConfig('@axium/storage').data, id));
 }

package/dist/server/hooks.d.ts

@@ -1,5 +1,6 @@
 import type { OpOptions } from '@axium/server/database';
 import '../common.js';
 import './index.js';
+export declare function load(): void;
 export declare function statusText(): Promise<string>;
 export declare function clean(opt: OpOptions): Promise<void>;

package/dist/server/hooks.js

@@ -1,11 +1,13 @@
+import { getConfig } from '@axium/core';
 import { formatBytes } from '@axium/core/format';
 import { done, start } from '@axium/core/node/io';
-import config from '@axium/server/config';
 import { count, database } from '@axium/server/database';
 import { mkdirSync } from 'node:fs';
 import '../common.js';
 import './index.js';
-mkdirSync(config.storage.data, { recursive: true });
+export function load() {
+    mkdirSync(getConfig('@axium/storage').data, { recursive: true });
+}
 export async function statusText() {
     const { storage: items } = await count('storage');
     const { size } = await database
@@ -16,7 +18,7 @@ export async function statusText() {
 }
 export async function clean(opt) {
     start('Removing expired trash items');
-    const nDaysAgo = new Date(Date.now() - 86400000 * config.storage.trash_duration);
+    const nDaysAgo = new Date(Date.now() - 86400000 * getConfig('@axium/storage').trash_duration);
     await database
         .deleteFrom('storage')
         .where('trashedAt', 'is not', null)

package/dist/server/raw.js

@@ -1,6 +1,6 @@
+import { getConfig } from '@axium/core';
 import { audit } from '@axium/server/audit';
 import { checkAuthForItem, requireSession } from '@axium/server/auth';
-import { config } from '@axium/server/config';
 import { database } from '@axium/server/database';
 import { error, withError } from '@axium/server/requests';
 import { addRoute } from '@axium/server/routes';
@@ -14,7 +14,7 @@ import { getUserStats, parseItem } from './db.js';
 addRoute({
     path: '/raw/storage',
     async PUT(request) {
-        if (!config.storage.enabled)
+        if (!getConfig('@axium/storage').enabled)
             error(503, 'User storage is disabled');
         const { userId } = await requireSession(request);
         const [usage, limits] = await Promise.all([getUserStats(userId), getLimits(userId)]).catch(withError('Could not fetch usage and/or limits'));
@@ -50,9 +50,9 @@ addRoute({
         const isDirectory = type == 'inode/directory';
         if (isDirectory && size > 0)
             error(400, 'Directories can not have content');
-        const useCAS = config.storage.cas.enabled &&
+        const useCAS = getConfig('@axium/storage').cas.enabled &&
             !isDirectory &&
-            (defaultCASMime.some(pattern => pattern.test(type)) || config.storage.cas.include.some(mime => type.match(mime)));
+            (defaultCASMime.some(pattern => pattern.test(type)) || getConfig('@axium/storage').cas.include?.some(mime => type.match(mime)));
         const hash = isDirectory ? null : createHash('BLAKE2b512').update(content).digest();
         const tx = await database.startTransaction().execute();
         try {
@@ -61,7 +61,7 @@ addRoute({
                 .values({ userId, hash, name, size, type, immutable: useCAS, parentId })
                 .returningAll()
                 .executeTakeFirstOrThrow());
-            const path = join(config.storage.data, item.id);
+            const path = join(getConfig('@axium/storage').data, item.id);
             if (!useCAS) {
                 if (!isDirectory)
                     writeFileSync(path, content);
@@ -81,7 +81,7 @@ addRoute({
                 await tx.commit().execute();
                 return item;
             }
-            linkSync(join(config.storage.data, existing.id), path);
+            linkSync(join(getConfig('@axium/storage').data, existing.id), path);
             await tx.commit().execute();
             return item;
         }
@@ -95,12 +95,12 @@ addRoute({
     path: '/raw/storage/:id',
     params: { id: z.uuid() },
     async GET(request, { id: itemId }) {
-        if (!config.storage.enabled)
+        if (!getConfig('@axium/storage').enabled)
             error(503, 'User storage is disabled');
         const { item } = await checkAuthForItem(request, 'storage', itemId, { read: true });
         if (item.trashedAt)
             error(410, 'Trashed items can not be downloaded');
-        const content = new Uint8Array(readFileSync(join(config.storage.data, item.id)));
+        const content = new Uint8Array(readFileSync(join(getConfig('@axium/storage').data, item.id)));
         return new Response(content, {
             headers: {
                 'Content-Type': item.type,
@@ -109,7 +109,7 @@ addRoute({
         });
     },
     async POST(request, { id: itemId }) {
-        if (!config.storage.enabled)
+        if (!getConfig('@axium/storage').enabled)
             error(503, 'User storage is disabled');
         const { item, session } = await checkAuthForItem(request, 'storage', itemId, { write: true });
         if (item.immutable)
@@ -145,7 +145,7 @@ addRoute({
                 .set({ size, modifiedAt: new Date(), hash })
                 .returningAll()
                 .executeTakeFirstOrThrow();
-            writeFileSync(join(config.storage.data, result.id), content);
+            writeFileSync(join(getConfig('@axium/storage').data, result.id), content);
             await tx.commit().execute();
             return parseItem(result);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@axium/storage",
-	"version": "0.12.0",
+	"version": "0.13.1",
 	"author": "James Prevett <axium@jamespre.dev>",
 	"description": "User file storage for Axium",
 	"funding": {
@@ -39,8 +39,8 @@
 		"build": "tsc"
 	},
 	"peerDependencies": {
-		"@axium/client": ">=0.9.0",
-		"@axium/core": ">=0.15.0",
+		"@axium/client": ">=0.12.0",
+		"@axium/core": ">=0.18.0",
 		"@axium/server": ">=0.30.0",
 		"@sveltejs/kit": "^2.27.3",
 		"utilium": "^2.3.8"
@@ -54,7 +54,8 @@
 			"hooks": "./dist/server/hooks.js",
 			"routes": "./routes",
 			"cli": "./dist/server/cli.js",
-			"db": "./db.json"
+			"db": "./db.json",
+			"web_client_hooks": "./dist/common.js"
 		},
 		"client": {
 			"cli": "./dist/client/cli.js",
@@ -67,6 +68,30 @@
 				"icon": "folders"
 			}
 		],
-		"update_checks": true
+		"update_checks": true,
+		"config": {
+			"app_enabled": true,
+			"batch": {
+				"enabled": false,
+				"max_items": 100,
+				"max_item_size": 100
+			},
+			"cas": {
+				"enabled": true,
+				"include": [],
+				"exclude": []
+			},
+			"chunk": false,
+			"data": "/srv/axium/storage",
+			"enabled": true,
+			"limits": {
+				"user_size": 1000,
+				"item_size": 100,
+				"user_items": 10000
+			},
+			"max_chunks": 10,
+			"max_transfer_size": 100,
+			"trash_duration": 30
+		}
 	}
 }

package/routes/+layout.ts

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