@fragno-dev/upload 0.1.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;iBA0CgB,oBAAA,SACN,+BACC,mDAA8B,uDAAA,2CAAA;mEAAA,IAAA,CAAA,SAAA;;;;;;;;;IAFzB,CAAA,CAAA;IAAoB,KAAA,gBAAA;yBAC1B,CAAA,CAAA,CAAA;MACC,kBAAA,cAAA,gBAAA,CAAA;YAA8B,kBAAA,aAAA,CAAA;;;;;;;;YAAA,IAAA,CAAA;;;;;;;;;;;;;;;;;;;;;aAAA,kBAAA,gBAAA;IAAA,aAAA,kBAAA,eAAA,gCAAA,CAAA;;;;;;;;;;;;sEAAA,sBAAA,CAAA;;;;;;;;;;;;;;;;;;;iCAAA,gBAAA;WAAA,cAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAH;;;;;;;;sBAW/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAX+B,QAAA,EAAA,MAAA;;IAW/B,WAAA,EAAA,MAAA"}

package/dist/node/index.js

@@ -0,0 +1,19 @@
+import { resolveUploadFragmentConfig } from "./config.js";
+import { uploadSchema } from "./schema.js";
+import { decodeFileKey, encodeFileKey, encodeFileKeyPrefix } from "./keys.js";
+import { uploadFragmentDefinition } from "./definition.js";
+import { uploadRoutes } from "./routes/index.js";
+import { createUploadFragmentClients } from "./client/clients.js";
+import { createFilesystemStorageAdapter } from "./storage/fs.js";
+import { createS3CompatibleStorageAdapter } from "./storage/s3.js";
+import { createR2StorageAdapter } from "./storage/r2.js";
+import { instantiate } from "@fragno-dev/core";
+
+//#region src/index.ts
+function createUploadFragment(config, options) {
+	return instantiate(uploadFragmentDefinition).withConfig(config).withRoutes(uploadRoutes).withOptions(options).build();
+}
+
+//#endregion
+export { createFilesystemStorageAdapter, createR2StorageAdapter, createS3CompatibleStorageAdapter, createUploadFragment, createUploadFragmentClients, decodeFileKey, encodeFileKey, encodeFileKeyPrefix, resolveUploadFragmentConfig, uploadFragmentDefinition, uploadRoutes, uploadSchema };
+//# sourceMappingURL=index.js.map

package/dist/node/index.js.map

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

package/dist/node/keys.d.ts

@@ -0,0 +1,12 @@
+//#region src/keys.d.ts
+type FileKeyPart = string | number;
+type FileKeyParts = readonly FileKeyPart[];
+type FileKeyEncoded = string;
+declare function encodeFileKey(parts: FileKeyParts): FileKeyEncoded;
+declare function decodeFileKey(key: FileKeyEncoded): FileKeyParts;
+declare function encodeFileKeyPrefix(parts: FileKeyParts): string;
+//# sourceMappingURL=keys.d.ts.map
+
+//#endregion
+export { FileKeyEncoded, FileKeyPart, FileKeyParts, decodeFileKey, encodeFileKey, encodeFileKeyPrefix };
+//# sourceMappingURL=keys.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keys.d.ts","names":[],"sources":["../../src/keys.ts"],"sourcesContent":[],"mappings":";KAAY,WAAA;AAAA,KACA,YAAA,GADW,SACa,WADb,EAAA;AACX,KACA,cAAA,GADY,MAAY;AACxB,iBAgGI,aAAA,CAhGU,KAAA,EAgGW,YAhGX,CAAA,EAgG0B,cAhG1B;AAgGV,iBAQA,aAAA,CARa,GAAA,EAQM,cARN,CAAA,EAQuB,YARvB;AAAA,iBA+Bb,mBAAA,CA/Ba,KAAA,EA+Bc,YA/Bd,CAAA,EAAA,MAAA"}

package/dist/node/keys.js

@@ -0,0 +1,63 @@
+//#region src/keys.ts
+const base64UrlPattern = /^[A-Za-z0-9_-]*$/;
+function base64UrlEncode(value) {
+	const bytes = new TextEncoder().encode(value);
+	if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+	const encoder = globalThis.btoa;
+	if (!encoder) throw new Error("Base64 encoding is not available");
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return encoder(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function base64UrlDecode(value) {
+	if (!base64UrlPattern.test(value)) throw new Error("Invalid base64url value");
+	const base64 = value.replace(/-/g, "+").replace(/_/g, "/");
+	const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+	if (typeof Buffer !== "undefined") return new TextDecoder().decode(Buffer.from(padded, "base64"));
+	const decoder = globalThis.atob;
+	if (!decoder) throw new Error("Base64 decoding is not available");
+	const binary = decoder(padded);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+	return new TextDecoder().decode(bytes);
+}
+function encodePart(part) {
+	if (typeof part === "string") return `s~${base64UrlEncode(part)}`;
+	if (typeof part === "number") {
+		if (!Number.isFinite(part)) throw new Error("File key number parts must be finite");
+		const serialized = String(part);
+		if (serialized.includes(".") || serialized.includes("e") || serialized.includes("E")) throw new Error("File key number parts must be integers");
+		return `n~${serialized}`;
+	}
+	throw new Error("File key parts must be strings or numbers");
+}
+function decodeNumberPart(raw) {
+	if (raw.length === 0) throw new Error("Invalid number part");
+	if (raw.includes(".") || raw.includes("e") || raw.includes("E")) throw new Error("Invalid number part");
+	const value = Number(raw);
+	if (!Number.isFinite(value)) throw new Error("Invalid number part");
+	if (String(value) !== raw) throw new Error("Invalid number part");
+	return value;
+}
+function encodeFileKey(parts) {
+	if (parts.length === 0) return "";
+	return parts.map((part) => encodePart(part)).join(".");
+}
+function decodeFileKey(key) {
+	if (key.length === 0) return [];
+	return key.split(".").map((segment) => {
+		const prefix = segment.slice(0, 2);
+		const payload = segment.slice(2);
+		if (prefix === "s~") return base64UrlDecode(payload);
+		if (prefix === "n~") return decodeNumberPart(payload);
+		throw new Error("Invalid file key segment");
+	});
+}
+function encodeFileKeyPrefix(parts) {
+	if (parts.length === 0) return "";
+	return `${encodeFileKey(parts)}.`;
+}
+
+//#endregion
+export { decodeFileKey, encodeFileKey, encodeFileKeyPrefix };
+//# sourceMappingURL=keys.js.map

package/dist/node/keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.js","names":[],"sources":["../../src/keys.ts"],"sourcesContent":["export type FileKeyPart = string | number;\nexport type FileKeyParts = readonly FileKeyPart[];\nexport type FileKeyEncoded = string;\n\nconst base64UrlPattern = /^[A-Za-z0-9_-]*$/;\n\nfunction base64UrlEncode(value: string): string {\n  const bytes = new TextEncoder().encode(value);\n\n  if (typeof Buffer !== \"undefined\") {\n    return Buffer.from(bytes)\n      .toString(\"base64\")\n      .replace(/\\+/g, \"-\")\n      .replace(/\\//g, \"_\")\n      .replace(/=+$/g, \"\");\n  }\n\n  const encoder = (globalThis as { btoa?: (value: string) => string }).btoa;\n  if (!encoder) {\n    throw new Error(\"Base64 encoding is not available\");\n  }\n\n  let binary = \"\";\n  for (const byte of bytes) {\n    binary += String.fromCharCode(byte);\n  }\n\n  return encoder(binary).replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/g, \"\");\n}\n\nfunction base64UrlDecode(value: string): string {\n  if (!base64UrlPattern.test(value)) {\n    throw new Error(\"Invalid base64url value\");\n  }\n\n  const base64 = value.replace(/-/g, \"+\").replace(/_/g, \"/\");\n  const padded = base64 + \"=\".repeat((4 - (base64.length % 4)) % 4);\n\n  if (typeof Buffer !== \"undefined\") {\n    return new TextDecoder().decode(Buffer.from(padded, \"base64\"));\n  }\n\n  const decoder = (globalThis as { atob?: (value: string) => string }).atob;\n  if (!decoder) {\n    throw new Error(\"Base64 decoding is not available\");\n  }\n\n  const binary = decoder(padded);\n  const bytes = new Uint8Array(binary.length);\n  for (let i = 0; i < binary.length; i += 1) {\n    bytes[i] = binary.charCodeAt(i);\n  }\n\n  return new TextDecoder().decode(bytes);\n}\n\nfunction encodePart(part: FileKeyPart): string {\n  if (typeof part === \"string\") {\n    return `s~${base64UrlEncode(part)}`;\n  }\n\n  if (typeof part === \"number\") {\n    if (!Number.isFinite(part)) {\n      throw new Error(\"File key number parts must be finite\");\n    }\n\n    const serialized = String(part);\n    if (serialized.includes(\".\") || serialized.includes(\"e\") || serialized.includes(\"E\")) {\n      throw new Error(\"File key number parts must be integers\");\n    }\n\n    return `n~${serialized}`;\n  }\n\n  throw new Error(\"File key parts must be strings or numbers\");\n}\n\nfunction decodeNumberPart(raw: string): number {\n  if (raw.length === 0) {\n    throw new Error(\"Invalid number part\");\n  }\n\n  if (raw.includes(\".\") || raw.includes(\"e\") || raw.includes(\"E\")) {\n    throw new Error(\"Invalid number part\");\n  }\n\n  const value = Number(raw);\n  if (!Number.isFinite(value)) {\n    throw new Error(\"Invalid number part\");\n  }\n\n  if (String(value) !== raw) {\n    throw new Error(\"Invalid number part\");\n  }\n\n  return value;\n}\n\nexport function encodeFileKey(parts: FileKeyParts): FileKeyEncoded {\n  if (parts.length === 0) {\n    return \"\";\n  }\n\n  return parts.map((part) => encodePart(part)).join(\".\");\n}\n\nexport function decodeFileKey(key: FileKeyEncoded): FileKeyParts {\n  if (key.length === 0) {\n    return [];\n  }\n\n  const segments = key.split(\".\");\n\n  return segments.map((segment) => {\n    const prefix = segment.slice(0, 2);\n    const payload = segment.slice(2);\n\n    if (prefix === \"s~\") {\n      return base64UrlDecode(payload);\n    }\n\n    if (prefix === \"n~\") {\n      return decodeNumberPart(payload);\n    }\n\n    throw new Error(\"Invalid file key segment\");\n  });\n}\n\nexport function encodeFileKeyPrefix(parts: FileKeyParts): string {\n  if (parts.length === 0) {\n    return \"\";\n  }\n\n  return `${encodeFileKey(parts)}.`;\n}\n"],"mappings":"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"}

package/dist/node/routes/files.js

@@ -0,0 +1,450 @@
+import { resolveUploadFragmentConfig } from "../config.js";
+import { resolveFileKeyInput } from "../services/helpers.js";
+import { uploadFragmentDefinition } from "../definition.js";
+import { checksumSchema, fileKeyPartsSchema, fileMetadataSchema, toFileMetadata, visibilitySchema } from "./shared.js";
+import { defineRoutes } from "@fragno-dev/core";
+import { z } from "zod";
+
+//#region src/routes/files.ts
+const listQuerySchema = z.object({
+	prefix: z.string().optional(),
+	cursor: z.string().optional(),
+	pageSize: z.coerce.number().min(1).max(100).catch(25),
+	status: z.enum(["ready", "deleted"]).optional(),
+	uploaderId: z.string().optional()
+});
+const updateFileSchema = z.object({
+	filename: z.string().min(1).optional(),
+	visibility: visibilitySchema.optional(),
+	tags: z.array(z.string()).nullable().optional(),
+	metadata: z.record(z.string(), z.unknown()).nullable().optional()
+});
+const errorCodes = [
+	"UPLOAD_NOT_FOUND",
+	"UPLOAD_ALREADY_ACTIVE",
+	"FILE_ALREADY_EXISTS",
+	"FILE_NOT_FOUND",
+	"UPLOAD_EXPIRED",
+	"UPLOAD_INVALID_STATE",
+	"SIGNED_URL_UNSUPPORTED",
+	"STORAGE_ERROR",
+	"INVALID_FILE_KEY",
+	"INVALID_CHECKSUM",
+	"INVALID_REQUEST"
+];
+const handleServiceError = (err, error) => {
+	if (!(err instanceof Error)) throw err;
+	switch (err.message) {
+		case "FILE_NOT_FOUND": return error({
+			message: "File not found",
+			code: "FILE_NOT_FOUND"
+		}, 404);
+		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_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);
+		default: throw err;
+	}
+};
+const parseJson = (value) => {
+	if (value === null || typeof value !== "string" || value.length === 0) return;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return;
+	}
+};
+const parseTags = (value) => {
+	if (value === null) return;
+	if (typeof value !== "string") return;
+	const parsed = parseJson(value);
+	if (Array.isArray(parsed)) return parsed.filter((tag) => typeof tag === "string");
+	if (typeof value === "string" && value.length > 0) return [value];
+};
+const parseMetadata = (value) => {
+	const parsed = parseJson(value);
+	if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+};
+const fileRoutesFactory = defineRoutes(uploadFragmentDefinition).create(({ services, defineRoute, config }) => {
+	const getResolvedConfig = () => resolveUploadFragmentConfig(config);
+	const parseListQuery = (query) => {
+		const result = listQuerySchema.safeParse({
+			prefix: query.get("prefix") || void 0,
+			cursor: query.get("cursor") || void 0,
+			pageSize: query.get("pageSize"),
+			status: query.get("status") || void 0,
+			uploaderId: query.get("uploaderId") || void 0
+		});
+		if (!result.success) throw new Error("INVALID_REQUEST");
+		const params = result.data;
+		if (params.prefix && !params.prefix.endsWith(".")) throw new Error("INVALID_FILE_KEY");
+		return params;
+	};
+	return [
+		defineRoute({
+			method: "POST",
+			path: "/files",
+			contentType: "multipart/form-data",
+			outputSchema: fileMetadataSchema,
+			errorCodes,
+			handler: async function(context, { json, error }) {
+				const resolvedConfig = getResolvedConfig();
+				const form = context.formData();
+				const file = form.get("file");
+				if (!(file instanceof Blob)) return error({
+					message: "File is required",
+					code: "INVALID_REQUEST"
+				}, 400);
+				let keyParts;
+				if (form.has("keyParts")) {
+					const parsed = parseJson(form.get("keyParts"));
+					const result = fileKeyPartsSchema.safeParse(parsed);
+					if (!result.success) return error({
+						message: "Invalid file key",
+						code: "INVALID_FILE_KEY"
+					}, 400);
+					keyParts = result.data;
+				}
+				const fileKeyValue = form.get("fileKey");
+				const fileKey = typeof fileKeyValue === "string" ? fileKeyValue : void 0;
+				const parsedChecksum = parseJson(form.get("checksum"));
+				const checksumResult = checksumSchema.safeParse(parsedChecksum);
+				if (!checksumResult.success) return error({
+					message: "Invalid checksum",
+					code: "INVALID_CHECKSUM"
+				}, 400);
+				const tags = parseTags(form.get("tags"));
+				const metadata = parseMetadata(form.get("metadata"));
+				let resolvedKey;
+				try {
+					resolvedKey = resolveFileKeyInput({
+						keyParts,
+						fileKey: fileKey ?? void 0
+					});
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+				const checksumForStorage = checksumResult.data ?? null;
+				const checksumForRecord = checksumResult.data ?? void 0;
+				let storageInit;
+				const uploaderIdValue = form.get("uploaderId");
+				const uploaderId = typeof uploaderIdValue === "string" ? uploaderIdValue : void 0;
+				const visibilityValue = form.get("visibility");
+				const parsedVisibility = typeof visibilityValue === "string" ? visibilityValue : void 0;
+				const visibilityResult = visibilitySchema.optional().safeParse(parsedVisibility);
+				if (!visibilityResult.success) return error({
+					message: "Invalid request",
+					code: "INVALID_REQUEST"
+				}, 400);
+				const visibility = visibilityResult.data;
+				const filenameValue = form.get("filename");
+				const filename = typeof filenameValue === "string" && filenameValue ? filenameValue : file instanceof File && file.name ? file.name : "upload";
+				const contentType = file.type || "application/octet-stream";
+				const createInput = {
+					fileKey: resolvedKey.fileKey,
+					keyParts: resolvedKey.fileKeyParts,
+					filename,
+					sizeBytes: file.size,
+					contentType,
+					checksum: checksumForRecord,
+					tags,
+					visibility,
+					uploaderId,
+					metadata
+				};
+				try {
+					await this.handlerTx().withServiceCalls(() => [services.checkUploadAvailability(createInput, { allowIdempotentReuse: false })]).execute();
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+				try {
+					storageInit = await resolvedConfig.storage.initUpload({
+						fileKey: resolvedKey.fileKey,
+						fileKeyParts: resolvedKey.fileKeyParts,
+						sizeBytes: BigInt(file.size),
+						contentType,
+						checksum: checksumForStorage,
+						metadata: metadata ?? null
+					});
+				} catch {
+					return error({
+						message: "Storage error",
+						code: "STORAGE_ERROR"
+					}, 502);
+				}
+				if (storageInit.strategy === "direct-multipart") {
+					if (resolvedConfig.storage.abortMultipartUpload && storageInit.storageUploadId) try {
+						await resolvedConfig.storage.abortMultipartUpload({
+							storageKey: storageInit.storageKey,
+							storageUploadId: storageInit.storageUploadId
+						});
+					} catch {}
+					return error({
+						message: "Upload invalid state",
+						code: "UPLOAD_INVALID_STATE"
+					}, 409);
+				}
+				let created;
+				try {
+					created = await this.handlerTx().withServiceCalls(() => [services.createUploadRecord({
+						...createInput,
+						storageInit,
+						allowIdempotentReuse: false
+					})]).transform(({ serviceResult: [result] }) => result).execute();
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+				const createdUpload = created.result;
+				try {
+					if (createdUpload.strategy === "proxy") {
+						if (!resolvedConfig.storage.writeStream) throw new Error("STORAGE_ERROR");
+						await resolvedConfig.storage.writeStream({
+							storageKey: storageInit.storageKey,
+							body: file.stream(),
+							contentType,
+							sizeBytes: BigInt(file.size)
+						});
+					} else if (createdUpload.strategy === "direct-single") {
+						if (!storageInit.uploadUrl) throw new Error("STORAGE_ERROR");
+						if (!(await fetch(storageInit.uploadUrl, {
+							method: "PUT",
+							headers: storageInit.uploadHeaders,
+							body: file
+						})).ok) throw new Error("STORAGE_ERROR");
+					} else return error({
+						message: "Upload invalid state",
+						code: "UPLOAD_INVALID_STATE"
+					}, 409);
+					if (resolvedConfig.storage.finalizeUpload) await resolvedConfig.storage.finalizeUpload({
+						storageKey: storageInit.storageKey,
+						expectedSizeBytes: BigInt(file.size),
+						checksum: checksumResult.data ?? null
+					});
+				} catch {
+					await this.handlerTx().withServiceCalls(() => [services.markUploadFailed(createdUpload.uploadId, "STORAGE_ERROR", "Storage upload failed")]).execute();
+					return error({
+						message: "Storage error",
+						code: "STORAGE_ERROR"
+					}, 502);
+				}
+				try {
+					return json(toFileMetadata((await this.handlerTx().withServiceCalls(() => [services.markUploadComplete(createdUpload.uploadId, createdUpload.fileKey, { sizeBytes: BigInt(file.size) })]).transform(({ serviceResult: [result] }) => result).execute()).file));
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+			}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/files",
+			queryParameters: [
+				"prefix",
+				"cursor",
+				"pageSize",
+				"status",
+				"uploaderId"
+			],
+			outputSchema: z.object({
+				files: z.array(fileMetadataSchema),
+				cursor: z.string().optional(),
+				hasNextPage: z.boolean()
+			}),
+			errorCodes,
+			handler: async function({ query }, { json, error }) {
+				let params;
+				try {
+					params = parseListQuery(query);
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+				const result = await this.handlerTx().withServiceCalls(() => [services.listFiles({
+					prefix: params.prefix,
+					pageSize: params.pageSize,
+					cursor: params.cursor,
+					status: params.status,
+					uploaderId: params.uploaderId
+				})]).transform(({ serviceResult: [files] }) => files).execute();
+				return json({
+					files: result.items.map(toFileMetadata),
+					cursor: result.cursor?.encode(),
+					hasNextPage: result.hasNextPage
+				});
+			}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/files/:fileKey",
+			outputSchema: fileMetadataSchema,
+			errorCodes,
+			handler: async function({ pathParams }, { json, error }) {
+				let resolvedKey;
+				try {
+					resolvedKey = resolveFileKeyInput({ fileKey: pathParams.fileKey });
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+				try {
+					return json(toFileMetadata(await this.handlerTx().withServiceCalls(() => [services.getFileByKey(resolvedKey.fileKey)]).transform(({ serviceResult: [result] }) => result).execute()));
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+			}
+		}),
+		defineRoute({
+			method: "PATCH",
+			path: "/files/:fileKey",
+			inputSchema: updateFileSchema,
+			outputSchema: fileMetadataSchema,
+			errorCodes,
+			handler: async function({ pathParams, input }, { json, error }) {
+				const payload = await input.valid();
+				let resolvedKey;
+				try {
+					resolvedKey = resolveFileKeyInput({ fileKey: pathParams.fileKey });
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+				try {
+					return json(toFileMetadata(await this.handlerTx().withServiceCalls(() => [services.updateFile(resolvedKey.fileKey, payload)]).transform(({ serviceResult: [result] }) => result).execute()));
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+			}
+		}),
+		defineRoute({
+			method: "DELETE",
+			path: "/files/:fileKey",
+			outputSchema: z.object({ ok: z.literal(true) }),
+			errorCodes,
+			handler: async function({ pathParams }, { json, error }) {
+				const resolvedConfig = getResolvedConfig();
+				let resolvedKey;
+				try {
+					resolvedKey = resolveFileKeyInput({ fileKey: pathParams.fileKey });
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+				try {
+					const file = await this.handlerTx().withServiceCalls(() => [services.getFileByKey(resolvedKey.fileKey)]).transform(({ serviceResult: [result] }) => result).execute();
+					try {
+						await resolvedConfig.storage.deleteObject({ storageKey: file.storageKey });
+					} catch {
+						return error({
+							message: "Storage error",
+							code: "STORAGE_ERROR"
+						}, 502);
+					}
+					await this.handlerTx().withServiceCalls(() => [services.markFileDeleted(resolvedKey.fileKey, resolvedKey.fileKeyParts)]).execute();
+					return json({ ok: true });
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+			}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/files/:fileKey/download-url",
+			outputSchema: z.object({
+				url: z.string(),
+				headers: z.record(z.string(), z.string()).optional(),
+				expiresAt: z.date()
+			}),
+			errorCodes,
+			handler: async function({ pathParams }, { json, error }) {
+				const resolvedConfig = getResolvedConfig();
+				let resolvedKey;
+				try {
+					resolvedKey = resolveFileKeyInput({ fileKey: pathParams.fileKey });
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+				if (!resolvedConfig.storage.getDownloadUrl) return error({
+					message: "Signed URLs are not supported",
+					code: "SIGNED_URL_UNSUPPORTED"
+				}, 400);
+				try {
+					const file = await this.handlerTx().withServiceCalls(() => [services.getFileByKey(resolvedKey.fileKey)]).transform(({ serviceResult: [result$1] }) => result$1).execute();
+					let result;
+					try {
+						result = await resolvedConfig.storage.getDownloadUrl({
+							storageKey: file.storageKey,
+							expiresInSeconds: resolvedConfig.signedUrlExpiresInSeconds,
+							contentType: file.contentType ?? void 0
+						});
+					} catch {
+						return error({
+							message: "Storage error",
+							code: "STORAGE_ERROR"
+						}, 502);
+					}
+					return json(result);
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+			}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/files/:fileKey/content",
+			errorCodes,
+			handler: async function({ pathParams }, { error }) {
+				const resolvedConfig = getResolvedConfig();
+				let resolvedKey;
+				try {
+					resolvedKey = resolveFileKeyInput({ fileKey: pathParams.fileKey });
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+				if (!resolvedConfig.storage.getDownloadStream) return error({
+					message: "Download streaming unsupported",
+					code: "SIGNED_URL_UNSUPPORTED"
+				}, 400);
+				try {
+					const file = await this.handlerTx().withServiceCalls(() => [services.getFileByKey(resolvedKey.fileKey)]).transform(({ serviceResult: [result] }) => result).execute();
+					try {
+						return await resolvedConfig.storage.getDownloadStream({ storageKey: file.storageKey });
+					} catch {
+						return error({
+							message: "Storage error",
+							code: "STORAGE_ERROR"
+						}, 502);
+					}
+				} catch (err) {
+					return handleServiceError(err, error);
+				}
+			}
+		})
+	];
+});
+
+//#endregion
+export { fileRoutesFactory };
+//# sourceMappingURL=files.js.map

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

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