@expo/entity-database-adapter-knex 0.54.0 → 0.57.0

package/src/__tests__/BasePostgresEntityDatabaseAdapter-test.ts

@@ -0,0 +1,160 @@
+import { EntityQueryContext, FieldTransformerMap } from '@expo/entity';
+import { describe, expect, it } from '@jest/globals';
+import { instance, mock } from 'ts-mockito';
+
+import {
+  BasePostgresEntityDatabaseAdapter,
+  TableFieldMultiValueEqualityCondition,
+  TableFieldSingleValueEqualityCondition,
+} from '../BasePostgresEntityDatabaseAdapter';
+import { testEntityConfiguration, TestFields } from './fixtures/TestEntity';
+
+class TestEntityDatabaseAdapter extends BasePostgresEntityDatabaseAdapter<
+  TestFields,
+  'customIdField'
+> {
+  private readonly fetchResults: object[];
+  private readonly fetchOneResult: object | null;
+  private readonly insertResults: object[];
+  private readonly updateResults: object[];
+  private readonly fetchEqualityConditionResults: object[];
+  private readonly fetchRawWhereResults: object[];
+  private readonly fetchSQLFragmentResults: object[];
+  private readonly deleteCount: number;
+
+  constructor({
+    fetchResults = [],
+    fetchOneResult = null,
+    insertResults = [],
+    updateResults = [],
+    fetchEqualityConditionResults = [],
+    fetchRawWhereResults = [],
+    fetchSQLFragmentResults = [],
+    deleteCount = 0,
+  }: {
+    fetchResults?: object[];
+    fetchOneResult?: object | null;
+    insertResults?: object[];
+    updateResults?: object[];
+    fetchEqualityConditionResults?: object[];
+    fetchRawWhereResults?: object[];
+    fetchSQLFragmentResults?: object[];
+    deleteCount?: number;
+  }) {
+    super(testEntityConfiguration);
+    this.fetchResults = fetchResults;
+    this.fetchOneResult = fetchOneResult;
+    this.insertResults = insertResults;
+    this.updateResults = updateResults;
+    this.fetchEqualityConditionResults = fetchEqualityConditionResults;
+    this.fetchRawWhereResults = fetchRawWhereResults;
+    this.fetchSQLFragmentResults = fetchSQLFragmentResults;
+    this.deleteCount = deleteCount;
+  }
+
+  protected getFieldTransformerMap(): FieldTransformerMap {
+    return new Map();
+  }
+
+  protected async fetchManyWhereInternalAsync(
+    _queryInterface: any,
+    _tableName: string,
+    _tableColumns: readonly string[],
+    _tableTuples: (readonly any[])[],
+  ): Promise<object[]> {
+    return this.fetchResults;
+  }
+
+  protected async fetchOneWhereInternalAsync(
+    _queryInterface: any,
+    _tableName: string,
+    _tableColumns: readonly string[],
+    _tableTuple: readonly any[],
+  ): Promise<object | null> {
+    return this.fetchOneResult;
+  }
+
+  protected async fetchManyByRawWhereClauseInternalAsync(
+    _queryInterface: any,
+    _tableName: string,
+    _rawWhereClause: string,
+    _bindings: object | any[],
+  ): Promise<object[]> {
+    return this.fetchRawWhereResults;
+  }
+
+  protected async fetchManyBySQLFragmentInternalAsync(
+    _queryInterface: any,
+    _tableName: string,
+    _sqlFragment: any,
+  ): Promise<object[]> {
+    return this.fetchSQLFragmentResults;
+  }
+
+  protected async fetchManyByFieldEqualityConjunctionInternalAsync(
+    _queryInterface: any,
+    _tableName: string,
+    _tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
+    _tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
+  ): Promise<object[]> {
+    return this.fetchEqualityConditionResults;
+  }
+
+  protected async insertInternalAsync(
+    _queryInterface: any,
+    _tableName: string,
+    _object: object,
+  ): Promise<object[]> {
+    return this.insertResults;
+  }
+
+  protected async updateInternalAsync(
+    _queryInterface: any,
+    _tableName: string,
+    _tableIdField: string,
+    _id: any,
+    _object: object,
+  ): Promise<object[]> {
+    return this.updateResults;
+  }
+
+  protected async deleteInternalAsync(
+    _queryInterface: any,
+    _tableName: string,
+    _tableIdField: string,
+    _id: any,
+  ): Promise<number> {
+    return this.deleteCount;
+  }
+}
+
+describe(BasePostgresEntityDatabaseAdapter, () => {
+  describe('get paginationMaxPageSize', () => {
+    it('returns the default paginationMaxPageSize (undefined)', () => {
+      const adapter = new TestEntityDatabaseAdapter({});
+      expect(adapter.paginationMaxPageSize).toBe(undefined);
+    });
+  });
+
+  describe('fetchManyByFieldEqualityConjunction', () => {
+    it('transforms object', async () => {
+      const queryContext = instance(mock(EntityQueryContext));
+      const adapter = new TestEntityDatabaseAdapter({
+        fetchEqualityConditionResults: [{ string_field: 'hello' }],
+      });
+      const results = await adapter.fetchManyByFieldEqualityConjunctionAsync(queryContext, [], {});
+      expect(results).toEqual([{ stringField: 'hello' }]);
+    });
+  });
+
+  describe('fetchManyWithRawWhereClause', () => {
+    it('transforms object', async () => {
+      const queryContext = instance(mock(EntityQueryContext));
+      const adapter = new TestEntityDatabaseAdapter({
+        fetchRawWhereResults: [{ string_field: 'hello' }],
+      });
+      const results = await adapter.fetchManyByRawWhereClauseAsync(queryContext, 'hello', [], {});
+      expect(results).toEqual([{ stringField: 'hello' }]);
+    });
+  });
+});

package/src/__tests__/EnforcingKnexEntityLoader-test.ts

@@ -0,0 +1,384 @@
+import { EntityConstructionUtils, EntityQueryContext, IEntityMetricsAdapter } from '@expo/entity';
+import { result } from '@expo/results';
+import { describe, expect, it } from '@jest/globals';
+import { anything, instance, mock, when } from 'ts-mockito';
+
+import {
+  AuthorizationResultBasedKnexEntityLoader,
+  AuthorizationResultBasedSQLQueryBuilder,
+} from '../AuthorizationResultBasedKnexEntityLoader';
+import { EnforcingKnexEntityLoader } from '../EnforcingKnexEntityLoader';
+import { PaginationStrategy } from '../PaginationStrategy';
+import { sql } from '../SQLOperator';
+import { EntityKnexDataManager } from '../internal/EntityKnexDataManager';
+
+describe(EnforcingKnexEntityLoader, () => {
+  describe('loadFirstByFieldEqualityConjunction', () => {
+    it('throws when result is unsuccessful', async () => {
+      const nonEnforcingKnexEntityLoaderMock = mock(
+        AuthorizationResultBasedKnexEntityLoader<any, any, any, any, any, any>,
+      );
+      const rejection = new Error();
+      when(
+        nonEnforcingKnexEntityLoaderMock.loadFirstByFieldEqualityConjunctionAsync(
+          anything(),
+          anything(),
+        ),
+      ).thenResolve(result(rejection));
+      const nonEnforcingKnexEntityLoader = instance(nonEnforcingKnexEntityLoaderMock);
+      const enforcingKnexEntityLoader = new EnforcingKnexEntityLoader(
+        nonEnforcingKnexEntityLoader,
+        instance(mock(EntityQueryContext)),
+        instance(mock(EntityKnexDataManager)),
+        instance(mock<IEntityMetricsAdapter>()),
+        instance(mock(EntityConstructionUtils)),
+      );
+      await expect(
+        enforcingKnexEntityLoader.loadFirstByFieldEqualityConjunctionAsync(anything(), anything()),
+      ).rejects.toThrow(rejection);
+    });
+
+    it('returns value when result is successful', async () => {
+      const nonEnforcingKnexEntityLoaderMock = mock(
+        AuthorizationResultBasedKnexEntityLoader<any, any, any, any, any, any>,
+      );
+      const resolved = {};
+      when(
+        nonEnforcingKnexEntityLoaderMock.loadFirstByFieldEqualityConjunctionAsync(
+          anything(),
+          anything(),
+        ),
+      ).thenResolve(result(resolved));
+      const nonEnforcingKnexEntityLoader = instance(nonEnforcingKnexEntityLoaderMock);
+      const enforcingKnexEntityLoader = new EnforcingKnexEntityLoader(
+        nonEnforcingKnexEntityLoader,
+        instance(mock(EntityQueryContext)),
+        instance(mock(EntityKnexDataManager)),
+        instance(mock<IEntityMetricsAdapter>()),
+        instance(mock(EntityConstructionUtils)),
+      );
+      await expect(
+        enforcingKnexEntityLoader.loadFirstByFieldEqualityConjunctionAsync(anything(), anything()),
+      ).resolves.toEqual(resolved);
+    });
+
+    it('returns null when the query is successful but no rows match', async () => {
+      const nonEnforcingKnexEntityLoaderMock = mock(
+        AuthorizationResultBasedKnexEntityLoader<any, any, any, any, any, any>,
+      );
+      when(
+        nonEnforcingKnexEntityLoaderMock.loadFirstByFieldEqualityConjunctionAsync(
+          anything(),
+          anything(),
+        ),
+      ).thenResolve(null);
+      const nonEnforcingKnexEntityLoader = instance(nonEnforcingKnexEntityLoaderMock);
+      const enforcingKnexEntityLoader = new EnforcingKnexEntityLoader(
+        nonEnforcingKnexEntityLoader,
+        instance(mock(EntityQueryContext)),
+        instance(mock(EntityKnexDataManager)),
+        instance(mock<IEntityMetricsAdapter>()),
+        instance(mock(EntityConstructionUtils)),
+      );
+      await expect(
+        enforcingKnexEntityLoader.loadFirstByFieldEqualityConjunctionAsync(anything(), anything()),
+      ).resolves.toBeNull();
+    });
+  });
+
+  describe('loadManyByFieldEqualityConjunction', () => {
+    it('throws when result is unsuccessful', async () => {
+      const nonEnforcingKnexEntityLoaderMock = mock(
+        AuthorizationResultBasedKnexEntityLoader<any, any, any, any, any, any>,
+      );
+      const rejection = new Error();
+      when(
+        nonEnforcingKnexEntityLoaderMock.loadManyByFieldEqualityConjunctionAsync(
+          anything(),
+          anything(),
+        ),
+      ).thenResolve([result(rejection)]);
+      const nonEnforcingKnexEntityLoader = instance(nonEnforcingKnexEntityLoaderMock);
+      const enforcingKnexEntityLoader = new EnforcingKnexEntityLoader(
+        nonEnforcingKnexEntityLoader,
+        instance(mock(EntityQueryContext)),
+        instance(mock(EntityKnexDataManager)),
+        instance(mock<IEntityMetricsAdapter>()),
+        instance(mock(EntityConstructionUtils)),
+      );
+      await expect(
+        enforcingKnexEntityLoader.loadManyByFieldEqualityConjunctionAsync(anything(), anything()),
+      ).rejects.toThrow(rejection);
+    });
+
+    it('returns value when result is successful', async () => {
+      const nonEnforcingKnexEntityLoaderMock = mock(
+        AuthorizationResultBasedKnexEntityLoader<any, any, any, any, any, any>,
+      );
+      const resolved = {};
+      when(
+        nonEnforcingKnexEntityLoaderMock.loadManyByFieldEqualityConjunctionAsync(
+          anything(),
+          anything(),
+        ),
+      ).thenResolve([result(resolved)]);
+      const nonEnforcingKnexEntityLoader = instance(nonEnforcingKnexEntityLoaderMock);
+      const enforcingKnexEntityLoader = new EnforcingKnexEntityLoader(
+        nonEnforcingKnexEntityLoader,
+        instance(mock(EntityQueryContext)),
+        instance(mock(EntityKnexDataManager)),
+        instance(mock<IEntityMetricsAdapter>()),
+        instance(mock(EntityConstructionUtils)),
+      );
+      await expect(
+        enforcingKnexEntityLoader.loadManyByFieldEqualityConjunctionAsync(anything(), anything()),
+      ).resolves.toEqual([resolved]);
+    });
+  });
+
+  describe('loadManyByRawWhereClause', () => {
+    it('throws when result is unsuccessful', async () => {
+      const nonEnforcingKnexEntityLoaderMock = mock(
+        AuthorizationResultBasedKnexEntityLoader<any, any, any, any, any, any>,
+      );
+      const rejection = new Error();
+      when(
+        nonEnforcingKnexEntityLoaderMock.loadManyByRawWhereClauseAsync(
+          anything(),
+          anything(),
+          anything(),
+        ),
+      ).thenResolve([result(rejection)]);
+      const nonEnforcingKnexEntityLoader = instance(nonEnforcingKnexEntityLoaderMock);
+      const enforcingKnexEntityLoader = new EnforcingKnexEntityLoader(
+        nonEnforcingKnexEntityLoader,
+        instance(mock(EntityQueryContext)),
+        instance(mock(EntityKnexDataManager)),
+        instance(mock<IEntityMetricsAdapter>()),
+        instance(mock(EntityConstructionUtils)),
+      );
+      await expect(
+        enforcingKnexEntityLoader.loadManyByRawWhereClauseAsync(anything(), anything(), anything()),
+      ).rejects.toThrow(rejection);
+    });
+
+    it('returns value when result is successful', async () => {
+      const nonEnforcingKnexEntityLoaderMock = mock(
+        AuthorizationResultBasedKnexEntityLoader<any, any, any, any, any, any>,
+      );
+      const resolved = {};
+      when(
+        nonEnforcingKnexEntityLoaderMock.loadManyByRawWhereClauseAsync(
+          anything(),
+          anything(),
+          anything(),
+        ),
+      ).thenResolve([result(resolved)]);
+      const nonEnforcingKnexEntityLoader = instance(nonEnforcingKnexEntityLoaderMock);
+      const enforcingKnexEntityLoader = new EnforcingKnexEntityLoader(
+        nonEnforcingKnexEntityLoader,
+        instance(mock(EntityQueryContext)),
+        instance(mock(EntityKnexDataManager)),
+        instance(mock<IEntityMetricsAdapter>()),
+        instance(mock(EntityConstructionUtils)),
+      );
+      await expect(
+        enforcingKnexEntityLoader.loadManyByRawWhereClauseAsync(anything(), anything(), anything()),
+      ).resolves.toEqual([resolved]);
+    });
+  });
+
+  describe('loadManyBySQL', () => {
+    it('throws when result is unsuccessful', async () => {
+      const nonEnforcingKnexEntityLoaderMock = mock(
+        AuthorizationResultBasedKnexEntityLoader<any, any, any, any, any, any>,
+      );
+      const rejection = new Error('Authorization failed');
+
+      const queryBuilderMock = mock(
+        AuthorizationResultBasedSQLQueryBuilder<any, any, any, any, any, any>,
+      );
+      when(queryBuilderMock.executeAsync()).thenResolve([result(rejection)]);
+      const queryBuilder = instance(queryBuilderMock);
+
+      when(nonEnforcingKnexEntityLoaderMock.loadManyBySQL(anything(), anything())).thenReturn(
+        queryBuilder,
+      );
+
+      const nonEnforcingKnexEntityLoader = instance(nonEnforcingKnexEntityLoaderMock);
+      const enforcingKnexEntityLoader = new EnforcingKnexEntityLoader(
+        nonEnforcingKnexEntityLoader,
+        instance(mock(EntityQueryContext)),
+        instance(mock(EntityKnexDataManager)),
+        instance(mock<IEntityMetricsAdapter>()),
+        instance(mock(EntityConstructionUtils)),
+      );
+
+      const enforcingQueryBuilder = enforcingKnexEntityLoader.loadManyBySQL(sql`1=1`);
+      await expect(enforcingQueryBuilder.executeAsync()).rejects.toThrow(rejection);
+    });
+
+    it('returns value when result is successful', async () => {
+      const nonEnforcingKnexEntityLoaderMock = mock(
+        AuthorizationResultBasedKnexEntityLoader<any, any, any, any, any, any>,
+      );
+      const entity1 = { id: '1', name: 'Entity 1' };
+      const entity2 = { id: '2', name: 'Entity 2' };
+
+      const queryBuilderMock = mock(
+        AuthorizationResultBasedSQLQueryBuilder<any, any, any, any, any, any>,
+      );
+      when(queryBuilderMock.executeAsync()).thenResolve([result(entity1), result(entity2)]);
+      const queryBuilder = instance(queryBuilderMock);
+
+      when(nonEnforcingKnexEntityLoaderMock.loadManyBySQL(anything(), anything())).thenReturn(
+        queryBuilder,
+      );
+
+      const nonEnforcingKnexEntityLoader = instance(nonEnforcingKnexEntityLoaderMock);
+      const enforcingKnexEntityLoader = new EnforcingKnexEntityLoader(
+        nonEnforcingKnexEntityLoader,
+        instance(mock(EntityQueryContext)),
+        instance(mock(EntityKnexDataManager)),
+        instance(mock<IEntityMetricsAdapter>()),
+        instance(mock(EntityConstructionUtils)),
+      );
+
+      const enforcingQueryBuilder = enforcingKnexEntityLoader.loadManyBySQL(sql`1=1`);
+      await expect(enforcingQueryBuilder.executeAsync()).resolves.toEqual([entity1, entity2]);
+    });
+  });
+
+  describe('loadPageAsync', () => {
+    it('throws when result is unsuccessful', async () => {
+      const queryContext = instance(mock(EntityQueryContext));
+      const knexDataManagerMock = mock<EntityKnexDataManager<any, any>>(EntityKnexDataManager);
+      const constructionUtilsMock =
+        mock<EntityConstructionUtils<any, any, any, any, any, any>>(EntityConstructionUtils);
+      const rejection = new Error('Entity not authorized');
+
+      // Mock the data manager to return a connection with field objects
+      when(knexDataManagerMock.loadPageAsync(anything(), anything())).thenResolve({
+        edges: [
+          {
+            cursor: 'cursor1',
+            node: { id: '1', name: 'Entity 1' },
+          },
+        ],
+        pageInfo: {
+          hasNextPage: false,
+          hasPreviousPage: false,
+          startCursor: 'cursor1',
+          endCursor: 'cursor1',
+        },
+      });
+
+      // Mock constructionUtils to throw when constructing entities
+      when(constructionUtilsMock.constructAndAuthorizeEntityAsync(anything())).thenResolve(
+        result(rejection),
+      );
+
+      const enforcingKnexEntityLoader = new EnforcingKnexEntityLoader(
+        instance(mock(AuthorizationResultBasedKnexEntityLoader<any, any, any, any, any, any>)),
+        queryContext,
+        instance(knexDataManagerMock),
+        instance(mock<IEntityMetricsAdapter>()),
+        instance(constructionUtilsMock),
+      );
+
+      await expect(
+        enforcingKnexEntityLoader.loadPageAsync({
+          first: 10,
+          pagination: {
+            strategy: PaginationStrategy.STANDARD,
+            orderBy: [],
+          },
+        }),
+      ).rejects.toThrow(rejection);
+    });
+
+    it('returns value when result is successful', async () => {
+      const queryContext = instance(mock(EntityQueryContext));
+      const knexDataManagerMock = mock<EntityKnexDataManager<any, any>>(EntityKnexDataManager);
+      const constructionUtilsMock =
+        mock<EntityConstructionUtils<any, any, any, any, any, any>>(EntityConstructionUtils);
+      const entity1 = { id: '1', name: 'Entity 1', getID: () => '1' };
+      const entity2 = { id: '2', name: 'Entity 2', getID: () => '2' };
+
+      when(knexDataManagerMock.loadPageAsync(anything(), anything())).thenResolve({
+        edges: [
+          {
+            cursor: 'cursor1',
+            node: { id: '1', name: 'Entity 1' },
+          },
+          {
+            cursor: 'cursor2',
+            node: { id: '2', name: 'Entity 2' },
+          },
+        ],
+        pageInfo: {
+          hasNextPage: true,
+          hasPreviousPage: false,
+          startCursor: 'cursor1',
+          endCursor: 'cursor2',
+        },
+      });
+
+      when(constructionUtilsMock.constructAndAuthorizeEntityAsync(anything())).thenCall(
+        async (fieldObject: any) => {
+          if (fieldObject.id === '1') {
+            return result(entity1);
+          } else if (fieldObject.id === '2') {
+            return result(entity2);
+          }
+          throw new Error('Unexpected field object');
+        },
+      );
+
+      const enforcingKnexEntityLoader = new EnforcingKnexEntityLoader(
+        instance(mock(AuthorizationResultBasedKnexEntityLoader<any, any, any, any, any, any>)),
+        queryContext,
+        instance(knexDataManagerMock),
+        instance(mock<IEntityMetricsAdapter>()),
+        instance(constructionUtilsMock),
+      );
+
+      const connection = await enforcingKnexEntityLoader.loadPageAsync({
+        first: 10,
+        pagination: {
+          strategy: PaginationStrategy.STANDARD,
+          orderBy: [],
+        },
+      });
+
+      expect(connection.edges).toHaveLength(2);
+      expect(connection.edges[0]).toEqual({
+        cursor: 'cursor1',
+        node: entity1,
+      });
+      expect(connection.edges[1]).toEqual({
+        cursor: 'cursor2',
+        node: entity2,
+      });
+      expect(connection.pageInfo).toEqual({
+        hasNextPage: true,
+        hasPreviousPage: false,
+        startCursor: 'cursor1',
+        endCursor: 'cursor2',
+      });
+    });
+  });
+
+  it('has the same method names as AuthorizationResultBasedKnexEntityLoader', () => {
+    const enforcingKnexLoaderProperties = Object.getOwnPropertyNames(
+      EnforcingKnexEntityLoader.prototype,
+    );
+    const nonEnforcingKnexLoaderProperties = Object.getOwnPropertyNames(
+      AuthorizationResultBasedKnexEntityLoader.prototype,
+    );
+
+    // The knex loaders don't have the internal validation methods that regular loaders have,
+    // so we just check that all methods match without any exclusions
+    expect(enforcingKnexLoaderProperties).toEqual(nonEnforcingKnexLoaderProperties);
+  });
+});

package/src/__tests__/EntityFields-test.ts

@@ -4,7 +4,7 @@ import { BigIntField, JSONArrayField, MaybeJSONArrayField } from '../EntityField
 
 describeFieldTestCase(
   new JSONArrayField({ columnName: 'wat' }),
-  [[[1, 2]] as any, [['hello']] as any],
+  [[[1, 2]], [['hello']]],
   [1, 'hello'],
 );
 describeFieldTestCase(