@openstax/ts-utils 1.33.0 → 1.34.0

package/packages/utils/src/services/documentStore/unversioned/dynamodb.spec.ts

@@ -0,0 +1,859 @@
+import * as awsSdk from '@aws-sdk/client-dynamodb';
+import { dynamoUnversionedDocumentStore } from './dynamodb';
+
+jest.mock('@aws-sdk/client-dynamodb', () => {
+  const sendSpy = jest.fn(() => Promise.resolve()) as any;
+   class DynamoDB {
+    static sendSpy = sendSpy;
+    send(...a: any[]) { return DynamoDB.sendSpy(...a); }
+  }
+  return {
+    ...jest.requireActual('@aws-sdk/client-dynamodb'),
+    DynamoDB: DynamoDB
+  };
+});
+
+type TTestDocument = {
+  coolId: string;
+  maybe?: null;
+  name: string;
+  strings?: string[];
+  isCool?: boolean;
+  counter?: number;
+};
+
+describe('dynamoUnversionedDocumentStore', () => {
+  const sendSpy: jest.SpyInstance = (awsSdk.DynamoDB as any).sendSpy;
+  const config = {dynamodb: {tableName: 'cool-table-name'}};
+  const middleware = {};
+  let mockDynamoClient: awsSdk.DynamoDB;
+  let mockClientSend: jest.SpyInstance;
+
+  beforeEach(() => {
+    mockClientSend = jest.fn();
+    mockDynamoClient = {send: mockClientSend} as unknown as awsSdk.DynamoDB;
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('loadAllDocumentsTheBadWay', () => {
+    it('loads pages of documents', async() => {
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+
+      sendSpy.mockReturnValueOnce(Promise.resolve({
+        LastEvaluatedKey: {
+          coolId: {S: 'my-document-id'},
+          timestamp: {N: '123'},
+        },
+        Items: [
+          {
+            coolId: {S: 'my-document-id'},
+            name: {S: 'my-doc-one'},
+          }
+        ]
+      }));
+      sendSpy.mockReturnValueOnce(Promise.resolve({
+        Items: [
+          {
+            coolId: {S: 'my-document-id-two'},
+            name: {S: 'my-doc-two'},
+          }
+        ]
+      }));
+
+      expect(await store.loadAllDocumentsTheBadWay()).toEqual([
+        {
+          coolId: 'my-document-id',
+          name: 'my-doc-one',
+        },
+        {
+          coolId: 'my-document-id-two',
+          name: 'my-doc-two',
+        }
+      ]);
+    });
+
+    it('handles null items', async() => {
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      sendSpy.mockReturnValueOnce(Promise.resolve({
+      }));
+      expect(await store.loadAllDocumentsTheBadWay()).toEqual([
+      ]);
+    });
+  });
+
+  describe('batchGetItem', () => {
+    it('gets documents', async() => {
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+
+      sendSpy.mockReturnValue(Promise.resolve({Responses: {
+        'cool-table-name': [
+          {
+            coolId: {S: 'my-document-id'},
+            maybe: {NULL: true},
+            strings: {L: [{S: 'string1'}, {S: 'string2'}]},
+            name: {S: 'my-doc'},
+            isCool: {BOOL: true}
+          },
+          {
+            coolId: {S: 'my-document-id-2'},
+            maybe: {NULL: true},
+            strings: {L: [{S: 'string3'}, {S: 'string4'}]},
+            name: {S: 'my-doc-2'},
+            isCool: {BOOL: false}
+          }
+        ]
+      }}));
+
+      expect(await store.batchGetItem(['my-document-id', 'my-document-id-2'])).toEqual([
+        {
+          coolId: 'my-document-id',
+          maybe: null,
+          strings: ['string1', 'string2'],
+          name: 'my-doc',
+          isCool: true
+        },
+        {
+          coolId: 'my-document-id-2',
+          maybe: null,
+          strings: ['string3', 'string4'],
+          name: 'my-doc-2',
+          isCool: false
+        },
+      ]);
+    });
+
+    it('gets documents in multiple batches', async() => {
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+
+      sendSpy.mockReturnValueOnce(Promise.resolve({Responses: {
+        'cool-table-name': [
+          {
+            coolId: {S: 'my-document-id'},
+            maybe: {NULL: true},
+            strings: {L: [{S: 'string1'}, {S: 'string2'}]},
+            name: {S: 'my-doc'},
+            isCool: {BOOL: true}
+          },
+        ]
+      }, UnprocessedKeys: {
+        'cool-table-name': { Keys: [ { coolId: { S: 'my-document-id-2' } } ] },
+      }})).mockReturnValueOnce(Promise.resolve({Responses: {
+        'cool-table-name': [
+          {
+            coolId: {S: 'my-document-id-2'},
+            maybe: {NULL: true},
+            strings: {L: [{S: 'string3'}, {S: 'string4'}]},
+            name: {S: 'my-doc-2'},
+            isCool: {BOOL: false}
+          },
+        ]
+      }}));
+
+      expect(await store.batchGetItem(['my-document-id', 'my-document-id-2'])).toEqual([
+        {
+          coolId: 'my-document-id',
+          maybe: null,
+          strings: ['string1', 'string2'],
+          name: 'my-doc',
+          isCool: true
+        },
+        {
+          coolId: 'my-document-id-2',
+          maybe: null,
+          strings: ['string3', 'string4'],
+          name: 'my-doc-2',
+          isCool: false
+        },
+      ]);
+    });
+
+    it('gets empty array for missing documents', async() => {
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      sendSpy.mockReturnValue(Promise.resolve({}));
+      expect(await store.batchGetItem(['my-document-id', 'my-document-id-2'])).toEqual([]);
+    });
+
+    it('throws on weirdo data types', async() => {
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      sendSpy.mockReturnValue(Promise.resolve({Responses: { isCool: {NOT_A_REAL_TYPE: true} }}));
+
+      await expect(async() => store.batchGetItem(['my-document-id', 'my-document-id-2'])).rejects.toThrow();
+    });
+  });
+
+  describe('getItem', () => {
+    it('gets a document', async() => {
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+
+      sendSpy.mockReturnValue(Promise.resolve({Item: {
+        coolId: {S: 'my-document-id'},
+        maybe: {NULL: true},
+        strings: {L: [{S: 'string1'}, {S: 'string2'}]},
+        name: {S: 'my-doc'},
+        isCool: {BOOL: true}
+      }}));
+
+      expect(await store.getItem('my-document-id')).toEqual({
+        coolId: 'my-document-id',
+        maybe: null,
+        strings: ['string1', 'string2'],
+        name: 'my-doc',
+        isCool: true
+      });
+    });
+
+    it('gets undefined for missing document', async() => {
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      sendSpy.mockReturnValue(Promise.resolve({}));
+      expect(await store.getItem('my-document-id')).toBeUndefined();
+    });
+
+    it('throws on weirdo data types', async() => {
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      sendSpy.mockReturnValue(Promise.resolve({Item: { isCool: {NOT_A_REAL_TYPE: true} }}));
+
+      await expect(async() => store.getItem('my-document-id')).rejects.toThrow();
+    });
+  });
+
+  describe('incrementItemAttribute', () => {
+    it('increments the given attribute, starting from 0 if undefined', async() => {
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      sendSpy.mockReturnValueOnce(Promise.resolve({Attributes: {counter: {N: 1}}}));
+      sendSpy.mockReturnValueOnce(Promise.resolve({Attributes: {counter: {N: 2}}}));
+
+      expect(await store.incrementItemAttribute('my-document-id', 'counter')).toBe(1);
+      expect(sendSpy).toHaveBeenCalledWith(expect.objectContaining({
+        input: {
+          Key: {coolId: {S: 'my-document-id'}},
+          TableName: 'cool-table-name',
+          UpdateExpression: 'ADD #f :one',
+          ConditionExpression: 'attribute_exists(#k)',
+          ExpressionAttributeNames: { '#k': 'coolId', '#f': 'counter' },
+          ExpressionAttributeValues: { ':one': { N: '1' } },
+          ReturnValues: 'ALL_NEW',
+        }
+      }));
+      expect(await store.incrementItemAttribute('my-document-id', 'counter')).toBe(2);
+      expect(sendSpy).toHaveBeenCalledWith(expect.objectContaining({
+        input: {
+          Key: {coolId: {S: 'my-document-id'}},
+          TableName: 'cool-table-name',
+          UpdateExpression: 'ADD #f :one',
+          ConditionExpression: 'attribute_exists(#k)',
+          ExpressionAttributeNames: { '#k': 'coolId', '#f': 'counter' },
+          ExpressionAttributeValues: { ':one': { N: '1' } },
+          ReturnValues: 'ALL_NEW',
+        }
+      }));
+    });
+
+    it('calls afterWrite', async() => {
+      const afterWrite = jest.fn();
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId', {afterWrite});
+      sendSpy.mockReturnValueOnce(Promise.resolve({Attributes: {counter: {N: 1}}}));
+
+      expect(await store.incrementItemAttribute('my-document-id', 'counter')).toBe(1);
+      expect(sendSpy).toHaveBeenCalledWith(expect.objectContaining({
+        input: {
+          Key: {coolId: {S: 'my-document-id'}},
+          TableName: 'cool-table-name',
+          UpdateExpression: 'ADD #f :one',
+          ConditionExpression: 'attribute_exists(#k)',
+          ExpressionAttributeNames: { '#k': 'coolId', '#f': 'counter' },
+          ExpressionAttributeValues: { ':one': { N: '1' } },
+          ReturnValues: 'ALL_NEW',
+        }
+      }));
+      expect(afterWrite).toHaveBeenCalledTimes(1);
+      expect(afterWrite).toHaveBeenCalledWith(expect.objectContaining({
+        counter: 1
+      }));
+    });
+
+    it('throws if the document does not exist', async() => {
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+
+      sendSpy.mockReturnValueOnce(Promise.resolve({}));
+      await expect(
+        store.incrementItemAttribute('my-document-id', 'counter')
+      ).rejects.toThrow('Item with coolId "my-document-id" does not exist');
+
+      sendSpy.mockReturnValueOnce(Promise.reject({ name: 'ConditionalCheckFailedException' }));
+      await expect(
+        store.incrementItemAttribute('my-document-id', 'counter')
+      ).rejects.toThrow('Item with coolId "my-document-id" does not exist');
+    });
+
+    it('throws if the document does not return the field', async() => {
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+
+      sendSpy.mockReturnValueOnce(Promise.resolve({Attributes: {}}));
+      await expect(
+        store.incrementItemAttribute('my-document-id', 'counter')
+      ).rejects.toThrow('Item with coolId "my-document-id" did not produce field "counter"');
+    });
+  });
+
+  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'};
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      sendSpy.mockReturnValueOnce(Promise.resolve({
+        Attributes: {coolId: {S: 'my-document-id'}, name: {S: 'my-doc'}, counter: {N: 42}}
+      }));
+      const result = await store.patchItem(testDoc);
+      expect(sendSpy).toHaveBeenCalledWith(expect.objectContaining({
+        input: {
+          Key: { coolId: {S: 'my-document-id'} },
+          TableName: 'cool-table-name',
+          UpdateExpression: 'SET #f0 = :f0',
+          ConditionExpression: 'attribute_exists(#k)',
+          ExpressionAttributeNames: { '#k': 'coolId', '#f0': 'name' },
+          ExpressionAttributeValues: { ':f0': { S: 'my-doc' } },
+          ReturnValues: 'ALL_NEW',
+        }
+      }));
+      expect(result).toEqual({...testDoc, counter: 42});
+    });
+
+    it('calls afterWrite', async() => {
+      const afterWrite = jest.fn();
+      const testDoc = {coolId: 'my-document-id', name: 'my-doc'};
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId', {afterWrite});
+      sendSpy.mockReturnValueOnce(Promise.resolve({
+        Attributes: {coolId: {S: 'my-document-id'}, name: {S: 'my-doc'}, counter: {N: 42}}
+      }));
+      const result = await store.patchItem(testDoc);
+      expect(sendSpy).toHaveBeenCalledWith(expect.objectContaining({
+        input: {
+          Key: { coolId: {S: 'my-document-id'} },
+          TableName: 'cool-table-name',
+          UpdateExpression: 'SET #f0 = :f0',
+          ConditionExpression: 'attribute_exists(#k)',
+          ExpressionAttributeNames: { '#k': 'coolId', '#f0': 'name' },
+          ExpressionAttributeValues: { ':f0': { S: 'my-doc' } },
+          ReturnValues: 'ALL_NEW',
+        }
+      }));
+      expect(result).toEqual({...testDoc, counter: 42});
+      expect(afterWrite).toHaveBeenCalledWith(expect.objectContaining({
+        ...testDoc, counter: 42
+      }));
+    });
+
+    it('throws if the key attribute is not provided', async() => {
+      const testDoc = {name: 'my-doc'};
+      const store = dynamoUnversionedDocumentStore()<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 = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      await expect(store.patchItem(testDoc)).rejects.toThrow('No attributes to update');
+    });
+
+    it('throws on weirdo data types', async() => {
+      const testDoc = {coolId: 'my-document-id', name: 'my-doc', foobar: Buffer.from('asdf')};
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      await expect(async() => store.patchItem(testDoc)).rejects.toThrow();
+    });
+
+    it('throws if the document does not exist', async() => {
+      const testDoc = {coolId: 'my-document-id', name: 'my-doc'};
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+
+      sendSpy.mockReturnValueOnce(Promise.resolve({}));
+      await expect(store.patchItem(testDoc)).rejects.toThrow('Item with coolId "my-document-id" does not exist');
+
+      sendSpy.mockReturnValueOnce(Promise.reject({ name: 'ConditionalCheckFailedException' }));
+      await expect(store.patchItem(testDoc)).rejects.toThrow('Item with coolId "my-document-id" does not exist');
+    });
+  });
+
+  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', isCool: false, maybe: null, strings: ['string1', 'string2']};
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      const result = await store.putItem(testDoc);
+      expect(sendSpy).toHaveBeenCalledWith(expect.objectContaining({
+        input: {
+          TableName: 'cool-table-name',
+          Item: {
+            coolId: {S: 'my-document-id'},
+            strings: {L: [{S: 'string1'}, {S: 'string2'}]},
+            maybe: {NULL: true},
+            name: {S: 'my-doc'},
+            isCool: {BOOL: false}
+          }
+        }
+      }));
+      expect(result).toEqual(testDoc);
+    });
+
+    it('calls afterWrite', async() => {
+      const afterWrite = jest.fn();
+      const testDoc = {coolId: 'my-document-id', name: 'my-doc', isCool: false, maybe: null, strings: ['string1', 'string2']};
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId', {afterWrite});
+      const result = await store.putItem(testDoc);
+      expect(sendSpy).toHaveBeenCalledWith(expect.objectContaining({
+        input: {
+          TableName: 'cool-table-name',
+          Item: {
+            coolId: {S: 'my-document-id'},
+            strings: {L: [{S: 'string1'}, {S: 'string2'}]},
+            maybe: {NULL: true},
+            name: {S: 'my-doc'},
+            isCool: {BOOL: false}
+          }
+        }
+      }));
+      expect(result).toEqual(testDoc);
+      expect(afterWrite).toHaveBeenCalledWith(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'};
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      const result = await store.putItem(testDoc);
+      expect(sendSpy).toHaveBeenCalledWith(expect.objectContaining({
+        input: {
+          TableName: 'cool-table-name',
+          Item: {
+            coolId: {S: 'my-document-id'},
+            name: {S: 'my-doc'},
+          }
+        }
+      }));
+      expect(result).toEqual(testDoc);
+      const result2 = await store.putItem(testDoc2);
+      expect(sendSpy).toHaveBeenCalledWith(expect.objectContaining({
+        input: {
+          TableName: 'cool-table-name',
+          Item: {
+            coolId: {S: 'my-document-id'},
+            name: {S: 'my-doc-2'},
+          }
+        }
+      }));
+      expect(result2).toEqual(testDoc2);
+    });
+
+    it('throws on weirdo data types', async() => {
+      const testDoc = {coolId: 'my-document-id', name: 'my-doc', foobar: Buffer.from('asdf')};
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      await expect(async() => store.putItem(testDoc)).rejects.toThrow();
+    });
+  });
+
+  describe('createItem', () => {
+    beforeAll(() => {
+      jest.useFakeTimers();
+      jest.setSystemTime(new Date(2020, 6, 28));
+    });
+
+    afterAll(() => {
+      jest.useRealTimers();
+    });
+
+    it('creates and returns new document', async() => {
+      const testDoc = {coolId: 'new-document-id', name: 'new-doc'};
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      
+      const result = await store.createItem(testDoc);
+      
+      expect(sendSpy).toHaveBeenCalledWith(expect.objectContaining({
+        input: expect.objectContaining({
+          TableName: 'cool-table-name',
+          Item: expect.objectContaining({
+            coolId: {S: 'new-document-id'},
+            name: {S: 'new-doc'}
+          }),
+          ConditionExpression: 'attribute_not_exists(#k)',
+          ExpressionAttributeNames: {
+            '#k': 'coolId'
+          }
+        })
+      }));
+      expect(result).toEqual(testDoc);
+    });
+
+    it('calls afterWrite callback', async() => {
+      const afterWrite = jest.fn();
+      const testDoc = {coolId: 'new-document-id', name: 'new-doc'};
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId', {afterWrite});
+      
+      await store.createItem(testDoc);
+      expect(afterWrite).toHaveBeenCalledWith(testDoc);
+    });
+
+    it('throws ConflictError if document already exists', async() => {
+      const testDoc = {coolId: 'existing-document-id', name: 'existing-doc'};
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      
+      sendSpy.mockRejectedValue({ name: 'ConditionalCheckFailedException' });
+      
+      await expect(store.createItem(testDoc)).rejects.toThrow('Item with coolId "existing-document-id" already exists');
+    });
+
+    it('throws other errors unchanged', async() => {
+      const testDoc = {coolId: 'new-document-id', name: 'new-doc'};
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      
+      const error = new Error('DynamoDB service error');
+      sendSpy.mockRejectedValue(error);
+      
+      await expect(store.createItem(testDoc)).rejects.toThrow('DynamoDB service error');
+    });
+
+    it('throws on weirdo data types', async() => {
+      const testDoc = {coolId: 'my-document-id', name: 'my-doc', foobar: Buffer.from('asdf')};
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      await expect(async() => store.createItem(testDoc)).rejects.toThrow();
+    });
+  });
+
+  describe('batchCreateItem', () => {
+    beforeAll(() => {
+      jest.useFakeTimers();
+      jest.setSystemTime(new Date(2020, 6, 28));
+    });
+
+    afterAll(() => {
+      jest.useRealTimers();
+    });
+
+    it('creates multiple new documents', 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 = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      
+      sendSpy.mockResolvedValue({}); // Reset mock to success
+      
+      const result = await store.batchCreateItem(testDocs);
+      
+      expect(sendSpy).toHaveBeenCalledTimes(3);
+      testDocs.forEach((testDoc) => {
+        expect(sendSpy).toHaveBeenCalledWith(expect.objectContaining({
+          input: expect.objectContaining({
+            TableName: 'cool-table-name',
+            Item: expect.objectContaining({
+              coolId: {S: testDoc.coolId},
+              name: {S: testDoc.name}
+            }),
+            ConditionExpression: 'attribute_not_exists(#k)',
+            ExpressionAttributeNames: {
+              '#k': 'coolId'
+            }
+          })
+        }));
+      });
+      expect(result).toEqual({ successful: testDocs, failed: [] });
+    });
+
+    it('handles empty array', async() => {
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      
+      const result = await store.batchCreateItem([]);
+      
+      expect(sendSpy).not.toHaveBeenCalled();
+      expect(result).toEqual({ successful: [], failed: [] });
+    });
+
+    it('calls afterWrite callback for each item', 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 = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId', {afterWrite});
+      
+      sendSpy.mockResolvedValue({}); // Reset mock to success
+      
+      const result = await store.batchCreateItem(testDocs);
+      
+      expect(afterWrite).toHaveBeenCalledTimes(2);
+      expect(afterWrite).toHaveBeenCalledWith(testDocs[0]);
+      expect(afterWrite).toHaveBeenCalledWith(testDocs[1]);
+      expect(result).toEqual({ successful: testDocs, 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 = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      
+      sendSpy
+        .mockResolvedValueOnce({}) // First item succeeds
+        .mockRejectedValueOnce({ name: 'ConditionalCheckFailedException' }) // Second item conflicts
+        .mockResolvedValueOnce({}); // Third item succeeds
+      
+      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 other errors in failed array', async() => {
+      const testDocs = [{coolId: 'new-document-1', name: 'new-doc-1'}];
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      
+      const error = new Error('DynamoDB service error');
+      sendSpy.mockRejectedValue(error);
+      
+      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('DynamoDB service error');
+    });
+
+    it('processes single item', async() => {
+      const testDoc = {coolId: 'new-document-1', name: 'new-doc-1'};
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      
+      sendSpy.mockResolvedValue({}); // Reset mock to success
+      
+      const result = await store.batchCreateItem([testDoc]);
+      
+      expect(sendSpy).toHaveBeenCalledTimes(1);
+      expect(result).toEqual({ successful: [testDoc], failed: [] });
+    });
+
+    it('respects custom concurrency parameter', async() => {
+      const testDocs = [
+        {coolId: 'new-document-1', name: 'new-doc-1'},
+        {coolId: 'new-document-2', name: 'new-doc-2'}
+      ];
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+      
+      sendSpy.mockResolvedValue({});
+      
+      const result = await store.batchCreateItem(testDocs, 5); // Custom concurrency
+      
+      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 = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId', {afterWrite, batchAfterWrite});
+      
+      sendSpy.mockResolvedValue({});
+      
+      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 = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId', {batchAfterWrite});
+      
+      sendSpy
+        .mockResolvedValueOnce({}) // First item succeeds
+        .mockRejectedValueOnce({ name: 'ConditionalCheckFailedException' }) // Second item conflicts
+        .mockResolvedValueOnce({}); // Third item succeeds
+      
+      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 = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId', {batchAfterWrite});
+      
+      sendSpy.mockRejectedValue({ name: 'ConditionalCheckFailedException' });
+      
+      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 = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId', {afterWrite});
+      
+      sendSpy.mockResolvedValue({});
+      
+      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: [] });
+    });
+  });
+
+  describe('custom client', () => {
+    it('uses provided dynamodb client', async() => {
+      const customSendSpy = jest.fn().mockResolvedValue({Item: {coolId: {S: 'test-id'}}});
+      mockDynamoClient.send = customSendSpy;
+
+      const store = dynamoUnversionedDocumentStore({dynamoClient: mockDynamoClient})<TTestDocument>()(config)(middleware, 'coolId');
+      await store.getItem('test-id');
+
+      expect(customSendSpy).toHaveBeenCalled();
+      expect(sendSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('getItemsByField', () => {
+    it('gets items by field', async() => {
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+
+      sendSpy.mockReturnValue(Promise.resolve({Items: [{
+        coolId: {S: 'my-document-id'},
+        maybe: {NULL: true},
+        strings: {L: [{S: 'string1'}, {S: 'string2'}]},
+        name: {S: 'my-doc'},
+        isCool: {BOOL: true}
+      }], LastEvaluatedKey: undefined}));
+
+      expect(await store.getItemsByField('name', 'my-doc')).toEqual({
+        items: [{
+          coolId: 'my-document-id',
+          maybe: null,
+          strings: ['string1', 'string2'],
+          name: 'my-doc',
+          isCool: true
+        }],
+        nextPageToken: undefined
+      });
+    });
+
+    it('processes nextPageToken', async() => {
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+
+      sendSpy.mockReturnValue(Promise.resolve({
+        Items: [{
+          coolId: {S: 'my-document-id'},
+          maybe: {NULL: true},
+          strings: {L: [{S: 'string1'}, {S: 'string2'}]},
+          name: {S: 'my-doc'},
+          isCool: {BOOL: true}
+        }],
+        LastEvaluatedKey: { coolId: {S: 'my-document-id' } }
+      }));
+
+      const page1 = await store.getItemsByField('name', 'my-doc');
+
+      expect(page1).toEqual({
+        items: [{
+          coolId: 'my-document-id',
+          maybe: null,
+          strings: ['string1', 'string2'],
+          name: 'my-doc',
+          isCool: true
+        }],
+        nextPageToken: 'eyJjb29sSWQiOnsiUyI6Im15LWRvY3VtZW50LWlkIn19'
+      });
+
+      sendSpy.mockReturnValue(Promise.resolve({
+        Items: [{
+          coolId: {S: 'my-document-id-2'},
+          maybe: {NULL: true},
+          strings: {L: [{S: 'string3'}, {S: 'string4'}]},
+          name: {S: 'my-doc-2'},
+          isCool: {BOOL: false}
+        }],
+        LastEvaluatedKey: undefined
+      }));
+
+      const page2 = await store.getItemsByField('name', 'my-doc', page1.nextPageToken);
+
+      expect(page2).toEqual({
+        items: [{
+          coolId: 'my-document-id-2',
+          maybe: null,
+          strings: ['string3', 'string4'],
+          name: 'my-doc-2',
+          isCool: false
+        }],
+        nextPageToken: undefined
+      });
+
+      expect(sendSpy).toHaveBeenCalledWith(expect.objectContaining({
+        input: expect.objectContaining({
+          ExclusiveStartKey: { coolId: {S: 'my-document-id' } }
+        })
+      }));
+    });
+
+    it('handles no items', async() => {
+      const store = dynamoUnversionedDocumentStore()<TTestDocument>()(config)(middleware, 'coolId');
+
+      sendSpy.mockReturnValue(Promise.resolve({Items: undefined, LastEvaluatedKey: undefined}));
+
+      expect(await store.getItemsByField('name', 'my-doc')).toEqual({
+        items: [],
+        nextPageToken: undefined
+      });
+    });
+  });
+});