@expo/entity 0.43.0 → 0.45.0

package/src/metrics/EntityMetricsUtils.ts

@@ -2,6 +2,7 @@ import IEntityMetricsAdapter, {
   EntityMetricsLoadType,
   EntityMetricsMutationType,
 } from './IEntityMetricsAdapter';
+import { EntityQueryContext } from '../EntityQueryContext';
 import { IEntityLoadValue } from '../internal/EntityLoadInterfaces';
 import { reduceMap } from '../utils/collections/maps';
 
@@ -10,6 +11,7 @@ export const timeAndLogLoadEventAsync =
     metricsAdapter: IEntityMetricsAdapter,
     loadType: EntityMetricsLoadType,
     entityClassName: string,
+    queryContext: EntityQueryContext,
   ) =>
   async <TFields>(promise: Promise<readonly Readonly<TFields>[]>) => {
     const startTime = Date.now();
@@ -18,6 +20,7 @@ export const timeAndLogLoadEventAsync =
 
     metricsAdapter.logDataManagerLoadEvent({
       type: loadType,
+      isInTransaction: queryContext.isInTransaction(),
       entityClassName,
       duration: endTime - startTime,
       count: result.length,
@@ -31,6 +34,7 @@ export const timeAndLogLoadMapEventAsync =
     metricsAdapter: IEntityMetricsAdapter,
     loadType: EntityMetricsLoadType,
     entityClassName: string,
+    queryContext: EntityQueryContext,
   ) =>
   async <
     TFields extends Record<string, any>,
@@ -47,6 +51,7 @@ export const timeAndLogLoadMapEventAsync =
 
     metricsAdapter.logDataManagerLoadEvent({
       type: loadType,
+      isInTransaction: queryContext.isInTransaction(),
       entityClassName,
       duration: endTime - startTime,
       count,
@@ -60,6 +65,7 @@ export const timeAndLogMutationEventAsync =
     metricsAdapter: IEntityMetricsAdapter,
     mutationType: EntityMetricsMutationType,
     entityClassName: string,
+    queryContext: EntityQueryContext,
   ) =>
   async <T>(promise: Promise<T>) => {
     const startTime = Date.now();
@@ -68,6 +74,7 @@ export const timeAndLogMutationEventAsync =
 
     metricsAdapter.logMutatorMutationEvent({
       type: mutationType,
+      isInTransaction: queryContext.isInTransaction(),
       entityClassName,
       duration: endTime - startTime,
     });

package/src/metrics/IEntityMetricsAdapter.ts

@@ -19,6 +19,11 @@ export interface EntityMetricsLoadEvent {
    */
   type: EntityMetricsLoadType;
 
+  /**
+   * Whether this load is within a transaction.
+   */
+  isInTransaction: boolean;
+
   /**
    * Class name of the Entity being loaded.
    */
@@ -47,6 +52,11 @@ export interface EntityMetricsMutationEvent {
    */
   type: EntityMetricsMutationType;
 
+  /**
+   * Whether this mutation is within a transaction.
+   */
+  isInTransaction: boolean;
+
   /**
    * Class name of the Entity being mutated.
    */
@@ -85,6 +95,11 @@ export interface IncrementLoadCountEvent {
    */
   type: IncrementLoadCountEventType;
 
+  /**
+   * Whether this load is within a transaction.
+   */
+  isInTransaction: boolean;
+
   /**
    * Load method type for this event.
    */
@@ -114,8 +129,20 @@ export interface EntityMetricsAuthorizationEvent {
    * Class name of the Entity being authorized.
    */
   entityClassName: string;
+
+  /**
+   * The action being authorized.
+   */
   action: EntityAuthorizationAction;
+
+  /**
+   * The result of the authorization.
+   */
   evaluationResult: EntityMetricsAuthorizationResult;
+
+  /**
+   * The evaluation mode of the privacy policy.
+   */
   privacyPolicyEvaluationMode: EntityPrivacyPolicyEvaluationMode;
 }
 

package/src/utils/EntityCreationUtils.ts

@@ -0,0 +1,143 @@
+import { IEntityClass } from '../Entity';
+import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
+import { EntityTransactionalQueryContext } from '../EntityQueryContext';
+import ReadonlyEntity from '../ReadonlyEntity';
+import ViewerContext from '../ViewerContext';
+import { EntityDatabaseAdapterUniqueConstraintError } from '../errors/EntityDatabaseAdapterError';
+import EntityNotFoundError from '../errors/EntityNotFoundError';
+
+/**
+ * Create an entity if it doesn't exist, or get the existing entity if it does.
+ */
+export async function createOrGetExistingAsync<
+  TFields extends object,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
+  TViewerContext extends ViewerContext,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
+  TPrivacyPolicy extends EntityPrivacyPolicy<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TSelectedFields
+  >,
+  TGetArgs,
+  TCreateArgs,
+  TSelectedFields extends keyof TFields = keyof TFields,
+>(
+  viewerContext: TViewerContext,
+  entityClass: IEntityClass<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TPrivacyPolicy,
+    TSelectedFields
+  >,
+  getAsync: (
+    viewerContext: TViewerContext,
+    getArgs: TGetArgs,
+    queryContext?: EntityTransactionalQueryContext,
+  ) => Promise<TEntity | null>,
+  getArgs: TGetArgs,
+  createAsync: (
+    viewerContext: TViewerContext,
+    createArgs: TCreateArgs,
+    queryContext?: EntityTransactionalQueryContext,
+  ) => Promise<TEntity>,
+  createArgs: TCreateArgs,
+  queryContext?: EntityTransactionalQueryContext,
+): Promise<TEntity> {
+  if (!queryContext) {
+    const maybeEntity = await getAsync(viewerContext, getArgs);
+    if (maybeEntity) {
+      return maybeEntity;
+    }
+  } else {
+    // This is done in a nested transaction since entity may negatively cache load results per-transaction (when configured).
+    // Without it, it would
+    // 1. load the entity in the current query context, negatively cache it
+    // 2. then try to create it in the nested transaction, which may fail due to a unique constraint error
+    // 3. then try to load the entity again in the current query context, which would return null due to negative cache
+    const maybeEntity = await queryContext.runInNestedTransactionAsync((nestedQueryContext) =>
+      getAsync(viewerContext, getArgs, nestedQueryContext),
+    );
+    if (maybeEntity) {
+      return maybeEntity;
+    }
+  }
+  return await createWithUniqueConstraintRecoveryAsync(
+    viewerContext,
+    entityClass,
+    getAsync,
+    getArgs,
+    createAsync,
+    createArgs,
+    queryContext,
+  );
+}
+
+/**
+ * Account for concurrent requests that may try to create the same entity.
+ * Return the existing entity if we get a Unique Constraint error.
+ */
+export async function createWithUniqueConstraintRecoveryAsync<
+  TFields extends object,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
+  TViewerContext extends ViewerContext,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
+  TPrivacyPolicy extends EntityPrivacyPolicy<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TSelectedFields
+  >,
+  TGetArgs,
+  TCreateArgs,
+  TSelectedFields extends keyof TFields = keyof TFields,
+>(
+  viewerContext: TViewerContext,
+  entityClass: IEntityClass<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TPrivacyPolicy,
+    TSelectedFields
+  >,
+  getAsync: (
+    viewerContext: TViewerContext,
+    getArgs: TGetArgs,
+    queryContext?: EntityTransactionalQueryContext,
+  ) => Promise<TEntity | null>,
+  getArgs: TGetArgs,
+  createAsync: (
+    viewerContext: TViewerContext,
+    createArgs: TCreateArgs,
+    queryContext?: EntityTransactionalQueryContext,
+  ) => Promise<TEntity>,
+  createArgs: TCreateArgs,
+  queryContext?: EntityTransactionalQueryContext,
+): Promise<TEntity> {
+  try {
+    if (!queryContext) {
+      return await createAsync(viewerContext, createArgs);
+    }
+    return await queryContext.runInNestedTransactionAsync((nestedQueryContext) =>
+      createAsync(viewerContext, createArgs, nestedQueryContext),
+    );
+  } catch (e) {
+    if (e instanceof EntityDatabaseAdapterUniqueConstraintError) {
+      const entity = await getAsync(viewerContext, getArgs, queryContext);
+      if (!entity) {
+        throw new EntityNotFoundError(
+          `Expected entity to exist after unique constraint error: ${entityClass.name}`,
+        );
+      }
+      return entity;
+    } else {
+      throw e;
+    }
+  }
+}

package/src/utils/__testfixtures__/StubDatabaseAdapter.ts

@@ -49,6 +49,18 @@ export default class StubDatabaseAdapter<
     return new Map();
   }
 
+  private static uniqBy<T>(a: T[], keyExtractor: (k: T) => string): T[] {
+    const seen = new Set();
+    return a.filter((item) => {
+      const k = keyExtractor(item);
+      if (seen.has(k)) {
+        return false;
+      }
+      seen.add(k);
+      return true;
+    });
+  }
+
   protected async fetchManyWhereInternalAsync(
     _queryInterface: any,
     tableName: string,
@@ -56,7 +68,7 @@ export default class StubDatabaseAdapter<
     tableTuples: (readonly any[])[],
   ): Promise<object[]> {
     const objectCollection = this.getObjectCollectionForTable(tableName);
-    const results = tableTuples.reduce(
+    const results = StubDatabaseAdapter.uniqBy(tableTuples, (tuple) => tuple.join(':')).reduce(
       (acc, tableTuple) => {
         return acc.concat(
           objectCollection.filter((obj) => {

package/src/utils/__tests__/EntityCreationUtils-test.ts

@@ -0,0 +1,354 @@
+import { EntityTransactionalQueryContext } from '../../EntityQueryContext';
+import ViewerContext from '../../ViewerContext';
+import { EntityDatabaseAdapterUniqueConstraintError } from '../../errors/EntityDatabaseAdapterError';
+import EntityNotFoundError from '../../errors/EntityNotFoundError';
+import {
+  createOrGetExistingAsync,
+  createWithUniqueConstraintRecoveryAsync,
+} from '../EntityCreationUtils';
+import SimpleTestEntity from '../__testfixtures__/SimpleTestEntity';
+import { createUnitTestEntityCompanionProvider } from '../__testfixtures__/createUnitTestEntityCompanionProvider';
+
+type TArgs = object;
+
+describe.each([true, false])('in transaction %p', (inTransaction) => {
+  describe(createOrGetExistingAsync, () => {
+    it('does not create when already exists', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+
+      const entity = await SimpleTestEntity.creator(viewerContext).createAsync();
+
+      const args: TArgs = {};
+
+      const getFn = jest.fn(
+        async (
+          _vc: ViewerContext,
+          _args: TArgs,
+          _queryContext?: EntityTransactionalQueryContext,
+        ) => {
+          return entity;
+        },
+      );
+
+      const createFn = jest.fn(
+        async (vc: ViewerContext, _args: TArgs, queryContext?: EntityTransactionalQueryContext) => {
+          return await SimpleTestEntity.creator(vc, queryContext).createAsync();
+        },
+      );
+
+      if (inTransaction) {
+        await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+          'postgres',
+          async (queryContext) => {
+            await createOrGetExistingAsync(
+              viewerContext,
+              SimpleTestEntity,
+              getFn,
+              args,
+              createFn,
+              args,
+              queryContext,
+            );
+          },
+        );
+      } else {
+        await createOrGetExistingAsync(
+          viewerContext,
+          SimpleTestEntity,
+          getFn,
+          args,
+          createFn,
+          args,
+        );
+      }
+
+      expect(getFn).toHaveBeenCalledTimes(1);
+      expect(createFn).toHaveBeenCalledTimes(0);
+    });
+
+    it('creates when not found', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+
+      const args: TArgs = {};
+
+      const getFn = jest.fn(
+        async (
+          _vc: ViewerContext,
+          _args: TArgs,
+          _queryContext?: EntityTransactionalQueryContext,
+        ) => {
+          return null;
+        },
+      );
+
+      const createFn = jest.fn(
+        async (vc: ViewerContext, _args: TArgs, queryContext?: EntityTransactionalQueryContext) => {
+          return await SimpleTestEntity.creator(vc, queryContext).createAsync();
+        },
+      );
+
+      if (inTransaction) {
+        await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+          'postgres',
+          async (queryContext) => {
+            await createOrGetExistingAsync(
+              viewerContext,
+              SimpleTestEntity,
+              getFn,
+              args,
+              createFn,
+              args,
+              queryContext,
+            );
+          },
+        );
+      } else {
+        await createOrGetExistingAsync(
+          viewerContext,
+          SimpleTestEntity,
+          getFn,
+          args,
+          createFn,
+          args,
+        );
+      }
+
+      expect(getFn).toHaveBeenCalledTimes(1);
+      expect(createFn).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe(createWithUniqueConstraintRecoveryAsync, () => {
+    it('does not call get when creation succeeds', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+
+      const args: TArgs = {};
+
+      const getFn = jest.fn(
+        async (
+          _vc: ViewerContext,
+          _args: TArgs,
+          _queryContext?: EntityTransactionalQueryContext,
+        ) => {
+          return null;
+        },
+      );
+
+      const createFn = jest.fn(
+        async (vc: ViewerContext, _args: TArgs, queryContext?: EntityTransactionalQueryContext) => {
+          return await SimpleTestEntity.creator(vc, queryContext).createAsync();
+        },
+      );
+
+      if (inTransaction) {
+        await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+          'postgres',
+          async (queryContext) => {
+            await createWithUniqueConstraintRecoveryAsync(
+              viewerContext,
+              SimpleTestEntity,
+              getFn,
+              args,
+              createFn,
+              args,
+              queryContext,
+            );
+          },
+        );
+      } else {
+        await createWithUniqueConstraintRecoveryAsync(
+          viewerContext,
+          SimpleTestEntity,
+          getFn,
+          args,
+          createFn,
+          args,
+        );
+      }
+
+      expect(getFn).toHaveBeenCalledTimes(0);
+      expect(createFn).toHaveBeenCalledTimes(1);
+    });
+
+    it('calls get when database adapter throws EntityDatabaseAdapterUniqueConstraintError', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+
+      const entity = await SimpleTestEntity.creator(viewerContext).createAsync();
+
+      const args: TArgs = {};
+
+      const getFn = jest.fn(
+        async (
+          _vc: ViewerContext,
+          _args: TArgs,
+          _queryContext?: EntityTransactionalQueryContext,
+        ) => {
+          return entity;
+        },
+      );
+
+      const createFn = jest.fn(
+        async (
+          _vc: ViewerContext,
+          _args: TArgs,
+          _queryContext?: EntityTransactionalQueryContext,
+        ) => {
+          throw new EntityDatabaseAdapterUniqueConstraintError('wat');
+        },
+      );
+
+      if (inTransaction) {
+        await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+          'postgres',
+          async (queryContext) => {
+            await createWithUniqueConstraintRecoveryAsync(
+              viewerContext,
+              SimpleTestEntity,
+              getFn,
+              args,
+              createFn,
+              args,
+              queryContext,
+            );
+          },
+        );
+      } else {
+        await createWithUniqueConstraintRecoveryAsync(
+          viewerContext,
+          SimpleTestEntity,
+          getFn,
+          args,
+          createFn,
+          args,
+        );
+      }
+
+      expect(getFn).toHaveBeenCalledTimes(1);
+      expect(createFn).toHaveBeenCalledTimes(1);
+    });
+
+    it('throws an EntityNotFoundError when database adapter throws EntityDatabaseAdapterUniqueConstraintError and getFn returns null', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+
+      const args: TArgs = {};
+
+      const getFn = jest.fn(
+        async (
+          _vc: ViewerContext,
+          _args: TArgs,
+          _queryContext?: EntityTransactionalQueryContext,
+        ) => {
+          return null;
+        },
+      );
+
+      const createFn = jest.fn(
+        async (
+          _vc: ViewerContext,
+          _args: TArgs,
+          _queryContext?: EntityTransactionalQueryContext,
+        ) => {
+          throw new EntityDatabaseAdapterUniqueConstraintError('wat');
+        },
+      );
+
+      if (inTransaction) {
+        await expect(
+          viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+            'postgres',
+            async (queryContext) => {
+              return await createWithUniqueConstraintRecoveryAsync(
+                viewerContext,
+                SimpleTestEntity,
+                getFn,
+                args,
+                createFn,
+                args,
+                queryContext,
+              );
+            },
+          ),
+        ).rejects.toThrow(EntityNotFoundError);
+      } else {
+        await expect(
+          createWithUniqueConstraintRecoveryAsync(
+            viewerContext,
+            SimpleTestEntity,
+            getFn,
+            args,
+            createFn,
+            args,
+          ),
+        ).rejects.toThrow(EntityNotFoundError);
+      }
+
+      expect(getFn).toHaveBeenCalledTimes(1);
+      expect(createFn).toHaveBeenCalledTimes(1);
+    });
+
+    it('rethrows whatever error is thrown from database adapter  if not EntityDatabaseAdapterUniqueConstraintError', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+
+      const args: TArgs = {};
+
+      const getFn = jest.fn(
+        async (
+          _vc: ViewerContext,
+          _args: TArgs,
+          _queryContext?: EntityTransactionalQueryContext,
+        ) => {
+          return null;
+        },
+      );
+
+      const createFn = jest.fn(
+        async (
+          _vc: ViewerContext,
+          _args: TArgs,
+          _queryContext?: EntityTransactionalQueryContext,
+        ) => {
+          throw new Error('wat');
+        },
+      );
+
+      if (inTransaction) {
+        await expect(
+          viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+            'postgres',
+            async (queryContext) => {
+              return await createWithUniqueConstraintRecoveryAsync(
+                viewerContext,
+                SimpleTestEntity,
+                getFn,
+                args,
+                createFn,
+                args,
+                queryContext,
+              );
+            },
+          ),
+        ).rejects.toThrow('wat');
+      } else {
+        await expect(
+          createWithUniqueConstraintRecoveryAsync(
+            viewerContext,
+            SimpleTestEntity,
+            getFn,
+            args,
+            createFn,
+            args,
+          ),
+        ).rejects.toThrow('wat');
+      }
+
+      expect(getFn).toHaveBeenCalledTimes(0);
+      expect(createFn).toHaveBeenCalledTimes(1);
+    });
+  });
+});