@axium/storage 0.11.2 → 0.12.0

package/db.json

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

package/dist/client/cli.js

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

package/dist/client/local.d.ts

@@ -25,7 +25,9 @@ declare const StorageCache: z.ZodObject<{
         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>>;
+        preferences: z.ZodOptional<z.ZodObject<{
+            debug: z.ZodBoolean;
+        }, z.core.$strip>>;
         roles: z.ZodArray<z.ZodString>;
         registeredAt: z.ZodCoercedDate<unknown>;
         isAdmin: z.ZodOptional<z.ZodBoolean>;

package/dist/client/local.js

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

package/dist/client/sync.js

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

package/dist/common.d.ts

@@ -38,31 +38,25 @@ declare module '@axium/core/api' {
         };
     }
 }
-export interface StoragePublicConfig {
-    /** Configuration for batch updates */
-    batch: {
-        /** Whether to enable sending multiple files per request */
-        enabled: boolean;
-        /** Maximum number of items that can be included in a single batch update */
-        max_items: number;
-        /** Maximum size in KiB per item */
-        max_item_size: number;
-    };
-    /** Whether to split files larger than `max_transfer_size` into multiple chunks */
-    chunk: boolean;
-    /** Maximum size in MiB per transfer/request */
-    max_transfer_size: number;
-    /** Maximum number of chunks */
-    max_chunks: number;
+export declare const 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 interface StorageLimits {
-    /** The maximum size per item in MB */
-    item_size: number;
-    /** Maximum number of items per user */
-    user_items: number;
-    /** The maximum storage size per user in MB */
-    user_size: number;
+export 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;

package/dist/common.js

@@ -1,5 +1,30 @@
 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.
  */

package/dist/server/cli.js

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

package/dist/server/config.d.ts

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

package/dist/server/config.js

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

package/package.json

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