@fragno-dev/upload 0.1.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/routes/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;cAGa,2CAAY,aAAoD,oBAAA;kBAApD;;;;;;;;;;;MAAZ,eAAgE,EAAA,CAAA,OAAA,sBAAA,EAAA,GAAA,IAAA,UAAA,CAAA,IAAA,CAAA;IAAA,CAAA,CAAA;KAAA,OAAA,gBAAA,EAAA,6BAAA,CAAA;IAApD,EAAA,mCAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGstC;;;;;;;;sBAAiQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAjQ,EAAA,CAAA,IAAA,0CAAA;;MAAiQ,WAAA,EAAA,CAAA,OAAA,iBAAA,EAAA,GAAA,IAAA,UAAA,CAAA,IAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAHv9C,CAAA,GAAA,CAAA;yCAAA,CAAA,KAAA,EAAA,4BAAA,0CAAA,CAAA,OAAA,EAAA,OAAA,CAAA,GAAA,SAAA,mBAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAAA,oBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGstC;;;;;;;;sBAAiQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAjQ,SAAA,MAAA;;IAAiQ,WAAA,MAAA,GAAA,IAAA"}

package/dist/node/routes/index.js

@@ -0,0 +1,9 @@
+import { fileRoutesFactory } from "./files.js";
+import { uploadRoutesFactory } from "./uploads.js";
+
+//#region src/routes/index.ts
+const uploadRoutes = [uploadRoutesFactory, fileRoutesFactory];
+
+//#endregion
+export { uploadRoutes };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/routes/index.ts"],"sourcesContent":["import { fileRoutesFactory } from \"./files\";\nimport { uploadRoutesFactory } from \"./uploads\";\n\nexport const uploadRoutes = [uploadRoutesFactory, fileRoutesFactory] as const;\n\nexport { fileRoutesFactory, uploadRoutesFactory };\n"],"mappings":";;;;AAGA,MAAa,eAAe,CAAC,qBAAqB,kBAAkB"}

package/dist/node/routes/shared.js

@@ -0,0 +1,66 @@
+import "../schema.js";
+import { decodeFileKey } from "../keys.js";
+import { z } from "zod";
+
+//#region src/routes/shared.ts
+const fileKeyPartsSchema = z.array(z.union([z.string(), z.number().int()]));
+const checksumSchema = z.object({
+	algo: z.enum(["sha256", "md5"]),
+	value: z.string()
+}).nullable().optional();
+const visibilitySchema = z.enum([
+	"private",
+	"public",
+	"unlisted"
+]);
+const fileMetadataSchema = z.object({
+	fileKey: z.string(),
+	fileKeyParts: fileKeyPartsSchema,
+	uploaderId: z.string().nullable(),
+	filename: z.string(),
+	sizeBytes: z.number(),
+	contentType: z.string(),
+	checksum: z.object({
+		algo: z.enum(["sha256", "md5"]),
+		value: z.string()
+	}).nullable(),
+	visibility: visibilitySchema,
+	tags: z.array(z.string()).nullable(),
+	metadata: z.record(z.string(), z.unknown()).nullable(),
+	status: z.enum(["ready", "deleted"]),
+	storageProvider: z.string(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	completedAt: z.string().nullable(),
+	deletedAt: z.string().nullable(),
+	errorCode: z.string().nullable(),
+	errorMessage: z.string().nullable()
+});
+const toFileMetadata = (file) => {
+	const fileKeyParts = Array.from(decodeFileKey(file.fileKey));
+	const toIsoString = (value) => value ? value.toISOString() : null;
+	return {
+		fileKey: file.fileKey,
+		fileKeyParts,
+		uploaderId: file.uploaderId,
+		filename: file.filename,
+		sizeBytes: Number(file.sizeBytes),
+		contentType: file.contentType,
+		checksum: file.checksum,
+		visibility: file.visibility,
+		tags: file.tags,
+		metadata: file.metadata,
+		status: file.status,
+		storageProvider: file.storageProvider,
+		createdAt: file.createdAt.toISOString(),
+		updatedAt: file.updatedAt.toISOString(),
+		completedAt: toIsoString(file.completedAt),
+		deletedAt: toIsoString(file.deletedAt),
+		errorCode: file.errorCode,
+		errorMessage: file.errorMessage
+	};
+};
+
+//#endregion
+export { checksumSchema, fileKeyPartsSchema, fileMetadataSchema, toFileMetadata, visibilitySchema };
+//# sourceMappingURL=shared.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shared.js","names":[],"sources":["../../../src/routes/shared.ts"],"sourcesContent":["import { z } from \"zod\";\nimport type { TableToColumnValues } from \"@fragno-dev/db/query\";\nimport { decodeFileKey } from \"../keys\";\nimport { uploadSchema } from \"../schema\";\nimport type { FileMetadata } from \"../types\";\n\ntype FileRow = TableToColumnValues<typeof uploadSchema.tables.file>;\n\nexport const fileKeyPartsSchema = z.array(z.union([z.string(), z.number().int()]));\n\nexport const checksumSchema = z\n  .object({\n    algo: z.enum([\"sha256\", \"md5\"]),\n    value: z.string(),\n  })\n  .nullable()\n  .optional();\n\nexport const visibilitySchema = z.enum([\"private\", \"public\", \"unlisted\"]);\n\nexport const fileMetadataSchema = z.object({\n  fileKey: z.string(),\n  fileKeyParts: fileKeyPartsSchema,\n  uploaderId: z.string().nullable(),\n  filename: z.string(),\n  sizeBytes: z.number(),\n  contentType: z.string(),\n  checksum: z\n    .object({\n      algo: z.enum([\"sha256\", \"md5\"]),\n      value: z.string(),\n    })\n    .nullable(),\n  visibility: visibilitySchema,\n  tags: z.array(z.string()).nullable(),\n  metadata: z.record(z.string(), z.unknown()).nullable(),\n  status: z.enum([\"ready\", \"deleted\"]),\n  storageProvider: z.string(),\n  createdAt: z.string(),\n  updatedAt: z.string(),\n  completedAt: z.string().nullable(),\n  deletedAt: z.string().nullable(),\n  errorCode: z.string().nullable(),\n  errorMessage: z.string().nullable(),\n});\n\nexport const toFileMetadata = (file: FileRow): FileMetadata => {\n  const fileKeyParts = Array.from(decodeFileKey(file.fileKey));\n\n  const toIsoString = (value: Date | null | undefined) => (value ? value.toISOString() : null);\n\n  return {\n    fileKey: file.fileKey,\n    fileKeyParts,\n    uploaderId: file.uploaderId,\n    filename: file.filename,\n    sizeBytes: Number(file.sizeBytes),\n    contentType: file.contentType,\n    checksum: file.checksum as FileMetadata[\"checksum\"],\n    visibility: file.visibility as FileMetadata[\"visibility\"],\n    tags: file.tags as FileMetadata[\"tags\"],\n    metadata: file.metadata as FileMetadata[\"metadata\"],\n    status: file.status as FileMetadata[\"status\"],\n    storageProvider: file.storageProvider,\n    createdAt: file.createdAt.toISOString(),\n    updatedAt: file.updatedAt.toISOString(),\n    completedAt: toIsoString(file.completedAt),\n    deletedAt: toIsoString(file.deletedAt),\n    errorCode: file.errorCode,\n    errorMessage: file.errorMessage,\n  };\n};\n"],"mappings":";;;;;AAQA,MAAa,qBAAqB,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;AAElF,MAAa,iBAAiB,EAC3B,OAAO;CACN,MAAM,EAAE,KAAK,CAAC,UAAU,MAAM,CAAC;CAC/B,OAAO,EAAE,QAAQ;CAClB,CAAC,CACD,UAAU,CACV,UAAU;AAEb,MAAa,mBAAmB,EAAE,KAAK;CAAC;CAAW;CAAU;CAAW,CAAC;AAEzE,MAAa,qBAAqB,EAAE,OAAO;CACzC,SAAS,EAAE,QAAQ;CACnB,cAAc;CACd,YAAY,EAAE,QAAQ,CAAC,UAAU;CACjC,UAAU,EAAE,QAAQ;CACpB,WAAW,EAAE,QAAQ;CACrB,aAAa,EAAE,QAAQ;CACvB,UAAU,EACP,OAAO;EACN,MAAM,EAAE,KAAK,CAAC,UAAU,MAAM,CAAC;EAC/B,OAAO,EAAE,QAAQ;EAClB,CAAC,CACD,UAAU;CACb,YAAY;CACZ,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,UAAU;CACpC,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,CAAC,UAAU;CACtD,QAAQ,EAAE,KAAK,CAAC,SAAS,UAAU,CAAC;CACpC,iBAAiB,EAAE,QAAQ;CAC3B,WAAW,EAAE,QAAQ;CACrB,WAAW,EAAE,QAAQ;CACrB,aAAa,EAAE,QAAQ,CAAC,UAAU;CAClC,WAAW,EAAE,QAAQ,CAAC,UAAU;CAChC,WAAW,EAAE,QAAQ,CAAC,UAAU;CAChC,cAAc,EAAE,QAAQ,CAAC,UAAU;CACpC,CAAC;AAEF,MAAa,kBAAkB,SAAgC;CAC7D,MAAM,eAAe,MAAM,KAAK,cAAc,KAAK,QAAQ,CAAC;CAE5D,MAAM,eAAe,UAAoC,QAAQ,MAAM,aAAa,GAAG;AAEvF,QAAO;EACL,SAAS,KAAK;EACd;EACA,YAAY,KAAK;EACjB,UAAU,KAAK;EACf,WAAW,OAAO,KAAK,UAAU;EACjC,aAAa,KAAK;EAClB,UAAU,KAAK;EACf,YAAY,KAAK;EACjB,MAAM,KAAK;EACX,UAAU,KAAK;EACf,QAAQ,KAAK;EACb,iBAAiB,KAAK;EACtB,WAAW,KAAK,UAAU,aAAa;EACvC,WAAW,KAAK,UAAU,aAAa;EACvC,aAAa,YAAY,KAAK,YAAY;EAC1C,WAAW,YAAY,KAAK,UAAU;EACtC,WAAW,KAAK;EAChB,cAAc,KAAK;EACpB"}

package/dist/node/routes/uploads.js

@@ -0,0 +1,454 @@
+import { resolveUploadFragmentConfig } from "../config.js";
+import { resolveFileKeyInput } from "../services/helpers.js";
+import { uploadFragmentDefinition } from "../definition.js";
+import { checksumSchema, fileKeyPartsSchema, fileMetadataSchema, toFileMetadata } from "./shared.js";
+import { defineRoutes } from "@fragno-dev/core";
+import { z } from "zod";
+
+//#region src/routes/uploads.ts
+const uploadStrategySchema = z.enum([
+	"direct-single",
+	"direct-multipart",
+	"proxy"
+]);
+const safeIntSchema = z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+const createUploadInputSchema = z.object({
+	keyParts: fileKeyPartsSchema.optional(),
+	fileKey: z.string().optional(),
+	filename: z.string().min(1),
+	sizeBytes: safeIntSchema,
+	contentType: z.string().min(1),
+	checksum: checksumSchema.optional(),
+	tags: z.array(z.string()).optional(),
+	visibility: z.enum([
+		"private",
+		"public",
+		"unlisted"
+	]).optional(),
+	uploaderId: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional()
+});
+const progressSchema = z.object({
+	bytesUploaded: safeIntSchema.optional(),
+	partsUploaded: z.number().int().min(0).optional()
+});
+const partNumbersSchema = z.object({ partNumbers: z.array(z.number().int().min(1)).min(1) });
+const completePartsSchema = z.object({ parts: z.array(z.object({
+	partNumber: z.number().int().min(1),
+	etag: z.string().min(1),
+	sizeBytes: safeIntSchema
+})).min(1) });
+const completeUploadSchema = z.object({ parts: z.array(z.object({
+	partNumber: z.number().int().min(1),
+	etag: z.string().min(1)
+})).optional() });
+const uploadStatusSchema = z.object({
+	uploadId: z.string(),
+	fileKey: z.string(),
+	status: z.enum([
+		"created",
+		"in_progress",
+		"completed",
+		"aborted",
+		"failed",
+		"expired"
+	]),
+	strategy: uploadStrategySchema,
+	expectedSizeBytes: z.number(),
+	bytesUploaded: z.number(),
+	partsUploaded: z.number(),
+	partSizeBytes: z.number().nullable(),
+	expiresAt: z.date(),
+	createdAt: z.date(),
+	updatedAt: z.date(),
+	completedAt: z.date().nullable(),
+	errorCode: z.string().nullable(),
+	errorMessage: z.string().nullable()
+});
+const errorCodes = [
+	"UPLOAD_NOT_FOUND",
+	"UPLOAD_ALREADY_ACTIVE",
+	"UPLOAD_METADATA_MISMATCH",
+	"FILE_ALREADY_EXISTS",
+	"UPLOAD_EXPIRED",
+	"UPLOAD_INVALID_STATE",
+	"INVALID_FILE_KEY",
+	"INVALID_CHECKSUM",
+	"INVALID_REQUEST",
+	"STORAGE_ERROR"
+];
+const handleServiceError = (err, error) => {
+	if (!(err instanceof Error)) throw err;
+	switch (err.message) {
+		case "UPLOAD_NOT_FOUND": return error({
+			message: "Upload not found",
+			code: "UPLOAD_NOT_FOUND"
+		}, 404);
+		case "FILE_ALREADY_EXISTS": return error({
+			message: "File already exists",
+			code: "FILE_ALREADY_EXISTS"
+		}, 409);
+		case "UPLOAD_ALREADY_ACTIVE": return error({
+			message: "Upload already active",
+			code: "UPLOAD_ALREADY_ACTIVE"
+		}, 409);
+		case "UPLOAD_METADATA_MISMATCH": return error({
+			message: "Upload metadata mismatch",
+			code: "UPLOAD_METADATA_MISMATCH"
+		}, 409);
+		case "UPLOAD_EXPIRED": return error({
+			message: "Upload expired",
+			code: "UPLOAD_EXPIRED"
+		}, 410);
+		case "UPLOAD_INVALID_STATE": return error({
+			message: "Upload invalid state",
+			code: "UPLOAD_INVALID_STATE"
+		}, 409);
+		case "INVALID_FILE_KEY": return error({
+			message: "Invalid file key",
+			code: "INVALID_FILE_KEY"
+		}, 400);
+		case "INVALID_CHECKSUM": return error({
+			message: "Invalid checksum",
+			code: "INVALID_CHECKSUM"
+		}, 400);
+		case "INVALID_REQUEST": return error({
+			message: "Invalid request",
+			code: "INVALID_REQUEST"
+		}, 400);
+		case "STORAGE_ERROR": return error({
+			message: "Storage error",
+			code: "STORAGE_ERROR"
+		}, 502);
+		default: throw err;
+	}
+};
+const uploadRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ services, defineRoute, config }) => {
+	const getResolvedConfig = () => resolveUploadFragmentConfig(config);
+	return [
+		defineRoute({
+			method: "POST",
+			path: "/uploads",
+			inputSchema: createUploadInputSchema,
+			outputSchema: z.object({
+				uploadId: z.string(),
+				fileKey: z.string(),
+				status: z.enum(["created", "in_progress"]),
+				strategy: uploadStrategySchema,
+				expiresAt: z.date(),
+				upload: z.object({
+					mode: z.enum(["single", "multipart"]),
+					transport: z.enum(["direct", "proxy"]),
+					uploadUrl: z.string().optional(),
+					uploadHeaders: z.record(z.string(), z.string()).optional(),
+					partSizeBytes: z.number().optional(),
+					maxParts: z.number().optional(),
+					partsEndpoint: z.string().optional(),
+					completeEndpoint: z.string(),
+					contentEndpoint: z.string().optional()
+				})
+			}),
+			errorCodes,
+			handler: async function({ input }, { json, error }) {
+				const payload = await input.valid();
+				const resolvedConfig = getResolvedConfig();
+				let resolvedKey;
+				try {
+					resolvedKey = resolveFileKeyInput({
+						keyParts: payload.keyParts,
+						fileKey: payload.fileKey
+					});
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+				try {
+					const existing = await this.handlerTx().withServiceCalls(() => [services.checkUploadAvailability(payload, { allowIdempotentReuse: true })]).transform(({ serviceResult: [result] }) => result).execute();
+					if (existing) return json(existing);
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+				let storageInit;
+				try {
+					storageInit = await resolvedConfig.storage.initUpload({
+						fileKey: resolvedKey.fileKey,
+						fileKeyParts: resolvedKey.fileKeyParts,
+						sizeBytes: BigInt(payload.sizeBytes),
+						contentType: payload.contentType,
+						checksum: payload.checksum ?? null,
+						metadata: payload.metadata ?? null
+					});
+				} catch (err) {
+					if (err instanceof Error && err.message === "INVALID_CHECKSUM") return error({
+						message: "Invalid checksum",
+						code: "INVALID_CHECKSUM"
+					}, 400);
+					return error({
+						message: "Storage error",
+						code: "STORAGE_ERROR"
+					}, 502);
+				}
+				try {
+					const result = await this.handlerTx().withServiceCalls(() => [services.createUploadRecord({
+						...payload,
+						storageInit,
+						allowIdempotentReuse: true
+					})]).transform(({ serviceResult: [created] }) => created).execute();
+					if (result.reused && storageInit.strategy === "direct-multipart" && resolvedConfig.storage.abortMultipartUpload && storageInit.storageUploadId) try {
+						await resolvedConfig.storage.abortMultipartUpload({
+							storageKey: storageInit.storageKey,
+							storageUploadId: storageInit.storageUploadId
+						});
+					} catch {}
+					return json(result.result);
+				} catch (err) {
+					if (storageInit.strategy === "direct-multipart" && resolvedConfig.storage.abortMultipartUpload && storageInit.storageUploadId) try {
+						await resolvedConfig.storage.abortMultipartUpload({
+							storageKey: storageInit.storageKey,
+							storageUploadId: storageInit.storageUploadId
+						});
+					} catch {}
+					return handleServiceError(err, error);
+				}
+			}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/uploads/:uploadId",
+			outputSchema: uploadStatusSchema,
+			errorCodes,
+			handler: async function({ pathParams }, { json, error }) {
+				try {
+					const upload = await this.handlerTx().withServiceCalls(() => [services.getUploadStatus(pathParams.uploadId)]).transform(({ serviceResult: [result] }) => result).execute();
+					return json({
+						uploadId: upload.id.toString(),
+						fileKey: upload.fileKey,
+						status: upload.status,
+						strategy: upload.strategy,
+						expectedSizeBytes: Number(upload.expectedSizeBytes),
+						bytesUploaded: Number(upload.bytesUploaded),
+						partsUploaded: upload.partsUploaded,
+						partSizeBytes: upload.partSizeBytes,
+						expiresAt: upload.expiresAt,
+						createdAt: upload.createdAt,
+						updatedAt: upload.updatedAt,
+						completedAt: upload.completedAt,
+						errorCode: upload.errorCode,
+						errorMessage: upload.errorMessage
+					});
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+			}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/uploads/:uploadId/progress",
+			inputSchema: progressSchema,
+			outputSchema: z.object({
+				bytesUploaded: z.number(),
+				partsUploaded: z.number()
+			}),
+			errorCodes,
+			handler: async function({ pathParams, input }, { json, error }) {
+				const payload = await input.valid();
+				try {
+					const result = await this.handlerTx().withServiceCalls(() => [services.recordUploadProgress(pathParams.uploadId, payload)]).transform(({ serviceResult: [updated] }) => updated).execute();
+					return json({
+						bytesUploaded: Number(result.bytesUploaded),
+						partsUploaded: result.partsUploaded
+					});
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+			}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/uploads/:uploadId/parts",
+			inputSchema: partNumbersSchema,
+			outputSchema: z.object({ parts: z.array(z.object({
+				partNumber: z.number(),
+				url: z.string(),
+				headers: z.record(z.string(), z.string()).optional()
+			})) }),
+			errorCodes,
+			handler: async function({ pathParams, input }, { json, error }) {
+				const payload = await input.valid();
+				const resolvedConfig = getResolvedConfig();
+				try {
+					const upload = await this.handlerTx().withServiceCalls(() => [services.getUploadStorageInfo(pathParams.uploadId)]).transform(({ serviceResult: [result] }) => result).execute();
+					if (upload.strategy !== "direct-multipart") return error({
+						message: "Upload invalid state",
+						code: "UPLOAD_INVALID_STATE"
+					}, 409);
+					if (!resolvedConfig.storage.getPartUploadUrls) return error({
+						message: "Storage error",
+						code: "STORAGE_ERROR"
+					}, 502);
+					return json({ parts: await resolvedConfig.storage.getPartUploadUrls({
+						storageKey: upload.storageKey,
+						storageUploadId: upload.storageUploadId ?? "",
+						partNumbers: payload.partNumbers,
+						partSizeBytes: upload.partSizeBytes ?? 0
+					}) });
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+			}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/uploads/:uploadId/parts",
+			outputSchema: z.object({ parts: z.array(z.object({
+				partNumber: z.number(),
+				etag: z.string(),
+				sizeBytes: z.number(),
+				createdAt: z.date()
+			})) }),
+			errorCodes,
+			handler: async function({ pathParams }, { json, error }) {
+				try {
+					return json({ parts: (await this.handlerTx().withServiceCalls(() => [services.getUploadParts(pathParams.uploadId)]).transform(({ serviceResult: [result] }) => result).execute()).map((part) => ({
+						partNumber: part.partNumber,
+						etag: part.etag,
+						sizeBytes: Number(part.sizeBytes),
+						createdAt: part.createdAt
+					})) });
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+			}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/uploads/:uploadId/parts/complete",
+			inputSchema: completePartsSchema,
+			outputSchema: z.object({
+				bytesUploaded: z.number(),
+				partsUploaded: z.number()
+			}),
+			errorCodes,
+			handler: async function({ pathParams, input }, { json, error }) {
+				const payload = await input.valid();
+				try {
+					const result = await this.handlerTx().withServiceCalls(() => [services.recordUploadParts(pathParams.uploadId, payload)]).transform(({ serviceResult: [updated] }) => updated).execute();
+					return json({
+						bytesUploaded: Number(result.bytesUploaded),
+						partsUploaded: result.partsUploaded
+					});
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+			}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/uploads/:uploadId/complete",
+			inputSchema: completeUploadSchema,
+			outputSchema: fileMetadataSchema,
+			errorCodes,
+			handler: async function({ pathParams, input }, { json, error }) {
+				const payload = await input.valid();
+				const resolvedConfig = getResolvedConfig();
+				try {
+					const upload = await this.handlerTx().withServiceCalls(() => [services.getUploadStorageInfo(pathParams.uploadId)]).transform(({ serviceResult: [result] }) => result).execute();
+					if (await this.handlerTx().withServiceCalls(() => [services.findFileByKey(upload.fileKey)]).transform(({ serviceResult: [result] }) => result).execute()) return error({
+						message: "File already exists",
+						code: "FILE_ALREADY_EXISTS"
+					}, 409);
+					let finalizeResult;
+					if (upload.strategy === "direct-multipart") {
+						if (!resolvedConfig.storage.completeMultipartUpload) return error({
+							message: "Storage error",
+							code: "STORAGE_ERROR"
+						}, 502);
+						if (!payload.parts || payload.parts.length === 0) return error({
+							message: "Upload invalid state",
+							code: "UPLOAD_INVALID_STATE"
+						}, 409);
+						await resolvedConfig.storage.completeMultipartUpload({
+							storageKey: upload.storageKey,
+							storageUploadId: upload.storageUploadId ?? "",
+							parts: payload.parts
+						});
+					} else if (resolvedConfig.storage.finalizeUpload) finalizeResult = await resolvedConfig.storage.finalizeUpload({
+						storageKey: upload.storageKey,
+						expectedSizeBytes: upload.expectedSizeBytes,
+						checksum: upload.checksum
+					});
+					return json(toFileMetadata((await this.handlerTx().withServiceCalls(() => [services.markUploadComplete(upload.id.toString(), upload.fileKey, finalizeResult?.sizeBytes ? { sizeBytes: finalizeResult.sizeBytes } : void 0)]).transform(({ serviceResult: [result] }) => result).execute()).file));
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+			}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/uploads/:uploadId/abort",
+			outputSchema: z.object({ ok: z.literal(true) }),
+			errorCodes,
+			handler: async function({ pathParams }, { json, error }) {
+				const resolvedConfig = getResolvedConfig();
+				try {
+					const upload = await this.handlerTx().withServiceCalls(() => [services.getUploadStorageInfo(pathParams.uploadId)]).transform(({ serviceResult: [result] }) => result).execute();
+					if (upload.strategy === "direct-multipart" && resolvedConfig.storage.abortMultipartUpload) await resolvedConfig.storage.abortMultipartUpload({
+						storageKey: upload.storageKey,
+						storageUploadId: upload.storageUploadId ?? ""
+					});
+					await this.handlerTx().withServiceCalls(() => [services.markUploadAborted(upload.id.toString())]).execute();
+					return json({ ok: true });
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+			}
+		}),
+		defineRoute({
+			method: "PUT",
+			path: "/uploads/:uploadId/content",
+			contentType: "application/octet-stream",
+			outputSchema: fileMetadataSchema,
+			errorCodes,
+			handler: async function(context, { json, error }) {
+				const { pathParams } = context;
+				const resolvedConfig = getResolvedConfig();
+				try {
+					const upload = await this.handlerTx().withServiceCalls(() => [services.getUploadStorageInfo(pathParams.uploadId)]).transform(({ serviceResult: [result$1] }) => result$1).execute();
+					if (upload.strategy !== "proxy") return error({
+						message: "Upload invalid state",
+						code: "UPLOAD_INVALID_STATE"
+					}, 409);
+					if (await this.handlerTx().withServiceCalls(() => [services.findFileByKey(upload.fileKey)]).transform(({ serviceResult: [result$1] }) => result$1).execute()) return error({
+						message: "File already exists",
+						code: "FILE_ALREADY_EXISTS"
+					}, 409);
+					if (!resolvedConfig.storage.writeStream) return error({
+						message: "Storage error",
+						code: "STORAGE_ERROR"
+					}, 502);
+					let result;
+					try {
+						result = await resolvedConfig.storage.writeStream({
+							storageKey: upload.storageKey,
+							body: context.bodyStream(),
+							contentType: upload.contentType,
+							sizeBytes: upload.expectedSizeBytes
+						});
+					} catch {
+						await this.handlerTx().withServiceCalls(() => [services.markUploadFailed(upload.id.toString(), "STORAGE_ERROR", "Storage upload failed")]).execute();
+						return error({
+							message: "Storage error",
+							code: "STORAGE_ERROR"
+						}, 502);
+					}
+					return json(toFileMetadata((await this.handlerTx().withServiceCalls(() => [services.markUploadComplete(upload.id.toString(), upload.fileKey, result?.sizeBytes ? { sizeBytes: result.sizeBytes } : void 0)]).transform(({ serviceResult: [done] }) => done).execute()).file));
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+			}
+		})
+	];
+});
+
+//#endregion
+export { uploadRoutesFactory };
+//# sourceMappingURL=uploads.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uploads.js","names":["finalizeResult: { sizeBytes?: bigint } | undefined","result","result: Awaited<ReturnType<NonNullable<typeof resolvedConfig.storage.writeStream>>>"],"sources":["../../../src/routes/uploads.ts"],"sourcesContent":["import { defineRoutes } from \"@fragno-dev/core\";\nimport type { FragnoRouteConfig } from \"@fragno-dev/core\";\nimport { z } from \"zod\";\nimport { resolveUploadFragmentConfig } from \"../config\";\nimport { uploadFragmentDefinition } from \"../definition\";\nimport { resolveFileKeyInput } from \"../services/helpers\";\nimport { checksumSchema, fileKeyPartsSchema, fileMetadataSchema, toFileMetadata } from \"./shared\";\nimport type { UploadStatus, UploadStrategy } from \"../types\";\nimport type { UploadChecksum } from \"../storage/types\";\n\nconst uploadStrategySchema = z.enum([\"direct-single\", \"direct-multipart\", \"proxy\"]);\nconst safeIntSchema = z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);\n\nconst createUploadInputSchema = z.object({\n  keyParts: fileKeyPartsSchema.optional(),\n  fileKey: z.string().optional(),\n  filename: z.string().min(1),\n  sizeBytes: safeIntSchema,\n  contentType: z.string().min(1),\n  checksum: checksumSchema.optional(),\n  tags: z.array(z.string()).optional(),\n  visibility: z.enum([\"private\", \"public\", \"unlisted\"]).optional(),\n  uploaderId: z.string().optional(),\n  metadata: z.record(z.string(), z.unknown()).optional(),\n});\n\nconst progressSchema = z.object({\n  bytesUploaded: safeIntSchema.optional(),\n  partsUploaded: z.number().int().min(0).optional(),\n});\n\nconst partNumbersSchema = z.object({\n  partNumbers: z.array(z.number().int().min(1)).min(1),\n});\n\nconst completePartsSchema = z.object({\n  parts: z\n    .array(\n      z.object({\n        partNumber: z.number().int().min(1),\n        etag: z.string().min(1),\n        sizeBytes: safeIntSchema,\n      }),\n    )\n    .min(1),\n});\n\nconst completeUploadSchema = z.object({\n  parts: z\n    .array(\n      z.object({\n        partNumber: z.number().int().min(1),\n        etag: z.string().min(1),\n      }),\n    )\n    .optional(),\n});\n\nconst uploadStatusSchema = z.object({\n  uploadId: z.string(),\n  fileKey: z.string(),\n  status: z.enum([\"created\", \"in_progress\", \"completed\", \"aborted\", \"failed\", \"expired\"]),\n  strategy: uploadStrategySchema,\n  expectedSizeBytes: z.number(),\n  bytesUploaded: z.number(),\n  partsUploaded: z.number(),\n  partSizeBytes: z.number().nullable(),\n  expiresAt: z.date(),\n  createdAt: z.date(),\n  updatedAt: z.date(),\n  completedAt: z.date().nullable(),\n  errorCode: z.string().nullable(),\n  errorMessage: z.string().nullable(),\n});\n\nconst errorCodes = [\n  \"UPLOAD_NOT_FOUND\",\n  \"UPLOAD_ALREADY_ACTIVE\",\n  \"UPLOAD_METADATA_MISMATCH\",\n  \"FILE_ALREADY_EXISTS\",\n  \"UPLOAD_EXPIRED\",\n  \"UPLOAD_INVALID_STATE\",\n  \"INVALID_FILE_KEY\",\n  \"INVALID_CHECKSUM\",\n  \"INVALID_REQUEST\",\n  \"STORAGE_ERROR\",\n] as const;\n\ntype UploadErrorCode = (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 UploadErrorCode>(\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 \"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_METADATA_MISMATCH\":\n      return error(\n        { message: \"Upload metadata mismatch\", code: \"UPLOAD_METADATA_MISMATCH\" 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    case \"STORAGE_ERROR\":\n      return error({ message: \"Storage error\", code: \"STORAGE_ERROR\" as Code }, 502);\n    default:\n      throw err;\n  }\n};\n\nexport const uploadRoutesFactory = defineRoutes(uploadFragmentDefinition).create(\n  ({ services, defineRoute, config }) => {\n    const getResolvedConfig = () => resolveUploadFragmentConfig(config);\n\n    return [\n      defineRoute({\n        method: \"POST\",\n        path: \"/uploads\",\n        inputSchema: createUploadInputSchema,\n        outputSchema: z.object({\n          uploadId: z.string(),\n          fileKey: z.string(),\n          status: z.enum([\"created\", \"in_progress\"]),\n          strategy: uploadStrategySchema,\n          expiresAt: z.date(),\n          upload: z.object({\n            mode: z.enum([\"single\", \"multipart\"]),\n            transport: z.enum([\"direct\", \"proxy\"]),\n            uploadUrl: z.string().optional(),\n            uploadHeaders: z.record(z.string(), z.string()).optional(),\n            partSizeBytes: z.number().optional(),\n            maxParts: z.number().optional(),\n            partsEndpoint: z.string().optional(),\n            completeEndpoint: z.string(),\n            contentEndpoint: z.string().optional(),\n          }),\n        }),\n        errorCodes,\n        handler: async function ({ input }, { json, error }) {\n          const payload = await input.valid();\n          const resolvedConfig = getResolvedConfig();\n\n          let resolvedKey;\n          try {\n            resolvedKey = resolveFileKeyInput({\n              keyParts: payload.keyParts,\n              fileKey: payload.fileKey,\n            });\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n\n          try {\n            const existing = await this.handlerTx()\n              .withServiceCalls(() => [\n                services.checkUploadAvailability(payload, { allowIdempotentReuse: true }),\n              ])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            if (existing) {\n              return json(existing);\n            }\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n\n          let storageInit;\n          try {\n            storageInit = await resolvedConfig.storage.initUpload({\n              fileKey: resolvedKey.fileKey,\n              fileKeyParts: resolvedKey.fileKeyParts,\n              sizeBytes: BigInt(payload.sizeBytes),\n              contentType: payload.contentType,\n              checksum: payload.checksum ?? null,\n              metadata: payload.metadata ?? null,\n            });\n          } catch (err) {\n            if (err instanceof Error && err.message === \"INVALID_CHECKSUM\") {\n              return error({ message: \"Invalid checksum\", code: \"INVALID_CHECKSUM\" }, 400);\n            }\n            return error({ message: \"Storage error\", code: \"STORAGE_ERROR\" }, 502);\n          }\n\n          try {\n            const result = await this.handlerTx()\n              .withServiceCalls(() => [\n                services.createUploadRecord({\n                  ...payload,\n                  storageInit,\n                  allowIdempotentReuse: true,\n                }),\n              ])\n              .transform(({ serviceResult: [created] }) => created)\n              .execute();\n\n            if (\n              result.reused &&\n              storageInit.strategy === \"direct-multipart\" &&\n              resolvedConfig.storage.abortMultipartUpload &&\n              storageInit.storageUploadId\n            ) {\n              try {\n                await resolvedConfig.storage.abortMultipartUpload({\n                  storageKey: storageInit.storageKey,\n                  storageUploadId: storageInit.storageUploadId,\n                });\n              } catch {\n                // Ignore abort failures for races.\n              }\n            }\n\n            return json(result.result);\n          } catch (err) {\n            if (\n              storageInit.strategy === \"direct-multipart\" &&\n              resolvedConfig.storage.abortMultipartUpload &&\n              storageInit.storageUploadId\n            ) {\n              try {\n                await resolvedConfig.storage.abortMultipartUpload({\n                  storageKey: storageInit.storageKey,\n                  storageUploadId: storageInit.storageUploadId,\n                });\n              } catch {\n                // Ignore abort failures for races.\n              }\n            }\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n\n      defineRoute({\n        method: \"GET\",\n        path: \"/uploads/:uploadId\",\n        outputSchema: uploadStatusSchema,\n        errorCodes,\n        handler: async function ({ pathParams }, { json, error }) {\n          try {\n            const upload = await this.handlerTx()\n              .withServiceCalls(() => [services.getUploadStatus(pathParams.uploadId)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            return json({\n              uploadId: upload.id.toString(),\n              fileKey: upload.fileKey,\n              status: upload.status as UploadStatus,\n              strategy: upload.strategy as UploadStrategy,\n              expectedSizeBytes: Number(upload.expectedSizeBytes),\n              bytesUploaded: Number(upload.bytesUploaded),\n              partsUploaded: upload.partsUploaded,\n              partSizeBytes: upload.partSizeBytes,\n              expiresAt: upload.expiresAt,\n              createdAt: upload.createdAt,\n              updatedAt: upload.updatedAt,\n              completedAt: upload.completedAt,\n              errorCode: upload.errorCode,\n              errorMessage: upload.errorMessage,\n            });\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n\n      defineRoute({\n        method: \"POST\",\n        path: \"/uploads/:uploadId/progress\",\n        inputSchema: progressSchema,\n        outputSchema: z.object({\n          bytesUploaded: z.number(),\n          partsUploaded: z.number(),\n        }),\n        errorCodes,\n        handler: async function ({ pathParams, input }, { json, error }) {\n          const payload = await input.valid();\n          try {\n            const result = await this.handlerTx()\n              .withServiceCalls(() => [services.recordUploadProgress(pathParams.uploadId, payload)])\n              .transform(({ serviceResult: [updated] }) => updated)\n              .execute();\n\n            return json({\n              bytesUploaded: Number(result.bytesUploaded),\n              partsUploaded: result.partsUploaded,\n            });\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n\n      defineRoute({\n        method: \"POST\",\n        path: \"/uploads/:uploadId/parts\",\n        inputSchema: partNumbersSchema,\n        outputSchema: z.object({\n          parts: z.array(\n            z.object({\n              partNumber: z.number(),\n              url: z.string(),\n              headers: z.record(z.string(), z.string()).optional(),\n            }),\n          ),\n        }),\n        errorCodes,\n        handler: async function ({ pathParams, input }, { json, error }) {\n          const payload = await input.valid();\n          const resolvedConfig = getResolvedConfig();\n          try {\n            const upload = await this.handlerTx()\n              .withServiceCalls(() => [services.getUploadStorageInfo(pathParams.uploadId)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            if (upload.strategy !== \"direct-multipart\") {\n              return error({ message: \"Upload invalid state\", code: \"UPLOAD_INVALID_STATE\" }, 409);\n            }\n\n            if (!resolvedConfig.storage.getPartUploadUrls) {\n              return error({ message: \"Storage error\", code: \"STORAGE_ERROR\" }, 502);\n            }\n\n            const parts = await resolvedConfig.storage.getPartUploadUrls({\n              storageKey: upload.storageKey,\n              storageUploadId: upload.storageUploadId ?? \"\",\n              partNumbers: payload.partNumbers,\n              partSizeBytes: upload.partSizeBytes ?? 0,\n            });\n\n            return json({ parts });\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n\n      defineRoute({\n        method: \"GET\",\n        path: \"/uploads/:uploadId/parts\",\n        outputSchema: z.object({\n          parts: z.array(\n            z.object({\n              partNumber: z.number(),\n              etag: z.string(),\n              sizeBytes: z.number(),\n              createdAt: z.date(),\n            }),\n          ),\n        }),\n        errorCodes,\n        handler: async function ({ pathParams }, { json, error }) {\n          try {\n            const parts = await this.handlerTx()\n              .withServiceCalls(() => [services.getUploadParts(pathParams.uploadId)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            const typedParts = parts as {\n              partNumber: number;\n              etag: string;\n              sizeBytes: bigint;\n              createdAt: Date;\n            }[];\n\n            return json({\n              parts: typedParts.map((part) => ({\n                partNumber: part.partNumber,\n                etag: part.etag,\n                sizeBytes: Number(part.sizeBytes),\n                createdAt: part.createdAt,\n              })),\n            });\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n\n      defineRoute({\n        method: \"POST\",\n        path: \"/uploads/:uploadId/parts/complete\",\n        inputSchema: completePartsSchema,\n        outputSchema: z.object({\n          bytesUploaded: z.number(),\n          partsUploaded: z.number(),\n        }),\n        errorCodes,\n        handler: async function ({ pathParams, input }, { json, error }) {\n          const payload = await input.valid();\n          try {\n            const result = await this.handlerTx()\n              .withServiceCalls(() => [services.recordUploadParts(pathParams.uploadId, payload)])\n              .transform(({ serviceResult: [updated] }) => updated)\n              .execute();\n\n            return json({\n              bytesUploaded: Number(result.bytesUploaded),\n              partsUploaded: result.partsUploaded,\n            });\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n\n      defineRoute({\n        method: \"POST\",\n        path: \"/uploads/:uploadId/complete\",\n        inputSchema: completeUploadSchema,\n        outputSchema: fileMetadataSchema,\n        errorCodes,\n        handler: async function ({ pathParams, input }, { json, error }) {\n          const payload = await input.valid();\n          const resolvedConfig = getResolvedConfig();\n          try {\n            const upload = await this.handlerTx()\n              .withServiceCalls(() => [services.getUploadStorageInfo(pathParams.uploadId)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            const existingFile = await this.handlerTx()\n              .withServiceCalls(() => [services.findFileByKey(upload.fileKey)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            if (existingFile) {\n              return error({ message: \"File already exists\", code: \"FILE_ALREADY_EXISTS\" }, 409);\n            }\n\n            let finalizeResult: { sizeBytes?: bigint } | undefined;\n\n            if (upload.strategy === \"direct-multipart\") {\n              if (!resolvedConfig.storage.completeMultipartUpload) {\n                return error({ message: \"Storage error\", code: \"STORAGE_ERROR\" }, 502);\n              }\n\n              if (!payload.parts || payload.parts.length === 0) {\n                return error(\n                  { message: \"Upload invalid state\", code: \"UPLOAD_INVALID_STATE\" },\n                  409,\n                );\n              }\n\n              await resolvedConfig.storage.completeMultipartUpload({\n                storageKey: upload.storageKey,\n                storageUploadId: upload.storageUploadId ?? \"\",\n                parts: payload.parts,\n              });\n            } else if (resolvedConfig.storage.finalizeUpload) {\n              finalizeResult = await resolvedConfig.storage.finalizeUpload({\n                storageKey: upload.storageKey,\n                expectedSizeBytes: upload.expectedSizeBytes,\n                checksum: upload.checksum as UploadChecksum | null,\n              });\n            }\n\n            const completed = await this.handlerTx()\n              .withServiceCalls(() => [\n                services.markUploadComplete(\n                  upload.id.toString(),\n                  upload.fileKey,\n                  finalizeResult?.sizeBytes ? { sizeBytes: finalizeResult.sizeBytes } : undefined,\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: \"POST\",\n        path: \"/uploads/:uploadId/abort\",\n        outputSchema: z.object({ ok: z.literal(true) }),\n        errorCodes,\n        handler: async function ({ pathParams }, { json, error }) {\n          const resolvedConfig = getResolvedConfig();\n          try {\n            const upload = await this.handlerTx()\n              .withServiceCalls(() => [services.getUploadStorageInfo(pathParams.uploadId)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            if (\n              upload.strategy === \"direct-multipart\" &&\n              resolvedConfig.storage.abortMultipartUpload\n            ) {\n              await resolvedConfig.storage.abortMultipartUpload({\n                storageKey: upload.storageKey,\n                storageUploadId: upload.storageUploadId ?? \"\",\n              });\n            }\n\n            await this.handlerTx()\n              .withServiceCalls(() => [services.markUploadAborted(upload.id.toString())])\n              .execute();\n\n            return json({ ok: true });\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n\n      defineRoute({\n        method: \"PUT\",\n        path: \"/uploads/:uploadId/content\",\n        contentType: \"application/octet-stream\",\n        outputSchema: fileMetadataSchema,\n        errorCodes,\n        handler: async function (context, { json, error }) {\n          const { pathParams } = context;\n          const resolvedConfig = getResolvedConfig();\n          try {\n            const upload = await this.handlerTx()\n              .withServiceCalls(() => [services.getUploadStorageInfo(pathParams.uploadId)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            if (upload.strategy !== \"proxy\") {\n              return error({ message: \"Upload invalid state\", code: \"UPLOAD_INVALID_STATE\" }, 409);\n            }\n\n            const existingFile = await this.handlerTx()\n              .withServiceCalls(() => [services.findFileByKey(upload.fileKey)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            if (existingFile) {\n              return error({ message: \"File already exists\", code: \"FILE_ALREADY_EXISTS\" }, 409);\n            }\n\n            if (!resolvedConfig.storage.writeStream) {\n              return error({ message: \"Storage error\", code: \"STORAGE_ERROR\" }, 502);\n            }\n\n            let result: Awaited<ReturnType<NonNullable<typeof resolvedConfig.storage.writeStream>>>;\n            try {\n              result = await resolvedConfig.storage.writeStream({\n                storageKey: upload.storageKey,\n                body: context.bodyStream(),\n                contentType: upload.contentType,\n                sizeBytes: upload.expectedSizeBytes,\n              });\n            } catch {\n              await this.handlerTx()\n                .withServiceCalls(() => [\n                  services.markUploadFailed(\n                    upload.id.toString(),\n                    \"STORAGE_ERROR\",\n                    \"Storage upload failed\",\n                  ),\n                ])\n                .execute();\n              return error({ message: \"Storage error\", code: \"STORAGE_ERROR\" }, 502);\n            }\n\n            const completed = await this.handlerTx()\n              .withServiceCalls(() => [\n                services.markUploadComplete(\n                  upload.id.toString(),\n                  upload.fileKey,\n                  result?.sizeBytes ? { sizeBytes: result.sizeBytes } : undefined,\n                ),\n              ])\n              .transform(({ serviceResult: [done] }) => done)\n              .execute();\n\n            return json(toFileMetadata(completed.file));\n          } catch (err) {\n            return handleServiceError(err, error);\n          }\n        },\n      }),\n    ];\n  },\n);\n"],"mappings":"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"}