@peers-app/peers-sdk 0.27.3 → 0.27.4

package/dist/data/files/files.test.js

@@ -1,770 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const keys_1 = require("../../keys");
-const field_type_1 = require("../../types/field-type");
-const utils_1 = require("../../utils");
-const file_types_1 = require("./file.types");
-const files_1 = require("./files");
-// Mock data source for testing
-class MockDataSource {
-    tableName;
-    primaryKeyName;
-    data = new Map();
-    constructor(tableName, primaryKeyName = "fileId", initialData = []) {
-        this.tableName = tableName;
-        this.primaryKeyName = primaryKeyName;
-        initialData.forEach((item) => {
-            this.data.set(item[primaryKeyName], item);
-        });
-    }
-    async get(id) {
-        return this.data.get(id);
-    }
-    async list() {
-        return Array.from(this.data.values());
-    }
-    async save(record) {
-        this.data.set(record[this.primaryKeyName], record);
-        return record;
-    }
-    async insert(record) {
-        this.data.set(record[this.primaryKeyName], record);
-        return record;
-    }
-    async update(record) {
-        this.data.set(record[this.primaryKeyName], record);
-        return record;
-    }
-    async delete(idOrRecord) {
-        const id = typeof idOrRecord === "string" ? idOrRecord : idOrRecord[this.primaryKeyName];
-        this.data.delete(id);
-    }
-    async count() {
-        return this.data.size;
-    }
-}
-// Mock FileOps for testing
-class MockFileOps {
-    files = new Map();
-    async downloadFileChunk(chunkHash) {
-        // For testing, just return the chunk if it exists locally
-        const chunkPath = `file_chunks/${chunkHash}`;
-        const data = this.files.get(chunkPath);
-        if (!data) {
-            throw new Error(`Chunk not found: ${chunkPath}`);
-        }
-        return data;
-    }
-    async fileExists(path) {
-        return this.files.has(path);
-    }
-    async readFile(path) {
-        const data = this.files.get(path);
-        if (!data) {
-            throw new Error(`File not found: ${path}`);
-        }
-        return data;
-    }
-    async writeFile(path, data) {
-        this.files.set(path, data);
-    }
-    async deletePath(path) {
-        this.files.delete(path);
-    }
-    // Helper method for testing
-    getStoredFiles() {
-        return Array.from(this.files.keys());
-    }
-}
-describe("FileTable", () => {
-    let fileTable;
-    let mockFileOps;
-    beforeEach(() => {
-        // Create mock data source
-        const mockDataSource = new MockDataSource("Files", "fileId");
-        // Use direct instantiation since factory requires setup
-        const metaData = {
-            name: "Files",
-            description: "Files stored in the chunked file system for peer sharing",
-            primaryKeyName: "fileId",
-            fields: [
-                { name: "fileId", type: field_type_1.FieldType.string },
-                { name: "name", type: field_type_1.FieldType.string },
-                { name: "fileSize", type: field_type_1.FieldType.number },
-                { name: "fileHash", type: field_type_1.FieldType.string },
-                { name: "mimeType", type: field_type_1.FieldType.string, optional: true },
-                { name: "chunkHashes", type: field_type_1.FieldType.string, isArray: true, optional: true },
-                { name: "isIndexFile", type: field_type_1.FieldType.boolean, optional: true },
-                { name: "indexFileId", type: field_type_1.FieldType.string, optional: true },
-            ],
-        };
-        // Create mock data context
-        const mockDataContextForRegistry = {
-            dataContextId: "files-test",
-        };
-        const { EventRegistry } = require("../orm/event-registry");
-        const eventRegistry = new EventRegistry(mockDataContextForRegistry);
-        const _mockDataContext = {
-            dataSourceFactory: () => mockDataSource,
-            eventRegistry: eventRegistry,
-        };
-        // Create FileTable instance directly with mock dataSource
-        const deps = {
-            dataSource: mockDataSource,
-            eventRegistry,
-            schema: file_types_1.fileSchema,
-        };
-        fileTable = new files_1.FilesTable(metaData, deps);
-        // Set up mock file operations
-        mockFileOps = new MockFileOps();
-        (0, file_types_1.setFileOps)(mockFileOps);
-    });
-    afterEach(() => {
-        // Clean up global state to prevent Jest from hanging
-        (0, file_types_1.resetFileOps)();
-    });
-    describe("saveFile", () => {
-        it("should save a small file in a single chunk", async () => {
-            const fileId = (0, utils_1.newid)();
-            const data = new Uint8Array(Buffer.from("Hello, World!", "utf8"));
-            const metadata = {
-                fileId,
-                name: "test.txt",
-                fileSize: data.length,
-                mimeType: "text/plain",
-            };
-            const result = await fileTable.saveFile(metadata, data);
-            expect(result.fileId).toBe(fileId);
-            expect(result.chunkHashes).toHaveLength(1);
-            // Check that chunk was written by hash
-            const chunkHash = result.chunkHashes?.[0];
-            const chunkPath = `file_chunks/${chunkHash}`;
-            expect(await mockFileOps.fileExists(chunkPath)).toBe(true);
-            const storedChunk = await mockFileOps.readFile(chunkPath);
-            expect(storedChunk).toBeInstanceOf(Uint8Array);
-            expect(storedChunk).toEqual(data);
-        });
-        it("should save a large file in multiple chunks", async () => {
-            const fileId = (0, utils_1.newid)();
-            const largeData = new Uint8Array(Buffer.alloc(file_types_1.FILE_CHUNK_SIZE + 1000, "A")); // Slightly larger than one chunk
-            const metadata = {
-                fileId,
-                name: "large.txt",
-                fileSize: largeData.length,
-                mimeType: "text/plain",
-            };
-            const result = await fileTable.saveFile(metadata, largeData);
-            expect(result.chunkHashes).toHaveLength(2);
-            // Check that both chunks were written by hash
-            const chunk0Hash = result.chunkHashes?.[0];
-            const chunk1Hash = result.chunkHashes?.[1];
-            expect(await mockFileOps.fileExists(`file_chunks/${chunk0Hash}`)).toBe(true);
-            expect(await mockFileOps.fileExists(`file_chunks/${chunk1Hash}`)).toBe(true);
-            // Verify chunk sizes
-            const chunk0 = await mockFileOps.readFile(`file_chunks/${chunk0Hash}`);
-            const chunk1 = await mockFileOps.readFile(`file_chunks/${chunk1Hash}`);
-            expect(chunk0.length).toBe(file_types_1.FILE_CHUNK_SIZE);
-            expect(chunk1.length).toBe(1000);
-        });
-    });
-    describe("getFile", () => {
-        it("should retrieve a single-chunk file", async () => {
-            const fileId = (0, utils_1.newid)();
-            const originalData = new Uint8Array(Buffer.from("Test content", "utf8"));
-            const metadata = {
-                fileId,
-                name: "test.txt",
-                fileSize: originalData.length,
-                mimeType: "text/plain",
-            };
-            // Save file first
-            await fileTable.saveFile(metadata, originalData);
-            // Retrieve file
-            const retrievedData = await fileTable.getFileContents(fileId);
-            expect(new Uint8Array(retrievedData)).toEqual(originalData);
-        });
-        it("should retrieve a multi-chunk file", async () => {
-            const fileId = (0, utils_1.newid)();
-            const originalData = new Uint8Array(Buffer.alloc(file_types_1.FILE_CHUNK_SIZE + 500, "B"));
-            const metadata = {
-                fileId,
-                name: "large.txt",
-                fileSize: originalData.length,
-                mimeType: "text/plain",
-            };
-            // Save file first
-            await fileTable.saveFile(metadata, originalData);
-            // Retrieve file
-            const retrievedData = await fileTable.getFileContents(fileId);
-            expect(new Uint8Array(retrievedData)).toEqual(originalData);
-        });
-        it("should return null for non-existent file", async () => {
-            const result = await fileTable.getFileContents("non-existent");
-            expect(result).toBeNull();
-        });
-        it("should throw integrity error when fileHash doesn't match chunk hashes", async () => {
-            const fileId = (0, utils_1.newid)();
-            const metadata = {
-                fileId,
-                name: "test.txt",
-                fileSize: 100,
-                fileHash: "hash123",
-                chunkHashes: ["hash1", "hash2"],
-            };
-            // Insert metadata directly with mismatched fileHash
-            await fileTable.dataSource.insert(metadata);
-            await expect(fileTable.getFileContents(fileId)).rejects.toThrow("File integrity check failed");
-        });
-        it("should return null when chunk is missing during read", async () => {
-            const result = await fileTable.getFileContents("non-existent");
-            expect(result).toBeNull();
-        });
-    });
-    describe("deleteFile", () => {
-        it("should delete file from database but preserve chunks", async () => {
-            const fileId = (0, utils_1.newid)();
-            const data = new Uint8Array(Buffer.from("Delete me", "utf8"));
-            const metadata = {
-                fileId,
-                name: "delete.txt",
-                fileSize: data.length,
-                mimeType: "text/plain",
-            };
-            // Save file first
-            const saved = await fileTable.saveFile(metadata, data);
-            // Verify file exists
-            const fileData = await fileTable.getFileContents(fileId);
-            expect(new Uint8Array(fileData)).toEqual(data);
-            const chunkHash = saved.chunkHashes?.[0];
-            expect(await mockFileOps.fileExists(`file_chunks/${chunkHash}`)).toBe(true);
-            // Delete file
-            await fileTable.deleteFile(fileId);
-            // Verify file metadata is gone but chunk remains (for potential sharing)
-            expect(await fileTable.getFileContents(fileId)).toBeNull();
-            expect(await mockFileOps.fileExists(`file_chunks/${chunkHash}`)).toBe(true);
-        });
-        it("should handle deleting non-existent file gracefully", async () => {
-            // Should not throw
-            await fileTable.deleteFile("non-existent");
-        });
-        it("should delete multi-chunk file from database but preserve chunks", async () => {
-            const fileId = (0, utils_1.newid)();
-            const data = new Uint8Array(Buffer.alloc(file_types_1.FILE_CHUNK_SIZE + 100, "C"));
-            const metadata = {
-                fileId,
-                name: "multi.txt",
-                fileSize: data.length,
-                mimeType: "text/plain",
-            };
-            // Save file first
-            const saved = await fileTable.saveFile(metadata, data);
-            // Verify chunks exist by hash
-            const chunk0Hash = saved.chunkHashes?.[0];
-            const chunk1Hash = saved.chunkHashes?.[1];
-            expect(await mockFileOps.fileExists(`file_chunks/${chunk0Hash}`)).toBe(true);
-            expect(await mockFileOps.fileExists(`file_chunks/${chunk1Hash}`)).toBe(true);
-            // Delete file
-            await fileTable.deleteFile(fileId);
-            // Verify file metadata is gone but chunks remain (for potential sharing)
-            expect(await fileTable.getFileContents(fileId)).toBeNull();
-            expect(await mockFileOps.fileExists(`file_chunks/${chunk0Hash}`)).toBe(true);
-            expect(await mockFileOps.fileExists(`file_chunks/${chunk1Hash}`)).toBe(true);
-        });
-    });
-    describe("chunk deduplication", () => {
-        it("should deduplicate identical chunks across different files", async () => {
-            const fileId1 = (0, utils_1.newid)();
-            const fileId2 = (0, utils_1.newid)();
-            // Create two files with identical content
-            const data = new Uint8Array(Buffer.from("Identical content for deduplication test", "utf8"));
-            const metadata1 = {
-                fileId: fileId1,
-                name: "file1.txt",
-                fileSize: data.length,
-                mimeType: "text/plain",
-            };
-            const metadata2 = {
-                fileId: fileId2,
-                name: "file2.txt",
-                fileSize: data.length,
-                mimeType: "text/plain",
-            };
-            // Save both files
-            const saved1 = await fileTable.saveFile(metadata1, data);
-            const saved2 = await fileTable.saveFile(metadata2, data);
-            // Both files should have the same chunk hash (deduplication)
-            expect(saved1.chunkHashes).toEqual(saved2.chunkHashes);
-            // Only one chunk should be stored physically
-            expect(saved1.chunkHashes?.length).toBeGreaterThan(0);
-            const chunkHash = saved1.chunkHashes[0];
-            const chunkPath = `file_chunks/${chunkHash}`;
-            expect(await mockFileOps.fileExists(chunkPath)).toBe(true);
-            expect(mockFileOps.getStoredFiles().filter((path) => path.includes(chunkHash))).toHaveLength(1);
-            // Both files should retrieve the same content
-            const file1Data = await fileTable.getFileContents(fileId1);
-            const file2Data = await fileTable.getFileContents(fileId2);
-            expect(new Uint8Array(file1Data)).toEqual(data);
-            expect(new Uint8Array(file2Data)).toEqual(data);
-        });
-    });
-    describe("Merkle tree (chunk index files)", () => {
-        it("should use direct chunk hashes for files under threshold", async () => {
-            const fileId = (0, utils_1.newid)();
-            // Create a small file that's well under the 1000 chunk threshold
-            const smallData = new Uint8Array(Buffer.from("Small file content for testing", "utf8"));
-            const metadata = {
-                fileId,
-                name: "small.bin",
-                fileSize: smallData.length,
-                mimeType: "application/octet-stream",
-            };
-            // Save small file
-            const result = await fileTable.saveFile(metadata, smallData);
-            // Small file should use direct chunk hashes, not index file
-            expect(result.chunkHashes).toBeTruthy();
-            expect(result.chunkHashes).toHaveLength(1);
-            expect(result.indexFileId).toBeUndefined();
-            // Should be able to retrieve the file
-            const retrievedData = await fileTable.getFileContents(fileId);
-            expect(new Uint8Array(retrievedData)).toEqual(smallData);
-        });
-        it("should use recursive index files for very large files", async () => {
-            // Temporarily lower the threshold to test recursive behavior with smaller data
-            const originalThreshold = file_types_1.CHUNK_INDEX_THRESHOLD;
-            (0, file_types_1.setChunkIndexThreshold)(3); // Use index file for files with >3 chunks
-            try {
-                const fileId = (0, utils_1.newid)();
-                // Create a file with 5 chunks (exceeds threshold of 3)
-                const largeData = new Uint8Array(Buffer.alloc(file_types_1.FILE_CHUNK_SIZE * 4 + 1000, "X")); // 4 full chunks + partial chunk = 5 chunks
-                const metadata = {
-                    fileId,
-                    name: "large.bin",
-                    fileSize: largeData.length,
-                    mimeType: "application/octet-stream",
-                };
-                // Save large file - should create recursive index file
-                const result = await fileTable.saveFile(metadata, largeData);
-                // Large file should use index file, not direct chunk hashes
-                expect(result.chunkHashes).toBeUndefined();
-                expect(result.indexFileId).toBeTruthy();
-                // Should be able to retrieve the file
-                const retrievedData = await fileTable.getFileContents(fileId);
-                expect(retrievedData).toBeTruthy();
-                expect(new Uint8Array(retrievedData)).toEqual(largeData);
-                // The index file should be marked as an index file
-                const indexFile = await fileTable.dataSource.get(result.indexFileId);
-                expect(indexFile).toBeTruthy();
-                expect(indexFile?.isIndexFile).toBe(true);
-                // The index file should contain JSON data
-                expect(indexFile?.mimeType).toBe("application/json");
-                expect(indexFile?.name).toMatch(/^index-.*\.json$/);
-            }
-            finally {
-                // Restore original threshold
-                (0, file_types_1.setChunkIndexThreshold)(originalThreshold);
-            }
-        });
-        it("should handle missing index file gracefully", async () => {
-            const fileId = (0, utils_1.newid)();
-            const metadata = {
-                fileId,
-                name: "test.txt",
-                fileSize: 100,
-                fileHash: "hash123",
-                indexFileId: "missing_index_file_id",
-            };
-            // Insert metadata directly without creating index file
-            await fileTable.dataSource.insert(metadata);
-            await expect(fileTable.getFileContents(fileId)).rejects.toThrow("Index file not found: missing_index_file_id");
-        });
-    });
-    describe("Streaming API", () => {
-        describe("FileWriteStream", () => {
-            it("should create a write stream and write small file chunk by chunk", async () => {
-                const fileId = (0, utils_1.newid)();
-                const metadata = {
-                    fileId,
-                    name: "stream-test.txt",
-                    fileSize: 0, // Will be calculated
-                    mimeType: "text/plain",
-                };
-                const writeStream = await fileTable.createWriteStream(metadata);
-                // Write data in chunks
-                await writeStream.write(new Uint8Array(Buffer.from("Hello, ", "utf8")));
-                await writeStream.write(new Uint8Array(Buffer.from("streaming ", "utf8")));
-                await writeStream.write(new Uint8Array(Buffer.from("world!", "utf8")));
-                // Finalize the stream
-                const result = await writeStream.finalize();
-                expect(result.fileId).toBe(fileId);
-                expect(result.name).toBe("stream-test.txt");
-                expect(result.fileSize).toBe(23); // Total bytes written: 'Hello, streaming world!'
-                expect(result.chunkHashes).toHaveLength(1); // Small file, single chunk
-                // Verify we can read the file back
-                const retrievedData = await fileTable.getFileContents(fileId);
-                expect(Buffer.from(retrievedData).toString("utf8")).toBe("Hello, streaming world!");
-            });
-            it("should handle large file streaming across multiple chunks", async () => {
-                const fileId = (0, utils_1.newid)();
-                const metadata = {
-                    fileId,
-                    name: "large-stream.bin",
-                    fileSize: 0,
-                    mimeType: "application/octet-stream",
-                };
-                const writeStream = await fileTable.createWriteStream(metadata);
-                // Write data larger than one chunk
-                const chunkSize = file_types_1.FILE_CHUNK_SIZE;
-                const chunk1 = new Uint8Array(Buffer.alloc(chunkSize, "A"));
-                const chunk2 = new Uint8Array(Buffer.alloc(500, "B")); // Partial second chunk
-                await writeStream.write(chunk1);
-                await writeStream.write(chunk2);
-                const result = await writeStream.finalize();
-                expect(result.fileSize).toBe(chunkSize + 500);
-                expect(result.chunkHashes).toHaveLength(2); // Two chunks
-                // Verify content
-                const retrievedData = await fileTable.getFileContents(fileId);
-                expect(retrievedData?.length).toBe(chunkSize + 500);
-                expect(new Uint8Array(retrievedData).subarray(0, chunkSize).every((b) => b === 65)).toBe(true); // All 'A's
-                expect(new Uint8Array(retrievedData).subarray(chunkSize).every((b) => b === 66)).toBe(true); // All 'B's
-            });
-            it("should support aborting a write stream", async () => {
-                const fileId = (0, utils_1.newid)();
-                const metadata = {
-                    fileId,
-                    name: "aborted.txt",
-                    fileSize: 0,
-                    mimeType: "text/plain",
-                };
-                const writeStream = await fileTable.createWriteStream(metadata);
-                await writeStream.write(new Uint8Array(Buffer.from("Some data", "utf8")));
-                expect(writeStream.getBytesWritten()).toBe(9);
-                // Abort the stream
-                await writeStream.abort();
-                expect(writeStream.isAborted()).toBe(true);
-                // Should not be able to write after abort
-                await expect(writeStream.write(new Uint8Array(Buffer.from("More data", "utf8")))).rejects.toThrow("Cannot write to aborted stream");
-                // Should not be able to finalize after abort
-                await expect(writeStream.finalize()).rejects.toThrow("Cannot finalize aborted stream");
-            });
-            it("should track progress during streaming", async () => {
-                const fileId = (0, utils_1.newid)();
-                const metadata = {
-                    fileId,
-                    name: "progress.txt",
-                    fileSize: 0,
-                    mimeType: "text/plain",
-                };
-                const writeStream = await fileTable.createWriteStream(metadata);
-                expect(writeStream.getBytesWritten()).toBe(0);
-                expect(writeStream.getChunkCount()).toBe(0);
-                await writeStream.write(new Uint8Array(Buffer.from("First chunk", "utf8")));
-                expect(writeStream.getBytesWritten()).toBe(11);
-                expect(writeStream.getChunkCount()).toBe(0); // Not complete chunk yet
-                await writeStream.write(new Uint8Array(Buffer.from(" Second part", "utf8")));
-                expect(writeStream.getBytesWritten()).toBe(23);
-                await writeStream.finalize();
-                expect(writeStream.isFinalized()).toBe(true);
-            });
-            it("should handle finalize with multiple complete chunks in buffer", async () => {
-                const fileId = (0, utils_1.newid)();
-                const metadata = {
-                    fileId,
-                    name: "buffered-chunks.bin",
-                    fileSize: 0,
-                    mimeType: "application/octet-stream",
-                };
-                const writeStream = await fileTable.createWriteStream(metadata);
-                // Write data that will create multiple complete chunks but don't trigger processCompleteChunks
-                // This simulates the edge case where finalize() needs to process multiple chunks
-                const chunkSize = file_types_1.FILE_CHUNK_SIZE;
-                const buffer = Buffer.alloc(chunkSize * 2 + 500); // 2 full chunks + partial chunk
-                buffer.fill(65); // Fill with 'A'
-                const data = new Uint8Array(buffer);
-                // Write as one large chunk to buffer (avoiding automatic processing)
-                await writeStream.write(data);
-                // At this point the buffer should have 2+ MB of data
-                expect(writeStream.getBytesWritten()).toBe(data.length);
-                // Finalize should process all complete chunks + final partial chunk
-                const result = await writeStream.finalize();
-                expect(result.fileSize).toBe(data.length);
-                expect(result.chunkHashes).toHaveLength(3); // 2 complete + 1 partial chunk
-                // Verify we can read it back correctly
-                const retrievedData = await fileTable.getFileContents(fileId);
-                expect(retrievedData?.length).toBe(data.length);
-                expect(new Uint8Array(retrievedData)).toEqual(data);
-            });
-        });
-        describe("FileReadStream", () => {
-            it("should read file data in chunks using read stream", async () => {
-                // First save a file using traditional method
-                const fileId = (0, utils_1.newid)();
-                const originalData = new Uint8Array(Buffer.from("This is test data for streaming read operations!", "utf8"));
-                const metadata = {
-                    fileId,
-                    name: "read-test.txt",
-                    fileSize: originalData.length,
-                    mimeType: "text/plain",
-                };
-                await fileTable.saveFile(metadata, originalData);
-                // Now open for streaming read
-                const readStream = await fileTable.openReadStream(fileId);
-                expect(readStream).toBeTruthy();
-                // Read entire file
-                const readData = await readStream?.readAll();
-                expect(readData).not.toBeNull();
-                expect(new Uint8Array(readData)).toEqual(originalData);
-                // Check metadata
-                const meta = readStream.getMetadata();
-                expect(meta.fileId).toBe(fileId);
-                expect(meta.name).toBe("read-test.txt");
-                expect(meta.fileSize).toBe(originalData.length);
-            });
-            it("should support seeking within file", async () => {
-                const fileId = (0, utils_1.newid)();
-                const originalData = new Uint8Array(Buffer.from("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ", "utf8"));
-                const metadata = {
-                    fileId,
-                    name: "seek-test.txt",
-                    fileSize: originalData.length,
-                    mimeType: "text/plain",
-                };
-                await fileTable.saveFile(metadata, originalData);
-                const readStream = await fileTable.openReadStream(fileId);
-                expect(readStream).toBeTruthy();
-                // Seek to position 10 (should be at 'A')
-                await readStream?.seek(10);
-                expect(readStream?.getPosition()).toBe(10);
-                // Read 5 bytes from position 10 (should get 'ABCDE')
-                const chunk = await readStream?.read(5);
-                expect(Buffer.from(chunk).toString("utf8")).toBe("ABCDE");
-                expect(readStream?.getPosition()).toBe(15);
-                // Seek back to beginning
-                await readStream?.seek(0);
-                expect(readStream?.getPosition()).toBe(0);
-                const firstChunk = await readStream?.read(10);
-                expect(Buffer.from(firstChunk).toString("utf8")).toBe("0123456789");
-                expect(readStream?.getPosition()).toBe(10);
-                // Seek to middle of data
-                await readStream?.seek(20);
-                expect(readStream?.getPosition()).toBe(20);
-                const middleChunk = await readStream?.read(5);
-                expect(Buffer.from(middleChunk).toString("utf8")).toBe("KLMNO");
-                expect(readStream?.getPosition()).toBe(25);
-            });
-            it("should handle seeking across chunk boundaries in large files", async () => {
-                // Create a file that spans multiple chunks
-                const fileId = (0, utils_1.newid)();
-                const chunkSize = file_types_1.FILE_CHUNK_SIZE;
-                const data1 = Buffer.alloc(chunkSize, "A"); // First chunk: all A's
-                const data2 = Buffer.alloc(chunkSize, "B"); // Second chunk: all B's
-                const data3 = Buffer.alloc(500, "C"); // Third partial chunk: all C's
-                const largeData = new Uint8Array(Buffer.concat([data1, data2, data3]));
-                const metadata = {
-                    fileId,
-                    name: "large-seek-test.bin",
-                    fileSize: largeData.length,
-                    mimeType: "application/octet-stream",
-                };
-                await fileTable.saveFile(metadata, largeData);
-                const readStream = await fileTable.openReadStream(fileId);
-                expect(readStream).toBeTruthy();
-                // Seek to end of first chunk
-                await readStream?.seek(chunkSize - 5);
-                const endOfFirst = await readStream?.read(10); // Should span chunk boundary
-                expect(endOfFirst?.length).toBe(10);
-                expect(endOfFirst?.subarray(0, 5).every((b) => b === 65)).toBe(true); // First 5 bytes: A's
-                expect(endOfFirst?.subarray(5, 10).every((b) => b === 66)).toBe(true); // Next 5 bytes: B's
-                // Seek to middle of second chunk
-                await readStream?.seek(chunkSize + 1000);
-                const middleOfSecond = await readStream?.read(100);
-                expect(middleOfSecond?.length).toBe(100);
-                expect(middleOfSecond?.every((b) => b === 66)).toBe(true); // All B's
-                // Seek to third chunk
-                await readStream?.seek(chunkSize * 2 + 100);
-                const inThirdChunk = await readStream?.read(200);
-                expect(inThirdChunk?.length).toBe(200);
-                expect(inThirdChunk?.every((b) => b === 67)).toBe(true); // All C's
-            });
-            it("should handle seek error conditions", async () => {
-                const fileId = (0, utils_1.newid)();
-                const data = new Uint8Array(Buffer.from("Short test data", "utf8"));
-                const metadata = {
-                    fileId,
-                    name: "error-test.txt",
-                    fileSize: data.length,
-                    mimeType: "text/plain",
-                };
-                await fileTable.saveFile(metadata, data);
-                const readStream = await fileTable.openReadStream(fileId);
-                expect(readStream).toBeTruthy();
-                // Test negative seek position
-                await expect(readStream?.seek(-1)).rejects.toThrow("Seek position cannot be negative");
-                // Test seeking beyond file size
-                await expect(readStream?.seek(data.length + 1)).rejects.toThrow("Seek position beyond file size");
-                // Test seeking to exact end of file
-                await readStream?.seek(data.length);
-                expect(readStream?.getPosition()).toBe(data.length);
-                expect(readStream?.getBytesRemaining()).toBe(0);
-                // Should return null when reading at EOF
-                const atEof = await readStream?.read();
-                expect(atEof).toBeNull();
-            });
-            it("should handle large file streaming reads", async () => {
-                // Create a large file with known pattern
-                const fileId = (0, utils_1.newid)();
-                const chunkSize = file_types_1.FILE_CHUNK_SIZE;
-                const buffer = Buffer.alloc(chunkSize + 1000);
-                // Fill with pattern: first chunk with 'A', remainder with 'B'
-                buffer.fill(65, 0, chunkSize); // 'A'
-                buffer.fill(66, chunkSize); // 'B'
-                const largeData = new Uint8Array(buffer);
-                const metadata = {
-                    fileId,
-                    name: "large-read.bin",
-                    fileSize: largeData.length,
-                    mimeType: "application/octet-stream",
-                };
-                await fileTable.saveFile(metadata, largeData);
-                const readStream = await fileTable.openReadStream(fileId);
-                expect(readStream).toBeTruthy();
-                // Read first chunk
-                const firstChunk = await readStream?.read(chunkSize);
-                expect(firstChunk?.length).toBe(chunkSize);
-                expect(firstChunk?.every((b) => b === 65)).toBe(true); // All 'A's
-                // Read remainder
-                const remainder = await readStream?.read();
-                expect(remainder?.length).toBe(1000);
-                expect(remainder?.every((b) => b === 66)).toBe(true); // All 'B's
-                // Should be at EOF
-                const eof = await readStream?.read();
-                expect(eof).toBeNull();
-                expect(readStream?.isEOF()).toBe(true);
-            });
-            it("should return null for non-existent file", async () => {
-                const readStream = await fileTable.openReadStream("non-existent-file");
-                expect(readStream).toBeNull();
-            });
-            it("should handle partial reads correctly", async () => {
-                const fileId = (0, utils_1.newid)();
-                const data = new Uint8Array(Buffer.from("ABCDEFGHIJKLMNOPQRSTUVWXYZ", "utf8"));
-                const metadata = {
-                    fileId,
-                    name: "partial-read.txt",
-                    fileSize: data.length,
-                    mimeType: "text/plain",
-                };
-                await fileTable.saveFile(metadata, data);
-                const readStream = await fileTable.openReadStream(fileId);
-                expect(readStream).toBeTruthy();
-                // Read in small chunks
-                const chunk1 = await readStream?.read(5);
-                expect(Buffer.from(chunk1).toString("utf8")).toBe("ABCDE");
-                expect(readStream?.getPosition()).toBe(5);
-                expect(readStream?.getBytesRemaining()).toBe(21);
-                const chunk2 = await readStream?.read(10);
-                expect(Buffer.from(chunk2).toString("utf8")).toBe("FGHIJKLMNO");
-                expect(readStream?.getPosition()).toBe(15);
-                const chunk3 = await readStream?.read(20); // More than remaining
-                expect(Buffer.from(chunk3).toString("utf8")).toBe("PQRSTUVWXYZ");
-                expect(readStream?.getPosition()).toBe(26);
-                expect(readStream?.getBytesRemaining()).toBe(0);
-                // Should be EOF now
-                const eof = await readStream?.read();
-                expect(eof).toBeNull();
-            });
-            it("should return null when chunk is unavailable", async () => {
-                const fileId = (0, utils_1.newid)();
-                const chunkHashes = ["missing_chunk_hash"];
-                const fileHash = (0, keys_1.hashBytes)(new TextEncoder().encode(JSON.stringify(chunkHashes)));
-                const metadata = {
-                    fileId,
-                    name: "missing-chunk.txt",
-                    fileSize: 50,
-                    fileHash,
-                    chunkHashes,
-                };
-                // Insert file metadata without storing the actual chunk
-                await fileTable.dataSource.insert(metadata);
-                // This should return null when the chunk can't be found
-                const result = await fileTable.getFileContents(fileId);
-                expect(result).toBeNull();
-            });
-            it("should throw when fileHash does not match chunk hashes", async () => {
-                const fileId = (0, utils_1.newid)();
-                const data = new Uint8Array(Buffer.from("Valid content", "utf8"));
-                const metadata = {
-                    fileId,
-                    name: "tampered.txt",
-                    fileSize: data.length,
-                    mimeType: "text/plain",
-                };
-                // Save file normally to get valid chunks on disk
-                const saved = await fileTable.saveFile(metadata, data);
-                // Tamper with the fileHash in the database record
-                const tamperedRecord = {
-                    ...saved,
-                    fileHash: "tampered-hash-value",
-                };
-                await fileTable.dataSource.save(tamperedRecord);
-                // Reading should throw a file integrity error
-                await expect(fileTable.getFileContents(fileId)).rejects.toThrow("File integrity check failed");
-            });
-            it("should skip fileHash verification when skipVerification is true", async () => {
-                const fileId = (0, utils_1.newid)();
-                const data = new Uint8Array(Buffer.from("Valid content", "utf8"));
-                const metadata = {
-                    fileId,
-                    name: "skip-verify.txt",
-                    fileSize: data.length,
-                    mimeType: "text/plain",
-                };
-                // Save file normally to get valid chunks on disk
-                const saved = await fileTable.saveFile(metadata, data);
-                // Tamper with the fileHash in the database record
-                const tamperedRecord = {
-                    ...saved,
-                    fileHash: "tampered-hash-value",
-                };
-                await fileTable.dataSource.save(tamperedRecord);
-                // Reading with skipVerification should succeed
-                const result = await fileTable.getFileContents(fileId, { skipVerification: true });
-                expect(result).not.toBeNull();
-                expect(new Uint8Array(result)).toEqual(data);
-            });
-        });
-        describe("Round-trip streaming", () => {
-            it("should write and read back identical data using streams", async () => {
-                const fileId = (0, utils_1.newid)();
-                const testData = "This is a round-trip test with streaming! ".repeat(1000);
-                const originalBuffer = new Uint8Array(Buffer.from(testData, "utf8"));
-                const metadata = {
-                    fileId,
-                    name: "roundtrip.txt",
-                    fileSize: 0,
-                    mimeType: "text/plain",
-                };
-                // Write using stream
-                const writeStream = await fileTable.createWriteStream(metadata);
-                // Write in chunks
-                let offset = 0;
-                const writeChunkSize = 1000;
-                while (offset < originalBuffer.length) {
-                    const end = Math.min(offset + writeChunkSize, originalBuffer.length);
-                    const chunk = originalBuffer.subarray(offset, end);
-                    await writeStream.write(chunk);
-                    offset = end;
-                }
-                const savedFile = await writeStream.finalize();
-                expect(savedFile.fileSize).toBe(originalBuffer.length);
-                // Read back using stream
-                const readStream = await fileTable.openReadStream(fileId);
-                expect(readStream).toBeTruthy();
-                const readBuffer = await readStream?.readAll();
-                // Verify identical
-                expect(readBuffer).not.toBeNull();
-                expect(new Uint8Array(readBuffer)).toEqual(originalBuffer);
-                expect(Buffer.from(readBuffer).toString("utf8")).toBe(testData);
-            });
-        });
-    });
-});