refactor(upload): split upload logic into separate classes for files and folders

This also refactors the uploader to support custom events
allowing apps to register event listeners for reactivity.

Signed-off-by: Ferdinand Thiessen <opensource@fthiessen.de>

Author: susnux

lib/upload/errors/UploadFailedError.spec.ts

@@ -0,0 +1,44 @@
+/*!
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { AxiosRequestHeaders, AxiosResponse } from 'axios'
+
+import { AxiosError } from 'axios'
+import { expect, test } from 'vitest'
+import { UploadFailedError } from './UploadFailedError.ts'
+
+test('UploadFailedError - axios error but no response', () => {
+	const cause = new AxiosError('Network error')
+	const error = new UploadFailedError(cause)
+	expect(error).toBeInstanceOf(Error)
+	expect(error).toBeInstanceOf(UploadFailedError)
+	expect(error.message).toBe('Upload has failed')
+	expect(error.cause).toBe(cause)
+	expect(error).toHaveProperty('__UPLOAD_FAILED__')
+	expect(error.response).toBeUndefined()
+})
+
+test('UploadFailedError - axios error', () => {
+	const response = {} as AxiosResponse
+	const cause = new AxiosError('Network error', '200', { headers: {} as AxiosRequestHeaders }, {}, response)
+	const error = new UploadFailedError(cause)
+	expect(error).toBeInstanceOf(Error)
+	expect(error).toBeInstanceOf(UploadFailedError)
+	expect(error.message).toBe('Upload has failed')
+	expect(error.cause).toBe(cause)
+	expect(error).toHaveProperty('__UPLOAD_FAILED__')
+	expect(error.response).toBe(response)
+})
+
+test('UploadFailedError - generic error', () => {
+	const cause = new Error('Generic error')
+	const error = new UploadFailedError(cause)
+	expect(error).toBeInstanceOf(Error)
+	expect(error).toBeInstanceOf(UploadFailedError)
+	expect(error.message).toBe('Upload has failed')
+	expect(error.cause).toBe(cause)
+	expect(error).toHaveProperty('__UPLOAD_FAILED__')
+	expect(error.response).toBeUndefined()
+})

lib/upload/errors/UploadFailedError.ts

@@ -0,0 +1,21 @@
+/*!
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { AxiosResponse } from '@nextcloud/axios'
+
+import { isAxiosError } from '@nextcloud/axios'
+
+export class UploadFailedError extends Error {
+	private __UPLOAD_FAILED__ = true
+
+	readonly response?: AxiosResponse
+
+	public constructor(cause?: unknown) {
+		super('Upload has failed', { cause })
+		if (isAxiosError(cause) && cause.response) {
+			this.response = cause.response
+		}
+	}
+}

lib/upload/index.ts

@@ -3,10 +3,7 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-export type { Eta, EtaEventsMap } from './uploader/index.ts'
-export type { Directory, IDirectory } from './utils/fileTree.ts'
-
+export { UploadCancelledError } from './errors/UploadCancelledError.ts'
+export { UploadFailedError } from './errors/UploadFailedError.ts'
+export * from './uploader/index.ts'
 export { getUploader } from './getUploader.ts'
-export { Upload, UploadStatus } from './uploader/Upload.ts'
-export { EtaStatus, Uploader, UploaderStatus } from './uploader/index.ts'
-export { getConflicts, hasConflict } from './utils/conflicts.ts'

lib/upload/uploader/Upload.ts

@@ -3,125 +3,89 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-import type { AxiosResponse } from 'axios'
+import type PQueue from 'p-queue'
 
-import { getMaxChunksSize } from '../utils/config.ts'
+import { TypedEventTarget } from 'typescript-event-target'
 
 export const UploadStatus = Object.freeze({
+	/** The upload was initialized */
 	INITIALIZED: 0,
-	UPLOADING: 1,
-	ASSEMBLING: 2,
-	FINISHED: 3,
-	CANCELLED: 4,
-	FAILED: 5,
+	/** The upload was scheduled but is not yet uploading */
+	SCHEDULED: 1,
+	/** The upload itself is running */
+	UPLOADING: 2,
+	/** Chunks are being assembled */
+	ASSEMBLING: 3,
+	/** The upload finished successfully */
+	FINISHED: 4,
+	/** The upload was cancelled by the user */
+	CANCELLED: 5,
+	/** The upload failed */
+	FAILED: 6,
 })
 
-type TUploadStatus = typeof UploadStatus[keyof typeof UploadStatus]
+export type TUploadStatus = typeof UploadStatus[keyof typeof UploadStatus]
 
-export class Upload {
-	private _source: string
-	private _file: File
-	private _isChunked: boolean
-	private _chunks: number
-
-	private _size: number
-	private _uploaded = 0
-	private _startTime = 0
-
-	private _status: TUploadStatus = UploadStatus.INITIALIZED
-	private _controller: AbortController
-	private _response: AxiosResponse | null = null
-
-	constructor(source: string, chunked = false, size: number, file: File) {
-		const chunks = Math.min(getMaxChunksSize() > 0 ? Math.ceil(size / getMaxChunksSize()) : 1, 10000)
-		this._source = source
-		this._isChunked = chunked && getMaxChunksSize() > 0 && chunks > 1
-		this._chunks = this._isChunked ? chunks : 1
-		this._size = size
-		this._file = file
-		this._controller = new AbortController()
-	}
-
-	get source(): string {
-		return this._source
-	}
-
-	get file(): File {
-		return this._file
-	}
-
-	get isChunked(): boolean {
-		return this._isChunked
-	}
-
-	get chunks(): number {
-		return this._chunks
-	}
-
-	get size(): number {
-		return this._size
-	}
-
-	get startTime(): number {
-		return this._startTime
-	}
-
-	set response(response: AxiosResponse | null) {
-		this._response = response
-	}
-
-	get response(): AxiosResponse | null {
-		return this._response
-	}
-
-	get uploaded(): number {
-		return this._uploaded
-	}
+interface UploadEvents {
+	finished: CustomEvent<IUpload>
+	progress: CustomEvent<IUpload>
+}
 
+export interface IUpload extends TypedEventTarget<UploadEvents> {
 	/**
-	 * Update the uploaded bytes of this upload
+	 * The source of the upload
 	 */
-	set uploaded(length: number) {
-		if (length >= this._size) {
-			this._status = this._isChunked
-				? UploadStatus.ASSEMBLING
-				: UploadStatus.FINISHED
-			this._uploaded = this._size
-			return
-		}
-
-		this._status = UploadStatus.UPLOADING
-		this._uploaded = length
-
-		// If first progress, let's log the start time
-		if (this._startTime === 0) {
-			this._startTime = new Date().getTime()
-		}
-	}
-
-	get status(): TUploadStatus {
-		return this._status
-	}
-
+	readonly source: string
 	/**
-	 * Update this upload status
+	 * Whether the upload is chunked or not
 	 */
-	set status(status: TUploadStatus) {
-		this._status = status
-	}
+	readonly isChunked: boolean
+	/**
+	 * The total size of the upload in bytes
+	 */
+	readonly totalBytes: number
+	/**
+	 * Timestamp of when the upload started.
+	 * Will return `undefined` if the upload has not started yet.
+	 */
+	readonly startTime?: number
+	/**
+	 * The number of bytes that have been uploaded so far
+	 */
+	readonly uploadedBytes: number
+	/**
+	 * The current status of the upload
+	 */
+	readonly status: TUploadStatus
+	/**
+	 * The internal abort signal
+	 */
+	readonly signal: AbortSignal
 
 	/**
-	 * Returns the axios cancel token source
+	 * Cancels the upload
 	 */
+	cancel(): void
+}
+
+export abstract class Upload extends TypedEventTarget<UploadEvents> implements Partial<IUpload> {
+	#abortController = new AbortController()
+
 	get signal(): AbortSignal {
-		return this._controller.signal
+		return this.#abortController.signal
 	}
 
 	/**
-	 * Cancel any ongoing requests linked to this upload
+	 * Cancels the upload
 	 */
-	cancel() {
-		this._controller.abort()
-		this._status = UploadStatus.CANCELLED
+	public cancel(): void {
+		this.#abortController.abort()
 	}
+
+	/**
+	 * Start the upload
+	 *
+	 * @param queue - The job queue. It is used to limit the number of concurrent upload jobs.
+	 */
+	public abstract start(queue: PQueue): Promise<void>
 }