@openstax/ts-utils 1.33.1 → 1.34.0

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

@@ -0,0 +1,629 @@
+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: [] });
+    });
+  });
+});