@peers-app/peers-sdk 0.1.4

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

@@ -0,0 +1,728 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.getFile(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.getFile(fileId);
+            expect(new Uint8Array(retrievedData)).toEqual(originalData);
+        });
+        it('should return null for non-existent file', async () => {
+            const result = await fileTable.getFile('non-existent');
+            expect(result).toBeNull();
+        });
+        it('should return null when chunk is missing', async () => {
+            const fileId = (0, utils_1.newid)();
+            const metadata = {
+                fileId,
+                name: 'test.txt',
+                fileSize: 100,
+                fileHash: 'hash123',
+                chunkHashes: ['hash1', 'hash2'],
+            };
+            // Insert metadata directly without saving chunks
+            await fileTable.dataSource.insert(metadata);
+            const result = await fileTable.getFile(fileId);
+            expect(result).toBeNull();
+        });
+        it('should return null when chunk is missing during read', async () => {
+            const result = await fileTable.getFile('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.getFile(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.getFile(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.getFile(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
+            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.getFile(fileId1);
+            const file2Data = await fileTable.getFile(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.getFile(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.getFile(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.getFile(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.getFile(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.getFile(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.getFile(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 metadata = {
+                    fileId,
+                    name: 'missing-chunk.txt',
+                    fileSize: 50,
+                    fileHash: 'hash123',
+                    chunkHashes: ['missing_chunk_hash'],
+                };
+                // Insert file metadata without storing the actual chunk
+                await fileTable.dataSource.insert(metadata);
+                // This should return null when the chunk can't be found
+                // instead of throwing an error or hanging
+                const result = await fileTable.getFile(fileId);
+                expect(result).toBeNull();
+            });
+        });
+        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);
+            });
+        });
+    });
+});