@openstax/ts-utils 1.34.0 → 1.35.0

package/packages/utils/src/services/documentStore/unversioned/file-system.spec.ts

@@ -1,629 +0,0 @@
-import { TextEncoder } from 'util';
-import { hashValue } from '../../..';
-import { fileSystemUnversionedDocumentStore } from './file-system';
-
-type TTestDocument = {
-  coolId: string;
-  counter?: number;
-  name: string;
-};
-
-describe('fileSystemUnversionedDocumentStore', () => {
-  const config = {fileSystem: {tableName: 'db'}};
-  const middleware = {};
-  let mkdirSpy: jest.SpyInstance;
-  let readdirSpy: jest.SpyInstance;
-  let readFileSpy: jest.SpyInstance;
-  let writeFileSpy: jest.SpyInstance;
-  let data: string[];
-  let dataIndex: number;
-  let mkdirError: Error | null = null;
-  let readError: Error | null = null;
-  let writeError: Error | null = null;
-  let fs: Pick<typeof import('fs'), 'mkdir' | 'readdir' | 'readFile' | 'writeFile'>;
-
-  let consoleError: jest.SpyInstance;
-
-  beforeEach(() => {
-    mkdirError = null;
-    readError = null;
-    writeError = null;
-    data = [];
-    dataIndex = 0;
-
-    consoleError = jest.spyOn(console, 'error').mockImplementation(() => null);
-
-    mkdirSpy = jest.fn()
-      .mockImplementation((_dir, _options, cb) => cb(mkdirError));
-    readdirSpy = jest.fn()
-      .mockImplementation((_dir, cb) => cb(readError, ['123456.json']));
-    readFileSpy = jest.fn().mockImplementation(
-      (_file, cb) => cb(readError, Buffer.from(new TextEncoder().encode(data[dataIndex++]).buffer))
-    );
-    writeFileSpy = jest.fn()
-      .mockImplementation((_file, _data, cb) => cb(writeError));
-
-    fs = {mkdir: mkdirSpy, readdir: readdirSpy, readFile: readFileSpy, writeFile: writeFileSpy} as any;
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-    consoleError.mockRestore();
-  });
-
-  describe('loadAllDocumentsTheBadWay', () => {
-    it('returns all records', async() => {
-      const testDoc = {coolId: 'my-document-id', name: 'my-doc'};
-      data.push(JSON.stringify(testDoc));
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId', {skipAssert: true});
-
-      expect(await store.loadAllDocumentsTheBadWay()).toEqual([testDoc]);
-    });
-
-    it('throws on mkdir error', async() => {
-      mkdirError = new Error('no space left on device');
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId', {skipAssert: false});
-      await expect(store.loadAllDocumentsTheBadWay()).rejects.toThrow(mkdirError);
-    });
-
-    it('throws on file read error', async() => {
-      readError = new Error('foobar error');
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      await expect(store.loadAllDocumentsTheBadWay()).rejects.toThrow(readError);
-    });
-
-    it('throws if data is invalid JSON', async() => {
-      data.push('not json');
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      await expect(store.loadAllDocumentsTheBadWay()).rejects.toThrow('Unexpected token');
-    });
-
-    it('throws if data is non-object JSON', async() => {
-      data.push(JSON.stringify('asf'));
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-
-      await expect(store.getItem('my-document-id')).rejects.toThrow('unexpected non-object JSON');
-    });
-  });
-
-  describe('getItemsByField', () => {
-    it('gets items', async() => {
-      const testDoc = {coolId: 'my-document-id', name: 'my-doc'};
-      data.push(JSON.stringify(testDoc));
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-
-      const result = await store.getItemsByField('name', 'my-doc');
-      expect(result.items).toEqual([testDoc]);
-      expect(result.nextPageToken).toBeUndefined();
-    });
-
-    it('gets a second page', async() => {
-      const testDocs = Array.from({length: 15}, (_, i) => ({coolId: `my-document-id-${i}`, name: 'my-doc'}));
-      data.push(...testDocs.map(doc => JSON.stringify(doc)));
-      readdirSpy.mockImplementation((_dir, cb) => cb(readError, testDocs.map(doc => `${hashValue(doc.coolId)}.json`)));
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-
-      const page1 = await store.getItemsByField('name', 'my-doc');
-      expect(page1.items).toHaveLength(10);
-      expect(page1.nextPageToken).toBeDefined();
-
-      dataIndex = 0; // reset the mock loader
-
-      const page2 = await store.getItemsByField('name', 'my-doc', page1.nextPageToken);
-      expect(page2.items).toHaveLength(5);
-      expect(page2.nextPageToken).toBeUndefined();
-    });
-  });
-
-  describe('batchGetItem', () => {
-    it('allows loading records from multiple files', async() => {
-      const testDoc = {coolId: 'my-document-id', name: 'my-doc'};
-      const testDoc2 = {coolId: 'my-document-id-2', name: 'my-doc-2'};
-      data.push(JSON.stringify(testDoc));
-      data.push(JSON.stringify(testDoc2));
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-
-      expect(await store.batchGetItem(['my-document-id', 'my-document-id-2'])).toEqual([testDoc, testDoc2]);
-    });
-
-    it('returns empty array for non-existent ids', async() => {
-      const testDoc = {coolId: 'my-document-id', name: 'my-doc'};
-      const testDoc2 = {coolId: 'my-document-id-2', name: 'my-doc-2'};
-      data.push(JSON.stringify(testDoc));
-      data.push(JSON.stringify(testDoc2));
-      readError = new Error('file not found');
-      Object.defineProperty(readError, 'code', { value: 'ENOENT' });
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      expect(await store.batchGetItem(['my-document-id', 'my-document-id-2'])).toEqual([]);
-    });
-
-    it('throws on file read error', async() => {
-      readError = new Error('foobar error');
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      await expect(store.batchGetItem(['my-document-id', 'my-document-id-2'])).rejects.toThrow(readError);
-    });
-
-    it('throws if data is invalid JSON', async() => {
-      data.push('not json');
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      await expect(store.batchGetItem(['my-document-id', 'my-document-id-2'])).rejects.toThrow('Unexpected token');
-    });
-
-    it('throws if data is non-object JSON', async() => {
-      data.push(JSON.stringify('asf'));
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-
-      await expect(store.batchGetItem(['my-document-id', 'my-document-id-2'])).rejects.toThrow('unexpected non-object JSON');
-    });
-  });
-
-  describe('getItem', () => {
-    it('allows loading records from a file', async() => {
-      const testDoc = {coolId: 'my-document-id', name: 'my-doc'};
-      data.push(JSON.stringify(testDoc));
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-
-      expect(await store.getItem('my-document-id')).toEqual(testDoc);
-    });
-
-    it('returns undefined for non-existent id', async() => {
-      const testDoc = {coolId: 'my-document-id', name: 'my-doc'};
-      data.push(JSON.stringify(testDoc));
-      readError = new Error('file not found');
-      Object.defineProperty(readError, 'code', { value: 'ENOENT' });
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      expect(await store.getItem('my-document')).toBeUndefined();
-    });
-
-    it('throws on file read error', async() => {
-      readError = new Error('foobar error');
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      await expect(store.getItem('my-document-id')).rejects.toThrow(readError);
-    });
-
-    it('throws if data is invalid JSON', async() => {
-      data.push('not json');
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      await expect(store.getItem('my-document-id')).rejects.toThrow('Unexpected token');
-    });
-
-    it('throws if data is non-object JSON', async() => {
-      data.push(JSON.stringify('asf'));
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-
-      await expect(store.getItem('my-document-id')).rejects.toThrow('unexpected non-object JSON');
-    });
-  });
-
-  describe('incrementItemAttribute', () => {
-    it('increments the given attribute, starting from 0 if undefined', async() => {
-      const testDoc = {coolId: 'my-document-id'};
-      data.push(JSON.stringify(testDoc));
-      data.push(JSON.stringify({...testDoc, counter: 1}));
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-
-      expect(await store.incrementItemAttribute('my-document-id', 'counter')).toBe(1);
-      const testData = JSON.stringify({...testDoc, counter: 1}, null, 2);
-      expect(writeFileSpy).toHaveBeenCalledWith(`file/path/to/db/${hashValue(testDoc.coolId)}.json`, testData, expect.anything());
-      expect(await store.incrementItemAttribute('my-document-id', 'counter')).toBe(2);
-      const testData2 = JSON.stringify({...testDoc, counter: 2}, null, 2);
-      expect(writeFileSpy).toHaveBeenCalledWith(`file/path/to/db/${hashValue(testDoc.coolId)}.json`, testData2, expect.anything());
-    });
-
-    it('throws if the document does not exist', async() => {
-      data.push('null');
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      await expect(
-        store.incrementItemAttribute('my-document-id', 'counter')
-      ).rejects.toThrow('Item with coolId "my-document-id" does not exist');
-      expect(writeFileSpy).not.toHaveBeenCalled();
-    });
-
-    it('throws on file write error', async() => {
-      const testDoc = {coolId: 'my-document-id', counter: 41};
-      data.push(JSON.stringify(testDoc));
-      writeError = new Error('foobar error');
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      await expect(store.incrementItemAttribute('my-document-id', 'counter')).rejects.toThrow(writeError);
-    });
-  });
-
-  describe('patchItem', () => {
-    beforeAll(() => {
-      jest.useFakeTimers();
-      jest.setSystemTime(new Date(2020, 6, 28));
-    });
-
-    afterAll(() => {
-      jest.useRealTimers();
-    });
-
-    it('overwrites only the given attributes and returns updated document', async() => {
-      const testDoc = {coolId: 'my-document-id', name: 'my-doc', counter: 42};
-      const testDoc2 = {coolId: 'my-document-id', name: 'my-doc-2'};
-      data.push(JSON.stringify(testDoc));
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      const result = await store.patchItem(testDoc2);
-      const testData = JSON.stringify({...testDoc2, counter: 42}, null, 2);
-      expect(writeFileSpy).toHaveBeenCalledWith(`file/path/to/db/${hashValue(testDoc.coolId)}.json`, testData, expect.anything());
-      expect(result).toEqual({...testDoc2, counter: 42});
-    });
-
-    it('throws if the key attribute is not provided', async() => {
-      const testDoc = {name: 'my-doc'};
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      await expect(store.patchItem(testDoc)).rejects.toThrow('Key attribute "coolId" is required for patchItem');
-    });
-
-    it('throws if there are no updates', async() => {
-      const testDoc = {coolId: 'my-document-id'};
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      await expect(store.patchItem(testDoc)).rejects.toThrow('No attributes to update');
-    });
-
-    it('throws if the document does not exist', async() => {
-      const testDoc = {coolId: 'my-document-id', name: 'my-doc'};
-      data.push('null');
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      await expect(store.patchItem(testDoc)).rejects.toThrow('Item with coolId "my-document-id" does not exist');
-      expect(writeFileSpy).not.toHaveBeenCalled();
-    });
-
-    it('throws on file write error', async() => {
-      const testDoc = {coolId: 'my-document-id', name: 'my-doc'};
-      data.push(JSON.stringify(testDoc));
-      writeError = new Error('foobar error');
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      await expect(store.patchItem(testDoc)).rejects.toThrow(writeError);
-    });
-  });
-
-  describe('putItem', () => {
-    beforeAll(() => {
-      jest.useFakeTimers();
-      jest.setSystemTime(new Date(2020, 6, 28));
-    });
-
-    afterAll(() => {
-      jest.useRealTimers();
-    });
-
-    it('saves and returns new document', async() => {
-      const testDoc = {coolId: 'my-document-id', name: 'my-doc'};
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      const result = await store.putItem(testDoc);
-      const testData = JSON.stringify(testDoc, null, 2);
-      expect(writeFileSpy).toHaveBeenCalledWith(`file/path/to/db/${hashValue(testDoc.coolId)}.json`, testData, expect.anything());
-      expect(result).toEqual(testDoc);
-    });
-
-    it('overwrites and returns updated document', async() => {
-      const testDoc = {coolId: 'my-document-id', name: 'my-doc'};
-      const testDoc2 = {coolId: 'my-document-id', name: 'my-doc-2'};
-      data.push(JSON.stringify(testDoc));
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      const result = await store.putItem(testDoc2);
-      const testData = JSON.stringify(testDoc2, null, 2);
-      expect(writeFileSpy).toHaveBeenCalledWith(`file/path/to/db/${hashValue(testDoc.coolId)}.json`, testData, expect.anything());
-      expect(result).toEqual(testDoc2);
-    });
-
-    it('throws on file write error', async() => {
-      writeError = new Error('foobar error');
-      const testDoc = {coolId: 'my-document-id', name: 'my-doc'};
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      await expect(store.putItem(testDoc)).rejects.toThrow(writeError);
-    });
-  });
-
-  describe('createItem', () => {
-    it('creates new file with document data', async() => {
-      const testDoc = {coolId: 'new-document-id', name: 'new-doc'};
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      
-      readFileSpy.mockImplementation((_path, callback) => {
-        const error = new Error('File not found');
-        (error as any).code = 'ENOENT';
-        callback(error);
-      });
-      
-      const result = await store.createItem(testDoc);
-      
-      const expectedData = JSON.stringify(testDoc, null, 2);
-      expect(writeFileSpy).toHaveBeenCalledWith(
-        `file/path/to/db/${hashValue(testDoc.coolId)}.json`, 
-        expectedData, 
-        expect.anything()
-      );
-      expect(result).toEqual(testDoc);
-    });
-
-    it('throws ConflictError if file already exists', async() => {
-      const testDoc = {coolId: 'existing-document-id', name: 'existing-doc'};
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      
-      readFileSpy.mockImplementation((_path, callback) => {
-        callback(null, Buffer.from('{"coolId":"existing-document-id","name":"existing-doc"}'));
-      });
-      
-      await expect(store.createItem(testDoc)).rejects.toThrow('Item with coolId "existing-document-id" already exists');
-    });
-
-    it('throws on read errors during existence check', async() => {
-      const testDoc = {coolId: 'new-document-id', name: 'new-doc'};
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      
-      const readError = new Error('Permission denied');
-      readFileSpy.mockImplementation((_path, callback) => {
-        callback(readError);
-      });
-      
-      await expect(store.createItem(testDoc)).rejects.toThrow('Permission denied');
-    });
-
-    it('throws on file write error', async() => {
-      const testDoc = {coolId: 'new-document-id', name: 'new-doc'};
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      
-      readFileSpy.mockImplementation((_path, callback) => {
-        const error = new Error('File not found');
-        (error as any).code = 'ENOENT';
-        callback(error);
-      });
-      
-      writeError = new Error('Write failed');
-      
-      await expect(store.createItem(testDoc)).rejects.toThrow('Write failed');
-    });
-  });
-
-  describe('batchCreateItem', () => {
-    it('creates multiple new files with document data', async() => {
-      const testDocs = [
-        {coolId: 'new-document-1', name: 'new-doc-1'},
-        {coolId: 'new-document-2', name: 'new-doc-2'},
-        {coolId: 'new-document-3', name: 'new-doc-3'}
-      ];
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      
-      readFileSpy.mockImplementation((_path, callback) => {
-        const error = new Error('File not found');
-        (error as any).code = 'ENOENT';
-        callback(error);
-      });
-      
-      const result = await store.batchCreateItem(testDocs);
-      
-      expect(writeFileSpy).toHaveBeenCalledTimes(3);
-      testDocs.forEach((testDoc) => {
-        const expectedData = JSON.stringify(testDoc, null, 2);
-        expect(writeFileSpy).toHaveBeenCalledWith(
-          `file/path/to/db/${hashValue(testDoc.coolId)}.json`, 
-          expectedData, 
-          expect.anything()
-        );
-      });
-      expect(result).toEqual({ successful: testDocs, failed: [] });
-    });
-
-    it('handles empty array', async() => {
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      
-      const result = await store.batchCreateItem([]);
-      
-      expect(readFileSpy).not.toHaveBeenCalled();
-      expect(writeFileSpy).not.toHaveBeenCalled();
-      expect(result).toEqual({ successful: [], failed: [] });
-    });
-
-    it('returns successful and failed items when some already exist', async() => {
-      const testDocs = [
-        {coolId: 'new-document-1', name: 'new-doc-1'},
-        {coolId: 'existing-document', name: 'existing-doc'},
-        {coolId: 'new-document-3', name: 'new-doc-3'}
-      ];
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      
-      readFileSpy
-        .mockImplementationOnce((_path, callback) => {
-          const error = new Error('File not found');
-          (error as any).code = 'ENOENT';
-          callback(error);
-        })
-        .mockImplementationOnce((_path, callback) => {
-          callback(null, Buffer.from('{"coolId":"existing-document","name":"existing-doc"}'));
-        })
-        .mockImplementationOnce((_path, callback) => {
-          const error = new Error('File not found');
-          (error as any).code = 'ENOENT';
-          callback(error);
-        });
-      
-      const result = await store.batchCreateItem(testDocs);
-      
-      expect(result.successful).toEqual([testDocs[0], testDocs[2]]);
-      expect(result.failed).toHaveLength(1);
-      expect(result.failed[0].item).toEqual(testDocs[1]);
-      expect(result.failed[0].error.message).toContain('Item with coolId "existing-document" already exists');
-    });
-
-    it('returns read errors in failed array', async() => {
-      const testDocs = [{coolId: 'new-document-1', name: 'new-doc-1'}];
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      
-      const readError = new Error('Permission denied');
-      readFileSpy.mockImplementation((_path, callback) => {
-        callback(readError);
-      });
-      
-      const result = await store.batchCreateItem(testDocs);
-      
-      expect(result.successful).toEqual([]);
-      expect(result.failed).toHaveLength(1);
-      expect(result.failed[0].item).toEqual(testDocs[0]);
-      expect(result.failed[0].error.message).toBe('Permission denied');
-    });
-
-    it('returns write errors in failed array', async() => {
-      const testDocs = [
-        {coolId: 'new-document-1', name: 'new-doc-1'},
-        {coolId: 'new-document-2', name: 'new-doc-2'}
-      ];
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      
-      readFileSpy.mockImplementation((_path, callback) => {
-        const error = new Error('File not found');
-        (error as any).code = 'ENOENT';
-        callback(error);
-      });
-      
-      writeError = new Error('Write failed');
-      
-      const result = await store.batchCreateItem(testDocs);
-      
-      expect(result.successful).toEqual([]);
-      expect(result.failed).toHaveLength(2);
-      expect(result.failed[0].item).toEqual(testDocs[0]);
-      expect(result.failed[0].error.message).toBe('Write failed');
-      expect(result.failed[1].item).toEqual(testDocs[1]);
-      expect(result.failed[1].error.message).toBe('Write failed');
-    });
-
-    it('processes single item', async() => {
-      const testDoc = {coolId: 'new-document-1', name: 'new-doc-1'};
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      
-      readFileSpy.mockImplementation((_path, callback) => {
-        const error = new Error('File not found');
-        (error as any).code = 'ENOENT';
-        callback(error);
-      });
-      
-      const result = await store.batchCreateItem([testDoc]);
-      
-      expect(writeFileSpy).toHaveBeenCalledTimes(1);
-      expect(result).toEqual({ successful: [testDoc], failed: [] });
-    });
-
-    it('ignores concurrency parameter for filesystem', async() => {
-      const testDocs = [
-        {coolId: 'new-document-1', name: 'new-doc-1'},
-        {coolId: 'new-document-2', name: 'new-doc-2'}
-      ];
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId');
-      
-      readFileSpy.mockImplementation((_path, callback) => {
-        const error = new Error('File not found');
-        (error as any).code = 'ENOENT';
-        callback(error);
-      });
-      
-      const result = await store.batchCreateItem(testDocs, 100); // High concurrency ignored
-      
-      expect(result).toEqual({ successful: testDocs, failed: [] });
-    });
-
-    it('calls batchAfterWrite instead of individual afterWrite', async() => {
-      const afterWrite = jest.fn();
-      const batchAfterWrite = jest.fn();
-      const testDocs = [
-        {coolId: 'new-document-1', name: 'new-doc-1'},
-        {coolId: 'new-document-2', name: 'new-doc-2'}
-      ];
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId', {afterWrite, batchAfterWrite});
-      
-      readFileSpy.mockImplementation((_path, callback) => {
-        const error = new Error('File not found');
-        (error as any).code = 'ENOENT';
-        callback(error);
-      });
-      
-      const result = await store.batchCreateItem(testDocs);
-      
-      // Should call batchAfterWrite once with all successful items
-      expect(batchAfterWrite).toHaveBeenCalledTimes(1);
-      expect(batchAfterWrite).toHaveBeenCalledWith(testDocs);
-      
-      // Should NOT call individual afterWrite when batchAfterWrite is defined
-      expect(afterWrite).not.toHaveBeenCalled();
-      
-      expect(result).toEqual({ successful: testDocs, failed: [] });
-    });
-
-    it('calls batchAfterWrite only with successful items', async() => {
-      const batchAfterWrite = jest.fn();
-      const testDocs = [
-        {coolId: 'new-document-1', name: 'new-doc-1'},
-        {coolId: 'existing-document', name: 'existing-doc'},
-        {coolId: 'new-document-3', name: 'new-doc-3'}
-      ];
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId', {batchAfterWrite});
-      
-      readFileSpy
-        .mockImplementationOnce((_path, callback) => {
-          const error = new Error('File not found');
-          (error as any).code = 'ENOENT';
-          callback(error);
-        })
-        .mockImplementationOnce((_path, callback) => {
-          callback(null, Buffer.from('{"coolId":"existing-document","name":"existing-doc"}'));
-        })
-        .mockImplementationOnce((_path, callback) => {
-          const error = new Error('File not found');
-          (error as any).code = 'ENOENT';
-          callback(error);
-        });
-      
-      const result = await store.batchCreateItem(testDocs);
-      
-      // Should call batchAfterWrite with only successful items
-      expect(batchAfterWrite).toHaveBeenCalledTimes(1);
-      expect(batchAfterWrite).toHaveBeenCalledWith([testDocs[0], testDocs[2]]);
-      
-      expect(result.successful).toEqual([testDocs[0], testDocs[2]]);
-      expect(result.failed).toHaveLength(1);
-    });
-
-    it('does not call batchAfterWrite if no items succeed', async() => {
-      const batchAfterWrite = jest.fn();
-      const testDocs = [{coolId: 'existing-document', name: 'existing-doc'}];
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId', {batchAfterWrite});
-      
-      readFileSpy.mockImplementation((_path, callback) => {
-        callback(null, Buffer.from('{"coolId":"existing-document","name":"existing-doc"}'));
-      });
-      
-      const result = await store.batchCreateItem(testDocs);
-      
-      // Should NOT call batchAfterWrite when no items succeed
-      expect(batchAfterWrite).not.toHaveBeenCalled();
-      
-      expect(result.successful).toEqual([]);
-      expect(result.failed).toHaveLength(1);
-    });
-
-    it('falls back to individual afterWrite when batchAfterWrite is not defined', async() => {
-      const afterWrite = jest.fn();
-      const testDocs = [
-        {coolId: 'new-document-1', name: 'new-doc-1'},
-        {coolId: 'new-document-2', name: 'new-doc-2'}
-      ];
-      const store = fileSystemUnversionedDocumentStore({fs, dataDir: 'file/path/to'})<TTestDocument>()(config)(middleware, 'coolId', {afterWrite});
-      
-      readFileSpy.mockImplementation((_path, callback) => {
-        const error = new Error('File not found');
-        (error as any).code = 'ENOENT';
-        callback(error);
-      });
-      
-      const result = await store.batchCreateItem(testDocs);
-      
-      // Should call afterWrite for each item when batchAfterWrite is not defined
-      expect(afterWrite).toHaveBeenCalledTimes(2);
-      expect(afterWrite).toHaveBeenCalledWith(testDocs[0]);
-      expect(afterWrite).toHaveBeenCalledWith(testDocs[1]);
-      
-      expect(result).toEqual({ successful: testDocs, failed: [] });
-    });
-  });
-});