@expo/entity 0.40.0 → 0.42.0

package/src/__tests__/EntityDatabaseAdapter-test.ts

@@ -5,10 +5,12 @@ import EntityDatabaseAdapter, {
   TableFieldMultiValueEqualityCondition,
 } from '../EntityDatabaseAdapter';
 import { EntityQueryContext } from '../EntityQueryContext';
+import { CompositeFieldHolder, CompositeFieldValueHolder } from '../internal/CompositeFieldHolder';
 import { FieldTransformerMap } from '../internal/EntityFieldTransformationUtils';
-import { TestFields, testEntityConfiguration } from '../testfixtures/TestEntity';
+import { SingleFieldHolder, SingleFieldValueHolder } from '../internal/SingleFieldHolder';
+import { TestFields, testEntityConfiguration } from '../utils/__testfixtures__/TestEntity';
 
-class TestEntityDatabaseAdapter extends EntityDatabaseAdapter<TestFields> {
+class TestEntityDatabaseAdapter extends EntityDatabaseAdapter<TestFields, 'customIdField'> {
   private readonly fetchResults: object[];
   private readonly insertResults: object[];
   private readonly updateResults: object[];
@@ -47,8 +49,8 @@ class TestEntityDatabaseAdapter extends EntityDatabaseAdapter<TestFields> {
   protected async fetchManyWhereInternalAsync(
     _queryInterface: any,
     _tableName: string,
-    _tableField: string,
-    _tableValues: readonly any[],
+    _tableColumns: readonly string[],
+    _tableTuples: (readonly any[])[],
   ): Promise<object[]> {
     return this.fetchResults;
   }
@@ -104,8 +106,12 @@ describe(EntityDatabaseAdapter, () => {
     it('transforms object', async () => {
       const queryContext = instance(mock(EntityQueryContext));
       const adapter = new TestEntityDatabaseAdapter({ fetchResults: [{ string_field: 'hello' }] });
-      const result = await adapter.fetchManyWhereAsync(queryContext, 'stringField', ['hello']);
-      expect(result.get('hello')).toEqual([{ stringField: 'hello' }]);
+      const result = await adapter.fetchManyWhereAsync(
+        queryContext,
+        new SingleFieldHolder('stringField'),
+        [new SingleFieldValueHolder('hello')],
+      );
+      expect(result.get(new SingleFieldValueHolder('hello'))).toEqual([{ stringField: 'hello' }]);
     });
 
     it('returns objects keyed by queried values', async () => {
@@ -113,22 +119,112 @@ describe(EntityDatabaseAdapter, () => {
       const adapter = new TestEntityDatabaseAdapter({
         fetchResults: [{ string_field: 'hello' }, { string_field: 'wat' }],
       });
-      const result = await adapter.fetchManyWhereAsync(queryContext, 'stringField', [
-        'hello',
-        'wat',
-      ]);
-      expect(result.get('hello')).toEqual([{ stringField: 'hello' }]);
-      expect(result.get('wat')).toEqual([{ stringField: 'wat' }]);
+      const result = await adapter.fetchManyWhereAsync(
+        queryContext,
+        new SingleFieldHolder('stringField'),
+        [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('wat')],
+      );
+      expect(result.get(new SingleFieldValueHolder('hello'))).toEqual([{ stringField: 'hello' }]);
+      expect(result.get(new SingleFieldValueHolder('wat'))).toEqual([{ stringField: 'wat' }]);
+    });
+
+    it('returns objects keyed by composite queried values', async () => {
+      const queryContext = instance(mock(EntityQueryContext));
+      const adapter = new TestEntityDatabaseAdapter({
+        fetchResults: [
+          { string_field: 'hello', number_field: 1 },
+          { string_field: 'wat', number_field: 2 },
+        ],
+      });
+      const result = await adapter.fetchManyWhereAsync(
+        queryContext,
+        new CompositeFieldHolder<TestFields, 'customIdField'>(['intField', 'stringField']),
+        [
+          new CompositeFieldValueHolder({ intField: 1, stringField: 'hello' }),
+          new CompositeFieldValueHolder({ intField: 2, stringField: 'wat' }),
+          new CompositeFieldValueHolder({ intField: 4, stringField: 'no' }),
+        ],
+      );
+      expect(
+        result.get(new CompositeFieldValueHolder({ intField: 1, stringField: 'hello' })),
+      ).toEqual([{ stringField: 'hello', intField: 1 }]);
+      expect(
+        result.get(new CompositeFieldValueHolder({ intField: 2, stringField: 'wat' })),
+      ).toEqual([{ stringField: 'wat', intField: 2 }]);
+      expect(result.get(new CompositeFieldValueHolder({ intField: 4, stringField: 'no' }))).toEqual(
+        [],
+      );
     });
 
     it('returns map with all keys even when no results are returned', async () => {
       const queryContext = instance(mock(EntityQueryContext));
       const adapter = new TestEntityDatabaseAdapter({});
-      const result = await adapter.fetchManyWhereAsync(queryContext, 'stringField', [
-        'what',
-        'who',
-      ]);
-      expect(Array.from(result.keys())).toEqual(['what', 'who']);
+      const result = await adapter.fetchManyWhereAsync(
+        queryContext,
+        new SingleFieldHolder('stringField'),
+        [new SingleFieldValueHolder('what'), new SingleFieldValueHolder('who')],
+      );
+      expect(Array.from(result.keys()).map((v) => v.fieldValue)).toEqual(['what', 'who']);
+    });
+
+    it('throws when result contains invalid (null) value for key', async () => {
+      const queryContext = instance(mock(EntityQueryContext));
+      const adapter = new TestEntityDatabaseAdapter({
+        fetchResults: [{ string_field: null }],
+      });
+      await expect(
+        adapter.fetchManyWhereAsync(queryContext, new SingleFieldHolder('stringField'), [
+          new SingleFieldValueHolder('hello'),
+        ]),
+      ).rejects.toThrow(
+        'One or more fields from the object is invalid for key SingleField(stringField); {"stringField":null}. This may indicate a faulty database adapter implementation.',
+      );
+    });
+
+    it('throws when result contains invalid (undefined) value for key', async () => {
+      const queryContext = instance(mock(EntityQueryContext));
+      const adapter = new TestEntityDatabaseAdapter({
+        fetchResults: [{ string_field: undefined }],
+      });
+      await expect(
+        adapter.fetchManyWhereAsync(queryContext, new SingleFieldHolder('stringField'), [
+          new SingleFieldValueHolder('hello'),
+        ]),
+      ).rejects.toThrow(
+        'One or more fields from the object is invalid for key SingleField(stringField); {}. This may indicate a faulty database adapter implementation.',
+      );
+    });
+
+    it('throws when result contains invalid (null) value for composite key', async () => {
+      const queryContext = instance(mock(EntityQueryContext));
+      const adapter = new TestEntityDatabaseAdapter({
+        fetchResults: [{ string_field: 'hello', number_field: null }],
+      });
+      await expect(
+        adapter.fetchManyWhereAsync(
+          queryContext,
+          new CompositeFieldHolder<TestFields, 'customIdField'>(['intField', 'stringField']),
+          [new CompositeFieldValueHolder({ intField: 1, stringField: 'hello' })],
+        ),
+      ).rejects.toThrow(
+        'One or more fields from the object is invalid for key CompositeField(intField,stringField); {"stringField":"hello","intField":null}. This may indicate a faulty database adapter implementation.',
+      );
+    });
+
+    it('throws when result contains invalid (undefined) value for composite key', async () => {
+      const queryContext = instance(mock(EntityQueryContext));
+      const adapter = new TestEntityDatabaseAdapter({
+        fetchResults: [{ string_field: 'hello', number_field: undefined }],
+      });
+      await expect(
+        adapter.fetchManyWhereAsync(
+          queryContext,
+          new CompositeFieldHolder<TestFields, 'customIdField'>(['intField', 'stringField']),
+          [new CompositeFieldValueHolder({ intField: 1, stringField: 'hello' })],
+        ),
+      ).rejects.toThrow(
+        'One or more fields from the object is invalid for key CompositeField(intField,stringField); {"stringField":"hello"}. This may indicate a faulty database adapter implementation.',
+      );
     });
   });