@axium/storage 0.24.0 → 0.24.2

package/dist/client/api.js

@@ -5,9 +5,9 @@ import { StorageItemMetadata } from '../common.js';
 import '../polyfills.js';
 import { warnOnce } from 'ioium';
 function rawStorage(suffix) {
-    const raw = origin + '/raw/storage' + (suffix ? '/' + suffix : '');
+    const raw = '/raw/storage' + (suffix ? '/' + suffix : '');
     if (prefix[0] == '/')
-        return raw;
+        return origin + raw;
     const url = new URL(prefix);
     url.pathname = raw;
     return url;

package/dist/client/cli/commands.js

@@ -55,7 +55,9 @@ import { Command } from 'commander';
 import * as io from 'ioium/node';
 import mime from 'mime';
 import * as fs from 'node:fs';
-import { basename } from 'node:path';
+import { basename, join, parse } from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { stringbool } from 'zod';
 import { colorItem, formatItems, streamRead } from '../../node.js';
 import * as api from '../api.js';
 import { getDirectory, resolveItem, resolvePathWithParent, syncCache, writeCache } from '../local.js';
@@ -102,6 +104,32 @@ export const remove = new Command('remove')
         writeCache();
     }
 });
+async function doUpload(local, name, size, parentId, text = name) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const type = mime.getType(local) || 'application/octet-stream';
+        const _ = __addDisposableResource(env_1, io.start('Uploading ' + text), false);
+        const item = await api.createItem(streamRead(local), {
+            parentId,
+            name,
+            size,
+            type,
+            onProgress(uploaded, total) {
+                io.progress(uploaded, total, Math.round((uploaded / total) * 100) + '%', `${formatBytes(BigInt(uploaded))}/${formatBytes(BigInt(total))}`);
+            },
+        });
+        const { items } = await syncCache();
+        items.push(item);
+        return item;
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+}
 export const upload = new Command('upload')
     .description('Upload a file or folder')
     .argument('<local>', 'local file or folder path to upload')
@@ -110,48 +138,76 @@ export const upload = new Command('upload')
     .option('-r, --recursive', 'operate recursively on local directories')
     .option('-T, --no-target-directory', 'always treat the remote path as a file')
     .action(async (local, remotePath, opts) => {
-    const env_1 = { stack: [], error: void 0, hasError: false };
+    const env_2 = { stack: [], error: void 0, hasError: false };
     try {
         const stats = fs.statSync(local);
         const existingTarget = await resolveItem(remotePath);
         let { parent, name } = await resolvePathWithParent(remotePath);
-        if (stats.isDirectory()) {
-            if (!opts.recursive)
-                throw '--recursive/-r not specified but the local path is a directory';
-            else
-                throw 'Uploading directories is not support yet';
+        if (!stats.isDirectory()) {
+            if (existingTarget?.type == 'inode/directory') {
+                if (opts.targetDirectory) {
+                    parent = existingTarget;
+                    name = basename(local);
+                }
+                else
+                    throw 'Directory exists at remote path: ' + existingTarget.name;
+            }
+            else if (existingTarget && !opts.force)
+                throw 'File exists at remote path, use --force to overwrite it';
+            await doUpload(local, name, stats.size, parent?.id);
+            writeCache();
+            return;
+        }
+        if (!opts.recursive)
+            throw '--recursive/-r not specified but the local path is a directory';
+        if (existingTarget)
+            throw 'Folder exists at remote path. Merging is not supported yet.';
+        const rl = __addDisposableResource(env_2, createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        }), false);
+        const toUpload = [];
+        let sum = 0n;
+        // Sort to make sure directories come first, e.g. `example` and `example/duck`
+        for (const path of fs.readdirSync(local, { recursive: true, encoding: 'utf8' }).sort((a, b) => a.localeCompare(b))) {
+            const full = join(local, path);
+            const stats = fs.statSync(full, { bigint: true });
+            toUpload.push({ path, stats, full });
+            sum += stats.size;
         }
-        if (existingTarget?.type == 'inode/directory') {
-            if (opts.targetDirectory) {
-                parent = existingTarget;
-                name = basename(local);
+        const { data, error } = stringbool()
+            .default(false)
+            .safeParse(await rl.question(`Upload ${toUpload.length} files totaling ${formatBytes(sum)}? [y/N]: `).catch(() => io.exit('Aborted.')));
+        if (error || !data)
+            io.exit('Aborted.');
+        const { id } = await io.track('Creating directory', api.createDirectory(name, parent?.id));
+        const dirs = new Map();
+        for (const { path, stats, full } of toUpload) {
+            const { dir, base } = parse(path);
+            let parentId;
+            if (dir) {
+                const md = dirs.get(dir);
+                if (!md)
+                    throw `Could not get metadata for the directory '${dir}'.`;
+                parentId = md.id;
             }
             else
-                throw 'Directory exists at remote path: ' + existingTarget.name;
+                parentId = id;
+            if (stats.isDirectory()) {
+                await io.track('Creating directory: ' + path, api.createDirectory(base, parentId));
+            }
+            else {
+                await doUpload(full, base, Number(stats.size), parentId, path);
+            }
         }
-        else if (existingTarget && !opts.force)
-            throw 'File exists at remote path, use --force to overwrite it';
-        const type = mime.getType(local) || 'application/octet-stream';
-        const _ = __addDisposableResource(env_1, io.start('Uploading ' + name), false);
-        const item = await api.createItem(streamRead(local), {
-            parentId: parent?.id,
-            name,
-            size: stats.size,
-            type,
-            onProgress(uploaded, total) {
-                io.progress(uploaded, total, Math.round((uploaded / total) * 100) + '%', `${formatBytes(BigInt(uploaded))}/${formatBytes(BigInt(total))}`);
-            },
-        });
-        const { items } = await syncCache();
-        items.push(item);
         writeCache();
     }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
     }
     finally {
-        __disposeResources(env_1);
+        __disposeResources(env_2);
     }
 });
 export const download = new Command('download')
@@ -159,7 +215,7 @@ export const download = new Command('download')
     .argument('<remote>', 'remote file path to download')
     .argument('[local]', 'local path to save the file to')
     .action(async (remotePath, localPath) => {
-    const env_2 = { stack: [], error: void 0, hasError: false };
+    const env_3 = { stack: [], error: void 0, hasError: false };
     try {
         const item = await resolveItem(remotePath);
         if (!item)
@@ -167,7 +223,7 @@ export const download = new Command('download')
         if (item.type == 'inode/directory')
             throw "Can't download directories yet.";
         localPath ||= item.name;
-        const _ = __addDisposableResource(env_2, io.start('Downloading to ' + localPath), false);
+        const _ = __addDisposableResource(env_3, io.start('Downloading to ' + localPath), false);
         const stream = await api.downloadItemStream(item.id);
         const size = Number(item.size);
         io.progress(0, size);
@@ -180,11 +236,11 @@ export const download = new Command('download')
         }
         fileStream.end();
     }
-    catch (e_2) {
-        env_2.error = e_2;
-        env_2.hasError = true;
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
     }
     finally {
-        __disposeResources(env_2);
+        __disposeResources(env_3);
     }
 });

package/dist/server/item.d.ts

@@ -22,7 +22,6 @@ export interface UploadInfo {
     file: string;
     stream: WritableStream;
     hash: Hash;
-    hashStream: WritableStream;
     uploadedBytes: bigint;
     sessionId: string;
     userId: string;

package/dist/server/item.js

@@ -153,7 +153,6 @@ export function startUpload(init, session, itemId) {
     const hash = createHash('BLAKE2b512'), stream = Writable.toWeb(createWriteStream(file));
     inProgress.set(token.toBase64(), {
         hash,
-        hashStream: Writable.toWeb(hash),
         file,
         stream,
         uploadedBytes: 0n,

package/dist/server/raw.js

@@ -63,16 +63,13 @@ addRoute({
         const counter = new TransformStream({
             transform(chunk, controller) {
                 actualSize += BigInt(chunk.length);
+                upload.hash.update(chunk);
                 controller.enqueue(chunk);
             },
         });
-        const [forFile, forHash] = request.body.pipeThrough(counter).tee();
         /* @todo Figure out if we need to handle stream cancellation differently.
         Right now an error with this chunk cancels the streams but may not cleanly fail the upload */
-        await Promise.all([
-            forFile.pipeTo(upload.stream, { preventClose: true }),
-            forHash.pipeTo(upload.hashStream, { preventClose: true }),
-        ]);
+        await request.body.pipeThrough(counter).pipeTo(upload.stream, { preventClose: true });
         if (actualSize != size) {
             upload.remove();
             await audit('storage_size_mismatch', upload.userId, { item: null });

package/lib/List.svelte

@@ -39,7 +39,7 @@
 			if (!sort) {
 				const dirDiff = +(_b.type == 'inode/directory') - +(_a.type == 'inode/directory');
 				if (sort_folders_first && dirDiff) return dirDiff;
-				return _b.name.localeCompare(_a.name);
+				return _a.name.localeCompare(_b.name);
 			}
 
 			const [a, b] = sort.descending ? [_b, _a] : [_a, _b];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@axium/storage",
-	"version": "0.24.0",
+	"version": "0.24.2",
 	"author": "James Prevett <axium@jamespre.dev>",
 	"description": "User file storage for Axium",
 	"funding": {