@fragno-dev/upload 0.1.1 → 0.1.3

package/dist/node/services/uploads.js

@@ -23,6 +23,7 @@ const ensureMultipartUpload = (upload) => {
 const normalizeUploadInput = (input) => {
 	return {
 		...input,
+		provider: input.provider,
 		uploaderId: input.uploaderId ?? null,
 		visibility: input.visibility ?? DEFAULT_VISIBILITY,
 		checksum: input.checksum ?? null,
@@ -39,65 +40,92 @@ const pickActiveUpload = (uploads, now) => {
 const uploadMetadataMatches = (upload, input) => {
 	return upload.filename === input.filename && upload.contentType === input.contentType && upload.visibility === input.visibility && (upload.uploaderId ?? null) === input.uploaderId && upload.expectedSizeBytes === input.expectedSizeBytes && isDeepStrictEqual(upload.checksum ?? null, input.checksum) && isDeepStrictEqual(upload.tags ?? null, input.tags) && isDeepStrictEqual(upload.metadata ?? null, input.metadata);
 };
+const buildProviderStickyUploadEndpoint = (uploadId, provider, suffix = "") => {
+	return `/uploads/${uploadId}${suffix}?${new URLSearchParams({ provider }).toString()}`;
+};
+const buildUploadSessionRouteData = (storage, input) => {
+	const { uploadId, provider, strategy } = input;
+	return {
+		provider,
+		upload: {
+			mode: strategy === "direct-multipart" ? "multipart" : "single",
+			transport: strategy === "proxy" ? "proxy" : "direct",
+			uploadUrl: input.uploadUrl,
+			uploadHeaders: input.uploadHeaders,
+			partSizeBytes: input.partSizeBytes,
+			maxParts: storage.limits?.maxMultipartParts,
+			statusEndpoint: buildProviderStickyUploadEndpoint(uploadId, provider),
+			progressEndpoint: buildProviderStickyUploadEndpoint(uploadId, provider, "/progress"),
+			partsEndpoint: strategy === "direct-multipart" ? buildProviderStickyUploadEndpoint(uploadId, provider, "/parts") : void 0,
+			partsCompleteEndpoint: strategy === "direct-multipart" ? buildProviderStickyUploadEndpoint(uploadId, provider, "/parts/complete") : void 0,
+			completeEndpoint: buildProviderStickyUploadEndpoint(uploadId, provider, "/complete"),
+			abortEndpoint: buildProviderStickyUploadEndpoint(uploadId, provider, "/abort"),
+			contentEndpoint: strategy === "proxy" ? buildProviderStickyUploadEndpoint(uploadId, provider, "/content") : void 0
+		}
+	};
+};
 const buildCreateUploadResult = (storage, upload) => {
 	const uploadId = upload.id.toString();
 	const strategy = upload.strategy;
-	const resolved = resolveFileKeyInput({ fileKey: upload.fileKey });
 	const uploadHeaders = upload.uploadHeaders;
 	return {
 		uploadId,
-		fileKey: upload.fileKey,
-		fileKeyParts: resolved.fileKeyParts,
-		status: upload.status,
-		strategy,
-		expiresAt: upload.expiresAt,
-		upload: {
-			mode: strategy === "direct-multipart" ? "multipart" : "single",
-			transport: strategy === "proxy" ? "proxy" : "direct",
+		fileKey: upload.key,
+		...buildUploadSessionRouteData(storage, {
+			uploadId,
+			provider: upload.provider,
+			strategy,
 			uploadUrl: upload.uploadUrl ?? void 0,
 			uploadHeaders: uploadHeaders ?? void 0,
-			partSizeBytes: upload.partSizeBytes ?? void 0,
-			maxParts: storage.limits?.maxMultipartParts,
-			partsEndpoint: strategy === "direct-multipart" ? `/uploads/${uploadId}/parts` : void 0,
-			completeEndpoint: `/uploads/${uploadId}/complete`,
-			contentEndpoint: strategy === "proxy" ? `/uploads/${uploadId}/content` : void 0
-		}
+			partSizeBytes: upload.partSizeBytes ?? void 0
+		}),
+		status: upload.status,
+		strategy,
+		expiresAt: upload.expiresAt
 	};
 };
-const buildCreateUploadResultFromInit = (storage, resolved, storageInit, uploadId) => {
+const buildCreateUploadResultFromInit = (storage, provider, resolved, storageInit, uploadId) => {
 	const strategy = storageInit.strategy;
 	return {
 		uploadId,
 		fileKey: resolved.fileKey,
-		fileKeyParts: resolved.fileKeyParts,
-		status: "created",
-		strategy,
-		expiresAt: storageInit.expiresAt,
-		upload: {
-			mode: strategy === "direct-multipart" ? "multipart" : "single",
-			transport: strategy === "proxy" ? "proxy" : "direct",
+		...buildUploadSessionRouteData(storage, {
+			uploadId,
+			provider,
+			strategy,
 			uploadUrl: storageInit.uploadUrl,
 			uploadHeaders: storageInit.uploadHeaders,
-			partSizeBytes: storageInit.partSizeBytes,
-			maxParts: storage.limits?.maxMultipartParts,
-			partsEndpoint: strategy === "direct-multipart" ? `/uploads/${uploadId}/parts` : void 0,
-			completeEndpoint: `/uploads/${uploadId}/complete`,
-			contentEndpoint: strategy === "proxy" ? `/uploads/${uploadId}/content` : void 0
-		}
+			partSizeBytes: storageInit.partSizeBytes
+		}),
+		status: "created",
+		strategy,
+		expiresAt: storageInit.expiresAt
 	};
 };
 const buildUploadHookPayload = (upload, sizeBytes) => {
-	const fileKeyParts = resolveFileKeyInput({ fileKey: upload.fileKey }).fileKeyParts;
 	const resolvedSizeBytes = sizeBytes ?? upload.expectedSizeBytes;
 	return {
-		fileKey: upload.fileKey,
-		fileKeyParts,
+		provider: upload.provider,
+		fileKey: upload.key,
+		objectKey: upload.objectKey,
 		uploadId: upload.id.toString(),
 		uploaderId: upload.uploaderId ?? null,
 		sizeBytes: toSafeNumber(resolvedSizeBytes),
 		contentType: upload.contentType
 	};
 };
+const buildFileHookPayload = (file) => ({
+	provider: file.provider,
+	fileKey: file.key,
+	objectKey: file.objectKey,
+	uploaderId: file.uploaderId ?? null,
+	sizeBytes: toSafeNumber(file.sizeBytes),
+	contentType: file.contentType
+});
+const ensureReplacementUsesDistinctObjectKey = (file, nextObjectKey) => {
+	if (file.objectKey === nextObjectKey) throw new Error("STORAGE_ERROR");
+};
+const shouldCleanupSupersededObject = (file, nextObjectKey) => file.status !== "deleted" && file.objectKey !== nextObjectKey;
 const createUploadServices = (config) => {
 	const storage = config.storage;
 	return {
@@ -106,13 +134,10 @@ const createUploadServices = (config) => {
 			const now = /* @__PURE__ */ new Date();
 			const normalized = normalizeUploadInput(input);
 			const hasChecksum = normalized.checksum !== null;
-			return this.serviceTx(uploadSchema).retrieve((uow) => uow.findFirst("file", (b) => b.whereIndex("idx_file_key", (eb) => eb("fileKey", "=", resolved.fileKey))).find("upload", (b) => b.whereIndex("idx_upload_file_key", (eb) => eb("fileKey", "=", resolved.fileKey)))).transformRetrieve(([file, uploads]) => {
-				if (file) throw new Error("FILE_ALREADY_EXISTS");
+			return this.serviceTx(uploadSchema).retrieve((uow) => uow.find("upload", (b) => b.whereIndex("idx_upload_provider_key", (eb) => eb.and(eb("provider", "=", normalized.provider), eb("key", "=", resolved.fileKey))))).transformRetrieve(([uploads]) => {
 				const activeUpload = pickActiveUpload(uploads, now);
-				if (!activeUpload) return null;
-				if (!options.allowIdempotentReuse || !hasChecksum) throw new Error("UPLOAD_ALREADY_ACTIVE");
-				if (!uploadMetadataMatches(activeUpload, normalized)) throw new Error("UPLOAD_METADATA_MISMATCH");
-				return buildCreateUploadResult(storage, activeUpload);
+				if (activeUpload && options.allowIdempotentReuse && hasChecksum && uploadMetadataMatches(activeUpload, normalized)) return buildCreateUploadResult(storage, activeUpload);
+				return null;
 			}).build();
 		},
 		createUploadRecord: function(input) {
@@ -120,20 +145,19 @@ const createUploadServices = (config) => {
 			const now = /* @__PURE__ */ new Date();
 			const normalized = normalizeUploadInput(input);
 			const hasChecksum = normalized.checksum !== null;
-			return this.serviceTx(uploadSchema).retrieve((uow) => uow.findFirst("file", (b) => b.whereIndex("idx_file_key", (eb) => eb("fileKey", "=", resolved.fileKey))).find("upload", (b) => b.whereIndex("idx_upload_file_key", (eb) => eb("fileKey", "=", resolved.fileKey)))).mutate(({ uow, retrieveResult: [existingFile, uploads] }) => {
-				if (existingFile) throw new Error("FILE_ALREADY_EXISTS");
+			return this.serviceTx(uploadSchema).retrieve((uow) => uow.find("upload", (b) => b.whereIndex("idx_upload_provider_key", (eb) => eb.and(eb("provider", "=", normalized.provider), eb("key", "=", resolved.fileKey))))).mutate(({ uow, retrieveResult: [uploads] }) => {
 				const activeUpload = pickActiveUpload(uploads, now);
 				if (activeUpload) {
-					if (!input.allowIdempotentReuse || !hasChecksum) throw new Error("UPLOAD_ALREADY_ACTIVE");
-					if (!uploadMetadataMatches(activeUpload, normalized)) throw new Error("UPLOAD_METADATA_MISMATCH");
-					return {
+					if (input.allowIdempotentReuse && hasChecksum && uploadMetadataMatches(activeUpload, normalized)) return {
 						reused: true,
 						existingUpload: activeUpload
 					};
+					throw new Error("UPLOAD_ALREADY_ACTIVE");
 				}
 				const storageInit = input.storageInit;
 				const uploadId = uow.create("upload", {
-					fileKey: resolved.fileKey,
+					key: resolved.fileKey,
+					provider: normalized.provider,
 					uploaderId: normalized.uploaderId,
 					filename: normalized.filename,
 					expectedSizeBytes: normalized.expectedSizeBytes,
@@ -144,8 +168,7 @@ const createUploadServices = (config) => {
 					metadata: normalized.metadata,
 					status: "created",
 					strategy: storageInit.strategy,
-					storageProvider: storage.name,
-					storageKey: storageInit.storageKey,
+					objectKey: storageInit.storageKey,
 					storageUploadId: storageInit.storageUploadId ?? null,
 					uploadUrl: storageInit.uploadUrl ?? null,
 					uploadHeaders: storageInit.uploadHeaders ?? null,
@@ -161,12 +184,13 @@ const createUploadServices = (config) => {
 				});
 				uow.triggerHook("onUploadTimeout", {
 					uploadId: uploadId.toString(),
-					fileKey: resolved.fileKey,
-					fileKeyParts: resolved.fileKeyParts
+					provider: normalized.provider,
+					fileKey: resolved.fileKey
 				}, { processAt: storageInit.expiresAt });
 				return {
 					reused: false,
 					uploadId: uploadId.toString(),
+					provider: normalized.provider,
 					resolved,
 					storageInit
 				};
@@ -177,8 +201,194 @@ const createUploadServices = (config) => {
 				};
 				return {
 					reused: false,
-					result: buildCreateUploadResultFromInit(storage, mutateResult.resolved, mutateResult.storageInit, mutateResult.uploadId)
+					result: buildCreateUploadResultFromInit(storage, mutateResult.provider, mutateResult.resolved, mutateResult.storageInit, mutateResult.uploadId)
+				};
+			}).build();
+		},
+		createCompletedUpload: function(input) {
+			const resolved = resolveFileKeyInput(input);
+			const now = /* @__PURE__ */ new Date();
+			const normalized = normalizeUploadInput(input);
+			const storageInit = input.storageInit;
+			return this.serviceTx(uploadSchema).retrieve((uow) => uow.findFirst("file", (b) => b.whereIndex("idx_file_provider_key", (eb) => eb.and(eb("provider", "=", normalized.provider), eb("key", "=", resolved.fileKey))))).mutate(({ uow, retrieveResult: [existingFile] }) => {
+				if (existingFile) ensureReplacementUsesDistinctObjectKey(existingFile, storageInit.storageKey);
+				const finalSizeBytes = input.completedSizeBytes;
+				const uploadId = uow.create("upload", {
+					key: resolved.fileKey,
+					provider: normalized.provider,
+					uploaderId: normalized.uploaderId,
+					filename: normalized.filename,
+					expectedSizeBytes: normalized.expectedSizeBytes,
+					contentType: normalized.contentType,
+					checksum: normalized.checksum,
+					visibility: normalized.visibility,
+					tags: normalized.tags,
+					metadata: normalized.metadata,
+					status: "completed",
+					strategy: storageInit.strategy,
+					objectKey: storageInit.storageKey,
+					storageUploadId: storageInit.storageUploadId ?? null,
+					uploadUrl: storageInit.uploadUrl ?? null,
+					uploadHeaders: storageInit.uploadHeaders ?? null,
+					bytesUploaded: finalSizeBytes,
+					partsUploaded: 0,
+					partSizeBytes: storageInit.partSizeBytes ?? null,
+					expiresAt: storageInit.expiresAt,
+					createdAt: now,
+					updatedAt: now,
+					completedAt: now,
+					errorCode: null,
+					errorMessage: null
+				});
+				const fileRecord = {
+					key: resolved.fileKey,
+					provider: normalized.provider,
+					uploaderId: normalized.uploaderId,
+					filename: normalized.filename,
+					sizeBytes: finalSizeBytes,
+					contentType: normalized.contentType,
+					checksum: normalized.checksum,
+					visibility: normalized.visibility,
+					tags: normalized.tags,
+					metadata: normalized.metadata,
+					status: "ready",
+					objectKey: storageInit.storageKey,
+					createdAt: now,
+					updatedAt: now,
+					completedAt: now,
+					deletedAt: null,
+					errorCode: null,
+					errorMessage: null
+				};
+				const persistedFile = existingFile ? (() => {
+					uow.update("file", existingFile.id, (b) => b.set({
+						key: fileRecord.key,
+						provider: fileRecord.provider,
+						uploaderId: fileRecord.uploaderId,
+						filename: fileRecord.filename,
+						sizeBytes: fileRecord.sizeBytes,
+						contentType: fileRecord.contentType,
+						checksum: fileRecord.checksum,
+						visibility: fileRecord.visibility,
+						tags: fileRecord.tags,
+						metadata: fileRecord.metadata,
+						status: fileRecord.status,
+						objectKey: fileRecord.objectKey,
+						createdAt: fileRecord.createdAt,
+						updatedAt: fileRecord.updatedAt,
+						completedAt: fileRecord.completedAt,
+						deletedAt: fileRecord.deletedAt,
+						errorCode: fileRecord.errorCode,
+						errorMessage: fileRecord.errorMessage
+					}).check());
+					if (shouldCleanupSupersededObject(existingFile, fileRecord.objectKey)) uow.triggerHook("cleanupStorageObject", buildFileHookPayload(existingFile));
+					return {
+						id: existingFile.id,
+						...fileRecord
+					};
+				})() : (() => {
+					return {
+						id: uow.create("file", fileRecord),
+						...fileRecord
+					};
+				})();
+				const uploadRow = {
+					id: uploadId,
+					key: resolved.fileKey,
+					provider: normalized.provider,
+					uploaderId: normalized.uploaderId,
+					filename: normalized.filename,
+					expectedSizeBytes: normalized.expectedSizeBytes,
+					contentType: normalized.contentType,
+					checksum: normalized.checksum,
+					visibility: normalized.visibility,
+					tags: normalized.tags,
+					metadata: normalized.metadata,
+					status: "completed",
+					strategy: storageInit.strategy,
+					objectKey: storageInit.storageKey,
+					storageUploadId: storageInit.storageUploadId ?? null,
+					uploadUrl: storageInit.uploadUrl ?? null,
+					uploadHeaders: storageInit.uploadHeaders ?? null,
+					bytesUploaded: finalSizeBytes,
+					partsUploaded: 0,
+					partSizeBytes: storageInit.partSizeBytes ?? null,
+					expiresAt: storageInit.expiresAt,
+					createdAt: now,
+					updatedAt: now,
+					completedAt: now,
+					errorCode: null,
+					errorMessage: null
+				};
+				uow.triggerHook("onFileReady", buildUploadHookPayload(uploadRow, finalSizeBytes));
+				return {
+					upload: uploadRow,
+					file: persistedFile
+				};
+			}).build();
+		},
+		createFailedUpload: function(input) {
+			const resolved = resolveFileKeyInput(input);
+			const now = /* @__PURE__ */ new Date();
+			const normalized = normalizeUploadInput(input);
+			const storageInit = input.storageInit;
+			return this.serviceTx(uploadSchema).mutate(({ uow }) => {
+				const uploadRow = {
+					id: uow.create("upload", {
+						key: resolved.fileKey,
+						provider: normalized.provider,
+						uploaderId: normalized.uploaderId,
+						filename: normalized.filename,
+						expectedSizeBytes: normalized.expectedSizeBytes,
+						contentType: normalized.contentType,
+						checksum: normalized.checksum,
+						visibility: normalized.visibility,
+						tags: normalized.tags,
+						metadata: normalized.metadata,
+						status: "failed",
+						strategy: storageInit.strategy,
+						objectKey: storageInit.storageKey,
+						storageUploadId: storageInit.storageUploadId ?? null,
+						uploadUrl: storageInit.uploadUrl ?? null,
+						uploadHeaders: storageInit.uploadHeaders ?? null,
+						bytesUploaded: 0n,
+						partsUploaded: 0,
+						partSizeBytes: storageInit.partSizeBytes ?? null,
+						expiresAt: storageInit.expiresAt,
+						createdAt: now,
+						updatedAt: now,
+						completedAt: null,
+						errorCode: input.errorCode,
+						errorMessage: input.errorMessage ?? null
+					}),
+					key: resolved.fileKey,
+					provider: normalized.provider,
+					uploaderId: normalized.uploaderId,
+					filename: normalized.filename,
+					expectedSizeBytes: normalized.expectedSizeBytes,
+					contentType: normalized.contentType,
+					checksum: normalized.checksum,
+					visibility: normalized.visibility,
+					tags: normalized.tags,
+					metadata: normalized.metadata,
+					status: "failed",
+					strategy: storageInit.strategy,
+					objectKey: storageInit.storageKey,
+					storageUploadId: storageInit.storageUploadId ?? null,
+					uploadUrl: storageInit.uploadUrl ?? null,
+					uploadHeaders: storageInit.uploadHeaders ?? null,
+					bytesUploaded: 0n,
+					partsUploaded: 0,
+					partSizeBytes: storageInit.partSizeBytes ?? null,
+					expiresAt: storageInit.expiresAt,
+					createdAt: now,
+					updatedAt: now,
+					completedAt: null,
+					errorCode: input.errorCode,
+					errorMessage: input.errorMessage ?? null
 				};
+				uow.triggerHook("onUploadFailed", buildUploadHookPayload(uploadRow));
+				return { upload: uploadRow };
 			}).build();
 		},
 		getUploadStatus: function(uploadId) {
@@ -251,12 +461,11 @@ const createUploadServices = (config) => {
 				};
 			}).build();
 		},
-		markUploadComplete: function(uploadId, fileKey, options) {
+		markUploadCompleteFromSnapshot: function(upload, options) {
 			const now = /* @__PURE__ */ new Date();
-			return this.serviceTx(uploadSchema).retrieve((uow) => uow.findFirst("upload", (b) => b.whereIndex("primary", (eb) => eb("id", "=", uploadId))).findFirst("file", (b) => b.whereIndex("idx_file_key", (eb) => eb("fileKey", "=", fileKey)))).mutate(({ uow, retrieveResult: [upload, existingFile] }) => {
-				if (!upload) throw new Error("UPLOAD_NOT_FOUND");
+			return this.serviceTx(uploadSchema).retrieve((uow) => uow.findFirst("file", (b) => b.whereIndex("idx_file_provider_key", (eb) => eb.and(eb("provider", "=", upload.provider), eb("key", "=", upload.key))))).mutate(({ uow, retrieveResult: [existingFile] }) => {
 				ensureActiveUpload(upload, now);
-				if (existingFile) throw new Error("FILE_ALREADY_EXISTS");
+				if (existingFile) ensureReplacementUsesDistinctObjectKey(existingFile, upload.objectKey);
 				const finalSizeBytes = options?.sizeBytes ?? upload.expectedSizeBytes;
 				const updatedUpload = {
 					...upload,
@@ -271,8 +480,9 @@ const createUploadServices = (config) => {
 					completedAt: updatedUpload.completedAt,
 					bytesUploaded: updatedUpload.bytesUploaded
 				}).check());
-				const createdFile = {
-					fileKey: upload.fileKey,
+				const completedFile = {
+					key: upload.key,
+					provider: upload.provider,
 					uploaderId: upload.uploaderId ?? null,
 					filename: upload.filename,
 					sizeBytes: finalSizeBytes,
@@ -282,8 +492,7 @@ const createUploadServices = (config) => {
 					tags: upload.tags ?? null,
 					metadata: upload.metadata ?? null,
 					status: "ready",
-					storageProvider: upload.storageProvider,
-					storageKey: upload.storageKey,
+					objectKey: upload.objectKey,
 					createdAt: now,
 					updatedAt: now,
 					completedAt: now,
@@ -291,14 +500,42 @@ const createUploadServices = (config) => {
 					errorCode: null,
 					errorMessage: null
 				};
-				const fileId = uow.create("file", createdFile);
+				const persistedFile = existingFile ? (() => {
+					uow.update("file", existingFile.id, (b) => b.set({
+						key: completedFile.key,
+						provider: completedFile.provider,
+						uploaderId: completedFile.uploaderId,
+						filename: completedFile.filename,
+						sizeBytes: completedFile.sizeBytes,
+						contentType: completedFile.contentType,
+						checksum: completedFile.checksum,
+						visibility: completedFile.visibility,
+						tags: completedFile.tags,
+						metadata: completedFile.metadata,
+						status: completedFile.status,
+						objectKey: completedFile.objectKey,
+						createdAt: completedFile.createdAt,
+						updatedAt: completedFile.updatedAt,
+						completedAt: completedFile.completedAt,
+						deletedAt: completedFile.deletedAt,
+						errorCode: completedFile.errorCode,
+						errorMessage: completedFile.errorMessage
+					}).check());
+					if (shouldCleanupSupersededObject(existingFile, completedFile.objectKey)) uow.triggerHook("cleanupStorageObject", buildFileHookPayload(existingFile));
+					return {
+						id: existingFile.id,
+						...completedFile
+					};
+				})() : (() => {
+					return {
+						id: uow.create("file", completedFile),
+						...completedFile
+					};
+				})();
 				uow.triggerHook("onFileReady", buildUploadHookPayload(upload, finalSizeBytes));
 				return {
 					upload: updatedUpload,
-					file: {
-						id: fileId,
-						...createdFile
-					}
+					file: persistedFile
 				};
 			}).build();
 		},
@@ -324,6 +561,27 @@ const createUploadServices = (config) => {
 				return { upload: updatedUpload };
 			}).build();
 		},
+		markUploadFailedFromSnapshot: function(upload, errorCode, errorMessage) {
+			const now = /* @__PURE__ */ new Date();
+			return this.serviceTx(uploadSchema).mutate(({ uow }) => {
+				if (isTerminalUploadStatus(upload.status)) throw new Error("UPLOAD_INVALID_STATE");
+				const updatedUpload = {
+					...upload,
+					status: "failed",
+					updatedAt: now,
+					errorCode,
+					errorMessage: errorMessage ?? null
+				};
+				uow.update("upload", upload.id, (b) => b.set({
+					status: updatedUpload.status,
+					updatedAt: updatedUpload.updatedAt,
+					errorCode: updatedUpload.errorCode,
+					errorMessage: updatedUpload.errorMessage
+				}).check());
+				uow.triggerHook("onUploadFailed", buildUploadHookPayload(upload));
+				return { upload: updatedUpload };
+			}).build();
+		},
 		markUploadAborted: function(uploadId) {
 			const now = /* @__PURE__ */ new Date();
 			return this.serviceTx(uploadSchema).retrieve((uow) => uow.findFirst("upload", (b) => b.whereIndex("primary", (eb) => eb("id", "=", uploadId)))).mutate(({ uow, retrieveResult: [upload] }) => {
@@ -344,6 +602,25 @@ const createUploadServices = (config) => {
 				return { upload: updatedUpload };
 			}).build();
 		},
+		markUploadAbortedFromSnapshot: function(upload) {
+			const now = /* @__PURE__ */ new Date();
+			return this.serviceTx(uploadSchema).mutate(({ uow }) => {
+				if (isTerminalUploadStatus(upload.status)) throw new Error("UPLOAD_INVALID_STATE");
+				const updatedUpload = {
+					...upload,
+					status: "aborted",
+					updatedAt: now,
+					errorCode: "UPLOAD_ABORTED"
+				};
+				uow.update("upload", upload.id, (b) => b.set({
+					status: updatedUpload.status,
+					updatedAt: updatedUpload.updatedAt,
+					errorCode: updatedUpload.errorCode
+				}).check());
+				uow.triggerHook("onUploadFailed", buildUploadHookPayload(upload));
+				return { upload: updatedUpload };
+			}).build();
+		},
 		getUploadStorageInfo: function(uploadId) {
 			return this.serviceTx(uploadSchema).retrieve((uow) => uow.findFirst("upload", (b) => b.whereIndex("primary", (eb) => eb("id", "=", uploadId)))).transformRetrieve(([upload]) => {
 				if (!upload) throw new Error("UPLOAD_NOT_FOUND");
@@ -354,5 +631,5 @@ const createUploadServices = (config) => {
 };
 
 //#endregion
-export { createUploadServices };
+export { buildUploadSessionRouteData, createUploadServices };
 //# sourceMappingURL=uploads.js.map