@axium/storage 0.13.0 → 0.13.2

package/dist/common.d.ts

@@ -1,16 +1,4 @@
 import * as z from 'zod';
-export declare const StoragePublicConfig: z.ZodObject<{
-    batch: z.ZodObject<{
-        enabled: z.ZodBoolean;
-        max_items: z.ZodNumber;
-        max_item_size: z.ZodNumber;
-    }, z.core.$strip>;
-    chunk: z.ZodBoolean;
-    max_transfer_size: z.ZodNumber;
-    max_chunks: z.ZodNumber;
-}, z.core.$strip>;
-export interface StoragePublicConfig extends z.infer<typeof StoragePublicConfig> {
-}
 /**
  * An update to file metadata.
  */
@@ -40,15 +28,15 @@ export interface StorageItemMetadata<T extends Record<string, unknown> = Record<
 }
 export declare const syncProtocolVersion = 0;
 export declare const StorageLimits: z.ZodObject<{
-    item_size: z.ZodNumber;
-    user_items: z.ZodNumber;
-    user_size: z.ZodNumber;
+    item_size: z.ZodInt;
+    user_items: z.ZodInt;
+    user_size: z.ZodInt;
 }, z.core.$strip>;
 export interface StorageLimits extends z.infer<typeof StorageLimits> {
 }
 export declare const StorageStats: z.ZodObject<{
-    usedBytes: z.ZodNumber;
-    itemCount: z.ZodNumber;
+    usedBytes: z.ZodInt;
+    itemCount: z.ZodInt;
     lastModified: z.ZodCoercedDate<unknown>;
     lastTrashed: z.ZodNullable<z.ZodCoercedDate<unknown>>;
 }, z.core.$strip>;
@@ -56,12 +44,12 @@ 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;
+        item_size: z.ZodInt;
+        user_items: z.ZodInt;
+        user_size: z.ZodInt;
     }, z.core.$strip>;
-    usedBytes: z.ZodNumber;
-    itemCount: z.ZodNumber;
+    usedBytes: z.ZodInt;
+    itemCount: z.ZodInt;
     lastModified: z.ZodCoercedDate<unknown>;
     lastTrashed: z.ZodNullable<z.ZodCoercedDate<unknown>>;
 }, z.core.$strip>;
@@ -84,12 +72,12 @@ export declare const UserStorage: z.ZodObject<{
         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;
+        item_size: z.ZodInt;
+        user_items: z.ZodInt;
+        user_size: z.ZodInt;
     }, z.core.$strip>;
-    usedBytes: z.ZodNumber;
-    itemCount: z.ZodNumber;
+    usedBytes: z.ZodInt;
+    itemCount: z.ZodInt;
     lastModified: z.ZodCoercedDate<unknown>;
     lastTrashed: z.ZodNullable<z.ZodCoercedDate<unknown>>;
 }, z.core.$strip>;
@@ -122,16 +110,57 @@ 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.ZodInt;
+        user_items: z.ZodInt;
+        user_size: z.ZodInt;
+    }, 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;
+                item_size: z.ZodInt;
+                user_items: z.ZodInt;
+                user_size: z.ZodInt;
             }, z.core.$strip>;
-            usedBytes: z.ZodNumber;
-            itemCount: z.ZodNumber;
+            usedBytes: z.ZodInt;
+            itemCount: z.ZodInt;
             lastModified: z.ZodCoercedDate<unknown>;
             lastTrashed: z.ZodNullable<z.ZodCoercedDate<unknown>>;
         }, z.core.$strip>;
@@ -152,12 +181,12 @@ declare const StorageAPI: {
                 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;
+                item_size: z.ZodInt;
+                user_items: z.ZodInt;
+                user_size: z.ZodInt;
             }, z.core.$strip>;
-            usedBytes: z.ZodNumber;
-            itemCount: z.ZodNumber;
+            usedBytes: z.ZodInt;
+            itemCount: z.ZodInt;
             lastModified: z.ZodCoercedDate<unknown>;
             lastTrashed: z.ZodNullable<z.ZodCoercedDate<unknown>>;
         }, z.core.$strip>;
@@ -217,14 +246,14 @@ declare const StorageAPI: {
         readonly OPTIONS: z.ZodObject<{
             batch: z.ZodObject<{
                 enabled: z.ZodBoolean;
-                max_items: z.ZodNumber;
-                max_item_size: z.ZodNumber;
+                max_items: z.ZodInt;
+                max_item_size: z.ZodInt;
             }, z.core.$strip>;
             chunk: z.ZodBoolean;
-            max_transfer_size: z.ZodNumber;
-            max_chunks: z.ZodNumber;
-            syncProtocolVersion: z.ZodNumber;
-            batchFormatVersion: z.ZodNumber;
+            max_transfer_size: z.ZodInt;
+            max_chunks: z.ZodInt;
+            syncProtocolVersion: z.ZodInt32;
+            batchFormatVersion: z.ZodInt32;
         }, z.core.$strip>;
     };
     readonly 'storage/batch': {

package/dist/common.js

@@ -1,22 +1,5 @@
-import { $API } from '@axium/core';
+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(),
-});
 /**
  * An update to file metadata.
  */
@@ -46,15 +29,15 @@ export const StorageItemMetadata = z.object({
 export const syncProtocolVersion = 0;
 export const StorageLimits = z.object({
     /** The maximum size per item in MB */
-    item_size: z.number(),
+    item_size: z.int().nonnegative(),
     /** Maximum number of items per user */
-    user_items: z.number(),
+    user_items: z.int().nonnegative(),
     /** The maximum storage size per user in MB */
-    user_size: z.number(),
+    user_size: z.int().nonnegative(),
 });
 export const StorageStats = z.object({
-    usedBytes: z.number().nonnegative(),
-    itemCount: z.number().nonnegative(),
+    usedBytes: z.int().nonnegative(),
+    itemCount: z.int().nonnegative(),
     lastModified: z.coerce.date(),
     lastTrashed: z.coerce.date().nullable(),
 });
@@ -85,6 +68,47 @@ 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,
@@ -101,8 +125,8 @@ const StorageAPI = {
     },
     storage: {
         OPTIONS: StoragePublicConfig.extend({
-            syncProtocolVersion: z.number(),
-            batchFormatVersion: z.number(),
+            syncProtocolVersion: z.int32().nonnegative(),
+            batchFormatVersion: z.int32().nonnegative(),
         }),
     },
     'storage/batch': {

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.13.0",
+	"version": "0.13.2",
 	"author": "James Prevett <axium@jamespre.dev>",
 	"description": "User file storage for Axium",
 	"funding": {
@@ -39,8 +39,8 @@
 		"build": "tsc"
 	},
 	"peerDependencies": {
-		"@axium/client": ">=0.11.0",
-		"@axium/core": ">=0.17.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
+		}
 	}
 }