@openstax/ts-utils 1.34.0 → 1.34.1

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

@@ -1,859 +0,0 @@
-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
-      });
-    });
-  });
-});