@expo/entity 0.17.0 → 0.21.0

package/src/__tests__/ViewerScopedEntityCompanion-test.ts

@@ -10,16 +10,17 @@ import TestEntity, { TestFields, TestEntityPrivacyPolicy } from '../testfixtures
 describe(ViewerScopedEntityCompanion, () => {
   it('returns viewer scoped loader and mutator factory', () => {
     const vc = instance(mock(ViewerContext));
-    const entityCompanion = mock<
-      EntityCompanion<
-        TestFields,
-        string,
-        ViewerContext,
-        TestEntity,
-        TestEntityPrivacyPolicy,
-        keyof TestFields
-      >
-    >();
+    const entityCompanion =
+      mock<
+        EntityCompanion<
+          TestFields,
+          string,
+          ViewerContext,
+          TestEntity,
+          TestEntityPrivacyPolicy,
+          keyof TestFields
+        >
+      >();
     const viewerScopedEntityCompanion = new ViewerScopedEntityCompanion(entityCompanion, vc);
     expect(viewerScopedEntityCompanion.getLoaderFactory()).toBeInstanceOf(
       ViewerScopedEntityLoaderFactory

package/src/__tests__/ViewerScopedEntityMutatorFactory-test.ts

@@ -10,9 +10,10 @@ describe(ViewerScopedEntityMutatorFactory, () => {
   it('correctly scopes viewer to entity mutations', async () => {
     const viewerContext = instance(mock(ViewerContext));
     const queryContext = instance(mock(EntityQueryContext));
-    const baseMutatorFactory = mock<
-      EntityMutatorFactory<TestFields, string, ViewerContext, TestEntity, TestEntityPrivacyPolicy>
-    >(EntityMutatorFactory);
+    const baseMutatorFactory =
+      mock<
+        EntityMutatorFactory<TestFields, string, ViewerContext, TestEntity, TestEntityPrivacyPolicy>
+      >(EntityMutatorFactory);
     const baseMutatorFactoryInstance = instance(baseMutatorFactory);
 
     const viewerScopedEntityLoader = new ViewerScopedEntityMutatorFactory<

package/src/__tests__/cases/TwoEntitySameTableDisjointRows-test.ts

@@ -45,8 +45,8 @@ describe('Two entities backed by the same table', () => {
     expect(successfulManyResults).toHaveLength(1);
     expect(failedManyResults).toHaveLength(1);
 
-    expect(successfulManyResults[0].enforceValue().getID()).toEqual(one.getID());
-    expect(failedManyResults[0].enforceError().message).toEqual(
+    expect(successfulManyResults[0]!.enforceValue().getID()).toEqual(one.getID());
+    expect(failedManyResults[0]!.enforceError().message).toEqual(
       'OneTestEntity must be instantiated with one data'
     );
 
@@ -107,16 +107,16 @@ const testEntityConfiguration = new EntityConfiguration<TestFields>({
 });
 
 class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<any, string, ViewerContext, any, any> {
-  protected readonly readRules = [
+  protected override readonly readRules = [
     new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
-  protected readonly createRules = [
+  protected override readonly createRules = [
     new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
-  protected readonly updateRules = [
+  protected override readonly updateRules = [
     new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
-  protected readonly deleteRules = [
+  protected override readonly deleteRules = [
     new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
 }

package/src/__tests__/cases/TwoEntitySameTableOverlappingRows-test.ts

@@ -115,16 +115,16 @@ const testEntityConfiguration = new EntityConfiguration<TestFields>({
 });
 
 class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<any, string, ViewerContext, any, any> {
-  protected readonly readRules = [
+  protected override readonly readRules = [
     new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
-  protected readonly createRules = [
+  protected override readonly createRules = [
     new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
-  protected readonly updateRules = [
+  protected override readonly updateRules = [
     new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
-  protected readonly deleteRules = [
+  protected override readonly deleteRules = [
     new AlwaysAllowPrivacyPolicyRule<any, string, ViewerContext, any, any>(),
   ];
 }

package/src/index.ts

@@ -26,12 +26,14 @@ export { default as EntityError } from './errors/EntityError';
 export { default as EntityNotAuthorizedError } from './errors/EntityNotAuthorizedError';
 export { default as EntityNotFoundError } from './errors/EntityNotFoundError';
 export * from './EntityFields';
+export * from './EntityFieldDefinition';
 export { default as EntityLoader } from './EntityLoader';
 export { default as EntityLoaderFactory } from './EntityLoaderFactory';
 export { default as EntitySecondaryCacheLoader } from './EntitySecondaryCacheLoader';
 export * from './EntitySecondaryCacheLoader';
 export * from './EntityMutator';
 export { default as EntityMutationValidator } from './EntityMutationValidator';
+export * from './EntityMutationInfo';
 export * from './EntityMutationTriggerConfiguration';
 export { default as EntityMutationTriggerConfiguration } from './EntityMutationTriggerConfiguration';
 export { default as EntityMutatorFactory } from './EntityMutatorFactory';
@@ -63,6 +65,7 @@ export { default as PrivacyPolicyRule } from './rules/PrivacyPolicyRule';
 export * from './rules/PrivacyPolicyRule';
 export * from './utils/testing/PrivacyPolicyRuleTestUtils';
 export * from './utils/testing/StubCacheAdapter';
+export { default as describeFieldTestCase } from './utils/testing/describeFieldTestCase';
 export { default as StubDatabaseAdapter } from './utils/testing/StubDatabaseAdapter';
 export { default as StubDatabaseAdapterProvider } from './utils/testing/StubDatabaseAdapterProvider';
 export { default as StubQueryContextProvider } from './utils/testing/StubQueryContextProvider';

package/src/internal/EntityDataManager.ts

@@ -125,7 +125,8 @@ export default class EntityDataManager<TFields> {
     const results = await dataLoader.loadMany(fieldValues);
     const [values, errors] = partitionErrors(results);
     if (errors.length > 0) {
-      throw errors[0];
+      const error = errors[0]!;
+      throw error;
     }
 
     return zipToMap(fieldValues, values);

package/src/internal/__tests__/EntityDataManager-test.ts

@@ -298,7 +298,7 @@ describe(EntityDataManager, () => {
     );
     const queryContext = StubQueryContextProvider.getQueryContext();
 
-    const objectInQuestion = objects.get(testEntityConfiguration.tableName)![1];
+    const objectInQuestion = objects.get(testEntityConfiguration.tableName)![1]!;
 
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
@@ -337,7 +337,7 @@ describe(EntityDataManager, () => {
     );
     const queryContext = StubQueryContextProvider.getQueryContext();
 
-    const objectInQuestion = objects.get(testEntityConfiguration.tableName)![1];
+    const objectInQuestion = objects.get(testEntityConfiguration.tableName)![1]!;
 
     const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyWhereAsync');
     const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');

package/src/internal/__tests__/ReadThroughEntityCache-test.ts

@@ -20,19 +20,21 @@ const makeEntityConfiguration = (cacheIdField: boolean): EntityConfiguration<Bla
     cacheAdapterFlavor: 'redis',
   });
 
-const createIdFetcher = (ids: string[]) => async <N extends keyof BlahFields>(
-  fetcherFieldValues: readonly NonNullable<BlahFields[N]>[]
-): Promise<ReadonlyMap<NonNullable<BlahFields[N]>, readonly Readonly<BlahFields>[]>> => {
-  const results = new Map();
-  fetcherFieldValues.forEach((v) => {
-    if (ids.includes(v)) {
-      results.set(v, [{ id: v }]);
-    } else {
-      results.set(v, []);
-    }
-  });
-  return results;
-};
+const createIdFetcher =
+  (ids: string[]) =>
+  async <N extends keyof BlahFields>(
+    fetcherFieldValues: readonly NonNullable<BlahFields[N]>[]
+  ): Promise<ReadonlyMap<NonNullable<BlahFields[N]>, readonly Readonly<BlahFields>[]>> => {
+    const results = new Map();
+    fetcherFieldValues.forEach((v) => {
+      if (ids.includes(v)) {
+        results.set(v, [{ id: v }]);
+      } else {
+        results.set(v, []);
+      }
+    });
+    return results;
+  };
 
 describe(ReadThroughEntityCache, () => {
   describe('readManyThroughAsync', () => {

package/src/metrics/EntityMetricsUtils.ts

@@ -4,62 +4,68 @@ import IEntityMetricsAdapter, {
   EntityMetricsMutationType,
 } from './IEntityMetricsAdapter';
 
-export const timeAndLogLoadEventAsync = (
-  metricsAdapter: IEntityMetricsAdapter,
-  loadType: EntityMetricsLoadType,
-  entityClassName: string
-) => async <TFields>(promise: Promise<readonly Readonly<TFields>[]>) => {
-  const startTime = Date.now();
-  const result = await promise;
-  const endTime = Date.now();
+export const timeAndLogLoadEventAsync =
+  (
+    metricsAdapter: IEntityMetricsAdapter,
+    loadType: EntityMetricsLoadType,
+    entityClassName: string
+  ) =>
+  async <TFields>(promise: Promise<readonly Readonly<TFields>[]>) => {
+    const startTime = Date.now();
+    const result = await promise;
+    const endTime = Date.now();
 
-  metricsAdapter.logDataManagerLoadEvent({
-    type: loadType,
-    entityClassName,
-    duration: endTime - startTime,
-    count: result.length,
-  });
+    metricsAdapter.logDataManagerLoadEvent({
+      type: loadType,
+      entityClassName,
+      duration: endTime - startTime,
+      count: result.length,
+    });
 
-  return result;
-};
+    return result;
+  };
 
-export const timeAndLogLoadMapEventAsync = (
-  metricsAdapter: IEntityMetricsAdapter,
-  loadType: EntityMetricsLoadType,
-  entityClassName: string
-) => async <TFields, N extends keyof TFields>(
-  promise: Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>>
-) => {
-  const startTime = Date.now();
-  const result = await promise;
-  const endTime = Date.now();
+export const timeAndLogLoadMapEventAsync =
+  (
+    metricsAdapter: IEntityMetricsAdapter,
+    loadType: EntityMetricsLoadType,
+    entityClassName: string
+  ) =>
+  async <TFields, N extends keyof TFields>(
+    promise: Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>>
+  ) => {
+    const startTime = Date.now();
+    const result = await promise;
+    const endTime = Date.now();
 
-  const count = reduceMap(result, (acc, v) => acc + v.length, 0);
+    const count = reduceMap(result, (acc, v) => acc + v.length, 0);
 
-  metricsAdapter.logDataManagerLoadEvent({
-    type: loadType,
-    entityClassName,
-    duration: endTime - startTime,
-    count,
-  });
+    metricsAdapter.logDataManagerLoadEvent({
+      type: loadType,
+      entityClassName,
+      duration: endTime - startTime,
+      count,
+    });
 
-  return result;
-};
+    return result;
+  };
 
-export const timeAndLogMutationEventAsync = (
-  metricsAdapter: IEntityMetricsAdapter,
-  mutationType: EntityMetricsMutationType,
-  entityClassName: string
-) => async <T>(promise: Promise<T>) => {
-  const startTime = Date.now();
-  const result = await promise;
-  const endTime = Date.now();
+export const timeAndLogMutationEventAsync =
+  (
+    metricsAdapter: IEntityMetricsAdapter,
+    mutationType: EntityMetricsMutationType,
+    entityClassName: string
+  ) =>
+  async <T>(promise: Promise<T>) => {
+    const startTime = Date.now();
+    const result = await promise;
+    const endTime = Date.now();
 
-  metricsAdapter.logMutatorMutationEvent({
-    type: mutationType,
-    entityClassName,
-    duration: endTime - startTime,
-  });
+    metricsAdapter.logMutatorMutationEvent({
+      type: mutationType,
+      entityClassName,
+      duration: endTime - startTime,
+    });
 
-  return result;
-};
+    return result;
+  };

package/src/metrics/IEntityMetricsAdapter.ts

@@ -1,3 +1,8 @@
+import {
+  EntityAuthorizationAction,
+  EntityPrivacyPolicyEvaluationMode,
+} from '../EntityPrivacyPolicy';
+
 export enum EntityMetricsLoadType {
   LOAD_MANY,
   LOAD_MANY_EQUALITY_CONJUNCTION,
@@ -28,11 +33,29 @@ export interface IncrementLoadCountEvent {
   entityClassName: string;
 }
 
+export enum EntityMetricsAuthorizationResult {
+  DENY,
+  ALLOW,
+}
+
+export interface EntityMetricsAuthorizationEvent {
+  entityClassName: string;
+  action: EntityAuthorizationAction;
+  evaluationResult: EntityMetricsAuthorizationResult;
+  privacyPolicyEvaluationMode: EntityPrivacyPolicyEvaluationMode;
+}
+
 /**
  * An interface for gathering metrics about the Entity framework. Information about
  * entity load and mutation operations is piped to an instance of this adapter.
  */
 export default interface IEntityMetricsAdapter {
+  /**
+   * Called when a {@link EntityPrivacyPolicy} authorization succeeds or fails.
+   * @param authorizationEvent - info about the authorization event
+   */
+  logAuthorizationEvent(authorizationEvent: EntityMetricsAuthorizationEvent): void;
+
   /**
    * Called when any load occurs.
    * @param loadEvent - info about the load event

package/src/metrics/NoOpEntityMetricsAdapter.ts

@@ -1,10 +1,12 @@
 import IEntityMetricsAdapter, {
+  EntityMetricsAuthorizationEvent,
   EntityMetricsLoadEvent,
   EntityMetricsMutationEvent,
   IncrementLoadCountEvent,
 } from './IEntityMetricsAdapter';
 
 export default class NoOpEntityMetricsAdapter implements IEntityMetricsAdapter {
+  logAuthorizationEvent(_authorizationEvent: EntityMetricsAuthorizationEvent): void {}
   logDataManagerLoadEvent(_loadEvent: EntityMetricsLoadEvent): void {}
   logMutatorMutationEvent(_mutationEvent: EntityMetricsMutationEvent): void {}
   incrementDataManagerDataloaderLoadCount(

package/src/testfixtures/DateIDTestEntity.ts

@@ -28,16 +28,16 @@ export class DateIDTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
   ViewerContext,
   DateIDTestEntity
 > {
-  protected readonly readRules = [
+  protected override readonly readRules = [
     new AlwaysAllowPrivacyPolicyRule<DateIDTestFields, Date, ViewerContext, DateIDTestEntity>(),
   ];
-  protected readonly createRules = [
+  protected override readonly createRules = [
     new AlwaysAllowPrivacyPolicyRule<DateIDTestFields, Date, ViewerContext, DateIDTestEntity>(),
   ];
-  protected readonly updateRules = [
+  protected override readonly updateRules = [
     new AlwaysAllowPrivacyPolicyRule<DateIDTestFields, Date, ViewerContext, DateIDTestEntity>(),
   ];
-  protected readonly deleteRules = [
+  protected override readonly deleteRules = [
     new AlwaysAllowPrivacyPolicyRule<DateIDTestFields, Date, ViewerContext, DateIDTestEntity>(),
   ];
 }

package/src/testfixtures/SimpleTestEntity.ts

@@ -31,7 +31,7 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
   SimpleTestEntity,
   SimpleTestFieldSelection
 > {
-  protected readonly readRules = [
+  protected override readonly readRules = [
     new AlwaysAllowPrivacyPolicyRule<
       SimpleTestFields,
       string,
@@ -40,7 +40,7 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
       SimpleTestFieldSelection
     >(),
   ];
-  protected readonly createRules = [
+  protected override readonly createRules = [
     new AlwaysAllowPrivacyPolicyRule<
       SimpleTestFields,
       string,
@@ -49,7 +49,7 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
       SimpleTestFieldSelection
     >(),
   ];
-  protected readonly updateRules = [
+  protected override readonly updateRules = [
     new AlwaysAllowPrivacyPolicyRule<
       SimpleTestFields,
       string,
@@ -58,7 +58,7 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
       SimpleTestFieldSelection
     >(),
   ];
-  protected readonly deleteRules = [
+  protected override readonly deleteRules = [
     new AlwaysAllowPrivacyPolicyRule<
       SimpleTestFields,
       string,

package/src/testfixtures/TestEntity.ts

@@ -51,16 +51,16 @@ export class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<
   ViewerContext,
   TestEntity
 > {
-  protected readonly readRules = [
+  protected override readonly readRules = [
     new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
   ];
-  protected readonly createRules = [
+  protected override readonly createRules = [
     new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
   ];
-  protected readonly updateRules = [
+  protected override readonly updateRules = [
     new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
   ];
-  protected readonly deleteRules = [
+  protected override readonly deleteRules = [
     new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
   ];
 }

package/src/testfixtures/TestEntity2.ts

@@ -32,16 +32,16 @@ export class TestEntity2PrivacyPolicy extends EntityPrivacyPolicy<
   ViewerContext,
   TestEntity2
 > {
-  protected readonly readRules = [
+  protected override readonly readRules = [
     new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, ViewerContext, TestEntity2>(),
   ];
-  protected readonly createRules = [
+  protected override readonly createRules = [
     new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, ViewerContext, TestEntity2>(),
   ];
-  protected readonly updateRules = [
+  protected override readonly updateRules = [
     new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, ViewerContext, TestEntity2>(),
   ];
-  protected readonly deleteRules = [
+  protected override readonly deleteRules = [
     new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, ViewerContext, TestEntity2>(),
   ];
 }

package/src/testfixtures/TestEntityNumberKey.ts

@@ -28,16 +28,16 @@ export class NumberKeyPrivacyPolicy extends EntityPrivacyPolicy<
   ViewerContext,
   NumberKeyEntity
 > {
-  protected readonly readRules = [
+  protected override readonly readRules = [
     new AlwaysAllowPrivacyPolicyRule<NumberKeyFields, number, ViewerContext, NumberKeyEntity>(),
   ];
-  protected readonly createRules = [
+  protected override readonly createRules = [
     new AlwaysAllowPrivacyPolicyRule<NumberKeyFields, number, ViewerContext, NumberKeyEntity>(),
   ];
-  protected readonly updateRules = [
+  protected override readonly updateRules = [
     new AlwaysAllowPrivacyPolicyRule<NumberKeyFields, number, ViewerContext, NumberKeyEntity>(),
   ];
-  protected readonly deleteRules = [
+  protected override readonly deleteRules = [
     new AlwaysAllowPrivacyPolicyRule<NumberKeyFields, number, ViewerContext, NumberKeyEntity>(),
   ];
 }

package/src/utils/testing/StubDatabaseAdapter.ts

@@ -71,7 +71,7 @@ export default class StubDatabaseAdapter<T> extends EntityDatabaseAdapter<T> {
       return 0;
     }
 
-    const currentOrderBy = orderBys[0];
+    const currentOrderBy = orderBys[0]!;
     const aField = objectA[currentOrderBy.columnName];
     const bField = objectB[currentOrderBy.columnName];
     switch (currentOrderBy.order) {
@@ -211,7 +211,7 @@ export default class StubDatabaseAdapter<T> extends EntityDatabaseAdapter<T> {
       ...objectCollection[objectIndex],
       ...object,
     };
-    return [objectCollection[objectIndex]];
+    return [objectCollection[objectIndex]!];
   }
 
   protected async deleteInternalAsync(

package/src/utils/testing/__tests__/StubDatabaseAdapter-test.ts

@@ -247,7 +247,7 @@ describe(StubDatabaseAdapter, () => {
         {}
       );
       expect(results).toHaveLength(2);
-      expect(results[0].nullableField).toBeNull();
+      expect(results[0]!.nullableField).toBeNull();
 
       const results2 = await databaseAdapter.fetchManyByFieldEqualityConjunctionAsync(
         queryContext,

package/src/utils/testing/describeFieldTestCase.ts

@@ -0,0 +1,21 @@
+import { EntityFieldDefinition } from '../../EntityFieldDefinition';
+
+export default function describeFieldTestCase<T>(
+  fieldDefinition: EntityFieldDefinition<T>,
+  validValues: T[],
+  invalidValues: any[]
+): void {
+  describe(fieldDefinition.constructor.name, () => {
+    if (validValues.length > 0) {
+      test.each(validValues)(`${fieldDefinition.constructor.name}.valid %p`, (value) => {
+        expect(fieldDefinition.validateInputValue(value)).toBe(true);
+      });
+    }
+
+    if (invalidValues.length > 0) {
+      test.each(invalidValues)(`${fieldDefinition.constructor.name}.invalid %p`, (value) => {
+        expect(fieldDefinition.validateInputValue(value)).toBe(false);
+      });
+    }
+  });
+}