@squiz/db-lib 1.76.0 → 1.77.0

package/src/externalized/ExternalizedDynamoDbRepository.spec.ts

@@ -0,0 +1,274 @@
+import { ExternalizedDynamoDbRepository } from './ExternalizedDynamoDbRepository';
+import { S3ExternalStorage, S3StorageLocation } from '../s3/S3ExternalStorage';
+import { DynamoDbManager } from '../dynamodb/DynamoDbManager';
+import { EntityDefinition } from '../dynamodb/AbstractDynamoDbRepository';
+
+// Mock model class for testing
+interface TestItemShape {
+  id: string;
+  name: string;
+  data: Array<{ key: string; value: object }>;
+}
+
+class TestItem implements TestItemShape {
+  id: string;
+  name: string;
+  data: Array<{ key: string; value: object }>;
+  storageLocation?: S3StorageLocation;
+
+  constructor(input: Record<string, unknown> = {}) {
+    this.id = (input.id as string) || '';
+    this.name = (input.name as string) || '';
+    this.data = (input.data as Array<{ key: string; value: object }>) || [];
+    // Note: storageLocation is intentionally not set from input to simulate model stripping it
+  }
+}
+
+// Test entity definition
+const testEntityDefinition: EntityDefinition = {
+  keys: {
+    pk: {
+      attributeName: 'pk',
+      format: 'ITEM#${id}',
+    },
+    sk: {
+      attributeName: 'sk',
+      format: 'ITEM#${id}',
+    },
+  },
+  indexes: {},
+  fieldsAsJsonString: ['data'],
+};
+
+// Concrete test repository
+class TestRepo extends ExternalizedDynamoDbRepository<TestItemShape, TestItem> {
+  public mockSuperUpdateItem?: jest.Mock;
+
+  constructor(dbManager: DynamoDbManager<any>, storage: S3ExternalStorage, overrides: Partial<EntityDefinition> = {}) {
+    super('test-table', dbManager, 'test_item', { ...testEntityDefinition, ...overrides }, TestItem, storage);
+  }
+
+  // Override updateItem to allow mocking super.updateItem
+  public async updateItem(value: Partial<TestItemShape>): Promise<TestItem | undefined> {
+    if (this.mockSuperUpdateItem) {
+      // Use mock if provided
+      const previousLocation = await (this as any).fetchStoredLocation(value);
+      const updatedItem = await this.mockSuperUpdateItem(value);
+      if (!updatedItem) {
+        return undefined;
+      }
+      const newLocation = (updatedItem as any).storageLocation;
+      if (previousLocation && previousLocation.key !== newLocation?.key) {
+        await (this as any).storage.delete(previousLocation);
+      }
+      return updatedItem;
+    }
+    return super.updateItem(value);
+  }
+}
+
+const createDbManager = (clientOverrides: Record<string, jest.Mock> = {}) =>
+  ({
+    client: {
+      get: jest.fn(),
+      put: jest.fn(),
+      delete: jest.fn(),
+      update: jest.fn(),
+      ...clientOverrides,
+    },
+    repositories: {} as any,
+    executeInTransaction: async <T>(fn: (transaction: any) => Promise<T>): Promise<T> => fn({}),
+    addWriteTransactionItem: jest.fn(),
+  } as unknown as DynamoDbManager<any>);
+
+const createStorage = () =>
+  ({
+    save: jest.fn(),
+    load: jest.fn(),
+    delete: jest.fn(),
+  } as unknown as S3ExternalStorage);
+
+const createTestItem = (overrides: Partial<TestItem> = {}): TestItem => {
+  const item = new TestItem({
+    id: 'item-1',
+    name: 'Test',
+    data: [{ key: 'sample', value: { main: [] } }],
+    ...overrides,
+  });
+  return item;
+};
+
+describe('ExternalizedDynamoDbRepository', () => {
+  it('externalizes data to S3 when prepareValueForStorage is called', async () => {
+    const storage = {
+      ...createStorage(),
+      save: jest.fn().mockResolvedValue({ location: { type: 's3', key: 'item-key' }, size: 500 }),
+    } as unknown as S3ExternalStorage;
+    const repo = new TestRepo(createDbManager(), storage);
+    const item = createTestItem();
+
+    const storedValue = await (repo as any).prepareValueForStorage(item);
+
+    expect(storage.save).toHaveBeenCalled();
+    // storedValue is a minimal payload - original item is NOT mutated
+    expect(storedValue.data).toEqual([]);
+    expect(storedValue.storageLocation).toEqual({ type: 's3', key: 'item-key' });
+  });
+
+  it('creates item with storageLocation preserved', async () => {
+    const client = createDbManager().client as any;
+    (client.put as jest.Mock).mockResolvedValue({});
+    const storage = {
+      ...createStorage(),
+      save: jest.fn().mockResolvedValue({ location: { type: 's3', key: 'item-key' }, size: 500 }),
+    } as unknown as S3ExternalStorage;
+
+    const repo = new TestRepo({ client } as any, storage);
+    const item = createTestItem();
+
+    // Use prepareValueForStorage to externalize data and set storageLocation
+    const preparedItem = await (repo as any).prepareValueForStorage(item);
+
+    // Verify the prepared value has minimal payload (empty data)
+    expect(preparedItem.data).toEqual([]);
+    expect(preparedItem.storageLocation).toEqual({ type: 's3', key: 'item-key' });
+
+    // Original item should NOT be mutated
+    expect(item.storageLocation).toBeUndefined();
+  });
+
+  it('loads payload from external storage when storageLocation is set', async () => {
+    const storage = createStorage();
+    const fullData = {
+      id: 'item-1',
+      name: 'From S3',
+      data: [{ key: 'sample', value: { main: [] } }],
+    };
+    (storage.load as jest.Mock).mockResolvedValue(fullData);
+
+    const repo = new TestRepo(createDbManager({ get: jest.fn() as any }), storage);
+    const result = await (repo as any).hydrateFromExternalStorage({
+      id: 'item-1',
+      name: 'Placeholder',
+      data: [],
+      storageLocation: { type: 's3', key: 'item-key' },
+    });
+
+    expect(storage.load).toHaveBeenCalledWith({ type: 's3', key: 'item-key' });
+    expect(result?.name).toBe('From S3');
+    expect(result?.data).toEqual([{ key: 'sample', value: { main: [] } }]);
+  });
+
+  it('deletes externalized payloads when deleting items', async () => {
+    const client = createDbManager({
+      get: jest.fn().mockResolvedValue({ Item: { storageLocation: { type: 's3', key: 'item-key' } } }),
+      delete: jest.fn().mockResolvedValue({}),
+    }).client as any;
+    const storage = createStorage();
+    const repo = new TestRepo({ client } as any, storage);
+
+    await repo.deleteItem({ id: 'item-1' });
+
+    expect(storage.delete).toHaveBeenCalledWith({ type: 's3', key: 'item-key' });
+  });
+
+  it('returns inline data when no storageLocation is present', async () => {
+    const storage = createStorage();
+    const repo = new TestRepo(createDbManager({ get: jest.fn() as any }), storage);
+    const inlineRecord = {
+      id: 'item-1',
+      name: 'Inline Item',
+      data: [{ key: 'sample', value: { main: [] } }],
+    };
+
+    const result = await (repo as any).hydrateFromExternalStorage(inlineRecord);
+
+    expect(storage.load).not.toHaveBeenCalled();
+    expect(result).toBeDefined();
+    expect(result?.name).toBe('Inline Item');
+    expect(result?.data).toEqual([{ key: 'sample', value: { main: [] } }]);
+  });
+
+  it('cleans up old S3 file when updating with new storageLocation', async () => {
+    const oldLocation = { type: 's3' as const, key: 'old-key' };
+    const newLocation = { type: 's3' as const, key: 'new-key' };
+
+    const client = createDbManager({
+      get: jest.fn().mockResolvedValue({
+        Item: {
+          id: 'item-1',
+          name: 'Test',
+          storageLocation: oldLocation,
+        },
+      }),
+      update: jest.fn().mockResolvedValue({
+        Attributes: {
+          id: 'item-1',
+          name: 'Updated',
+          storageLocation: newLocation,
+        },
+      }),
+    }).client as any;
+
+    const storage = createStorage();
+    const repo = new TestRepo({ client } as any, storage);
+
+    // Update without storageLocation (it will be fetched from DynamoDB)
+    const updateValue = {
+      id: 'item-1',
+      name: 'Updated',
+    };
+
+    // Create an updated item with the new storageLocation
+    const updatedItem = createTestItem({ id: 'item-1', name: 'Updated' });
+    (updatedItem as any).storageLocation = newLocation;
+
+    // Mock super.updateItem using the custom mock hook
+    repo.mockSuperUpdateItem = jest.fn().mockResolvedValue(updatedItem as any);
+
+    await repo.updateItem(updateValue);
+
+    expect(storage.delete).toHaveBeenCalledWith(oldLocation);
+  });
+
+  it('does not delete S3 file when storageLocation is unchanged', async () => {
+    const location = { type: 's3' as const, key: 'same-key' };
+
+    const client = createDbManager({
+      get: jest.fn().mockResolvedValue({
+        Item: {
+          id: 'item-1',
+          name: 'Test',
+          storageLocation: location,
+        },
+      }),
+      update: jest.fn().mockResolvedValue({
+        Attributes: {
+          id: 'item-1',
+          name: 'Updated',
+          storageLocation: location,
+        },
+      }),
+    }).client as any;
+
+    const storage = createStorage();
+    const repo = new TestRepo({ client } as any, storage);
+
+    // Update without storageLocation (it will be fetched from DynamoDB)
+    const updateValue = {
+      id: 'item-1',
+      name: 'Updated',
+    };
+
+    // Create an updated item with the same storageLocation
+    const updatedItem = createTestItem({ id: 'item-1', name: 'Updated' });
+    (updatedItem as any).storageLocation = location;
+
+    // Mock super.updateItem using the custom mock hook
+    repo.mockSuperUpdateItem = jest.fn().mockResolvedValue(updatedItem as any);
+
+    await repo.updateItem(updateValue);
+
+    expect(storage.delete).not.toHaveBeenCalled();
+  });
+});