fix: preserve media upload retry integrity

Author: khoinguyenpham04

packages/core/src/api/schemas/media.ts

@@ -59,7 +59,6 @@ export function formatFileSize(bytes: number): string {
 // Matches a full MIME type (type/subtype) with an optional semicolon-delimited
 // parameter section. Forbids CR/LF to prevent header injection.
 export const CONTENT_TYPE_RE = /^[a-z0-9][a-z0-9!#$&^_+\-.]*\/[a-z0-9!#$&^_+\-.]+(\s*;[^\r\n]*)?$/i;
-const CONTENT_HASH_RE = /^sha1:[0-9a-f]{40}$/;
 
 export function mediaUploadUrlBody(maxSize: number) {
 	if (!Number.isFinite(maxSize) || maxSize <= 0) {
@@ -77,7 +76,7 @@ export function mediaUploadUrlBody(maxSize: number) {
 				.int()
 				.nonnegative()
 				.max(maxSize, `File size must not exceed ${formatFileSize(maxSize)}`),
-			contentHash: z.string().max(80).regex(CONTENT_HASH_RE, "Invalid content hash").optional(),
+			contentHash: z.string().optional(),
 			fieldId: z.string().optional(),
 		})
 		.meta({ id: "MediaUploadUrlBody" });

packages/core/src/astro/routes/api/media/[id]/upload.ts

@@ -143,11 +143,6 @@ export const PUT: APIRoute = async ({ params, request, locals }) => {
 			}
 		}
 
-		const storedSize = await getStoredSize(emdash.storage, media.storageKey);
-		if (storedSize === expectedSize) {
-			return apiSuccess({ uploaded: true, size: expectedSize });
-		}
-
 		let receivedSize = 0;
 		const shouldHash = expectedSize > 0 && expectedSize <= MAX_CONTENT_HASH_BYTES;
 		let hashBytes: Uint8Array | null = null;
@@ -259,6 +254,7 @@ export const PUT: APIRoute = async ({ params, request, locals }) => {
 			return apiError("INVALID_STATE", "Media item is no longer pending", 400);
 		}
 
+		await removeUploadAttempt(emdash.storage, repo, media.storageKey);
 		return apiSuccess({ uploaded: true, size: receivedSize });
 	} catch (error) {
 		return handleError(error, "Upload failed", "UPLOAD_ERROR");

packages/core/tests/integration/astro/media-stream-upload.test.ts

@@ -170,6 +170,31 @@ describe("streamed media upload fallback", () => {
 		});
 	});
 
+	it("accepts existing client hash formats for deduplication", async () => {
+		const repo = new MediaRepository(db);
+		const contentHash =
+			"sha256:ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad";
+		const existing = await repo.create({
+			filename: "photo.png",
+			mimeType: "image/png",
+			size: 3,
+			storageKey: "photo.png",
+			contentHash,
+		});
+
+		const response = await postUploadUrl(
+			buildContext({
+				db,
+				request: uploadUrlRequestWithHash(contentHash),
+				storage: unsupportedSignedUrlStorage(),
+			}),
+		);
+
+		expect(response.status).toBe(200);
+		const body = (await response.json()) as { data: { existing?: boolean; mediaId: string } };
+		expect(body.data).toMatchObject({ existing: true, mediaId: existing.id });
+	});
+
 	it.each([
 		{ difference: "MIME type", contentType: "video/mp4", size: 3 },
 		{ difference: "size", contentType: "audio/mp4", size: 4 },
@@ -533,7 +558,7 @@ describe("streamed media upload fallback", () => {
 		expect(storage.objects.size).toBe(0);
 	});
 
-	it("keeps a completed object when the upload request is retried", async () => {
+	it("preserves a completed object when a retry upload fails", async () => {
 		const repo = new MediaRepository(db);
 		const pending = await repo.createPending({
 			filename: "photo.png",
@@ -571,11 +596,53 @@ describe("streamed media upload fallback", () => {
 			}),
 		);
 
-		expect(retryResponse.status).toBe(200);
-		expect(storage.upload).toHaveBeenCalledOnce();
+		expect(retryResponse.status).toBe(500);
+		expect(storage.upload).toHaveBeenCalledTimes(2);
+		expect(await repo.findById(pending.id)).toMatchObject({ storageKey: completedKey });
 		expect(storage.objects.get(completedKey)).toEqual(new Uint8Array([1, 2, 3]));
 	});
 
+	it("processes different same-size bytes when an upload target is retried", async () => {
+		const repo = new MediaRepository(db);
+		const pending = await repo.createPending({
+			filename: "photo.png",
+			mimeType: "image/png",
+			size: 3,
+			storageKey: "photo.png",
+			authorId: "user-1",
+		});
+		const storage = streamingStorage();
+
+		const firstResponse = await putUpload(
+			buildContext({
+				db,
+				id: pending.id,
+				request: uploadRequest(pending.id, new Uint8Array([1, 2, 3])),
+				storage,
+			}),
+		);
+		expect(firstResponse.status).toBe(200);
+		const firstUpload = await repo.findById(pending.id);
+		expect(firstUpload).not.toBeNull();
+
+		const secondResponse = await putUpload(
+			buildContext({
+				db,
+				id: pending.id,
+				request: uploadRequest(pending.id, new Uint8Array([4, 5, 6])),
+				storage,
+			}),
+		);
+
+		expect(secondResponse.status).toBe(200);
+		expect(storage.upload).toHaveBeenCalledTimes(2);
+		const retried = await repo.findById(pending.id);
+		expect(retried?.storageKey).not.toBe(firstUpload!.storageKey);
+		expect(storage.objects.get(retried!.storageKey)).toEqual(new Uint8Array([4, 5, 6]));
+		expect(storage.objects.has(firstUpload!.storageKey)).toBe(false);
+		expect(storage.delete).toHaveBeenCalledOnce();
+	});
+
 	it("publishes only one object when two uploads race", async () => {
 		const repo = new MediaRepository(db);
 		const pending = await repo.createPending({

packages/core/tests/unit/api/schemas.test.ts

@@ -253,16 +253,16 @@ describe("mediaUploadUrlBody schema factory", () => {
 		expect(result.size).toBe(0);
 	});
 
-	it("rejects malformed client content hashes", () => {
+	it("accepts client content hashes in existing formats", () => {
 		const schema = mediaUploadUrlBody(1_000);
-		expect(
-			schema.safeParse({
-				filename: "a.jpg",
-				contentType: "image/jpeg",
-				size: 500,
-				contentHash: "not-a-content-hash",
-			}).success,
-		).toBe(false);
+		const contentHash = "sha256:ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad";
+		const result = schema.parse({
+			filename: "a.jpg",
+			contentType: "image/jpeg",
+			size: 500,
+			contentHash,
+		});
+		expect(result.contentHash).toBe(contentHash);
 	});
 
 	it("each call returns an independent schema with its own limit", () => {