@fragno-dev/upload 0.1.1 → 0.1.3

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

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/routes/index.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/node/routes/shared.js

@@ -1,13 +1,12 @@
 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 providerNamespaceSchema = z.string().trim().min(1).refine((value) => value !== "." && value !== ".." && !value.includes("/") && !value.includes("\\"), { message: "Invalid provider" });
 const visibilitySchema = z.enum([
 	"private",
 	"public",
@@ -15,7 +14,6 @@ const visibilitySchema = z.enum([
 ]);
 const fileMetadataSchema = z.object({
 	fileKey: z.string(),
-	fileKeyParts: fileKeyPartsSchema,
 	uploaderId: z.string().nullable(),
 	filename: z.string(),
 	sizeBytes: z.number(),
@@ -28,7 +26,7 @@ const fileMetadataSchema = z.object({
 	tags: z.array(z.string()).nullable(),
 	metadata: z.record(z.string(), z.unknown()).nullable(),
 	status: z.enum(["ready", "deleted"]),
-	storageProvider: z.string(),
+	provider: providerNamespaceSchema,
 	createdAt: z.string(),
 	updatedAt: z.string(),
 	completedAt: z.string().nullable(),
@@ -37,11 +35,9 @@ const fileMetadataSchema = z.object({
 	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,
+		fileKey: file.key,
 		uploaderId: file.uploaderId,
 		filename: file.filename,
 		sizeBytes: Number(file.sizeBytes),
@@ -51,7 +47,7 @@ const toFileMetadata = (file) => {
 		tags: file.tags,
 		metadata: file.metadata,
 		status: file.status,
-		storageProvider: file.storageProvider,
+		provider: file.provider,
 		createdAt: file.createdAt.toISOString(),
 		updatedAt: file.updatedAt.toISOString(),
 		completedAt: toIsoString(file.completedAt),
@@ -62,5 +58,5 @@ const toFileMetadata = (file) => {
 };
 
 //#endregion
-export { checksumSchema, fileKeyPartsSchema, fileMetadataSchema, toFileMetadata, visibilitySchema };
+export { checksumSchema, fileMetadataSchema, providerNamespaceSchema, toFileMetadata, visibilitySchema };
 //# sourceMappingURL=shared.js.map

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

@@ -1 +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"}
+{"version":3,"file":"shared.js","names":[],"sources":["../../../src/routes/shared.ts"],"sourcesContent":["import type { TableToColumnValues } from \"@fragno-dev/db/query\";\nimport { z } from \"zod\";\n\nimport { uploadSchema } from \"../schema\";\nimport type { FileMetadata } from \"../types\";\n\ntype FileRow = TableToColumnValues<typeof uploadSchema.tables.file>;\ntype FileMetadataSource = Omit<FileRow, \"id\"> & { id?: unknown };\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 providerNamespaceSchema = z\n  .string()\n  .trim()\n  .min(1)\n  .refine(\n    (value) => value !== \".\" && value !== \"..\" && !value.includes(\"/\") && !value.includes(\"\\\\\"),\n    {\n      message: \"Invalid provider\",\n    },\n  );\n\nexport const visibilitySchema = z.enum([\"private\", \"public\", \"unlisted\"]);\n\nexport const fileMetadataSchema = z.object({\n  fileKey: z.string(),\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  provider: providerNamespaceSchema,\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: FileMetadataSource): FileMetadata => {\n  const toIsoString = (value: Date | null | undefined) => (value ? value.toISOString() : null);\n\n  return {\n    fileKey: file.key,\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    provider: file.provider,\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":";;;;AASA,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,0BAA0B,EACpC,QAAQ,CACR,MAAM,CACN,IAAI,EAAE,CACN,QACE,UAAU,UAAU,OAAO,UAAU,QAAQ,CAAC,MAAM,SAAS,IAAI,IAAI,CAAC,MAAM,SAAS,KAAK,EAC3F,EACE,SAAS,oBACV,CACF;AAEH,MAAa,mBAAmB,EAAE,KAAK;CAAC;CAAW;CAAU;CAAW,CAAC;AAEzE,MAAa,qBAAqB,EAAE,OAAO;CACzC,SAAS,EAAE,QAAQ;CACnB,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,UAAU;CACV,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,SAA2C;CACxE,MAAM,eAAe,UAAoC,QAAQ,MAAM,aAAa,GAAG;AAEvF,QAAO;EACL,SAAS,KAAK;EACd,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,UAAU,KAAK;EACf,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

@@ -1,7 +1,9 @@
 import { resolveUploadFragmentConfig } from "../config.js";
 import { resolveFileKeyInput } from "../services/helpers.js";
+import { buildUploadSessionRouteData } from "../services/uploads.js";
 import { uploadFragmentDefinition } from "../definition.js";
-import { checksumSchema, fileKeyPartsSchema, fileMetadataSchema, toFileMetadata } from "./shared.js";
+import { buildStorageObjectVersionSegment } from "../storage/object-key.js";
+import { checksumSchema, fileMetadataSchema, providerNamespaceSchema, toFileMetadata } from "./shared.js";
 import { defineRoutes } from "@fragno-dev/core";
 import { z } from "zod";
 
@@ -12,8 +14,10 @@ const uploadStrategySchema = z.enum([
 	"proxy"
 ]);
 const safeIntSchema = z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+const legacyFileKeyPartsSchema = z.array(z.union([z.string(), z.number().int()]));
 const createUploadInputSchema = z.object({
-	keyParts: fileKeyPartsSchema.optional(),
+	provider: providerNamespaceSchema.optional(),
+	keyParts: legacyFileKeyPartsSchema.optional(),
 	fileKey: z.string().optional(),
 	filename: z.string().min(1),
 	sizeBytes: safeIntSchema,
@@ -42,7 +46,32 @@ 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({
+const uploadRouteDataSchema = z.object({
+	provider: z.string(),
+	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(),
+		statusEndpoint: z.string(),
+		progressEndpoint: z.string(),
+		partsEndpoint: z.string().optional(),
+		partsCompleteEndpoint: z.string().optional(),
+		completeEndpoint: z.string(),
+		abortEndpoint: z.string(),
+		contentEndpoint: z.string().optional()
+	})
+});
+const createUploadOutputSchema = uploadRouteDataSchema.extend({
+	uploadId: z.string(),
+	fileKey: z.string(),
+	status: z.enum(["created", "in_progress"]),
+	strategy: uploadStrategySchema,
+	expiresAt: z.date()
+});
+const uploadStatusSchema = uploadRouteDataSchema.extend({
 	uploadId: z.string(),
 	fileKey: z.string(),
 	status: z.enum([
@@ -72,11 +101,35 @@ const errorCodes = [
 	"FILE_ALREADY_EXISTS",
 	"UPLOAD_EXPIRED",
 	"UPLOAD_INVALID_STATE",
+	"PROVIDER_MISMATCH",
 	"INVALID_FILE_KEY",
 	"INVALID_CHECKSUM",
 	"INVALID_REQUEST",
 	"STORAGE_ERROR"
 ];
+const rejectInactiveUpload = (upload, error) => {
+	const now = Date.now();
+	if (upload.status === "completed") return error({
+		message: "File already exists",
+		code: "FILE_ALREADY_EXISTS"
+	}, 409);
+	if (upload.status === "expired" || upload.expiresAt.getTime() <= now) return error({
+		message: "Upload expired",
+		code: "UPLOAD_EXPIRED"
+	}, 410);
+	if (upload.status === "aborted" || upload.status === "failed") return error({
+		message: "Upload invalid state",
+		code: "UPLOAD_INVALID_STATE"
+	}, 409);
+	return null;
+};
+const rejectProviderMismatch = (upload, activeProvider, error) => {
+	if (upload.provider === activeProvider) return null;
+	return error({
+		message: "Upload provider mismatch",
+		code: "PROVIDER_MISMATCH"
+	}, 409);
+};
 const handleServiceError = (err, error) => {
 	if (!(err instanceof Error)) throw err;
 	switch (err.message) {
@@ -104,6 +157,10 @@ const handleServiceError = (err, error) => {
 			message: "Upload invalid state",
 			code: "UPLOAD_INVALID_STATE"
 		}, 409);
+		case "PROVIDER_MISMATCH": return error({
+			message: "Upload provider mismatch",
+			code: "PROVIDER_MISMATCH"
+		}, 409);
 		case "INVALID_FILE_KEY": return error({
 			message: "Invalid file key",
 			code: "INVALID_FILE_KEY"
@@ -130,28 +187,12 @@ const uploadRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ ser
 			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()
-				})
-			}),
+			outputSchema: createUploadOutputSchema,
 			errorCodes,
 			handler: async function({ input }, { json, error }) {
 				const payload = await input.valid();
 				const resolvedConfig = getResolvedConfig();
+				const provider = payload.provider ?? resolvedConfig.storage.name;
 				let resolvedKey;
 				try {
 					resolvedKey = resolveFileKeyInput({
@@ -161,21 +202,17 @@ const uploadRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ ser
 				} 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);
-				}
+				const objectKeyVersionSegment = buildStorageObjectVersionSegment();
 				let storageInit;
 				try {
 					storageInit = await resolvedConfig.storage.initUpload({
+						provider,
 						fileKey: resolvedKey.fileKey,
-						fileKeyParts: resolvedKey.fileKeyParts,
 						sizeBytes: BigInt(payload.sizeBytes),
 						contentType: payload.contentType,
 						checksum: payload.checksum ?? null,
-						metadata: payload.metadata ?? null
+						metadata: payload.metadata ?? null,
+						objectKeyVersionSegment
 					});
 				} catch (err) {
 					if (err instanceof Error && err.message === "INVALID_CHECKSUM") return error({
@@ -190,6 +227,7 @@ const uploadRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ ser
 				try {
 					const result = await this.handlerTx().withServiceCalls(() => [services.createUploadRecord({
 						...payload,
+						provider,
 						storageInit,
 						allowIdempotentReuse: true
 					})]).transform(({ serviceResult: [created] }) => created).execute();
@@ -217,11 +255,21 @@ const uploadRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ ser
 			outputSchema: uploadStatusSchema,
 			errorCodes,
 			handler: async function({ pathParams }, { json, error }) {
+				const resolvedConfig = getResolvedConfig();
 				try {
 					const upload = await this.handlerTx().withServiceCalls(() => [services.getUploadStatus(pathParams.uploadId)]).transform(({ serviceResult: [result] }) => result).execute();
+					const uploadHeaders = upload.uploadHeaders;
 					return json({
 						uploadId: upload.id.toString(),
-						fileKey: upload.fileKey,
+						fileKey: upload.key,
+						...buildUploadSessionRouteData(resolvedConfig.storage, {
+							uploadId: upload.id.toString(),
+							provider: upload.provider,
+							strategy: upload.strategy,
+							uploadUrl: upload.uploadUrl ?? void 0,
+							uploadHeaders: uploadHeaders ?? void 0,
+							partSizeBytes: upload.partSizeBytes ?? void 0
+						}),
 						status: upload.status,
 						strategy: upload.strategy,
 						expectedSizeBytes: Number(upload.expectedSizeBytes),
@@ -277,6 +325,8 @@ const uploadRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ ser
 				const resolvedConfig = getResolvedConfig();
 				try {
 					const upload = await this.handlerTx().withServiceCalls(() => [services.getUploadStorageInfo(pathParams.uploadId)]).transform(({ serviceResult: [result] }) => result).execute();
+					const providerMismatch = rejectProviderMismatch(upload, resolvedConfig.storage.name, error);
+					if (providerMismatch) return providerMismatch;
 					if (upload.strategy !== "direct-multipart") return error({
 						message: "Upload invalid state",
 						code: "UPLOAD_INVALID_STATE"
@@ -286,7 +336,7 @@ const uploadRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ ser
 						code: "STORAGE_ERROR"
 					}, 502);
 					return json({ parts: await resolvedConfig.storage.getPartUploadUrls({
-						storageKey: upload.storageKey,
+						storageKey: upload.objectKey,
 						storageUploadId: upload.storageUploadId ?? "",
 						partNumbers: payload.partNumbers,
 						partSizeBytes: upload.partSizeBytes ?? 0
@@ -352,10 +402,13 @@ const uploadRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ ser
 				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);
+					const providerMismatch = rejectProviderMismatch(upload, resolvedConfig.storage.name, error);
+					if (providerMismatch) return providerMismatch;
+					const inactiveResponse = rejectInactiveUpload({
+						status: upload.status,
+						expiresAt: upload.expiresAt
+					}, error);
+					if (inactiveResponse) return inactiveResponse;
 					let finalizeResult;
 					if (upload.strategy === "direct-multipart") {
 						if (!resolvedConfig.storage.completeMultipartUpload) return error({
@@ -367,16 +420,16 @@ const uploadRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ ser
 							code: "UPLOAD_INVALID_STATE"
 						}, 409);
 						await resolvedConfig.storage.completeMultipartUpload({
-							storageKey: upload.storageKey,
+							storageKey: upload.objectKey,
 							storageUploadId: upload.storageUploadId ?? "",
 							parts: payload.parts
 						});
 					} else if (resolvedConfig.storage.finalizeUpload) finalizeResult = await resolvedConfig.storage.finalizeUpload({
-						storageKey: upload.storageKey,
+						storageKey: upload.objectKey,
 						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));
+					return json(toFileMetadata((await this.handlerTx().withServiceCalls(() => [services.markUploadCompleteFromSnapshot(upload, finalizeResult?.sizeBytes ? { sizeBytes: finalizeResult.sizeBytes } : void 0)]).transform(({ serviceResult: [result] }) => result).execute()).file));
 				} catch (err) {
 					return handleServiceError(err, error);
 				}
@@ -391,11 +444,13 @@ const uploadRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ ser
 				const resolvedConfig = getResolvedConfig();
 				try {
 					const upload = await this.handlerTx().withServiceCalls(() => [services.getUploadStorageInfo(pathParams.uploadId)]).transform(({ serviceResult: [result] }) => result).execute();
+					const providerMismatch = rejectProviderMismatch(upload, resolvedConfig.storage.name, error);
+					if (providerMismatch) return providerMismatch;
 					if (upload.strategy === "direct-multipart" && resolvedConfig.storage.abortMultipartUpload) await resolvedConfig.storage.abortMultipartUpload({
-						storageKey: upload.storageKey,
+						storageKey: upload.objectKey,
 						storageUploadId: upload.storageUploadId ?? ""
 					});
-					await this.handlerTx().withServiceCalls(() => [services.markUploadAborted(upload.id.toString())]).execute();
+					await this.handlerTx().withServiceCalls(() => [services.markUploadAbortedFromSnapshot(upload)]).execute();
 					return json({ ok: true });
 				} catch (err) {
 					return handleServiceError(err, error);
@@ -413,14 +468,17 @@ const uploadRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ ser
 				const resolvedConfig = getResolvedConfig();
 				try {
 					const upload = await this.handlerTx().withServiceCalls(() => [services.getUploadStorageInfo(pathParams.uploadId)]).transform(({ serviceResult: [result$1] }) => result$1).execute();
+					const providerMismatch = rejectProviderMismatch(upload, resolvedConfig.storage.name, error);
+					if (providerMismatch) return providerMismatch;
 					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);
+					const inactiveResponse = rejectInactiveUpload({
+						status: upload.status,
+						expiresAt: upload.expiresAt
+					}, error);
+					if (inactiveResponse) return inactiveResponse;
 					if (!resolvedConfig.storage.writeStream) return error({
 						message: "Storage error",
 						code: "STORAGE_ERROR"
@@ -428,19 +486,19 @@ const uploadRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ ser
 					let result;
 					try {
 						result = await resolvedConfig.storage.writeStream({
-							storageKey: upload.storageKey,
+							storageKey: upload.objectKey,
 							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();
+						await this.handlerTx().withServiceCalls(() => [services.markUploadFailedFromSnapshot(upload, "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));
+					return json(toFileMetadata((await this.handlerTx().withServiceCalls(() => [services.markUploadCompleteFromSnapshot(upload, result?.sizeBytes ? { sizeBytes: result.sizeBytes } : void 0)]).transform(({ serviceResult: [done] }) => done).execute()).file));
 				} catch (err) {
 					return handleServiceError(err, error);
 				}

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

@@ -1 +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":";;;;;;;;AAUA,MAAM,uBAAuB,EAAE,KAAK;CAAC;CAAiB;CAAoB;CAAQ,CAAC;AACnF,MAAM,gBAAgB,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,OAAO,iBAAiB;AAE1E,MAAM,0BAA0B,EAAE,OAAO;CACvC,UAAU,mBAAmB,UAAU;CACvC,SAAS,EAAE,QAAQ,CAAC,UAAU;CAC9B,UAAU,EAAE,QAAQ,CAAC,IAAI,EAAE;CAC3B,WAAW;CACX,aAAa,EAAE,QAAQ,CAAC,IAAI,EAAE;CAC9B,UAAU,eAAe,UAAU;CACnC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,UAAU;CACpC,YAAY,EAAE,KAAK;EAAC;EAAW;EAAU;EAAW,CAAC,CAAC,UAAU;CAChE,YAAY,EAAE,QAAQ,CAAC,UAAU;CACjC,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,CAAC,UAAU;CACvD,CAAC;AAEF,MAAM,iBAAiB,EAAE,OAAO;CAC9B,eAAe,cAAc,UAAU;CACvC,eAAe,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,UAAU;CAClD,CAAC;AAEF,MAAM,oBAAoB,EAAE,OAAO,EACjC,aAAa,EAAE,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,EACrD,CAAC;AAEF,MAAM,sBAAsB,EAAE,OAAO,EACnC,OAAO,EACJ,MACC,EAAE,OAAO;CACP,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE;CACnC,MAAM,EAAE,QAAQ,CAAC,IAAI,EAAE;CACvB,WAAW;CACZ,CAAC,CACH,CACA,IAAI,EAAE,EACV,CAAC;AAEF,MAAM,uBAAuB,EAAE,OAAO,EACpC,OAAO,EACJ,MACC,EAAE,OAAO;CACP,YAAY,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE;CACnC,MAAM,EAAE,QAAQ,CAAC,IAAI,EAAE;CACxB,CAAC,CACH,CACA,UAAU,EACd,CAAC;AAEF,MAAM,qBAAqB,EAAE,OAAO;CAClC,UAAU,EAAE,QAAQ;CACpB,SAAS,EAAE,QAAQ;CACnB,QAAQ,EAAE,KAAK;EAAC;EAAW;EAAe;EAAa;EAAW;EAAU;EAAU,CAAC;CACvF,UAAU;CACV,mBAAmB,EAAE,QAAQ;CAC7B,eAAe,EAAE,QAAQ;CACzB,eAAe,EAAE,QAAQ;CACzB,eAAe,EAAE,QAAQ,CAAC,UAAU;CACpC,WAAW,EAAE,MAAM;CACnB,WAAW,EAAE,MAAM;CACnB,WAAW,EAAE,MAAM;CACnB,aAAa,EAAE,MAAM,CAAC,UAAU;CAChC,WAAW,EAAE,QAAQ,CAAC,UAAU;CAChC,cAAc,EAAE,QAAQ,CAAC,UAAU;CACpC,CAAC;AAEF,MAAM,aAAa;CACjB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD;AAQD,MAAM,sBACJ,KACA,UACa;AACb,KAAI,EAAE,eAAe,OACnB,OAAM;AAGR,SAAQ,IAAI,SAAZ;EACE,KAAK,mBACH,QAAO,MAAM;GAAE,SAAS;GAAoB,MAAM;GAA4B,EAAE,IAAI;EACtF,KAAK,sBACH,QAAO,MAAM;GAAE,SAAS;GAAuB,MAAM;GAA+B,EAAE,IAAI;EAC5F,KAAK,wBACH,QAAO,MACL;GAAE,SAAS;GAAyB,MAAM;GAAiC,EAC3E,IACD;EACH,KAAK,2BACH,QAAO,MACL;GAAE,SAAS;GAA4B,MAAM;GAAoC,EACjF,IACD;EACH,KAAK,iBACH,QAAO,MAAM;GAAE,SAAS;GAAkB,MAAM;GAA0B,EAAE,IAAI;EAClF,KAAK,uBACH,QAAO,MAAM;GAAE,SAAS;GAAwB,MAAM;GAAgC,EAAE,IAAI;EAC9F,KAAK,mBACH,QAAO,MAAM;GAAE,SAAS;GAAoB,MAAM;GAA4B,EAAE,IAAI;EACtF,KAAK,mBACH,QAAO,MAAM;GAAE,SAAS;GAAoB,MAAM;GAA4B,EAAE,IAAI;EACtF,KAAK,kBACH,QAAO,MAAM;GAAE,SAAS;GAAmB,MAAM;GAA2B,EAAE,IAAI;EACpF,KAAK,gBACH,QAAO,MAAM;GAAE,SAAS;GAAiB,MAAM;GAAyB,EAAE,IAAI;EAChF,QACE,OAAM;;;AAIZ,MAAa,sBAAsB,aAAa,yBAAyB,CAAC,QACvE,EAAE,UAAU,aAAa,aAAa;CACrC,MAAM,0BAA0B,4BAA4B,OAAO;AAEnE,QAAO;EACL,YAAY;GACV,QAAQ;GACR,MAAM;GACN,aAAa;GACb,cAAc,EAAE,OAAO;IACrB,UAAU,EAAE,QAAQ;IACpB,SAAS,EAAE,QAAQ;IACnB,QAAQ,EAAE,KAAK,CAAC,WAAW,cAAc,CAAC;IAC1C,UAAU;IACV,WAAW,EAAE,MAAM;IACnB,QAAQ,EAAE,OAAO;KACf,MAAM,EAAE,KAAK,CAAC,UAAU,YAAY,CAAC;KACrC,WAAW,EAAE,KAAK,CAAC,UAAU,QAAQ,CAAC;KACtC,WAAW,EAAE,QAAQ,CAAC,UAAU;KAChC,eAAe,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,QAAQ,CAAC,CAAC,UAAU;KAC1D,eAAe,EAAE,QAAQ,CAAC,UAAU;KACpC,UAAU,EAAE,QAAQ,CAAC,UAAU;KAC/B,eAAe,EAAE,QAAQ,CAAC,UAAU;KACpC,kBAAkB,EAAE,QAAQ;KAC5B,iBAAiB,EAAE,QAAQ,CAAC,UAAU;KACvC,CAAC;IACH,CAAC;GACF;GACA,SAAS,eAAgB,EAAE,SAAS,EAAE,MAAM,SAAS;IACnD,MAAM,UAAU,MAAM,MAAM,OAAO;IACnC,MAAM,iBAAiB,mBAAmB;IAE1C,IAAI;AACJ,QAAI;AACF,mBAAc,oBAAoB;MAChC,UAAU,QAAQ;MAClB,SAAS,QAAQ;MAClB,CAAC;aACK,KAAK;AACZ,YAAO,mBAAmB,KAAK,MAAM;;AAGvC,QAAI;KACF,MAAM,WAAW,MAAM,KAAK,WAAW,CACpC,uBAAuB,CACtB,SAAS,wBAAwB,SAAS,EAAE,sBAAsB,MAAM,CAAC,CAC1E,CAAC,CACD,WAAW,EAAE,eAAe,CAAC,cAAc,OAAO,CAClD,SAAS;AAEZ,SAAI,SACF,QAAO,KAAK,SAAS;aAEhB,KAAK;AACZ,YAAO,mBAAmB,KAAK,MAAM;;IAGvC,IAAI;AACJ,QAAI;AACF,mBAAc,MAAM,eAAe,QAAQ,WAAW;MACpD,SAAS,YAAY;MACrB,cAAc,YAAY;MAC1B,WAAW,OAAO,QAAQ,UAAU;MACpC,aAAa,QAAQ;MACrB,UAAU,QAAQ,YAAY;MAC9B,UAAU,QAAQ,YAAY;MAC/B,CAAC;aACK,KAAK;AACZ,SAAI,eAAe,SAAS,IAAI,YAAY,mBAC1C,QAAO,MAAM;MAAE,SAAS;MAAoB,MAAM;MAAoB,EAAE,IAAI;AAE9E,YAAO,MAAM;MAAE,SAAS;MAAiB,MAAM;MAAiB,EAAE,IAAI;;AAGxE,QAAI;KACF,MAAM,SAAS,MAAM,KAAK,WAAW,CAClC,uBAAuB,CACtB,SAAS,mBAAmB;MAC1B,GAAG;MACH;MACA,sBAAsB;MACvB,CAAC,CACH,CAAC,CACD,WAAW,EAAE,eAAe,CAAC,eAAe,QAAQ,CACpD,SAAS;AAEZ,SACE,OAAO,UACP,YAAY,aAAa,sBACzB,eAAe,QAAQ,wBACvB,YAAY,gBAEZ,KAAI;AACF,YAAM,eAAe,QAAQ,qBAAqB;OAChD,YAAY,YAAY;OACxB,iBAAiB,YAAY;OAC9B,CAAC;aACI;AAKV,YAAO,KAAK,OAAO,OAAO;aACnB,KAAK;AACZ,SACE,YAAY,aAAa,sBACzB,eAAe,QAAQ,wBACvB,YAAY,gBAEZ,KAAI;AACF,YAAM,eAAe,QAAQ,qBAAqB;OAChD,YAAY,YAAY;OACxB,iBAAiB,YAAY;OAC9B,CAAC;aACI;AAIV,YAAO,mBAAmB,KAAK,MAAM;;;GAG1C,CAAC;EAEF,YAAY;GACV,QAAQ;GACR,MAAM;GACN,cAAc;GACd;GACA,SAAS,eAAgB,EAAE,cAAc,EAAE,MAAM,SAAS;AACxD,QAAI;KACF,MAAM,SAAS,MAAM,KAAK,WAAW,CAClC,uBAAuB,CAAC,SAAS,gBAAgB,WAAW,SAAS,CAAC,CAAC,CACvE,WAAW,EAAE,eAAe,CAAC,cAAc,OAAO,CAClD,SAAS;AAEZ,YAAO,KAAK;MACV,UAAU,OAAO,GAAG,UAAU;MAC9B,SAAS,OAAO;MAChB,QAAQ,OAAO;MACf,UAAU,OAAO;MACjB,mBAAmB,OAAO,OAAO,kBAAkB;MACnD,eAAe,OAAO,OAAO,cAAc;MAC3C,eAAe,OAAO;MACtB,eAAe,OAAO;MACtB,WAAW,OAAO;MAClB,WAAW,OAAO;MAClB,WAAW,OAAO;MAClB,aAAa,OAAO;MACpB,WAAW,OAAO;MAClB,cAAc,OAAO;MACtB,CAAC;aACK,KAAK;AACZ,YAAO,mBAAmB,KAAK,MAAM;;;GAG1C,CAAC;EAEF,YAAY;GACV,QAAQ;GACR,MAAM;GACN,aAAa;GACb,cAAc,EAAE,OAAO;IACrB,eAAe,EAAE,QAAQ;IACzB,eAAe,EAAE,QAAQ;IAC1B,CAAC;GACF;GACA,SAAS,eAAgB,EAAE,YAAY,SAAS,EAAE,MAAM,SAAS;IAC/D,MAAM,UAAU,MAAM,MAAM,OAAO;AACnC,QAAI;KACF,MAAM,SAAS,MAAM,KAAK,WAAW,CAClC,uBAAuB,CAAC,SAAS,qBAAqB,WAAW,UAAU,QAAQ,CAAC,CAAC,CACrF,WAAW,EAAE,eAAe,CAAC,eAAe,QAAQ,CACpD,SAAS;AAEZ,YAAO,KAAK;MACV,eAAe,OAAO,OAAO,cAAc;MAC3C,eAAe,OAAO;MACvB,CAAC;aACK,KAAK;AACZ,YAAO,mBAAmB,KAAK,MAAM;;;GAG1C,CAAC;EAEF,YAAY;GACV,QAAQ;GACR,MAAM;GACN,aAAa;GACb,cAAc,EAAE,OAAO,EACrB,OAAO,EAAE,MACP,EAAE,OAAO;IACP,YAAY,EAAE,QAAQ;IACtB,KAAK,EAAE,QAAQ;IACf,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,QAAQ,CAAC,CAAC,UAAU;IACrD,CAAC,CACH,EACF,CAAC;GACF;GACA,SAAS,eAAgB,EAAE,YAAY,SAAS,EAAE,MAAM,SAAS;IAC/D,MAAM,UAAU,MAAM,MAAM,OAAO;IACnC,MAAM,iBAAiB,mBAAmB;AAC1C,QAAI;KACF,MAAM,SAAS,MAAM,KAAK,WAAW,CAClC,uBAAuB,CAAC,SAAS,qBAAqB,WAAW,SAAS,CAAC,CAAC,CAC5E,WAAW,EAAE,eAAe,CAAC,cAAc,OAAO,CAClD,SAAS;AAEZ,SAAI,OAAO,aAAa,mBACtB,QAAO,MAAM;MAAE,SAAS;MAAwB,MAAM;MAAwB,EAAE,IAAI;AAGtF,SAAI,CAAC,eAAe,QAAQ,kBAC1B,QAAO,MAAM;MAAE,SAAS;MAAiB,MAAM;MAAiB,EAAE,IAAI;AAUxE,YAAO,KAAK,EAAE,OAPA,MAAM,eAAe,QAAQ,kBAAkB;MAC3D,YAAY,OAAO;MACnB,iBAAiB,OAAO,mBAAmB;MAC3C,aAAa,QAAQ;MACrB,eAAe,OAAO,iBAAiB;MACxC,CAAC,EAEmB,CAAC;aACf,KAAK;AACZ,YAAO,mBAAmB,KAAK,MAAM;;;GAG1C,CAAC;EAEF,YAAY;GACV,QAAQ;GACR,MAAM;GACN,cAAc,EAAE,OAAO,EACrB,OAAO,EAAE,MACP,EAAE,OAAO;IACP,YAAY,EAAE,QAAQ;IACtB,MAAM,EAAE,QAAQ;IAChB,WAAW,EAAE,QAAQ;IACrB,WAAW,EAAE,MAAM;IACpB,CAAC,CACH,EACF,CAAC;GACF;GACA,SAAS,eAAgB,EAAE,cAAc,EAAE,MAAM,SAAS;AACxD,QAAI;AAaF,YAAO,KAAK,EACV,QAbY,MAAM,KAAK,WAAW,CACjC,uBAAuB,CAAC,SAAS,eAAe,WAAW,SAAS,CAAC,CAAC,CACtE,WAAW,EAAE,eAAe,CAAC,cAAc,OAAO,CAClD,SAAS,EAUQ,KAAK,UAAU;MAC/B,YAAY,KAAK;MACjB,MAAM,KAAK;MACX,WAAW,OAAO,KAAK,UAAU;MACjC,WAAW,KAAK;MACjB,EAAE,EACJ,CAAC;aACK,KAAK;AACZ,YAAO,mBAAmB,KAAK,MAAM;;;GAG1C,CAAC;EAEF,YAAY;GACV,QAAQ;GACR,MAAM;GACN,aAAa;GACb,cAAc,EAAE,OAAO;IACrB,eAAe,EAAE,QAAQ;IACzB,eAAe,EAAE,QAAQ;IAC1B,CAAC;GACF;GACA,SAAS,eAAgB,EAAE,YAAY,SAAS,EAAE,MAAM,SAAS;IAC/D,MAAM,UAAU,MAAM,MAAM,OAAO;AACnC,QAAI;KACF,MAAM,SAAS,MAAM,KAAK,WAAW,CAClC,uBAAuB,CAAC,SAAS,kBAAkB,WAAW,UAAU,QAAQ,CAAC,CAAC,CAClF,WAAW,EAAE,eAAe,CAAC,eAAe,QAAQ,CACpD,SAAS;AAEZ,YAAO,KAAK;MACV,eAAe,OAAO,OAAO,cAAc;MAC3C,eAAe,OAAO;MACvB,CAAC;aACK,KAAK;AACZ,YAAO,mBAAmB,KAAK,MAAM;;;GAG1C,CAAC;EAEF,YAAY;GACV,QAAQ;GACR,MAAM;GACN,aAAa;GACb,cAAc;GACd;GACA,SAAS,eAAgB,EAAE,YAAY,SAAS,EAAE,MAAM,SAAS;IAC/D,MAAM,UAAU,MAAM,MAAM,OAAO;IACnC,MAAM,iBAAiB,mBAAmB;AAC1C,QAAI;KACF,MAAM,SAAS,MAAM,KAAK,WAAW,CAClC,uBAAuB,CAAC,SAAS,qBAAqB,WAAW,SAAS,CAAC,CAAC,CAC5E,WAAW,EAAE,eAAe,CAAC,cAAc,OAAO,CAClD,SAAS;AAOZ,SALqB,MAAM,KAAK,WAAW,CACxC,uBAAuB,CAAC,SAAS,cAAc,OAAO,QAAQ,CAAC,CAAC,CAChE,WAAW,EAAE,eAAe,CAAC,cAAc,OAAO,CAClD,SAAS,CAGV,QAAO,MAAM;MAAE,SAAS;MAAuB,MAAM;MAAuB,EAAE,IAAI;KAGpF,IAAIA;AAEJ,SAAI,OAAO,aAAa,oBAAoB;AAC1C,UAAI,CAAC,eAAe,QAAQ,wBAC1B,QAAO,MAAM;OAAE,SAAS;OAAiB,MAAM;OAAiB,EAAE,IAAI;AAGxE,UAAI,CAAC,QAAQ,SAAS,QAAQ,MAAM,WAAW,EAC7C,QAAO,MACL;OAAE,SAAS;OAAwB,MAAM;OAAwB,EACjE,IACD;AAGH,YAAM,eAAe,QAAQ,wBAAwB;OACnD,YAAY,OAAO;OACnB,iBAAiB,OAAO,mBAAmB;OAC3C,OAAO,QAAQ;OAChB,CAAC;gBACO,eAAe,QAAQ,eAChC,kBAAiB,MAAM,eAAe,QAAQ,eAAe;MAC3D,YAAY,OAAO;MACnB,mBAAmB,OAAO;MAC1B,UAAU,OAAO;MAClB,CAAC;AAcJ,YAAO,KAAK,gBAXM,MAAM,KAAK,WAAW,CACrC,uBAAuB,CACtB,SAAS,mBACP,OAAO,GAAG,UAAU,EACpB,OAAO,SACP,gBAAgB,YAAY,EAAE,WAAW,eAAe,WAAW,GAAG,OACvE,CACF,CAAC,CACD,WAAW,EAAE,eAAe,CAAC,cAAc,OAAO,CAClD,SAAS,EAEyB,KAAK,CAAC;aACpC,KAAK;AACZ,YAAO,mBAAmB,KAAK,MAAM;;;GAG1C,CAAC;EAEF,YAAY;GACV,QAAQ;GACR,MAAM;GACN,cAAc,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,KAAK,EAAE,CAAC;GAC/C;GACA,SAAS,eAAgB,EAAE,cAAc,EAAE,MAAM,SAAS;IACxD,MAAM,iBAAiB,mBAAmB;AAC1C,QAAI;KACF,MAAM,SAAS,MAAM,KAAK,WAAW,CAClC,uBAAuB,CAAC,SAAS,qBAAqB,WAAW,SAAS,CAAC,CAAC,CAC5E,WAAW,EAAE,eAAe,CAAC,cAAc,OAAO,CAClD,SAAS;AAEZ,SACE,OAAO,aAAa,sBACpB,eAAe,QAAQ,qBAEvB,OAAM,eAAe,QAAQ,qBAAqB;MAChD,YAAY,OAAO;MACnB,iBAAiB,OAAO,mBAAmB;MAC5C,CAAC;AAGJ,WAAM,KAAK,WAAW,CACnB,uBAAuB,CAAC,SAAS,kBAAkB,OAAO,GAAG,UAAU,CAAC,CAAC,CAAC,CAC1E,SAAS;AAEZ,YAAO,KAAK,EAAE,IAAI,MAAM,CAAC;aAClB,KAAK;AACZ,YAAO,mBAAmB,KAAK,MAAM;;;GAG1C,CAAC;EAEF,YAAY;GACV,QAAQ;GACR,MAAM;GACN,aAAa;GACb,cAAc;GACd;GACA,SAAS,eAAgB,SAAS,EAAE,MAAM,SAAS;IACjD,MAAM,EAAE,eAAe;IACvB,MAAM,iBAAiB,mBAAmB;AAC1C,QAAI;KACF,MAAM,SAAS,MAAM,KAAK,WAAW,CAClC,uBAAuB,CAAC,SAAS,qBAAqB,WAAW,SAAS,CAAC,CAAC,CAC5E,WAAW,EAAE,eAAe,CAACC,gBAAcA,SAAO,CAClD,SAAS;AAEZ,SAAI,OAAO,aAAa,QACtB,QAAO,MAAM;MAAE,SAAS;MAAwB,MAAM;MAAwB,EAAE,IAAI;AAQtF,SALqB,MAAM,KAAK,WAAW,CACxC,uBAAuB,CAAC,SAAS,cAAc,OAAO,QAAQ,CAAC,CAAC,CAChE,WAAW,EAAE,eAAe,CAACA,gBAAcA,SAAO,CAClD,SAAS,CAGV,QAAO,MAAM;MAAE,SAAS;MAAuB,MAAM;MAAuB,EAAE,IAAI;AAGpF,SAAI,CAAC,eAAe,QAAQ,YAC1B,QAAO,MAAM;MAAE,SAAS;MAAiB,MAAM;MAAiB,EAAE,IAAI;KAGxE,IAAIC;AACJ,SAAI;AACF,eAAS,MAAM,eAAe,QAAQ,YAAY;OAChD,YAAY,OAAO;OACnB,MAAM,QAAQ,YAAY;OAC1B,aAAa,OAAO;OACpB,WAAW,OAAO;OACnB,CAAC;aACI;AACN,YAAM,KAAK,WAAW,CACnB,uBAAuB,CACtB,SAAS,iBACP,OAAO,GAAG,UAAU,EACpB,iBACA,wBACD,CACF,CAAC,CACD,SAAS;AACZ,aAAO,MAAM;OAAE,SAAS;OAAiB,MAAM;OAAiB,EAAE,IAAI;;AAcxE,YAAO,KAAK,gBAXM,MAAM,KAAK,WAAW,CACrC,uBAAuB,CACtB,SAAS,mBACP,OAAO,GAAG,UAAU,EACpB,OAAO,SACP,QAAQ,YAAY,EAAE,WAAW,OAAO,WAAW,GAAG,OACvD,CACF,CAAC,CACD,WAAW,EAAE,eAAe,CAAC,YAAY,KAAK,CAC9C,SAAS,EAEyB,KAAK,CAAC;aACpC,KAAK;AACZ,YAAO,mBAAmB,KAAK,MAAM;;;GAG1C,CAAC;EACH;EAEJ"}
+{"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 { 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 { buildUploadSessionRouteData } from \"../services/uploads\";\nimport { buildStorageObjectVersionSegment } from \"../storage/object-key\";\nimport type { UploadChecksum } from \"../storage/types\";\nimport type { UploadStatus, UploadStrategy } from \"../types\";\nimport {\n  checksumSchema,\n  fileMetadataSchema,\n  providerNamespaceSchema,\n  toFileMetadata,\n} from \"./shared\";\n\nconst uploadStrategySchema = z.enum([\"direct-single\", \"direct-multipart\", \"proxy\"]);\nconst safeIntSchema = z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);\nconst legacyFileKeyPartsSchema = z.array(z.union([z.string(), z.number().int()]));\n\nconst createUploadInputSchema = z.object({\n  provider: providerNamespaceSchema.optional(),\n  keyParts: legacyFileKeyPartsSchema.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 uploadRouteDataSchema = z.object({\n  provider: z.string(),\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    statusEndpoint: z.string(),\n    progressEndpoint: z.string(),\n    partsEndpoint: z.string().optional(),\n    partsCompleteEndpoint: z.string().optional(),\n    completeEndpoint: z.string(),\n    abortEndpoint: z.string(),\n    contentEndpoint: z.string().optional(),\n  }),\n});\n\nconst createUploadOutputSchema = uploadRouteDataSchema.extend({\n  uploadId: z.string(),\n  fileKey: z.string(),\n  status: z.enum([\"created\", \"in_progress\"]),\n  strategy: uploadStrategySchema,\n  expiresAt: z.date(),\n});\n\nconst uploadStatusSchema = uploadRouteDataSchema.extend({\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  \"PROVIDER_MISMATCH\",\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 rejectInactiveUpload = (\n  upload: { status: UploadStatus; expiresAt: Date },\n  error: ErrorFn<UploadErrorCode>,\n): Response | null => {\n  const now = Date.now();\n\n  if (upload.status === \"completed\") {\n    return error({ message: \"File already exists\", code: \"FILE_ALREADY_EXISTS\" }, 409);\n  }\n\n  if (upload.status === \"expired\" || upload.expiresAt.getTime() <= now) {\n    return error({ message: \"Upload expired\", code: \"UPLOAD_EXPIRED\" }, 410);\n  }\n\n  if (upload.status === \"aborted\" || upload.status === \"failed\") {\n    return error({ message: \"Upload invalid state\", code: \"UPLOAD_INVALID_STATE\" }, 409);\n  }\n\n  return null;\n};\n\nconst rejectProviderMismatch = (\n  upload: { provider: string },\n  activeProvider: string,\n  error: ErrorFn<UploadErrorCode>,\n): Response | null => {\n  if (upload.provider === activeProvider) {\n    return null;\n  }\n\n  return error({ message: \"Upload provider mismatch\", code: \"PROVIDER_MISMATCH\" }, 409);\n};\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        {\n          message: \"Upload already active\",\n          code: \"UPLOAD_ALREADY_ACTIVE\" as Code,\n        },\n        409,\n      );\n    case \"UPLOAD_METADATA_MISMATCH\":\n      return error(\n        {\n          message: \"Upload metadata mismatch\",\n          code: \"UPLOAD_METADATA_MISMATCH\" 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 \"PROVIDER_MISMATCH\":\n      return error(\n        {\n          message: \"Upload provider mismatch\",\n          code: \"PROVIDER_MISMATCH\" 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\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: createUploadOutputSchema,\n        errorCodes,\n        handler: async function ({ input }, { json, error }) {\n          const payload = await input.valid();\n          const resolvedConfig = getResolvedConfig();\n          const provider = payload.provider ?? resolvedConfig.storage.name;\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          const objectKeyVersionSegment = buildStorageObjectVersionSegment();\n\n          let storageInit;\n          try {\n            storageInit = await resolvedConfig.storage.initUpload({\n              provider,\n              fileKey: resolvedKey.fileKey,\n              sizeBytes: BigInt(payload.sizeBytes),\n              contentType: payload.contentType,\n              checksum: payload.checksum ?? null,\n              metadata: payload.metadata ?? null,\n              objectKeyVersionSegment,\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                  provider,\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          const resolvedConfig = getResolvedConfig();\n          try {\n            const upload = await this.handlerTx()\n              .withServiceCalls(() => [services.getUploadStatus(pathParams.uploadId)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            const uploadHeaders = upload.uploadHeaders as Record<string, string> | null;\n\n            return json({\n              uploadId: upload.id.toString(),\n              fileKey: upload.key,\n              ...buildUploadSessionRouteData(resolvedConfig.storage, {\n                uploadId: upload.id.toString(),\n                provider: upload.provider,\n                strategy: upload.strategy as UploadStrategy,\n                uploadUrl: upload.uploadUrl ?? undefined,\n                uploadHeaders: uploadHeaders ?? undefined,\n                partSizeBytes: upload.partSizeBytes ?? undefined,\n              }),\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            // Rule of Fragno exception: read -> storage I/O -> mutate.\n            const upload = await this.handlerTx()\n              .withServiceCalls(() => [services.getUploadStorageInfo(pathParams.uploadId)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            const providerMismatch = rejectProviderMismatch(\n              upload,\n              resolvedConfig.storage.name,\n              error,\n            );\n            if (providerMismatch) {\n              return providerMismatch;\n            }\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.objectKey,\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            // Rule of Fragno exception: read -> storage I/O -> mutate.\n            const upload = await this.handlerTx()\n              .withServiceCalls(() => [services.getUploadStorageInfo(pathParams.uploadId)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            const providerMismatch = rejectProviderMismatch(\n              upload,\n              resolvedConfig.storage.name,\n              error,\n            );\n            if (providerMismatch) {\n              return providerMismatch;\n            }\n\n            const inactiveResponse = rejectInactiveUpload(\n              {\n                status: upload.status as UploadStatus,\n                expiresAt: upload.expiresAt,\n              },\n              error,\n            );\n            if (inactiveResponse) {\n              return inactiveResponse;\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                  {\n                    message: \"Upload invalid state\",\n                    code: \"UPLOAD_INVALID_STATE\",\n                  },\n                  409,\n                );\n              }\n\n              await resolvedConfig.storage.completeMultipartUpload({\n                storageKey: upload.objectKey,\n                storageUploadId: upload.storageUploadId ?? \"\",\n                parts: payload.parts,\n              });\n            } else if (resolvedConfig.storage.finalizeUpload) {\n              finalizeResult = await resolvedConfig.storage.finalizeUpload({\n                storageKey: upload.objectKey,\n                expectedSizeBytes: upload.expectedSizeBytes,\n                checksum: upload.checksum as UploadChecksum | null,\n              });\n            }\n\n            const completed = await this.handlerTx()\n              .withServiceCalls(() => [\n                services.markUploadCompleteFromSnapshot(\n                  upload,\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            // Rule of Fragno exception: read -> storage I/O -> mutate.\n            const upload = await this.handlerTx()\n              .withServiceCalls(() => [services.getUploadStorageInfo(pathParams.uploadId)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            const providerMismatch = rejectProviderMismatch(\n              upload,\n              resolvedConfig.storage.name,\n              error,\n            );\n            if (providerMismatch) {\n              return providerMismatch;\n            }\n\n            if (\n              upload.strategy === \"direct-multipart\" &&\n              resolvedConfig.storage.abortMultipartUpload\n            ) {\n              await resolvedConfig.storage.abortMultipartUpload({\n                storageKey: upload.objectKey,\n                storageUploadId: upload.storageUploadId ?? \"\",\n              });\n            }\n\n            await this.handlerTx()\n              .withServiceCalls(() => [services.markUploadAbortedFromSnapshot(upload)])\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            // Rule of Fragno exception: read -> storage I/O -> mutate.\n            const upload = await this.handlerTx()\n              .withServiceCalls(() => [services.getUploadStorageInfo(pathParams.uploadId)])\n              .transform(({ serviceResult: [result] }) => result)\n              .execute();\n\n            const providerMismatch = rejectProviderMismatch(\n              upload,\n              resolvedConfig.storage.name,\n              error,\n            );\n            if (providerMismatch) {\n              return providerMismatch;\n            }\n\n            if (upload.strategy !== \"proxy\") {\n              return error({ message: \"Upload invalid state\", code: \"UPLOAD_INVALID_STATE\" }, 409);\n            }\n\n            const inactiveResponse = rejectInactiveUpload(\n              {\n                status: upload.status as UploadStatus,\n                expiresAt: upload.expiresAt,\n              },\n              error,\n            );\n            if (inactiveResponse) {\n              return inactiveResponse;\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.objectKey,\n                body: context.bodyStream(),\n                contentType: upload.contentType,\n                sizeBytes: upload.expectedSizeBytes,\n              });\n            } catch {\n              await this.handlerTx()\n                .withServiceCalls(() => [\n                  services.markUploadFailedFromSnapshot(\n                    upload,\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.markUploadCompleteFromSnapshot(\n                  upload,\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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"}