@expo/entity 0.25.3 → 0.27.0

package/src/metrics/IEntityMetricsAdapter.ts

@@ -9,10 +9,28 @@ export enum EntityMetricsLoadType {
   LOAD_MANY_RAW,
 }
 
+/**
+ * Event about a single call to an EntityLoader method.
+ */
 export interface EntityMetricsLoadEvent {
+  /**
+   * EntityMetricsLoadType for this load.
+   */
   type: EntityMetricsLoadType;
+
+  /**
+   * Class name of the Entity being loaded.
+   */
   entityClassName: string;
+
+  /**
+   * Total duration of this load, including fetch and construction of entities.
+   */
   duration: number;
+
+  /**
+   * Number of entities returned for this load.
+   */
   count: number;
 }
 
@@ -23,13 +41,57 @@ export enum EntityMetricsMutationType {
 }
 
 export interface EntityMetricsMutationEvent {
+  /**
+   * EntityMetricsMutationType for this mutation.
+   */
   type: EntityMetricsMutationType;
+
+  /**
+   * Class name of the Entity being mutated.
+   */
   entityClassName: string;
+
+  /**
+   * Total duration of this mutation.
+   */
   duration: number;
 }
 
+export enum IncrementLoadCountEventType {
+  /**
+   * Type for when a dataloader load is initiated via the standard load methods
+   * since all loads go through a dataloader.
+   */
+  DATALOADER,
+
+  /**
+   * Type for when a cache load is initiated due to a dataloader miss.
+   */
+  CACHE,
+
+  /**
+   * Type for when a database load is initiated due to a dataloader and cache miss, when an entity query doesn't support caching, or during a transaction.
+   */
+  DATABASE,
+}
+
+/**
+ * Event used to record dataloader, cache, and database load counts in EntityDataManager.
+ */
 export interface IncrementLoadCountEvent {
+  /**
+   * Type of this event.
+   */
+  type: IncrementLoadCountEventType;
+
+  /**
+   * Number of field values being loaded for this call.
+   */
   fieldValueCount: number;
+
+  /**
+   * Class name of the Entity being loaded.
+   */
   entityClassName: string;
 }
 
@@ -38,7 +100,13 @@ export enum EntityMetricsAuthorizationResult {
   ALLOW,
 }
 
+/**
+ * Event used to record a singe EntityPrivacyPolicy authorization.
+ */
 export interface EntityMetricsAuthorizationEvent {
+  /**
+   * Class name of the Entity being authorized.
+   */
   entityClassName: string;
   action: EntityAuthorizationAction;
   evaluationResult: EntityMetricsAuthorizationResult;
@@ -51,7 +119,7 @@ export interface EntityMetricsAuthorizationEvent {
  */
 export default interface IEntityMetricsAdapter {
   /**
-   * Called when a {@link EntityPrivacyPolicy} authorization succeeds or fails.
+   * Called when a EntityPrivacyPolicy authorization succeeds or fails.
    * @param authorizationEvent - info about the authorization event
    */
   logAuthorizationEvent(authorizationEvent: EntityMetricsAuthorizationEvent): void;
@@ -69,25 +137,10 @@ export default interface IEntityMetricsAdapter {
   logMutatorMutationEvent(mutationEvent: EntityMetricsMutationEvent): void;
 
   /**
-   * Called when a dataloader load is initiated via the standard
-   * load methods (not equality conjunction or raw).
-   * @param fieldValueCount - count of field values being loaded for a field
-   */
-  incrementDataManagerDataloaderLoadCount(incrementLoadCountEvent: IncrementLoadCountEvent): void;
-
-  /**
-   * Called when a cache load is initiated via the standard
-   * load methods (not equality conjunction or raw). Occurs upon a dataloader
-   * miss.
-   * @param fieldValueCount - count of field values being loaded for a field
-   */
-  incrementDataManagerCacheLoadCount(incrementLoadCountEvent: IncrementLoadCountEvent): void;
-
-  /**
-   * Called when a database load is initiated via the standard
-   * load methods (not equality conjunction or raw). Occurs upon a cache
-   * miss or when fetching an uncacheable field.
+   * Called when a dataloader, cache, or database load is initiated via the standard
+   * load methods (not equality conjunction or raw). Most commonly used for logging
+   * a waterfall to determine dataloader and cache hit rates and ratios.
    * @param fieldValueCount - count of field values being loaded for a field
    */
-  incrementDataManagerDatabaseLoadCount(incrementLoadCountEvent: IncrementLoadCountEvent): void;
+  incrementDataManagerLoadCount(incrementLoadCountEvent: IncrementLoadCountEvent): void;
 }

package/src/metrics/NoOpEntityMetricsAdapter.ts

@@ -9,9 +9,5 @@ export default class NoOpEntityMetricsAdapter implements IEntityMetricsAdapter {
   logAuthorizationEvent(_authorizationEvent: EntityMetricsAuthorizationEvent): void {}
   logDataManagerLoadEvent(_loadEvent: EntityMetricsLoadEvent): void {}
   logMutatorMutationEvent(_mutationEvent: EntityMetricsMutationEvent): void {}
-  incrementDataManagerDataloaderLoadCount(
-    _incrementLoadCountEvent: IncrementLoadCountEvent
-  ): void {}
-  incrementDataManagerCacheLoadCount(_incrementLoadCountEvent: IncrementLoadCountEvent): void {}
-  incrementDataManagerDatabaseLoadCount(_incrementLoadCountEvent: IncrementLoadCountEvent): void {}
+  incrementDataManagerLoadCount(_incrementLoadCountEvent: IncrementLoadCountEvent): void {}
 }

package/src/rules/PrivacyPolicyRule.ts

@@ -32,7 +32,7 @@ export enum RuleEvaluationResult {
  * rule in the privacy policy. If all rules in the policy SKIP, the policy is denied.
  *
  * Returning DENY from a rule is useful in a few notable cases:
- * - Preventing a CRUD action on an entity ({@link AlwaysDenyPrivacyPolicyRule})
+ * - Preventing a CRUD action on an entity (AlwaysDenyPrivacyPolicyRule)
  * - Blocking. For example, a user blocks another user from seeing their posts, and the rule
  *   would be named something like `DenyIfViewerHasBeenBlockedPrivacyPolicyRule`.
  */

package/src/utils/collections/maps.ts

@@ -60,7 +60,7 @@ export const mapMapAsync = async function <K, V, M>(
 
 /**
  * Create a new Map by associating the value of each key with mapper executed for each key in the source map.
- * The opposite of {@link mapMap}. In the event two source keys map to the same result key, the second source key's
+ * The opposite of mapMap. In the event two source keys map to the same result key, the second source key's
  * value will overwrite the first, in which case the cardinality of the returned map may be smaller than the
  * source map's.
  *

package/src/utils/testing/PrivacyPolicyRuleTestUtils.ts

@@ -17,7 +17,7 @@ export interface Case<
   entity: TEntity;
 }
 
-type CaseMap<
+export type CaseMap<
   TFields,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,

package/src/utils/testing/StubDatabaseAdapter.ts

@@ -158,7 +158,10 @@ export default class StubDatabaseAdapter<T> extends EntityDatabaseAdapter<T> {
 
   private generateRandomID(): any {
     const idSchemaField = this.entityConfiguration2.schema.get(this.entityConfiguration2.idField);
-    invariant(idSchemaField, `No schema field found for ${this.entityConfiguration2.idField}`);
+    invariant(
+      idSchemaField,
+      `No schema field found for ${String(this.entityConfiguration2.idField)}`
+    );
     if (idSchemaField instanceof StringField) {
       return uuidv4();
     } else if (idSchemaField instanceof IntField) {

package/src/utils/testing/StubQueryContextProvider.ts

@@ -1,6 +1,6 @@
 import EntityQueryContextProvider from '../../EntityQueryContextProvider';
 
-class StubQueryContextProvider extends EntityQueryContextProvider {
+export class StubQueryContextProvider extends EntityQueryContextProvider {
   protected getQueryInterface(): any {
     return {};
   }