@peers-app/peers-sdk 0.14.0 → 0.15.0

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

@@ -9,10 +9,10 @@ class MockDataSource {
     tableName;
     primaryKeyName;
     data = new Map();
-    constructor(tableName, primaryKeyName = 'fileId', initialData = []) {
+    constructor(tableName, primaryKeyName = "fileId", initialData = []) {
         this.tableName = tableName;
         this.primaryKeyName = primaryKeyName;
-        initialData.forEach(item => {
+        initialData.forEach((item) => {
             this.data.set(item[primaryKeyName], item);
         });
     }
@@ -35,7 +35,7 @@ class MockDataSource {
         return record;
     }
     async delete(idOrRecord) {
-        const id = typeof idOrRecord === 'string' ? idOrRecord : idOrRecord[this.primaryKeyName];
+        const id = typeof idOrRecord === "string" ? idOrRecord : idOrRecord[this.primaryKeyName];
         this.data.delete(id);
     }
     async count() {
@@ -75,43 +75,43 @@ class MockFileOps {
         return Array.from(this.files.keys());
     }
 }
-describe('FileTable', () => {
+describe("FileTable", () => {
     let fileTable;
     let mockFileOps;
     beforeEach(() => {
         // Create mock data source
-        const mockDataSource = new MockDataSource('Files', 'fileId');
+        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',
+            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 },
-            ]
+                { 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'
+            dataContextId: "files-test",
         };
-        const { EventRegistry } = require('../orm/event-registry');
+        const { EventRegistry } = require("../orm/event-registry");
         const eventRegistry = new EventRegistry(mockDataContextForRegistry);
-        const mockDataContext = {
+        const _mockDataContext = {
             dataSourceFactory: () => mockDataSource,
-            eventRegistry: eventRegistry
+            eventRegistry: eventRegistry,
         };
         // Create FileTable instance directly with mock dataSource
         const deps = {
             dataSource: mockDataSource,
             eventRegistry,
-            schema: file_types_1.fileSchema
+            schema: file_types_1.fileSchema,
         };
         fileTable = new files_1.FilesTable(metaData, deps);
         // Set up mock file operations
@@ -122,41 +122,41 @@ describe('FileTable', () => {
         // 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 () => {
+    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 data = new Uint8Array(Buffer.from("Hello, World!", "utf8"));
             const metadata = {
                 fileId,
-                name: 'test.txt',
+                name: "test.txt",
                 fileSize: data.length,
-                mimeType: 'text/plain',
+                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 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 () => {
+        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 largeData = new Uint8Array(Buffer.alloc(file_types_1.FILE_CHUNK_SIZE + 1000, "A")); // Slightly larger than one chunk
             const metadata = {
                 fileId,
-                name: 'large.txt',
+                name: "large.txt",
                 fileSize: largeData.length,
-                mimeType: 'text/plain',
+                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];
+            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
@@ -166,15 +166,15 @@ describe('FileTable', () => {
             expect(chunk1.length).toBe(1000);
         });
     });
-    describe('getFile', () => {
-        it('should retrieve a single-chunk file', async () => {
+    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 originalData = new Uint8Array(Buffer.from("Test content", "utf8"));
             const metadata = {
                 fileId,
-                name: 'test.txt',
+                name: "test.txt",
                 fileSize: originalData.length,
-                mimeType: 'text/plain',
+                mimeType: "text/plain",
             };
             // Save file first
             await fileTable.saveFile(metadata, originalData);
@@ -182,14 +182,14 @@ describe('FileTable', () => {
             const retrievedData = await fileTable.getFileContents(fileId);
             expect(new Uint8Array(retrievedData)).toEqual(originalData);
         });
-        it('should retrieve a multi-chunk file', async () => {
+        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 originalData = new Uint8Array(Buffer.alloc(file_types_1.FILE_CHUNK_SIZE + 500, "B"));
             const metadata = {
                 fileId,
-                name: 'large.txt',
+                name: "large.txt",
                 fileSize: originalData.length,
-                mimeType: 'text/plain',
+                mimeType: "text/plain",
             };
             // Save file first
             await fileTable.saveFile(metadata, originalData);
@@ -197,45 +197,45 @@ describe('FileTable', () => {
             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');
+        it("should return null for non-existent file", async () => {
+            const result = await fileTable.getFileContents("non-existent");
             expect(result).toBeNull();
         });
-        it('should return null when chunk is missing', async () => {
+        it("should return null when chunk is missing", async () => {
             const fileId = (0, utils_1.newid)();
             const metadata = {
                 fileId,
-                name: 'test.txt',
+                name: "test.txt",
                 fileSize: 100,
-                fileHash: 'hash123',
-                chunkHashes: ['hash1', 'hash2'],
+                fileHash: "hash123",
+                chunkHashes: ["hash1", "hash2"],
             };
             // Insert metadata directly without saving chunks
             await fileTable.dataSource.insert(metadata);
             const result = await fileTable.getFileContents(fileId);
             expect(result).toBeNull();
         });
-        it('should return null when chunk is missing during read', async () => {
-            const result = await fileTable.getFileContents('non-existent');
+        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 () => {
+    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 data = new Uint8Array(Buffer.from("Delete me", "utf8"));
             const metadata = {
                 fileId,
-                name: 'delete.txt',
+                name: "delete.txt",
                 fileSize: data.length,
-                mimeType: 'text/plain',
+                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];
+            const chunkHash = saved.chunkHashes?.[0];
             expect(await mockFileOps.fileExists(`file_chunks/${chunkHash}`)).toBe(true);
             // Delete file
             await fileTable.deleteFile(fileId);
@@ -243,24 +243,24 @@ describe('FileTable', () => {
             expect(await fileTable.getFileContents(fileId)).toBeNull();
             expect(await mockFileOps.fileExists(`file_chunks/${chunkHash}`)).toBe(true);
         });
-        it('should handle deleting non-existent file gracefully', async () => {
+        it("should handle deleting non-existent file gracefully", async () => {
             // Should not throw
-            await fileTable.deleteFile('non-existent');
+            await fileTable.deleteFile("non-existent");
         });
-        it('should delete multi-chunk file from database but preserve chunks', async () => {
+        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 data = new Uint8Array(Buffer.alloc(file_types_1.FILE_CHUNK_SIZE + 100, "C"));
             const metadata = {
                 fileId,
-                name: 'multi.txt',
+                name: "multi.txt",
                 fileSize: data.length,
-                mimeType: 'text/plain',
+                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];
+            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
@@ -271,23 +271,23 @@ describe('FileTable', () => {
             expect(await mockFileOps.fileExists(`file_chunks/${chunk1Hash}`)).toBe(true);
         });
     });
-    describe('chunk deduplication', () => {
-        it('should deduplicate identical chunks across different files', async () => {
+    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 data = new Uint8Array(Buffer.from("Identical content for deduplication test", "utf8"));
             const metadata1 = {
                 fileId: fileId1,
-                name: 'file1.txt',
+                name: "file1.txt",
                 fileSize: data.length,
-                mimeType: 'text/plain',
+                mimeType: "text/plain",
             };
             const metadata2 = {
                 fileId: fileId2,
-                name: 'file2.txt',
+                name: "file2.txt",
                 fileSize: data.length,
-                mimeType: 'text/plain',
+                mimeType: "text/plain",
             };
             // Save both files
             const saved1 = await fileTable.saveFile(metadata1, data);
@@ -295,10 +295,11 @@ describe('FileTable', () => {
             // 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);
+            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);
@@ -306,16 +307,16 @@ describe('FileTable', () => {
             expect(new Uint8Array(file2Data)).toEqual(data);
         });
     });
-    describe('Merkle tree (chunk index files)', () => {
-        it('should use direct chunk hashes for files under threshold', async () => {
+    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 smallData = new Uint8Array(Buffer.from("Small file content for testing", "utf8"));
             const metadata = {
                 fileId,
-                name: 'small.bin',
+                name: "small.bin",
                 fileSize: smallData.length,
-                mimeType: 'application/octet-stream',
+                mimeType: "application/octet-stream",
             };
             // Save small file
             const result = await fileTable.saveFile(metadata, smallData);
@@ -327,19 +328,19 @@ describe('FileTable', () => {
             const retrievedData = await fileTable.getFileContents(fileId);
             expect(new Uint8Array(retrievedData)).toEqual(smallData);
         });
-        it('should use recursive index files for very large files', async () => {
+        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 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',
+                    name: "large.bin",
                     fileSize: largeData.length,
-                    mimeType: 'application/octet-stream',
+                    mimeType: "application/octet-stream",
                 };
                 // Save large file - should create recursive index file
                 const result = await fileTable.saveFile(metadata, largeData);
@@ -353,68 +354,68 @@ describe('FileTable', () => {
                 // 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);
+                expect(indexFile?.isIndexFile).toBe(true);
                 // The index file should contain JSON data
-                expect(indexFile.mimeType).toBe('application/json');
-                expect(indexFile.name).toMatch(/^index-.*\.json$/);
+                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 () => {
+        it("should handle missing index file gracefully", async () => {
             const fileId = (0, utils_1.newid)();
             const metadata = {
                 fileId,
-                name: 'test.txt',
+                name: "test.txt",
                 fileSize: 100,
-                fileHash: 'hash123',
-                indexFileId: 'missing_index_file_id',
+                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');
+            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 () => {
+    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',
+                    name: "stream-test.txt",
                     fileSize: 0, // Will be calculated
-                    mimeType: 'text/plain',
+                    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')));
+                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.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!');
+                expect(Buffer.from(retrievedData).toString("utf8")).toBe("Hello, streaming world!");
             });
-            it('should handle large file streaming across multiple chunks', async () => {
+            it("should handle large file streaming across multiple chunks", async () => {
                 const fileId = (0, utils_1.newid)();
                 const metadata = {
                     fileId,
-                    name: 'large-stream.bin',
+                    name: "large-stream.bin",
                     fileSize: 0,
-                    mimeType: 'application/octet-stream',
+                    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
+                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();
@@ -423,56 +424,54 @@ describe('FileTable', () => {
                 // 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
+                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 () => {
+            it("should support aborting a write stream", async () => {
                 const fileId = (0, utils_1.newid)();
                 const metadata = {
                     fileId,
-                    name: 'aborted.txt',
+                    name: "aborted.txt",
                     fileSize: 0,
-                    mimeType: 'text/plain',
+                    mimeType: "text/plain",
                 };
                 const writeStream = await fileTable.createWriteStream(metadata);
-                await writeStream.write(new Uint8Array(Buffer.from('Some data', 'utf8')));
+                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');
+                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');
+                await expect(writeStream.finalize()).rejects.toThrow("Cannot finalize aborted stream");
             });
-            it('should track progress during streaming', async () => {
+            it("should track progress during streaming", async () => {
                 const fileId = (0, utils_1.newid)();
                 const metadata = {
                     fileId,
-                    name: 'progress.txt',
+                    name: "progress.txt",
                     fileSize: 0,
-                    mimeType: 'text/plain',
+                    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')));
+                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')));
+                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 () => {
+            it("should handle finalize with multiple complete chunks in buffer", async () => {
                 const fileId = (0, utils_1.newid)();
                 const metadata = {
                     fileId,
-                    name: 'buffered-chunks.bin',
+                    name: "buffered-chunks.bin",
                     fileSize: 0,
-                    mimeType: 'application/octet-stream',
+                    mimeType: "application/octet-stream",
                 };
                 const writeStream = await fileTable.createWriteStream(metadata);
                 // Write data that will create multiple complete chunks but don't trigger processCompleteChunks
@@ -495,122 +494,122 @@ describe('FileTable', () => {
                 expect(new Uint8Array(retrievedData)).toEqual(data);
             });
         });
-        describe('FileReadStream', () => {
-            it('should read file data in chunks using read stream', async () => {
+        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 originalData = new Uint8Array(Buffer.from("This is test data for streaming read operations!", "utf8"));
                 const metadata = {
                     fileId,
-                    name: 'read-test.txt',
+                    name: "read-test.txt",
                     fileSize: originalData.length,
-                    mimeType: 'text/plain',
+                    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();
+                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.name).toBe("read-test.txt");
                 expect(meta.fileSize).toBe(originalData.length);
             });
-            it('should support seeking within file', async () => {
+            it("should support seeking within file", async () => {
                 const fileId = (0, utils_1.newid)();
-                const originalData = new Uint8Array(Buffer.from('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'utf8'));
+                const originalData = new Uint8Array(Buffer.from("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ", "utf8"));
                 const metadata = {
                     fileId,
-                    name: 'seek-test.txt',
+                    name: "seek-test.txt",
                     fileSize: originalData.length,
-                    mimeType: 'text/plain',
+                    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);
+                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);
+                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);
+                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);
+                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 () => {
+            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 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',
+                    name: "large-seek-test.bin",
                     fileSize: largeData.length,
-                    mimeType: 'application/octet-stream',
+                    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
+                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
+                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);
+                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
+                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);
+                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
+                expect(inThirdChunk?.every((b) => b === 67)).toBe(true); // All C's
             });
-            it('should handle seek error conditions', async () => {
+            it("should handle seek error conditions", async () => {
                 const fileId = (0, utils_1.newid)();
-                const data = new Uint8Array(Buffer.from('Short test data', 'utf8'));
+                const data = new Uint8Array(Buffer.from("Short test data", "utf8"));
                 const metadata = {
                     fileId,
-                    name: 'error-test.txt',
+                    name: "error-test.txt",
                     fileSize: data.length,
-                    mimeType: 'text/plain',
+                    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');
+                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');
+                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);
+                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();
+                const atEof = await readStream?.read();
                 expect(atEof).toBeNull();
             });
-            it('should handle large file streaming reads', async () => {
+            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;
@@ -621,66 +620,66 @@ describe('FileTable', () => {
                 const largeData = new Uint8Array(buffer);
                 const metadata = {
                     fileId,
-                    name: 'large-read.bin',
+                    name: "large-read.bin",
                     fileSize: largeData.length,
-                    mimeType: 'application/octet-stream',
+                    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);
+                const firstChunk = await readStream?.read(chunkSize);
                 expect(firstChunk?.length).toBe(chunkSize);
-                expect(firstChunk?.every(b => b === 65)).toBe(true); // All 'A's
+                expect(firstChunk?.every((b) => b === 65)).toBe(true); // All 'A's
                 // Read remainder
-                const remainder = await readStream.read();
+                const remainder = await readStream?.read();
                 expect(remainder?.length).toBe(1000);
-                expect(remainder?.every(b => b === 66)).toBe(true); // All 'B's
+                expect(remainder?.every((b) => b === 66)).toBe(true); // All 'B's
                 // Should be at EOF
-                const eof = await readStream.read();
+                const eof = await readStream?.read();
                 expect(eof).toBeNull();
-                expect(readStream.isEOF()).toBe(true);
+                expect(readStream?.isEOF()).toBe(true);
             });
-            it('should return null for non-existent file', async () => {
-                const readStream = await fileTable.openReadStream('non-existent-file');
+            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 () => {
+            it("should handle partial reads correctly", async () => {
                 const fileId = (0, utils_1.newid)();
-                const data = new Uint8Array(Buffer.from('ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'utf8'));
+                const data = new Uint8Array(Buffer.from("ABCDEFGHIJKLMNOPQRSTUVWXYZ", "utf8"));
                 const metadata = {
                     fileId,
-                    name: 'partial-read.txt',
+                    name: "partial-read.txt",
                     fileSize: data.length,
-                    mimeType: 'text/plain',
+                    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);
+                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();
+                const eof = await readStream?.read();
                 expect(eof).toBeNull();
             });
-            it('should return null when chunk is unavailable', async () => {
+            it("should return null when chunk is unavailable", async () => {
                 const fileId = (0, utils_1.newid)();
                 const metadata = {
                     fileId,
-                    name: 'missing-chunk.txt',
+                    name: "missing-chunk.txt",
                     fileSize: 50,
-                    fileHash: 'hash123',
-                    chunkHashes: ['missing_chunk_hash'],
+                    fileHash: "hash123",
+                    chunkHashes: ["missing_chunk_hash"],
                 };
                 // Insert file metadata without storing the actual chunk
                 await fileTable.dataSource.insert(metadata);
@@ -690,16 +689,16 @@ describe('FileTable', () => {
                 expect(result).toBeNull();
             });
         });
-        describe('Round-trip streaming', () => {
-            it('should write and read back identical data using streams', async () => {
+        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 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',
+                    name: "roundtrip.txt",
                     fileSize: 0,
-                    mimeType: 'text/plain',
+                    mimeType: "text/plain",
                 };
                 // Write using stream
                 const writeStream = await fileTable.createWriteStream(metadata);
@@ -717,11 +716,11 @@ describe('FileTable', () => {
                 // Read back using stream
                 const readStream = await fileTable.openReadStream(fileId);
                 expect(readStream).toBeTruthy();
-                const readBuffer = await readStream.readAll();
+                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);
+                expect(Buffer.from(readBuffer).toString("utf8")).toBe(testData);
             });
         });
     });