fix(pack): accept parsed tar entry with data (#93)

Author: ayuhito

src/web/helpers.ts

@@ -40,14 +40,19 @@ import { createTarDecoder } from "./unpack";
  * });
  * ```
  */
-export async function packTar(entries: TarEntry[]): Promise<Uint8Array> {
+export async function packTar(
+	entries: (TarEntry | ParsedTarEntryWithData)[],
+): Promise<Uint8Array> {
 	const { readable, controller } = createTarPacker();
 
 	// This promise runs the packing process in the background.
 	const packingPromise = (async () => {
 		for (const entry of entries) {
 			const entryStream = controller.add(entry.header);
-			const { body } = entry;
+
+			// Handle both TarEntry and ParsedTarEntryWithData formats.
+			const body =
+				"body" in entry ? entry.body : (entry as ParsedTarEntryWithData).data;
 
 			if (!body) {
 				await entryStream.close();

tests/fs/repack.test.ts

@@ -0,0 +1,96 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { decoder } from "../../src/tar/utils";
+import { packTar, unpackTar } from "../../src/web/helpers";
+
+describe("repack", () => {
+	it("successfully repacks unpacked entries", async () => {
+		const originalEntries = [
+			{
+				header: { name: "example.txt", size: 11, type: "file" as const },
+				body: "hello world",
+			},
+			{
+				header: { name: "empty.txt", size: 0, type: "file" as const },
+				body: "",
+			},
+			{
+				header: { name: "dir/", type: "directory" as const, size: 0 },
+			},
+		];
+
+		const archive = await packTar(originalEntries);
+		const tempPath = join(tmpdir(), "test-repack.tar");
+		await writeFile(tempPath, archive);
+
+		// Original workflow that was failing
+		const data = await readFile(tempPath);
+		const entries = await unpackTar(data);
+
+		// This used to throw "Size mismatch" but now works
+		const repackedArchive = await packTar(entries);
+
+		// Verify integrity
+		const verifyEntries = await unpackTar(repackedArchive);
+		expect(verifyEntries).toHaveLength(3);
+
+		const textFile = verifyEntries.find((e) => e.header.name === "example.txt");
+		expect(decoder.decode(textFile?.data)).toBe("hello world");
+	});
+
+	it("supports adding new entries to existing archive", async () => {
+		const original = await packTar([
+			{
+				header: { name: "existing.txt", size: 8, type: "file" as const },
+				body: "existing",
+			},
+		]);
+
+		// Unpack and add new entries
+		const entries = await unpackTar(original);
+		const newEntry = {
+			header: { name: "new.txt", size: 3, type: "file" as const },
+			body: "new",
+		};
+
+		// Combine and repack
+		const updatedArchive = await packTar([...entries, newEntry]);
+		const finalEntries = await unpackTar(updatedArchive);
+
+		expect(finalEntries).toHaveLength(2);
+		expect(finalEntries.map((e) => e.header.name)).toEqual([
+			"existing.txt",
+			"new.txt",
+		]);
+	});
+
+	it("handles mixed entry formats", async () => {
+		// Fresh entry with body
+		const freshEntry = {
+			header: { name: "fresh.txt", size: 5, type: "file" as const },
+			body: "fresh",
+		};
+
+		// Unpacked entry with data
+		const archive = await packTar([freshEntry]);
+		const [unpackedEntry] = await unpackTar(archive);
+
+		// Mix both formats in one call
+		const mixedEntries = [
+			unpackedEntry, // Has 'data' property
+			{
+				header: { name: "another.txt", size: 7, type: "file" as const },
+				body: "another", // Has 'body' property
+			},
+		];
+
+		const mixedArchive = await packTar(mixedEntries);
+		const verifyEntries = await unpackTar(mixedArchive);
+
+		expect(verifyEntries).toHaveLength(2);
+		expect(decoder.decode(verifyEntries[0].data)).toBe("fresh");
+		expect(decoder.decode(verifyEntries[1].data)).toBe("another");
+	});
+});

tests/web/repack.ts renamed to tests/web/repack.test.ts

@@ -1,10 +1,10 @@
 /** biome-ignore-all lint/style/noNonNullAssertion: Tests */
 import { describe, expect, it } from "vitest";
-import { isBodyless } from "../../src/tar/utils";
+import { decoder, isBodyless } from "../../src/tar/utils";
 import { packTar, unpackTar } from "../../src/web/helpers";
 import type { TarEntry } from "../../src/web/types";
 
-describe("round-trip pack/unpack", () => {
+describe("repack", () => {
 	it("handles unpack then repack correctly", async () => {
 		// Create a test archive with various entry types
 		const originalEntries: TarEntry[] = [
@@ -45,9 +45,7 @@ describe("round-trip pack/unpack", () => {
 		expect(unpackedEntries[0].header.size).toBe(11);
 		expect(unpackedEntries[0].data).toBeDefined();
 		expect(unpackedEntries[0].data!.length).toBe(11);
-		expect(new TextDecoder().decode(unpackedEntries[0].data!)).toBe(
-			"hello world",
-		);
+		expect(decoder.decode(unpackedEntries[0].data!)).toBe("hello world");
 
 		expect(unpackedEntries[1].header.name).toBe("empty.txt");
 		expect(unpackedEntries[1].header.size).toBe(0);
@@ -63,20 +61,15 @@ describe("round-trip pack/unpack", () => {
 		expect(unpackedEntries[3].header.size).toBe(12);
 		expect(unpackedEntries[3].data).toBeDefined();
 		expect(unpackedEntries[3].data!.length).toBe(12);
-		expect(new TextDecoder().decode(unpackedEntries[3].data!)).toBe(
-			"nested file!",
-		);
+		expect(decoder.decode(unpackedEntries[3].data!)).toBe("nested file!");
 
 		expect(unpackedEntries[4].header.name).toBe("link");
 		expect(unpackedEntries[4].header.type).toBe("symlink");
 		expect(unpackedEntries[4].header.size).toBe(0);
 		expect(unpackedEntries[4].data).toBeUndefined();
 
-		// Convert unpacked entries back to TarEntry format for repacking
-		const entriesForRepack: TarEntry[] = unpackedEntries.map((entry) => ({
-			header: { ...entry.header },
-			body: entry.data,
-		}));
+		// With unified API, unpacked entries can be repacked directly
+		const entriesForRepack: TarEntry[] = unpackedEntries;
 
 		// This should not throw an error (this was the original bug)
 		const repackedArchive = await packTar(entriesForRepack);
@@ -101,7 +94,7 @@ describe("round-trip pack/unpack", () => {
 				expect(final.data).toBeDefined();
 				expect(final.data!.length).toBe(original.header.size);
 				if (original.body && typeof original.body === "string") {
-					expect(new TextDecoder().decode(final.data!)).toBe(original.body);
+					expect(decoder.decode(final.data!)).toBe(original.body);
 				}
 			}
 		}