@axium/storage 0.24.4 → 0.25.0

package/dist/client/api.d.ts

@@ -9,10 +9,11 @@ export interface CreateItemInit {
     name: string;
     size: number;
     type: string;
+    signal?: AbortSignal;
 }
 export declare function createItem(stream: ReadableStream<Uint8Array<ArrayBuffer>>, init: CreateItemInit): Promise<StorageItemMetadata>;
 export declare function createItemFromFile(file: File, init: Partial<CreateItemInit>): Promise<StorageItemMetadata>;
-export declare function updateItem(fileId: string, newSize: number | bigint, stream: ReadableStream<Uint8Array<ArrayBuffer>>, onProgress?: ProgressHandler): Promise<StorageItemMetadata>;
+export declare function updateItem(fileId: string, newSize: number | bigint, stream: ReadableStream<Uint8Array<ArrayBuffer>>, onProgress?: ProgressHandler, signal?: AbortSignal): Promise<StorageItemMetadata>;
 export declare function getItemMetadata(fileId: string, options?: GetItemOptions): Promise<StorageItemMetadata>;
 /** Gets the metadata for all items in a directory. */
 export declare function getDirectoryMetadata(parentId: string): Promise<StorageItemMetadata[]>;

package/dist/client/api.js

@@ -39,14 +39,21 @@ async function handleResponse(response) {
         throw prettifyError(e);
     }
 }
-async function _upload(upload, stream, itemSize, onProgress) {
+async function _upload(upload, stream, itemSize, onProgress, signal) {
     if (upload.status == 'created')
         return upload.item;
+    signal?.addEventListener('abort', () => {
+        void fetch(rawStorage('upload'), {
+            method: 'DELETE',
+            headers: { 'x-upload': upload.token },
+        });
+    });
     const targetChunkSize = upload.max_transfer_size * 1_000_000;
     let response;
     const reader = stream.getReader();
     let buffer = new Uint8Array(0);
     for (let offset = 0; offset < itemSize; offset += targetChunkSize) {
+        signal?.throwIfAborted();
         const chunkSize = Math.min(targetChunkSize, itemSize - offset);
         let bytesReadForChunk = 0;
         const headers = {
@@ -108,10 +115,11 @@ async function _upload(upload, stream, itemSize, onProgress) {
             body = chunkData.subarray(0, bytesReadForChunk);
             onProgress?.(offset + bytesReadForChunk, itemSize);
         }
-        response = await fetch(rawStorage('chunk'), {
+        response = await fetch(rawStorage('upload'), {
             method: 'POST',
             headers,
             body,
+            signal,
             ...init,
         }).catch(handleFetchFailed);
         if (!response.ok)
@@ -132,14 +140,14 @@ export async function createItem(stream, init) {
     if (!init.name)
         throw 'item name is required';
     const upload = await fetchAPI('PUT', 'storage', { ...init, hash: null });
-    return await _upload(upload, stream, init.size, init.onProgress);
+    return await _upload(upload, stream, init.size, init.onProgress, init.signal);
 }
 export async function createItemFromFile(file, init) {
     return await createItem(file.stream(), { ...pick(file, 'name', 'size', 'type'), ...init });
 }
-export async function updateItem(fileId, newSize, stream, onProgress) {
+export async function updateItem(fileId, newSize, stream, onProgress, signal) {
     const upload = await fetchAPI('POST', 'storage/item/:id', newSize, fileId);
-    return await _upload(upload, stream, Number(newSize), onProgress);
+    return await _upload(upload, stream, Number(newSize), onProgress, signal);
 }
 export async function getItemMetadata(fileId, options = {}) {
     return await fetchAPI('GET', 'storage/item/:id', options, fileId);

package/dist/client/sync.js

@@ -76,7 +76,7 @@ export function computeDelta(sync) {
     }));
     const delta = {
         _items: items,
-        items: Array.from(items.values()),
+        items: items.values().toArray(),
         synced: Array.from(synced.difference(modified)).map(p => items.get(p)),
         modified: Array.from(modified).map(p => items.get(p)),
         local_only: Array.from(new Set(files.keys()).difference(items)).map(p => files.get(p)),

package/dist/common.d.ts

@@ -244,7 +244,7 @@ export declare const UploadInitResult: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>;
     max_transfer_size: z.ZodInt;
     status: z.ZodLiteral<"accepted">;
-    token: z.ZodBase64;
+    token: z.ZodBase64URL;
 }, z.core.$strip>, z.ZodObject<{
     status: z.ZodLiteral<"created">;
     item: z.ZodObject<{
@@ -510,7 +510,7 @@ declare const StorageAPI: {
             }, z.core.$strip>;
             max_transfer_size: z.ZodInt;
             status: z.ZodLiteral<"accepted">;
-            token: z.ZodBase64;
+            token: z.ZodBase64URL;
         }, z.core.$strip>, z.ZodObject<{
             status: z.ZodLiteral<"created">;
             item: z.ZodObject<{
@@ -743,7 +743,7 @@ declare const StorageAPI: {
             }, z.core.$strip>;
             max_transfer_size: z.ZodInt;
             status: z.ZodLiteral<"accepted">;
-            token: z.ZodBase64;
+            token: z.ZodBase64URL;
         }, z.core.$strip>, z.ZodObject<{
             status: z.ZodLiteral<"created">;
             item: z.ZodObject<{

package/dist/common.js

@@ -144,7 +144,7 @@ export const UploadInitResult = z.discriminatedUnion('status', [
     StoragePublicConfig.safeExtend({
         status: z.literal('accepted'),
         /** Used for chunked uploads */
-        token: z.base64(),
+        token: z.base64url(),
     }),
     z.object({
         status: z.literal('created'),

package/dist/server/batch.js

@@ -126,6 +126,6 @@ addRoute({
             await tx.rollback().execute();
             throw withError('Could not update item', 500)(error);
         }
-        return Array.from(results.values());
+        return results.values().toArray();
     },
 });

package/dist/server/item.d.ts

@@ -28,8 +28,11 @@ export interface UploadInfo {
     init: StorageItemInit;
     /** If set we are updating an existing item. Explicit null used to avoid bugs */
     itemId: string | null;
-    /** Remove the upload from pending and clean up resources */
-    remove(): void;
+    /**
+     * Remove the upload from pending and clean up resources
+     * @param isSuccess whether the upload was successful. If not, abort-style behavior will be used instead.
+     */
+    remove(isSuccess?: boolean): void;
 }
 export declare function startUpload(init: StorageItemInit, session: Session, itemId: string | null): string;
 export declare function requireUpload(request: Request): Promise<UploadInfo>;

package/dist/server/item.js

@@ -4,7 +4,7 @@ import { authRequestForItem, authSessionForItem, requireSession } from '@axium/s
 import { database } from '@axium/server/database';
 import { error, withError } from '@axium/server/requests';
 import { createHash, randomBytes } from 'node:crypto';
-import { createWriteStream, linkSync, mkdirSync } from 'node:fs';
+import { createWriteStream, linkSync, mkdirSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
 import { Writable } from 'node:stream';
 import * as z from 'zod';
@@ -138,20 +138,29 @@ export async function finishItemUpdate(itemId, size, hash, writeContent) {
 const inProgress = new Map();
 export function startUpload(init, session, itemId) {
     const { temp_dir, upload_timeout } = getConfig('@axium/storage');
-    const token = randomBytes(32);
+    const token = randomBytes(32), tokenB64 = token.toBase64({ alphabet: 'base64url', omitPadding: true });
     mkdirSync(temp_dir, { recursive: true });
     const file = join(temp_dir, token.toHex());
     let removed = false;
-    function remove() {
+    function remove(isSuccess = false) {
         if (removed)
             return;
         removed = true;
-        inProgress.delete(token.toBase64());
-        void stream.close();
+        inProgress.delete(tokenB64);
+        if (isSuccess)
+            void stream.close();
+        else
+            void stream.abort();
         hash.end();
+        try {
+            unlinkSync(file);
+        }
+        catch {
+            // probably renamed
+        }
     }
     const hash = createHash('BLAKE2b512'), stream = Writable.toWeb(createWriteStream(file));
-    inProgress.set(token.toBase64(), {
+    inProgress.set(tokenB64, {
         hash,
         file,
         stream,
@@ -165,7 +174,7 @@ export function startUpload(init, session, itemId) {
     setTimeout(() => {
         remove();
     }, upload_timeout * 60_000);
-    return token.toBase64();
+    return tokenB64;
 }
 export async function requireUpload(request) {
     const token = request.headers.get('x-upload');

package/dist/server/raw.js

@@ -4,7 +4,7 @@ import { authRequestForItem, requireSession } from '@axium/server/auth';
 import { error, withError } from '@axium/server/requests';
 import { addRoute } from '@axium/server/routes';
 import { createHash } from 'node:crypto';
-import { copyFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { copyFileSync, renameSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path/posix';
 import * as z from 'zod';
 import { streamRead } from '../node.js';
@@ -44,7 +44,7 @@ addRoute({
     },
 });
 addRoute({
-    path: '/raw/storage/chunk',
+    path: '/raw/storage/upload',
     async POST(request) {
         if (!getConfig('@axium/storage').enabled)
             error(503, 'User storage is disabled');
@@ -70,6 +70,9 @@ addRoute({
         /* @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 request.body.pipeThrough(counter).pipeTo(upload.stream, { preventClose: true });
+        if (request.signal.aborted) {
+            return;
+        }
         if (actualSize != size) {
             upload.remove();
             await audit('storage_size_mismatch', upload.userId, { item: null });
@@ -82,7 +85,6 @@ addRoute({
         upload.init.hash ??= hash.toHex();
         if (hash.toHex() != upload.init.hash)
             error(409, 'Hash mismatch');
-        upload.remove();
         function writeContent(path) {
             try {
                 renameSync(upload.file, path);
@@ -93,16 +95,22 @@ addRoute({
                 copyFileSync(upload.file, path);
             }
         }
-        const item = upload.itemId
-            ? await finishItemUpdate(upload.itemId, upload.init.size, hash, writeContent)
-            : await createNewItem(upload.init, upload.userId, writeContent);
         try {
-            unlinkSync(upload.file);
+            const item = upload.itemId
+                ? await finishItemUpdate(upload.itemId, upload.init.size, hash, writeContent)
+                : await createNewItem(upload.init, upload.userId, writeContent);
+            return item;
         }
-        catch {
-            // probably renamed
+        finally {
+            upload.remove(true);
         }
-        return item;
+    },
+    async DELETE(request) {
+        if (!getConfig('@axium/storage').enabled)
+            error(503, 'User storage is disabled');
+        const upload = await requireUpload(request);
+        upload.remove();
+        return new Response(null, { status: 204 });
     },
 });
 function parseRange(itemSize, range) {

package/lib/Add.svelte

@@ -4,16 +4,19 @@
 	import { createItemFromFile } from '@axium/storage/client';
 	import type { StorageItemMetadata } from '@axium/storage/common';
 	import { text } from '@axium/client';
+	import { toast } from '@axium/client/toast';
 
 	const { parentId, onAdd }: { parentId?: string; onAdd?(item: StorageItemMetadata): void } = $props();
 
-	let uploadDialog = $state<HTMLDialogElement>()!;
-	let uploadProgress = $state<[number, number][]>([]);
-	let files = $state<FileList>()!;
+	let uploadDialog = $state<HTMLDialogElement>()!,
+		uploadProgress = $state<[number, number][]>([]),
+		uploading = $state(false),
+		controller = $state(new AbortController()),
+		files = $state<FileList>()!;
 
-	let createDialog = $state<HTMLDialogElement>()!;
-	let createType = $state<string>();
-	let createIncludesContent = $state(false);
+	let createDialog = $state<HTMLDialogElement>()!,
+		createType = $state<string>(),
+		createIncludesContent = $state(false);
 </script>
 
 {#snippet _item(type: string, text: string, includeContent: boolean = false)}
@@ -37,23 +40,41 @@
 
 	<span class="menu-item" onclick={() => uploadDialog.showModal()}><Icon i="upload" />{text('storage.Add.upload')}</span>
 	{@render _item('inode/directory', text('storage.Add.new_folder'))}
-	{@render _item('text/plain', text('storage.Add.plain_text'))}
+	{@render _item('text/plain', text('storage.Add.plain_text'), true)}
 </Popover>
 
 <FormDialog
 	bind:dialog={uploadDialog}
 	submitText={text('storage.Add.upload')}
-	cancel={() => (files = new DataTransfer().files)}
+	cancel={() => {
+		files = new DataTransfer().files;
+		if (!uploading) return;
+		uploading = false;
+		uploadProgress = [];
+		controller.abort();
+		toast('info', text('storage.Add.cancelled'));
+		controller = new AbortController();
+	}}
 	submit={async () => {
+		uploading = true;
 		for (const [i, file] of Array.from(files!).entries()) {
-			const item = await createItemFromFile(file, {
-				parentId,
-				onProgress(uploaded, total) {
-					uploadProgress[i] = [uploaded, total];
-				},
-			});
-			onAdd?.(item);
+			try {
+				const item = await createItemFromFile(file, {
+					parentId,
+					onProgress(uploaded, total) {
+						uploadProgress[i] = [uploaded, total];
+					},
+					signal: controller.signal,
+				});
+				onAdd?.(item);
+			} catch (e) {
+				if (e && e instanceof DOMException && e.name == 'AbortError') return;
+				throw e;
+			}
 		}
+		uploading = false;
+		uploadProgress = [];
+		files = new DataTransfer().files;
 	}}
 >
 	<Upload bind:files bind:progress={uploadProgress} multiple />

package/locales/en.json

@@ -78,7 +78,8 @@
 			"new_folder": "New Folder",
 			"plain_text": "Plain Text",
 			"text": "Add",
-			"upload": "Upload"
+			"upload": "Upload",
+			"cancelled": "Upload cancelled"
 		},
 		"List": {
 			"copy_link": "Copy Link",

package/package.json

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