@fragno-dev/upload 0.1.1 → 0.1.3

package/dist/node/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;iBA0CgB,oBAAA,SACN,+BACC,mDAA8B,uDAAA,2CAAA;mEAAA,IAAA,CAAA,SAAA;;;;;;;;;IAFzB,CAAA,CAAA;IAAoB,KAAA,gBAAA;yBAC1B,CAAA,CAAA,CAAA;MACC,kBAAA,cAAA,gBAAA,CAAA;YAA8B,kBAAA,aAAA,CAAA;;;;;;;;YAAA,IAAA,CAAA;;;;;;;;;;;;;;;;;;;;;aAAA,kBAAA,gBAAA;IAAA,aAAA,kBAAA,eAAA,gCAAA,CAAA;;;;;;;;;;;;sEAAA,sBAAA,CAAA;;;;;;;;;;;;;;;;;;;iCAAA,gBAAA;WAAA,cAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAH;;;;;;;;sBAW/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAX+B,QAAA,EAAA,MAAA;;IAW/B,WAAA,EAAA,MAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;iBAmDgB,oBAAA,SACN,+BACC,mDAA8B,uDAAA,2CAAA;6BAAA,IAAA,CAAA,SAAA;;;;;;;;MAFzB,MAAA,EAAA,QAAoB;MAAA,GAAA,EAAA,KAAA;IAC1B,CAAA,CAAA;IACC,KAAA,gBAAA;yBAA8B,CAAA,CAAA,CAAA;;;;;;;;;;YAAA,IAAA,CAAA;;;;;;;;;;;;;;;;;;;;;yBAAA;UAAA,gBAAA;;;;;;;;;;;;;;;;;;sEAAA,sBAAA,CAAA;;;;;;;;;;;;;;;;;;;;iCAAA;IAAA,eAAA,kBAAA,gBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBANxB;;;;;;;;;sBAajB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAbiB;;;;;;;;;sBAajB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAbiB;;;;;;;;;sBAajB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAbiB,EAAA;;IAajB,QAAA,wCAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAbiB,QAAA,EAAA,MAAA;;IAajB,eAAA,EAAA,MAAA,GAAA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAbiB,aAAA,EAAA,OAAA;;IAajB,aAAA,EAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAPyC;MAAA,eAAA,EAAA,MAAA,GAAA,IAAA"}

package/dist/node/index.js

@@ -1,12 +1,13 @@
 import { resolveUploadFragmentConfig } from "./config.js";
 import { uploadSchema } from "./schema.js";
-import { decodeFileKey, encodeFileKey, encodeFileKeyPrefix } from "./keys.js";
+import { assertFileKey, splitFileKey, validateFileKey } from "./file-key.js";
 import { uploadFragmentDefinition } from "./definition.js";
 import { uploadRoutes } from "./routes/index.js";
 import { createUploadFragmentClients } from "./client/clients.js";
 import { createFilesystemStorageAdapter } from "./storage/fs.js";
 import { createS3CompatibleStorageAdapter } from "./storage/s3.js";
 import { createR2StorageAdapter } from "./storage/r2.js";
+import { createR2BindingStorageAdapter, resolveR2BindingBucket } from "./storage/r2-binding.js";
 import { instantiate } from "@fragno-dev/core";
 
 //#region src/index.ts
@@ -15,5 +16,5 @@ function createUploadFragment(config, options) {
 }
 
 //#endregion
-export { createFilesystemStorageAdapter, createR2StorageAdapter, createS3CompatibleStorageAdapter, createUploadFragment, createUploadFragmentClients, decodeFileKey, encodeFileKey, encodeFileKeyPrefix, resolveUploadFragmentConfig, uploadFragmentDefinition, uploadRoutes, uploadSchema };
+export { assertFileKey, createFilesystemStorageAdapter, createR2BindingStorageAdapter, createR2StorageAdapter, createS3CompatibleStorageAdapter, createUploadFragment, createUploadFragmentClients, resolveR2BindingBucket, resolveUploadFragmentConfig, splitFileKey, uploadFragmentDefinition, uploadRoutes, uploadSchema, validateFileKey };
 //# sourceMappingURL=index.js.map

package/dist/node/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["import type { FragnoPublicConfigWithDatabase } from \"@fragno-dev/db\";\nimport { instantiate } from \"@fragno-dev/core\";\nimport { uploadFragmentDefinition } from \"./definition\";\nimport type { UploadFragmentConfig } from \"./config\";\nimport { uploadRoutes } from \"./routes\";\nimport { createUploadFragmentClients } from \"./client/clients\";\n\nexport type {\n  FileHookPayload,\n  UploadFragmentConfig,\n  UploadFragmentResolvedConfig,\n  UploadTimeoutPayload,\n} from \"./config\";\nexport { resolveUploadFragmentConfig } from \"./config\";\nexport { uploadSchema } from \"./schema\";\nexport type { FileKeyEncoded, FileKeyPart, FileKeyParts } from \"./keys\";\nexport { decodeFileKey, encodeFileKey, encodeFileKeyPrefix } from \"./keys\";\nexport type {\n  StorageAdapter,\n  StorageAdapterCapabilities,\n  StorageAdapterLimits,\n  StorageAdapterRecommendations,\n  UploadChecksum,\n  UploadMode,\n  UploadTransport,\n} from \"./storage/types\";\nexport { createFilesystemStorageAdapter, type FilesystemStorageAdapterOptions } from \"./storage/fs\";\nexport {\n  createS3CompatibleStorageAdapter,\n  type S3CompatibleStorageAdapterOptions,\n  type S3Signer,\n  type S3SignerInput,\n} from \"./storage/s3\";\nexport { createR2StorageAdapter, type R2StorageAdapterOptions } from \"./storage/r2\";\nexport type {\n  CreateUploadAndTransferOptions,\n  UploadHelpers,\n  UploadProgress,\n} from \"./client/helpers\";\n\nexport { uploadRoutes };\n\nexport function createUploadFragment(\n  config: UploadFragmentConfig,\n  options: FragnoPublicConfigWithDatabase,\n) {\n  return instantiate(uploadFragmentDefinition)\n    .withConfig(config)\n    .withRoutes(uploadRoutes)\n    .withOptions(options)\n    .build();\n}\nexport { createUploadFragmentClients };\n\nexport { uploadFragmentDefinition } from \"./definition\";\n"],"mappings":";;;;;;;;;;;;AA0CA,SAAgB,qBACd,QACA,SACA;AACA,QAAO,YAAY,yBAAyB,CACzC,WAAW,OAAO,CAClB,WAAW,aAAa,CACxB,YAAY,QAAQ,CACpB,OAAO"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["import { instantiate } from \"@fragno-dev/core\";\nimport type { FragnoPublicConfigWithDatabase } from \"@fragno-dev/db\";\n\nimport { createUploadFragmentClients } from \"./client/clients\";\nimport type { UploadFragmentConfig } from \"./config\";\nimport { uploadFragmentDefinition } from \"./definition\";\nimport { uploadRoutes } from \"./routes\";\n\nexport type {\n  FileHookPayload,\n  UploadFragmentConfig,\n  UploadFragmentResolvedConfig,\n  UploadTimeoutPayload,\n} from \"./config\";\nexport { resolveUploadFragmentConfig } from \"./config\";\nexport { uploadSchema } from \"./schema\";\nexport type { FileKey, FileKeyValidationResult, ValidateFileKeyOptions } from \"./file-key\";\nexport { assertFileKey, splitFileKey, validateFileKey } from \"./file-key\";\nexport type {\n  StorageAdapter,\n  StorageAdapterCapabilities,\n  StorageAdapterLimits,\n  StorageAdapterRecommendations,\n  UploadChecksum,\n  UploadMode,\n  UploadTransport,\n} from \"./storage/types\";\nexport { createFilesystemStorageAdapter, type FilesystemStorageAdapterOptions } from \"./storage/fs\";\nexport {\n  createS3CompatibleStorageAdapter,\n  type S3CompatibleStorageAdapterOptions,\n  type S3Signer,\n  type S3SignerInput,\n} from \"./storage/s3\";\nexport { createR2StorageAdapter, type R2StorageAdapterOptions } from \"./storage/r2\";\nexport {\n  createR2BindingStorageAdapter,\n  resolveR2BindingBucket,\n  type R2BindingBucket,\n  type R2BindingStorageAdapterOptions,\n} from \"./storage/r2-binding\";\nexport type {\n  CreateUploadAndTransferOptions,\n  DownloadFileOptions,\n  DownloadMethod,\n  UploadHelpers,\n  UploadProgress,\n} from \"./client/helpers\";\n\nexport { uploadRoutes };\n\nexport function createUploadFragment(\n  config: UploadFragmentConfig,\n  options: FragnoPublicConfigWithDatabase,\n) {\n  return instantiate(uploadFragmentDefinition)\n    .withConfig(config)\n    .withRoutes(uploadRoutes)\n    .withOptions(options)\n    .build();\n}\nexport { createUploadFragmentClients };\n\nexport { uploadFragmentDefinition } from \"./definition\";\n"],"mappings":";;;;;;;;;;;;;AAmDA,SAAgB,qBACd,QACA,SACA;AACA,QAAO,YAAY,yBAAyB,CACzC,WAAW,OAAO,CAClB,WAAW,aAAa,CACxB,YAAY,QAAQ,CACpB,OAAO"}

package/dist/node/routes/files.js

@@ -1,18 +1,25 @@
 import { resolveUploadFragmentConfig } from "../config.js";
 import { resolveFileKeyInput } from "../services/helpers.js";
 import { uploadFragmentDefinition } from "../definition.js";
-import { checksumSchema, fileKeyPartsSchema, fileMetadataSchema, toFileMetadata, visibilitySchema } from "./shared.js";
+import { buildStorageObjectVersionSegment } from "../storage/object-key.js";
+import { checksumSchema, fileMetadataSchema, providerNamespaceSchema, toFileMetadata, visibilitySchema } from "./shared.js";
 import { defineRoutes } from "@fragno-dev/core";
 import { z } from "zod";
 
 //#region src/routes/files.ts
+const legacyFileKeyPartsSchema = z.array(z.union([z.string(), z.number().int()]));
 const listQuerySchema = z.object({
+	provider: providerNamespaceSchema.optional(),
 	prefix: z.string().optional(),
 	cursor: z.string().optional(),
 	pageSize: z.coerce.number().min(1).max(100).catch(25),
 	status: z.enum(["ready", "deleted"]).optional(),
 	uploaderId: z.string().optional()
 });
+const byKeyQuerySchema = z.object({
+	provider: providerNamespaceSchema,
+	key: z.string().min(1)
+});
 const updateFileSchema = z.object({
 	filename: z.string().min(1).optional(),
 	visibility: visibilitySchema.optional(),
@@ -24,6 +31,7 @@ const errorCodes = [
 	"UPLOAD_ALREADY_ACTIVE",
 	"FILE_ALREADY_EXISTS",
 	"FILE_NOT_FOUND",
+	"FILE_DELETED",
 	"UPLOAD_EXPIRED",
 	"UPLOAD_INVALID_STATE",
 	"SIGNED_URL_UNSUPPORTED",
@@ -39,6 +47,10 @@ const handleServiceError = (err, error) => {
 			message: "File not found",
 			code: "FILE_NOT_FOUND"
 		}, 404);
+		case "FILE_DELETED": return error({
+			message: "File deleted",
+			code: "FILE_DELETED"
+		}, 410);
 		case "UPLOAD_NOT_FOUND": return error({
 			message: "Upload not found",
 			code: "UPLOAD_NOT_FOUND"
@@ -71,6 +83,10 @@ const handleServiceError = (err, error) => {
 			message: "Invalid request",
 			code: "INVALID_REQUEST"
 		}, 400);
+		case "STORAGE_ERROR": return error({
+			message: "Storage error",
+			code: "STORAGE_ERROR"
+		}, 502);
 		default: throw err;
 	}
 };
@@ -93,10 +109,15 @@ const parseMetadata = (value) => {
 	const parsed = parseJson(value);
 	if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
 };
+const assertFileAvailable = (file) => {
+	if (file.status === "deleted") throw new Error("FILE_DELETED");
+	return file;
+};
 const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ services, defineRoute, config }) => {
 	const getResolvedConfig = () => resolveUploadFragmentConfig(config);
 	const parseListQuery = (query) => {
 		const result = listQuerySchema.safeParse({
+			provider: query.has("provider") ? query.get("provider") : void 0,
 			prefix: query.get("prefix") || void 0,
 			cursor: query.get("cursor") || void 0,
 			pageSize: query.get("pageSize"),
@@ -104,9 +125,23 @@ const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ servi
 			uploaderId: query.get("uploaderId") || void 0
 		});
 		if (!result.success) throw new Error("INVALID_REQUEST");
-		const params = result.data;
-		if (params.prefix && !params.prefix.endsWith(".")) throw new Error("INVALID_FILE_KEY");
-		return params;
+		return result.data;
+	};
+	const parseByKeyQuery = (query) => {
+		const result = byKeyQuerySchema.safeParse({
+			provider: query.get("provider"),
+			key: query.get("key")
+		});
+		if (!result.success) throw new Error("INVALID_REQUEST");
+		try {
+			const resolvedKey = resolveFileKeyInput({ fileKey: result.data.key });
+			return {
+				provider: result.data.provider,
+				fileKey: resolvedKey.fileKey
+			};
+		} catch {
+			throw new Error("INVALID_FILE_KEY");
+		}
 	};
 	return [
 		defineRoute({
@@ -123,10 +158,17 @@ const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ servi
 					message: "File is required",
 					code: "INVALID_REQUEST"
 				}, 400);
+				const providerValue = form.get("provider");
+				const providerResult = providerNamespaceSchema.safeParse(providerValue);
+				if (!providerResult.success) return error({
+					message: "Invalid request",
+					code: "INVALID_REQUEST"
+				}, 400);
+				const provider = providerResult.data;
 				let keyParts;
 				if (form.has("keyParts")) {
 					const parsed = parseJson(form.get("keyParts"));
-					const result = fileKeyPartsSchema.safeParse(parsed);
+					const result = legacyFileKeyPartsSchema.safeParse(parsed);
 					if (!result.success) return error({
 						message: "Invalid file key",
 						code: "INVALID_FILE_KEY"
@@ -168,7 +210,9 @@ const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ servi
 				const filenameValue = form.get("filename");
 				const filename = typeof filenameValue === "string" && filenameValue ? filenameValue : file instanceof File && file.name ? file.name : "upload";
 				const contentType = file.type || "application/octet-stream";
+				const objectKeyVersionSegment = buildStorageObjectVersionSegment();
 				const createInput = {
+					provider,
 					fileKey: resolvedKey.fileKey,
 					keyParts: resolvedKey.fileKeyParts,
 					filename,
@@ -180,19 +224,15 @@ const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ servi
 					uploaderId,
 					metadata
 				};
-				try {
-					await this.handlerTx().withServiceCalls(() => [services.checkUploadAvailability(createInput, { allowIdempotentReuse: false })]).execute();
-				} catch (err) {
-					return handleServiceError(err, error);
-				}
 				try {
 					storageInit = await resolvedConfig.storage.initUpload({
+						provider,
 						fileKey: resolvedKey.fileKey,
-						fileKeyParts: resolvedKey.fileKeyParts,
 						sizeBytes: BigInt(file.size),
 						contentType,
 						checksum: checksumForStorage,
-						metadata: metadata ?? null
+						metadata: metadata ?? null,
+						objectKeyVersionSegment
 					});
 				} catch {
 					return error({
@@ -212,19 +252,8 @@ const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ servi
 						code: "UPLOAD_INVALID_STATE"
 					}, 409);
 				}
-				let created;
-				try {
-					created = await this.handlerTx().withServiceCalls(() => [services.createUploadRecord({
-						...createInput,
-						storageInit,
-						allowIdempotentReuse: false
-					})]).transform(({ serviceResult: [result] }) => result).execute();
-				} catch (err) {
-					return handleServiceError(err, error);
-				}
-				const createdUpload = created.result;
 				try {
-					if (createdUpload.strategy === "proxy") {
+					if (storageInit.strategy === "proxy") {
 						if (!resolvedConfig.storage.writeStream) throw new Error("STORAGE_ERROR");
 						await resolvedConfig.storage.writeStream({
 							storageKey: storageInit.storageKey,
@@ -232,7 +261,7 @@ const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ servi
 							contentType,
 							sizeBytes: BigInt(file.size)
 						});
-					} else if (createdUpload.strategy === "direct-single") {
+					} else if (storageInit.strategy === "direct-single") {
 						if (!storageInit.uploadUrl) throw new Error("STORAGE_ERROR");
 						if (!(await fetch(storageInit.uploadUrl, {
 							method: "PUT",
@@ -249,14 +278,23 @@ const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ servi
 						checksum: checksumResult.data ?? null
 					});
 				} catch {
-					await this.handlerTx().withServiceCalls(() => [services.markUploadFailed(createdUpload.uploadId, "STORAGE_ERROR", "Storage upload failed")]).execute();
+					await this.handlerTx().withServiceCalls(() => [services.createFailedUpload({
+						...createInput,
+						storageInit,
+						errorCode: "STORAGE_ERROR",
+						errorMessage: "Storage upload failed"
+					})]).execute();
 					return error({
 						message: "Storage error",
 						code: "STORAGE_ERROR"
 					}, 502);
 				}
 				try {
-					return json(toFileMetadata((await this.handlerTx().withServiceCalls(() => [services.markUploadComplete(createdUpload.uploadId, createdUpload.fileKey, { sizeBytes: BigInt(file.size) })]).transform(({ serviceResult: [result] }) => result).execute()).file));
+					return json(toFileMetadata((await this.handlerTx().withServiceCalls(() => [services.createCompletedUpload({
+						...createInput,
+						storageInit,
+						completedSizeBytes: BigInt(file.size)
+					})]).transform(({ serviceResult: [result] }) => result).execute()).file));
 				} catch (err) {
 					return handleServiceError(err, error);
 				}
@@ -266,6 +304,7 @@ const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ servi
 			method: "GET",
 			path: "/files",
 			queryParameters: [
+				"provider",
 				"prefix",
 				"cursor",
 				"pageSize",
@@ -286,6 +325,7 @@ const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ servi
 					return handleServiceError(err, error);
 				}
 				const result = await this.handlerTx().withServiceCalls(() => [services.listFiles({
+					provider: params.provider,
 					prefix: params.prefix,
 					pageSize: params.pageSize,
 					cursor: params.cursor,
@@ -301,18 +341,19 @@ const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ servi
 		}),
 		defineRoute({
 			method: "GET",
-			path: "/files/:fileKey",
+			path: "/files/by-key",
+			queryParameters: ["provider", "key"],
 			outputSchema: fileMetadataSchema,
 			errorCodes,
-			handler: async function({ pathParams }, { json, error }) {
-				let resolvedKey;
+			handler: async function({ query }, { json, error }) {
+				let byKey;
 				try {
-					resolvedKey = resolveFileKeyInput({ fileKey: pathParams.fileKey });
+					byKey = parseByKeyQuery(query);
 				} catch (err) {
 					return handleServiceError(err, error);
 				}
 				try {
-					return json(toFileMetadata(await this.handlerTx().withServiceCalls(() => [services.getFileByKey(resolvedKey.fileKey)]).transform(({ serviceResult: [result] }) => result).execute()));
+					return json(toFileMetadata(await this.handlerTx().withServiceCalls(() => [services.getFileByKey(byKey)]).transform(({ serviceResult: [result] }) => result).execute()));
 				} catch (err) {
 					return handleServiceError(err, error);
 				}
@@ -320,20 +361,21 @@ const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ servi
 		}),
 		defineRoute({
 			method: "PATCH",
-			path: "/files/:fileKey",
+			path: "/files/by-key",
+			queryParameters: ["provider", "key"],
 			inputSchema: updateFileSchema,
 			outputSchema: fileMetadataSchema,
 			errorCodes,
-			handler: async function({ pathParams, input }, { json, error }) {
+			handler: async function({ query, input }, { json, error }) {
 				const payload = await input.valid();
-				let resolvedKey;
+				let byKey;
 				try {
-					resolvedKey = resolveFileKeyInput({ fileKey: pathParams.fileKey });
+					byKey = parseByKeyQuery(query);
 				} catch (err) {
 					return handleServiceError(err, error);
 				}
 				try {
-					return json(toFileMetadata(await this.handlerTx().withServiceCalls(() => [services.updateFile(resolvedKey.fileKey, payload)]).transform(({ serviceResult: [result] }) => result).execute()));
+					return json(toFileMetadata(await this.handlerTx().withServiceCalls(() => [services.updateFile(byKey, payload)]).transform(({ serviceResult: [result] }) => result).execute()));
 				} catch (err) {
 					return handleServiceError(err, error);
 				}
@@ -341,28 +383,19 @@ const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ servi
 		}),
 		defineRoute({
 			method: "DELETE",
-			path: "/files/:fileKey",
+			path: "/files/by-key",
+			queryParameters: ["provider", "key"],
 			outputSchema: z.object({ ok: z.literal(true) }),
 			errorCodes,
-			handler: async function({ pathParams }, { json, error }) {
-				const resolvedConfig = getResolvedConfig();
-				let resolvedKey;
+			handler: async function({ query }, { json, error }) {
+				let byKey;
 				try {
-					resolvedKey = resolveFileKeyInput({ fileKey: pathParams.fileKey });
+					byKey = parseByKeyQuery(query);
 				} catch (err) {
 					return handleServiceError(err, error);
 				}
 				try {
-					const file = await this.handlerTx().withServiceCalls(() => [services.getFileByKey(resolvedKey.fileKey)]).transform(({ serviceResult: [result] }) => result).execute();
-					try {
-						await resolvedConfig.storage.deleteObject({ storageKey: file.storageKey });
-					} catch {
-						return error({
-							message: "Storage error",
-							code: "STORAGE_ERROR"
-						}, 502);
-					}
-					await this.handlerTx().withServiceCalls(() => [services.markFileDeleted(resolvedKey.fileKey, resolvedKey.fileKeyParts)]).execute();
+					await this.handlerTx().withServiceCalls(() => [services.markFileDeleted(byKey)]).execute();
 					return json({ ok: true });
 				} catch (err) {
 					return handleServiceError(err, error);
@@ -371,18 +404,19 @@ const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ servi
 		}),
 		defineRoute({
 			method: "GET",
-			path: "/files/:fileKey/download-url",
+			path: "/files/by-key/download-url",
+			queryParameters: ["provider", "key"],
 			outputSchema: z.object({
 				url: z.string(),
 				headers: z.record(z.string(), z.string()).optional(),
 				expiresAt: z.date()
 			}),
 			errorCodes,
-			handler: async function({ pathParams }, { json, error }) {
+			handler: async function({ query }, { json, error }) {
 				const resolvedConfig = getResolvedConfig();
-				let resolvedKey;
+				let byKey;
 				try {
-					resolvedKey = resolveFileKeyInput({ fileKey: pathParams.fileKey });
+					byKey = parseByKeyQuery(query);
 				} catch (err) {
 					return handleServiceError(err, error);
 				}
@@ -391,11 +425,11 @@ const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ servi
 					code: "SIGNED_URL_UNSUPPORTED"
 				}, 400);
 				try {
-					const file = await this.handlerTx().withServiceCalls(() => [services.getFileByKey(resolvedKey.fileKey)]).transform(({ serviceResult: [result$1] }) => result$1).execute();
+					const file = assertFileAvailable(await this.handlerTx().withServiceCalls(() => [services.getFileByKey(byKey)]).transform(({ serviceResult: [result$1] }) => result$1).execute());
 					let result;
 					try {
 						result = await resolvedConfig.storage.getDownloadUrl({
-							storageKey: file.storageKey,
+							storageKey: file.objectKey,
 							expiresInSeconds: resolvedConfig.signedUrlExpiresInSeconds,
 							contentType: file.contentType ?? void 0
 						});
@@ -413,13 +447,14 @@ const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ servi
 		}),
 		defineRoute({
 			method: "GET",
-			path: "/files/:fileKey/content",
+			path: "/files/by-key/content",
+			queryParameters: ["provider", "key"],
 			errorCodes,
-			handler: async function({ pathParams }, { error }) {
+			handler: async function({ query }, { error }) {
 				const resolvedConfig = getResolvedConfig();
-				let resolvedKey;
+				let byKey;
 				try {
-					resolvedKey = resolveFileKeyInput({ fileKey: pathParams.fileKey });
+					byKey = parseByKeyQuery(query);
 				} catch (err) {
 					return handleServiceError(err, error);
 				}
@@ -428,9 +463,9 @@ const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ servi
 					code: "SIGNED_URL_UNSUPPORTED"
 				}, 400);
 				try {
-					const file = await this.handlerTx().withServiceCalls(() => [services.getFileByKey(resolvedKey.fileKey)]).transform(({ serviceResult: [result] }) => result).execute();
+					const file = assertFileAvailable(await this.handlerTx().withServiceCalls(() => [services.getFileByKey(byKey)]).transform(({ serviceResult: [result] }) => result).execute());
 					try {
-						return await resolvedConfig.storage.getDownloadStream({ storageKey: file.storageKey });
+						return await resolvedConfig.storage.getDownloadStream({ storageKey: file.objectKey });
 					} catch {
 						return error({
 							message: "Storage error",

package/dist/node/routes/files.js.map

@@ -1 +1 @@
-{"version":3,"file":"files.js","names":["keyParts: z.infer<typeof fileKeyPartsSchema> | undefined","result"],"sources":["../../../src/routes/files.ts"],"sourcesContent":["import { defineRoutes } from \"@fragno-dev/core\";\nimport type { FragnoRouteConfig } from \"@fragno-dev/core\";\nimport { z } from \"zod\";\nimport { uploadFragmentDefinition } from \"../definition\";\nimport { resolveUploadFragmentConfig } from \"../config\";\nimport { resolveFileKeyInput } from \"../services/helpers\";\nimport {\n  checksumSchema,\n  fileKeyPartsSchema,\n  fileMetadataSchema,\n  toFileMetadata,\n  visibilitySchema,\n} from \"./shared\";\n\nconst listQuerySchema = z.object({\n  prefix: z.string().optional(),\n  cursor: z.string().optional(),\n  pageSize: z.coerce.number().min(1).max(100).catch(25),\n  status: z.enum([\"ready\", \"deleted\"]).optional(),\n  uploaderId: z.string().optional(),\n});\n\nconst updateFileSchema = z.object({\n  filename: z.string().min(1).optional(),\n  visibility: visibilitySchema.optional(),\n  tags: z.array(z.string()).nullable().optional(),\n  metadata: z.record(z.string(), z.unknown()).nullable().optional(),\n});\n\nconst errorCodes = [\n  \"UPLOAD_NOT_FOUND\",\n  \"UPLOAD_ALREADY_ACTIVE\",\n  \"FILE_ALREADY_EXISTS\",\n  \"FILE_NOT_FOUND\",\n  \"UPLOAD_EXPIRED\",\n  \"UPLOAD_INVALID_STATE\",\n  \"SIGNED_URL_UNSUPPORTED\",\n  \"STORAGE_ERROR\",\n  \"INVALID_FILE_KEY\",\n  \"INVALID_CHECKSUM\",\n  \"INVALID_REQUEST\",\n] as const;\n\ntype FileErrorCode = (typeof errorCodes)[number];\n\ntype ErrorFn<Code extends string> = Parameters<\n  FragnoRouteConfig<\"GET\", \"/__error\", undefined, undefined, Code>[\"handler\"]\n>[1][\"error\"];\n\nconst handleServiceError = <Code extends FileErrorCode>(\n  err: unknown,\n  error: ErrorFn<Code>,\n): Response => {\n  if (!(err instanceof Error)) {\n    throw err;\n  }\n\n  switch (err.message) {\n    case \"FILE_NOT_FOUND\":\n      return error({ message: \"File not found\", code: \"FILE_NOT_FOUND\" as Code }, 404);\n    case \"UPLOAD_NOT_FOUND\":\n      return error({ message: \"Upload not found\", code: \"UPLOAD_NOT_FOUND\" as Code }, 404);\n    case \"FILE_ALREADY_EXISTS\":\n      return error({ message: \"File already exists\", code: \"FILE_ALREADY_EXISTS\" as Code }, 409);\n    case \"UPLOAD_ALREADY_ACTIVE\":\n      return error(\n        { message: \"Upload already active\", code: \"UPLOAD_ALREADY_ACTIVE\" as Code },\n        409,\n      );\n    case \"UPLOAD_EXPIRED\":\n      return error({ message: \"Upload expired\", code: \"UPLOAD_EXPIRED\" as Code }, 410);\n    case \"UPLOAD_INVALID_STATE\":\n      return error({ message: \"Upload invalid state\", code: \"UPLOAD_INVALID_STATE\" as Code }, 409);\n    case \"INVALID_FILE_KEY\":\n      return error({ message: \"Invalid file key\", code: \"INVALID_FILE_KEY\" as Code }, 400);\n    case \"INVALID_CHECKSUM\":\n      return error({ message: \"Invalid checksum\", code: \"INVALID_CHECKSUM\" as Code }, 400);\n    case \"INVALID_REQUEST\":\n      return error({ message: \"Invalid request\", code: \"INVALID_REQUEST\" as Code }, 400);\n    default:\n      throw err;\n  }\n};\n\nconst parseJson = <T>(value: FormDataEntryValue | null): T | undefined => {\n  if (value === null || typeof value !== \"string\" || value.length === 0) {\n    return undefined;\n  }\n  try {\n    return JSON.parse(value) as T;\n  } catch {\n    return undefined;\n  }\n};\n\nconst parseTags = (value: FormDataEntryValue | null): string[] | undefined => {\n  if (value === null) {\n    return undefined;\n  }\n  if (typeof value !== \"string\") {\n    return undefined;\n  }\n  const parsed = parseJson<unknown>(value);\n  if (Array.isArray(parsed)) {\n    return parsed.filter((tag) => typeof tag === \"string\") as string[];\n  }\n  if (typeof value === \"string\" && value.length > 0) {\n    return [value];\n  }\n  return undefined;\n};\n\nconst parseMetadata = (value: FormDataEntryValue | null): Record<string, unknown> | undefined => {\n  const parsed = parseJson<unknown>(value);\n  if (parsed && typeof parsed === \"object\" && !Array.isArray(parsed)) {\n    return parsed as Record<string, unknown>;\n  }\n  return undefined;\n};\n\nexport const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(\n  ({ services, defineRoute, config }) => {\n    const getResolvedConfig = () => resolveUploadFragmentConfig(config);\n\n    const parseListQuery = (query: URLSearchParams) => {\n      const result = listQuerySchema.safeParse({\n        prefix: query.get(\"prefix\") || undefined,\n        cursor: query.get(\"cursor\") || undefined,\n        pageSize: query.get(\"pageSize\"),\n        status: query.get(\"status\") || undefined,\n        uploaderId: query.get(\"uploaderId\") || undefined,\n      });\n      if (!result.success) {\n        throw new Error(\"INVALID_REQUEST\");\n      }\n      const params = result.data;\n\n      if (params.prefix && !params.prefix.endsWith(\".\")) {\n        throw new Error(\"INVALID_FILE_KEY\");\n      }\n\n      return params;\n    };\n\n    return [\n      defineRoute({\n        method: \"POST\",\n        path: \"/files\",\n        contentType: \"multipart/form-data\",\n        outputSchema: fileMetadataSchema,\n        errorCodes,\n        handler: async function (context, { json, error }) {\n          const resolvedConfig = getResolvedConfig();\n          const form = context.formData();\n          const file = form.get(\"file\");\n          if (!(file instanceof Blob)) {\n            return error({ message: \"File is required\", code: \"INVALID_REQUEST\" }, 400);\n          }\n\n          let keyParts: z.infer<typeof fileKeyPartsSchema> | undefined;\n          if (form.has(\"keyParts\")) {\n            const parsed = parseJson<unknown>(form.get(\"keyParts\"));\n            const result = fileKeyPartsSchema.safeParse(parsed);\n            if (!result.success) {\n              return error({ message: \"Invalid file key\", code: \"INVALID_FILE_KEY\" }, 400);\n            }\n            keyParts = result.data;\n          }\n\n          const fileKeyValue = form.get(\"fileKey\");\n          const fileKey = typeof fileKeyValue === \"string\" ? fileKeyValue : undefined;\n\n          const checksumValue = form.get(\"checksum\");\n          const parsedChecksum = parseJson<unknown>(checksumValue);\n          const checksumResult = checksumSchema.safeParse(parsedChecksum);\n          if (!checksumResult.success) {\n            return error({ message: \"Invalid checksum\", code: \"INVALID_CHECKSUM\" }, 400);\n          }\n\n          const tags = parseTags(form.get(\"tags\"));\n          const metadata = parseMetadata(form.get(\"metadata\"));\n\n          let resolvedKey;\n          try {\n            resolvedKey = resolveFileKeyInput({ keyParts, fileKey: fileKey ?? undefined });\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n\n          const checksumForStorage = checksumResult.data ?? null;\n          const checksumForRecord = checksumResult.data ?? undefined;\n\n          let storageInit;\n\n          const uploaderIdValue = form.get(\"uploaderId\");\n          const uploaderId = typeof uploaderIdValue === \"string\" ? uploaderIdValue : undefined;\n          const visibilityValue = form.get(\"visibility\");\n          const parsedVisibility =\n            typeof visibilityValue === \"string\" ? visibilityValue : undefined;\n          const visibilityResult = visibilitySchema.optional().safeParse(parsedVisibility);\n          if (!visibilityResult.success) {\n            return error({ message: \"Invalid request\", code: \"INVALID_REQUEST\" }, 400);\n          }\n          const visibility = visibilityResult.data;\n          const filenameValue = form.get(\"filename\");\n          const filename =\n            typeof filenameValue === \"string\" && filenameValue\n              ? filenameValue\n              : file instanceof File && file.name\n                ? file.name\n                : \"upload\";\n          const contentType = file.type || \"application/octet-stream\";\n\n          const createInput = {\n            fileKey: resolvedKey.fileKey,\n            keyParts: resolvedKey.fileKeyParts,\n            filename,\n            sizeBytes: file.size,\n            contentType,\n            checksum: checksumForRecord,\n            tags,\n            visibility,\n            uploaderId,\n            metadata,\n          };\n\n          try {\n            await this.handlerTx()\n              .withServiceCalls(() => [\n                services.checkUploadAvailability(createInput, { allowIdempotentReuse: false }),\n              ])\n              .execute();\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n\n          try {\n            storageInit = await resolvedConfig.storage.initUpload({\n              fileKey: resolvedKey.fileKey,\n              fileKeyParts: resolvedKey.fileKeyParts,\n              sizeBytes: BigInt(file.size),\n              contentType,\n              checksum: checksumForStorage,\n              metadata: metadata ?? null,\n            });\n          } catch {\n            return error({ message: \"Storage error\", code: \"STORAGE_ERROR\" }, 502);\n          }\n\n          if (storageInit.strategy === \"direct-multipart\") {\n            if (resolvedConfig.storage.abortMultipartUpload && storageInit.storageUploadId) {\n              try {\n                await resolvedConfig.storage.abortMultipartUpload({\n                  storageKey: storageInit.storageKey,\n                  storageUploadId: storageInit.storageUploadId,\n                });\n              } catch {\n                // Ignore abort failures; the request is still invalid for this endpoint.\n              }\n            }\n\n            return error({ message: \"Upload invalid state\", code: \"UPLOAD_INVALID_STATE\" }, 409);\n          }\n\n          let created;\n          try {\n            created = await this.handlerTx()\n              .withServiceCalls(() => [\n                services.createUploadRecord({\n                  ...createInput,\n                  storageInit,\n                  allowIdempotentReuse: false,\n                }),\n              ])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n\n          const createdUpload = created.result;\n\n          try {\n            if (createdUpload.strategy === \"proxy\") {\n              if (!resolvedConfig.storage.writeStream) {\n                throw new Error(\"STORAGE_ERROR\");\n              }\n              await resolvedConfig.storage.writeStream({\n                storageKey: storageInit.storageKey,\n                body: file.stream(),\n                contentType,\n                sizeBytes: BigInt(file.size),\n              });\n            } else if (createdUpload.strategy === \"direct-single\") {\n              if (!storageInit.uploadUrl) {\n                throw new Error(\"STORAGE_ERROR\");\n              }\n              const response = await fetch(storageInit.uploadUrl, {\n                method: \"PUT\",\n                headers: storageInit.uploadHeaders,\n                body: file,\n              });\n              if (!response.ok) {\n                throw new Error(\"STORAGE_ERROR\");\n              }\n            } else {\n              return error({ message: \"Upload invalid state\", code: \"UPLOAD_INVALID_STATE\" }, 409);\n            }\n\n            if (resolvedConfig.storage.finalizeUpload) {\n              await resolvedConfig.storage.finalizeUpload({\n                storageKey: storageInit.storageKey,\n                expectedSizeBytes: BigInt(file.size),\n                checksum: checksumResult.data ?? null,\n              });\n            }\n          } catch {\n            await this.handlerTx()\n              .withServiceCalls(() => [\n                services.markUploadFailed(\n                  createdUpload.uploadId,\n                  \"STORAGE_ERROR\",\n                  \"Storage upload failed\",\n                ),\n              ])\n              .execute();\n            return error({ message: \"Storage error\", code: \"STORAGE_ERROR\" }, 502);\n          }\n\n          try {\n            const completed = await this.handlerTx()\n              .withServiceCalls(() => [\n                services.markUploadComplete(createdUpload.uploadId, createdUpload.fileKey, {\n                  sizeBytes: BigInt(file.size),\n                }),\n              ])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            return json(toFileMetadata(completed.file));\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n\n      defineRoute({\n        method: \"GET\",\n        path: \"/files\",\n        queryParameters: [\"prefix\", \"cursor\", \"pageSize\", \"status\", \"uploaderId\"],\n        outputSchema: z.object({\n          files: z.array(fileMetadataSchema),\n          cursor: z.string().optional(),\n          hasNextPage: z.boolean(),\n        }),\n        errorCodes,\n        handler: async function ({ query }, { json, error }) {\n          let params;\n          try {\n            params = parseListQuery(query);\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n\n          const result = await this.handlerTx()\n            .withServiceCalls(() => [\n              services.listFiles({\n                prefix: params.prefix,\n                pageSize: params.pageSize,\n                cursor: params.cursor,\n                status: params.status,\n                uploaderId: params.uploaderId,\n              }),\n            ])\n            .transform(({ serviceResult: [files] }) => files)\n            .execute();\n\n          return json({\n            files: result.items.map(toFileMetadata),\n            cursor: result.cursor?.encode(),\n            hasNextPage: result.hasNextPage,\n          });\n        },\n      }),\n\n      defineRoute({\n        method: \"GET\",\n        path: \"/files/:fileKey\",\n        outputSchema: fileMetadataSchema,\n        errorCodes,\n        handler: async function ({ pathParams }, { json, error }) {\n          let resolvedKey;\n          try {\n            resolvedKey = resolveFileKeyInput({ fileKey: pathParams.fileKey });\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n\n          try {\n            const file = await this.handlerTx()\n              .withServiceCalls(() => [services.getFileByKey(resolvedKey.fileKey)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            return json(toFileMetadata(file));\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n\n      defineRoute({\n        method: \"PATCH\",\n        path: \"/files/:fileKey\",\n        inputSchema: updateFileSchema,\n        outputSchema: fileMetadataSchema,\n        errorCodes,\n        handler: async function ({ pathParams, input }, { json, error }) {\n          const payload = await input.valid();\n          let resolvedKey;\n          try {\n            resolvedKey = resolveFileKeyInput({ fileKey: pathParams.fileKey });\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n\n          try {\n            const file = await this.handlerTx()\n              .withServiceCalls(() => [services.updateFile(resolvedKey.fileKey, payload)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            return json(toFileMetadata(file));\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n\n      defineRoute({\n        method: \"DELETE\",\n        path: \"/files/:fileKey\",\n        outputSchema: z.object({ ok: z.literal(true) }),\n        errorCodes,\n        handler: async function ({ pathParams }, { json, error }) {\n          const resolvedConfig = getResolvedConfig();\n          let resolvedKey;\n          try {\n            resolvedKey = resolveFileKeyInput({ fileKey: pathParams.fileKey });\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n\n          try {\n            const file = await this.handlerTx()\n              .withServiceCalls(() => [services.getFileByKey(resolvedKey.fileKey)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            try {\n              await resolvedConfig.storage.deleteObject({ storageKey: file.storageKey });\n            } catch {\n              return error({ message: \"Storage error\", code: \"STORAGE_ERROR\" }, 502);\n            }\n\n            await this.handlerTx()\n              .withServiceCalls(() => [\n                services.markFileDeleted(resolvedKey.fileKey, resolvedKey.fileKeyParts),\n              ])\n              .execute();\n\n            return json({ ok: true });\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n\n      defineRoute({\n        method: \"GET\",\n        path: \"/files/:fileKey/download-url\",\n        outputSchema: z.object({\n          url: z.string(),\n          headers: z.record(z.string(), z.string()).optional(),\n          expiresAt: z.date(),\n        }),\n        errorCodes,\n        handler: async function ({ pathParams }, { json, error }) {\n          const resolvedConfig = getResolvedConfig();\n          let resolvedKey;\n          try {\n            resolvedKey = resolveFileKeyInput({ fileKey: pathParams.fileKey });\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n\n          if (!resolvedConfig.storage.getDownloadUrl) {\n            return error(\n              { message: \"Signed URLs are not supported\", code: \"SIGNED_URL_UNSUPPORTED\" },\n              400,\n            );\n          }\n\n          try {\n            const file = await this.handlerTx()\n              .withServiceCalls(() => [services.getFileByKey(resolvedKey.fileKey)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            let result;\n            try {\n              result = await resolvedConfig.storage.getDownloadUrl({\n                storageKey: file.storageKey,\n                expiresInSeconds: resolvedConfig.signedUrlExpiresInSeconds,\n                contentType: file.contentType ?? undefined,\n              });\n            } catch {\n              return error({ message: \"Storage error\", code: \"STORAGE_ERROR\" }, 502);\n            }\n\n            return json(result);\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n\n      defineRoute({\n        method: \"GET\",\n        path: \"/files/:fileKey/content\",\n        errorCodes,\n        handler: async function ({ pathParams }, { error }) {\n          const resolvedConfig = getResolvedConfig();\n          let resolvedKey;\n          try {\n            resolvedKey = resolveFileKeyInput({ fileKey: pathParams.fileKey });\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n\n          if (!resolvedConfig.storage.getDownloadStream) {\n            return error(\n              { message: \"Download streaming unsupported\", code: \"SIGNED_URL_UNSUPPORTED\" },\n              400,\n            );\n          }\n\n          try {\n            const file = await this.handlerTx()\n              .withServiceCalls(() => [services.getFileByKey(resolvedKey.fileKey)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            try {\n              return await resolvedConfig.storage.getDownloadStream({\n                storageKey: file.storageKey,\n              });\n            } catch {\n              return error({ message: \"Storage error\", code: \"STORAGE_ERROR\" }, 502);\n            }\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n    ];\n  },\n);\n"],"mappings":"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"}
+{"version":3,"file":"files.js","names":["keyParts: z.infer<typeof legacyFileKeyPartsSchema> | undefined","result"],"sources":["../../../src/routes/files.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { defineRoutes } from \"@fragno-dev/core\";\nimport type { FragnoRouteConfig } from \"@fragno-dev/core\";\n\nimport { resolveUploadFragmentConfig } from \"../config\";\nimport { uploadFragmentDefinition } from \"../definition\";\nimport { resolveFileKeyInput } from \"../services/helpers\";\nimport { buildStorageObjectVersionSegment } from \"../storage/object-key\";\nimport {\n  checksumSchema,\n  fileMetadataSchema,\n  providerNamespaceSchema,\n  toFileMetadata,\n  visibilitySchema,\n} from \"./shared\";\n\nconst legacyFileKeyPartsSchema = z.array(z.union([z.string(), z.number().int()]));\n\nconst listQuerySchema = z.object({\n  provider: providerNamespaceSchema.optional(),\n  prefix: z.string().optional(),\n  cursor: z.string().optional(),\n  pageSize: z.coerce.number().min(1).max(100).catch(25),\n  status: z.enum([\"ready\", \"deleted\"]).optional(),\n  uploaderId: z.string().optional(),\n});\n\nconst byKeyQuerySchema = z.object({\n  provider: providerNamespaceSchema,\n  key: z.string().min(1),\n});\n\nconst updateFileSchema = z.object({\n  filename: z.string().min(1).optional(),\n  visibility: visibilitySchema.optional(),\n  tags: z.array(z.string()).nullable().optional(),\n  metadata: z.record(z.string(), z.unknown()).nullable().optional(),\n});\n\nconst errorCodes = [\n  \"UPLOAD_NOT_FOUND\",\n  \"UPLOAD_ALREADY_ACTIVE\",\n  \"FILE_ALREADY_EXISTS\",\n  \"FILE_NOT_FOUND\",\n  \"FILE_DELETED\",\n  \"UPLOAD_EXPIRED\",\n  \"UPLOAD_INVALID_STATE\",\n  \"SIGNED_URL_UNSUPPORTED\",\n  \"STORAGE_ERROR\",\n  \"INVALID_FILE_KEY\",\n  \"INVALID_CHECKSUM\",\n  \"INVALID_REQUEST\",\n] as const;\n\ntype FileErrorCode = (typeof errorCodes)[number];\n\ntype ErrorFn<Code extends string> = Parameters<\n  FragnoRouteConfig<\"GET\", \"/__error\", undefined, undefined, Code>[\"handler\"]\n>[1][\"error\"];\n\nconst handleServiceError = <Code extends FileErrorCode>(\n  err: unknown,\n  error: ErrorFn<Code>,\n): Response => {\n  if (!(err instanceof Error)) {\n    throw err;\n  }\n\n  switch (err.message) {\n    case \"FILE_NOT_FOUND\":\n      return error({ message: \"File not found\", code: \"FILE_NOT_FOUND\" as Code }, 404);\n    case \"FILE_DELETED\":\n      return error({ message: \"File deleted\", code: \"FILE_DELETED\" as Code }, 410);\n    case \"UPLOAD_NOT_FOUND\":\n      return error({ message: \"Upload not found\", code: \"UPLOAD_NOT_FOUND\" as Code }, 404);\n    case \"FILE_ALREADY_EXISTS\":\n      return error({ message: \"File already exists\", code: \"FILE_ALREADY_EXISTS\" as Code }, 409);\n    case \"UPLOAD_ALREADY_ACTIVE\":\n      return error(\n        {\n          message: \"Upload already active\",\n          code: \"UPLOAD_ALREADY_ACTIVE\" as Code,\n        },\n        409,\n      );\n    case \"UPLOAD_EXPIRED\":\n      return error({ message: \"Upload expired\", code: \"UPLOAD_EXPIRED\" as Code }, 410);\n    case \"UPLOAD_INVALID_STATE\":\n      return error(\n        {\n          message: \"Upload invalid state\",\n          code: \"UPLOAD_INVALID_STATE\" as Code,\n        },\n        409,\n      );\n    case \"INVALID_FILE_KEY\":\n      return error({ message: \"Invalid file key\", code: \"INVALID_FILE_KEY\" as Code }, 400);\n    case \"INVALID_CHECKSUM\":\n      return error({ message: \"Invalid checksum\", code: \"INVALID_CHECKSUM\" as Code }, 400);\n    case \"INVALID_REQUEST\":\n      return error({ message: \"Invalid request\", code: \"INVALID_REQUEST\" as Code }, 400);\n    case \"STORAGE_ERROR\":\n      return error({ message: \"Storage error\", code: \"STORAGE_ERROR\" as Code }, 502);\n    default:\n      throw err;\n  }\n};\n\nconst parseJson = <T>(value: FormDataEntryValue | null): T | undefined => {\n  if (value === null || typeof value !== \"string\" || value.length === 0) {\n    return undefined;\n  }\n  try {\n    return JSON.parse(value) as T;\n  } catch {\n    return undefined;\n  }\n};\n\nconst parseTags = (value: FormDataEntryValue | null): string[] | undefined => {\n  if (value === null) {\n    return undefined;\n  }\n  if (typeof value !== \"string\") {\n    return undefined;\n  }\n  const parsed = parseJson<unknown>(value);\n  if (Array.isArray(parsed)) {\n    return parsed.filter((tag) => typeof tag === \"string\") as string[];\n  }\n  if (typeof value === \"string\" && value.length > 0) {\n    return [value];\n  }\n  return undefined;\n};\n\nconst parseMetadata = (value: FormDataEntryValue | null): Record<string, unknown> | undefined => {\n  const parsed = parseJson<unknown>(value);\n  if (parsed && typeof parsed === \"object\" && !Array.isArray(parsed)) {\n    return parsed as Record<string, unknown>;\n  }\n  return undefined;\n};\n\nconst assertFileAvailable = <T extends { status: string }>(file: T) => {\n  if (file.status === \"deleted\") {\n    throw new Error(\"FILE_DELETED\");\n  }\n  return file;\n};\n\nexport const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(\n  ({ services, defineRoute, config }) => {\n    const getResolvedConfig = () => resolveUploadFragmentConfig(config);\n\n    const parseListQuery = (query: URLSearchParams) => {\n      const result = listQuerySchema.safeParse({\n        provider: query.has(\"provider\") ? query.get(\"provider\") : undefined,\n        prefix: query.get(\"prefix\") || undefined,\n        cursor: query.get(\"cursor\") || undefined,\n        pageSize: query.get(\"pageSize\"),\n        status: query.get(\"status\") || undefined,\n        uploaderId: query.get(\"uploaderId\") || undefined,\n      });\n      if (!result.success) {\n        throw new Error(\"INVALID_REQUEST\");\n      }\n      return result.data;\n    };\n\n    const parseByKeyQuery = (query: URLSearchParams) => {\n      const result = byKeyQuerySchema.safeParse({\n        provider: query.get(\"provider\"),\n        key: query.get(\"key\"),\n      });\n      if (!result.success) {\n        throw new Error(\"INVALID_REQUEST\");\n      }\n\n      try {\n        const resolvedKey = resolveFileKeyInput({ fileKey: result.data.key });\n        return {\n          provider: result.data.provider,\n          fileKey: resolvedKey.fileKey,\n        };\n      } catch {\n        throw new Error(\"INVALID_FILE_KEY\");\n      }\n    };\n\n    return [\n      defineRoute({\n        method: \"POST\",\n        path: \"/files\",\n        contentType: \"multipart/form-data\",\n        outputSchema: fileMetadataSchema,\n        errorCodes,\n        handler: async function (context, { json, error }) {\n          const resolvedConfig = getResolvedConfig();\n          const form = context.formData();\n          const file = form.get(\"file\");\n          if (!(file instanceof Blob)) {\n            return error({ message: \"File is required\", code: \"INVALID_REQUEST\" }, 400);\n          }\n\n          const providerValue = form.get(\"provider\");\n          const providerResult = providerNamespaceSchema.safeParse(providerValue);\n          if (!providerResult.success) {\n            return error({ message: \"Invalid request\", code: \"INVALID_REQUEST\" }, 400);\n          }\n          const provider = providerResult.data;\n\n          let keyParts: z.infer<typeof legacyFileKeyPartsSchema> | undefined;\n          if (form.has(\"keyParts\")) {\n            const parsed = parseJson<unknown>(form.get(\"keyParts\"));\n            const result = legacyFileKeyPartsSchema.safeParse(parsed);\n            if (!result.success) {\n              return error({ message: \"Invalid file key\", code: \"INVALID_FILE_KEY\" }, 400);\n            }\n            keyParts = result.data;\n          }\n\n          const fileKeyValue = form.get(\"fileKey\");\n          const fileKey = typeof fileKeyValue === \"string\" ? fileKeyValue : undefined;\n\n          const checksumValue = form.get(\"checksum\");\n          const parsedChecksum = parseJson<unknown>(checksumValue);\n          const checksumResult = checksumSchema.safeParse(parsedChecksum);\n          if (!checksumResult.success) {\n            return error({ message: \"Invalid checksum\", code: \"INVALID_CHECKSUM\" }, 400);\n          }\n\n          const tags = parseTags(form.get(\"tags\"));\n          const metadata = parseMetadata(form.get(\"metadata\"));\n\n          let resolvedKey;\n          try {\n            resolvedKey = resolveFileKeyInput({\n              keyParts,\n              fileKey: fileKey ?? undefined,\n            });\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n\n          const checksumForStorage = checksumResult.data ?? null;\n          const checksumForRecord = checksumResult.data ?? undefined;\n\n          let storageInit;\n\n          const uploaderIdValue = form.get(\"uploaderId\");\n          const uploaderId = typeof uploaderIdValue === \"string\" ? uploaderIdValue : undefined;\n          const visibilityValue = form.get(\"visibility\");\n          const parsedVisibility =\n            typeof visibilityValue === \"string\" ? visibilityValue : undefined;\n          const visibilityResult = visibilitySchema.optional().safeParse(parsedVisibility);\n          if (!visibilityResult.success) {\n            return error({ message: \"Invalid request\", code: \"INVALID_REQUEST\" }, 400);\n          }\n          const visibility = visibilityResult.data;\n          const filenameValue = form.get(\"filename\");\n          const filename =\n            typeof filenameValue === \"string\" && filenameValue\n              ? filenameValue\n              : file instanceof File && file.name\n                ? file.name\n                : \"upload\";\n          const contentType = file.type || \"application/octet-stream\";\n\n          const objectKeyVersionSegment = buildStorageObjectVersionSegment();\n\n          const createInput = {\n            provider,\n            fileKey: resolvedKey.fileKey,\n            keyParts: resolvedKey.fileKeyParts,\n            filename,\n            sizeBytes: file.size,\n            contentType,\n            checksum: checksumForRecord,\n            tags,\n            visibility,\n            uploaderId,\n            metadata,\n          };\n\n          try {\n            storageInit = await resolvedConfig.storage.initUpload({\n              provider,\n              fileKey: resolvedKey.fileKey,\n              sizeBytes: BigInt(file.size),\n              contentType,\n              checksum: checksumForStorage,\n              metadata: metadata ?? null,\n              objectKeyVersionSegment,\n            });\n          } catch {\n            return error({ message: \"Storage error\", code: \"STORAGE_ERROR\" }, 502);\n          }\n\n          if (storageInit.strategy === \"direct-multipart\") {\n            if (resolvedConfig.storage.abortMultipartUpload && storageInit.storageUploadId) {\n              try {\n                await resolvedConfig.storage.abortMultipartUpload({\n                  storageKey: storageInit.storageKey,\n                  storageUploadId: storageInit.storageUploadId,\n                });\n              } catch {\n                // Ignore abort failures; the request is still invalid for this endpoint.\n              }\n            }\n\n            return error({ message: \"Upload invalid state\", code: \"UPLOAD_INVALID_STATE\" }, 409);\n          }\n\n          try {\n            if (storageInit.strategy === \"proxy\") {\n              if (!resolvedConfig.storage.writeStream) {\n                throw new Error(\"STORAGE_ERROR\");\n              }\n              await resolvedConfig.storage.writeStream({\n                storageKey: storageInit.storageKey,\n                body: file.stream(),\n                contentType,\n                sizeBytes: BigInt(file.size),\n              });\n            } else if (storageInit.strategy === \"direct-single\") {\n              if (!storageInit.uploadUrl) {\n                throw new Error(\"STORAGE_ERROR\");\n              }\n              const response = await fetch(storageInit.uploadUrl, {\n                method: \"PUT\",\n                headers: storageInit.uploadHeaders,\n                body: file,\n              });\n              if (!response.ok) {\n                throw new Error(\"STORAGE_ERROR\");\n              }\n            } else {\n              return error(\n                {\n                  message: \"Upload invalid state\",\n                  code: \"UPLOAD_INVALID_STATE\",\n                },\n                409,\n              );\n            }\n\n            if (resolvedConfig.storage.finalizeUpload) {\n              await resolvedConfig.storage.finalizeUpload({\n                storageKey: storageInit.storageKey,\n                expectedSizeBytes: BigInt(file.size),\n                checksum: checksumResult.data ?? null,\n              });\n            }\n          } catch {\n            await this.handlerTx()\n              .withServiceCalls(() => [\n                services.createFailedUpload({\n                  ...createInput,\n                  storageInit,\n                  errorCode: \"STORAGE_ERROR\",\n                  errorMessage: \"Storage upload failed\",\n                }),\n              ])\n              .execute();\n            return error({ message: \"Storage error\", code: \"STORAGE_ERROR\" }, 502);\n          }\n\n          try {\n            const completed = await this.handlerTx()\n              .withServiceCalls(() => [\n                services.createCompletedUpload({\n                  ...createInput,\n                  storageInit,\n                  completedSizeBytes: BigInt(file.size),\n                }),\n              ])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            return json(toFileMetadata(completed.file));\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n\n      defineRoute({\n        method: \"GET\",\n        path: \"/files\",\n        queryParameters: [\"provider\", \"prefix\", \"cursor\", \"pageSize\", \"status\", \"uploaderId\"],\n        outputSchema: z.object({\n          files: z.array(fileMetadataSchema),\n          cursor: z.string().optional(),\n          hasNextPage: z.boolean(),\n        }),\n        errorCodes,\n        handler: async function ({ query }, { json, error }) {\n          let params;\n          try {\n            params = parseListQuery(query);\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n\n          const result = await this.handlerTx()\n            .withServiceCalls(() => [\n              services.listFiles({\n                provider: params.provider,\n                prefix: params.prefix,\n                pageSize: params.pageSize,\n                cursor: params.cursor,\n                status: params.status,\n                uploaderId: params.uploaderId,\n              }),\n            ])\n            .transform(({ serviceResult: [files] }) => files)\n            .execute();\n\n          return json({\n            files: result.items.map(toFileMetadata),\n            cursor: result.cursor?.encode(),\n            hasNextPage: result.hasNextPage,\n          });\n        },\n      }),\n\n      defineRoute({\n        method: \"GET\",\n        path: \"/files/by-key\",\n        queryParameters: [\"provider\", \"key\"],\n        outputSchema: fileMetadataSchema,\n        errorCodes,\n        handler: async function ({ query }, { json, error }) {\n          let byKey;\n          try {\n            byKey = parseByKeyQuery(query);\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n\n          try {\n            const file = await this.handlerTx()\n              .withServiceCalls(() => [services.getFileByKey(byKey)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            return json(toFileMetadata(file));\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n\n      defineRoute({\n        method: \"PATCH\",\n        path: \"/files/by-key\",\n        queryParameters: [\"provider\", \"key\"],\n        inputSchema: updateFileSchema,\n        outputSchema: fileMetadataSchema,\n        errorCodes,\n        handler: async function ({ query, input }, { json, error }) {\n          const payload = await input.valid();\n          let byKey;\n          try {\n            byKey = parseByKeyQuery(query);\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n\n          try {\n            const file = await this.handlerTx()\n              .withServiceCalls(() => [services.updateFile(byKey, payload)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            return json(toFileMetadata(file));\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n\n      defineRoute({\n        method: \"DELETE\",\n        path: \"/files/by-key\",\n        queryParameters: [\"provider\", \"key\"],\n        outputSchema: z.object({ ok: z.literal(true) }),\n        errorCodes,\n        handler: async function ({ query }, { json, error }) {\n          let byKey;\n          try {\n            byKey = parseByKeyQuery(query);\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n\n          try {\n            await this.handlerTx()\n              .withServiceCalls(() => [services.markFileDeleted(byKey)])\n              .execute();\n\n            return json({ ok: true });\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n\n      defineRoute({\n        method: \"GET\",\n        path: \"/files/by-key/download-url\",\n        queryParameters: [\"provider\", \"key\"],\n        outputSchema: z.object({\n          url: z.string(),\n          headers: z.record(z.string(), z.string()).optional(),\n          expiresAt: z.date(),\n        }),\n        errorCodes,\n        handler: async function ({ query }, { json, error }) {\n          const resolvedConfig = getResolvedConfig();\n          let byKey;\n          try {\n            byKey = parseByKeyQuery(query);\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n\n          if (!resolvedConfig.storage.getDownloadUrl) {\n            return error(\n              {\n                message: \"Signed URLs are not supported\",\n                code: \"SIGNED_URL_UNSUPPORTED\",\n              },\n              400,\n            );\n          }\n\n          try {\n            const file = assertFileAvailable(\n              await this.handlerTx()\n                .withServiceCalls(() => [services.getFileByKey(byKey)])\n                .transform(({ serviceResult: [result] }) => result)\n                .execute(),\n            );\n\n            let result;\n            try {\n              result = await resolvedConfig.storage.getDownloadUrl({\n                storageKey: file.objectKey,\n                expiresInSeconds: resolvedConfig.signedUrlExpiresInSeconds,\n                contentType: file.contentType ?? undefined,\n              });\n            } catch {\n              return error({ message: \"Storage error\", code: \"STORAGE_ERROR\" }, 502);\n            }\n\n            return json(result);\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n\n      defineRoute({\n        method: \"GET\",\n        path: \"/files/by-key/content\",\n        queryParameters: [\"provider\", \"key\"],\n        errorCodes,\n        handler: async function ({ query }, { error }) {\n          const resolvedConfig = getResolvedConfig();\n          let byKey;\n          try {\n            byKey = parseByKeyQuery(query);\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n\n          if (!resolvedConfig.storage.getDownloadStream) {\n            return error(\n              {\n                message: \"Download streaming unsupported\",\n                code: \"SIGNED_URL_UNSUPPORTED\",\n              },\n              400,\n            );\n          }\n\n          try {\n            const file = assertFileAvailable(\n              await this.handlerTx()\n                .withServiceCalls(() => [services.getFileByKey(byKey)])\n                .transform(({ serviceResult: [result] }) => result)\n                .execute(),\n            );\n\n            try {\n              return await resolvedConfig.storage.getDownloadStream({\n                storageKey: file.objectKey,\n              });\n            } catch {\n              return error({ message: \"Storage error\", code: \"STORAGE_ERROR\" }, 502);\n            }\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n    ];\n  },\n);\n"],"mappings":"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"}