@expo/entity 0.55.0 → 0.57.0

package/src/index.ts

@@ -19,14 +19,15 @@ export * from './EntityAssociationLoader';
 export * from './EntityCompanion';
 export * from './EntityCompanionProvider';
 export * from './EntityConfiguration';
+export * from './EntityConstructionUtils';
 export * from './EntityCreator';
 export * from './EntityDatabaseAdapter';
 export * from './EntityDeleter';
 export * from './EntityFieldDefinition';
 export * from './EntityFields';
+export * from './EntityInvalidationUtils';
 export * from './EntityLoader';
 export * from './EntityLoaderFactory';
-export * from './EntityLoaderUtils';
 export * from './EntityMutationInfo';
 export * from './EntityMutationTriggerConfiguration';
 export * from './EntityMutationValidatorConfiguration';

package/src/internal/EntityDataManager.ts

@@ -1,12 +1,7 @@
 import DataLoader from 'dataloader';
 import invariant from 'invariant';
 
-import {
-  EntityDatabaseAdapter,
-  FieldEqualityCondition,
-  QuerySelectionModifiers,
-  QuerySelectionModifiersWithOrderByRaw,
-} from '../EntityDatabaseAdapter';
+import { EntityDatabaseAdapter } from '../EntityDatabaseAdapter';
 import {
   EntityQueryContext,
   EntityTransactionalQueryContext,
@@ -17,8 +12,8 @@ import { partitionErrors } from '../entityUtils';
 import { IEntityLoadKey, IEntityLoadValue, LoadPair } from './EntityLoadInterfaces';
 import { ReadThroughEntityCache } from './ReadThroughEntityCache';
 import {
-  timeAndLogLoadEventAsync,
   timeAndLogLoadMapEventAsync,
+  timeAndLogLoadOneEventAsync,
 } from '../metrics/EntityMetricsUtils';
 import {
   EntityMetricsLoadType,
@@ -252,61 +247,31 @@ export class EntityDataManager<
   }
 
   /**
-   * Loads many objects matching the conjunction of where clauses constructed from
-   * specified field equality operands.
+   * Load one object matching load key and load value if at least one matching object exists.
+   * Returned object is not guaranteed to be deterministic.
    *
-   * @param queryContext - query context in which to perform the load
-   * @param fieldEqualityOperands - list of field equality where clause operand specifications
-   * @param querySelectionModifiers - limit, offset, and orderBy for the query
-   * @returns array of objects matching the query
-   */
-  async loadManyByFieldEqualityConjunctionAsync<N extends keyof TFields>(
-    queryContext: EntityQueryContext,
-    fieldEqualityOperands: FieldEqualityCondition<TFields, N>[],
-    querySelectionModifiers: QuerySelectionModifiers<TFields>,
-  ): Promise<readonly Readonly<TFields>[]> {
-    return await timeAndLogLoadEventAsync(
-      this.metricsAdapter,
-      EntityMetricsLoadType.LOAD_MANY_EQUALITY_CONJUNCTION,
-      this.entityClassName,
-      queryContext,
-    )(
-      this.databaseAdapter.fetchManyByFieldEqualityConjunctionAsync(
-        queryContext,
-        fieldEqualityOperands,
-        querySelectionModifiers,
-      ),
-    );
-  }
-
-  /**
-   * Loads many objects matching the raw WHERE clause.
+   * Used when evaluating EntityEdgeDeletionAuthorizationInferenceBehavior.ONE_IMPLIES_ALL.
    *
    * @param queryContext - query context in which to perform the load
-   * @param rawWhereClause - parameterized SQL WHERE clause with positional binding placeholders or named binding placeholders
-   * @param bindings - array of positional bindings or object of named bindings
-   * @param querySelectionModifiers - limit, offset, orderBy, and orderByRaw for the query
-   * @returns array of objects matching the query
+   * @param key - load key being queried
+   * @param values - load value being queried for the key
+   * @returns at most one that match the query for that load value
    */
-  async loadManyByRawWhereClauseAsync(
+  public async loadOneEqualingAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
     queryContext: EntityQueryContext,
-    rawWhereClause: string,
-    bindings: any[] | object,
-    querySelectionModifiers: QuerySelectionModifiersWithOrderByRaw<TFields>,
-  ): Promise<readonly Readonly<TFields>[]> {
-    return await timeAndLogLoadEventAsync(
+    key: TLoadKey,
+    value: TLoadValue,
+  ): Promise<Readonly<TFields> | null> {
+    return await timeAndLogLoadOneEventAsync(
       this.metricsAdapter,
-      EntityMetricsLoadType.LOAD_MANY_RAW,
+      EntityMetricsLoadType.LOAD_ONE,
       this.entityClassName,
       queryContext,
-    )(
-      this.databaseAdapter.fetchManyByRawWhereClauseAsync(
-        queryContext,
-        rawWhereClause,
-        bindings,
-        querySelectionModifiers,
-      ),
-    );
+    )(this.databaseAdapter.fetchOneWhereAsync(queryContext, key, value));
   }
 
   private async invalidateOneAsync<

package/src/internal/EntityFieldTransformationUtils.ts

@@ -51,7 +51,7 @@ export const transformDatabaseObjectToFields = <
   fieldTransformerMap: FieldTransformerMap,
   databaseObject: { [key: string]: any },
 ): Readonly<TFields> => {
-  const fields: TFields = {} as any;
+  const fields: Partial<TFields> = {};
   for (const k in databaseObject) {
     const val = databaseObject[k];
     const fieldsKey = entityConfiguration.dbToEntityFieldsKeyMapping.get(k);
@@ -64,7 +64,7 @@ export const transformDatabaseObjectToFields = <
       );
     }
   }
-  return fields;
+  return fields as Readonly<TFields>;
 };
 
 /**
@@ -81,7 +81,7 @@ export const transformFieldsToDatabaseObject = <
   const databaseObject: { [key: string]: any } = {};
   for (const k in fields) {
     const val = fields[k]!;
-    const databaseKey = entityConfiguration.entityToDBFieldsKeyMapping.get(k as any);
+    const databaseKey = entityConfiguration.entityToDBFieldsKeyMapping.get(k);
     invariant(databaseKey, `must be database key for field: ${k}`);
     databaseObject[databaseKey] = maybeTransformFieldValueToDatabaseValue(
       entityConfiguration,
@@ -104,7 +104,7 @@ export const transformCacheObjectToFields = <
   fieldTransformerMap: FieldTransformerMap,
   cacheObject: { [key: string]: any },
 ): Readonly<TFields> => {
-  const fields: TFields = {} as any;
+  const fields: Partial<TFields> = {};
   for (const fieldsKey in cacheObject) {
     const val = cacheObject[fieldsKey]!;
     fields[fieldsKey as keyof TFields] = maybeTransformCacheValueToFieldValue(
@@ -114,7 +114,7 @@ export const transformCacheObjectToFields = <
       val,
     );
   }
-  return fields;
+  return fields as Readonly<TFields>;
 };
 
 /**

package/src/internal/EntityLoadInterfaces.ts

@@ -3,6 +3,8 @@ import { ISerializable, SerializableKeyMap } from '../utils/collections/Serializ
 
 /**
  * Load method type identifier of a load key. Used for keying data loaders and identification in metrics.
+ *
+ * @internal
  */
 export enum EntityLoadMethodType {
   /**

package/src/internal/EntityTableDataCoordinator.ts

@@ -28,8 +28,8 @@ export class EntityTableDataCoordinator<
     databaseAdapterProvider: IEntityDatabaseAdapterProvider,
     cacheAdapterProvider: IEntityCacheAdapterProvider,
     private readonly queryContextProvider: EntityQueryContextProvider,
-    metricsAdapter: IEntityMetricsAdapter,
-    entityClassName: string,
+    public readonly metricsAdapter: IEntityMetricsAdapter,
+    public readonly entityClassName: string,
   ) {
     this.databaseAdapter = databaseAdapterProvider.getDatabaseAdapter(entityConfiguration);
     this.cacheAdapter = cacheAdapterProvider.getCacheAdapter(entityConfiguration);

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

@@ -2,10 +2,16 @@ import { describe, expect, it } from '@jest/globals';
 
 import { CompositeFieldHolder, CompositeFieldValueHolder } from '../CompositeFieldHolder';
 
+type TestFields = {
+  id: string;
+  field1: string;
+  field2: string;
+};
+
 describe(CompositeFieldHolder, () => {
   it('is order-agnostic for serialization', () => {
-    const compositeFieldHolder = new CompositeFieldHolder(['field1', 'field2']);
-    const compositeFieldHolder2 = new CompositeFieldHolder(['field2', 'field1']);
+    const compositeFieldHolder = new CompositeFieldHolder<TestFields, 'id'>(['field1', 'field2']);
+    const compositeFieldHolder2 = new CompositeFieldHolder<TestFields, 'id'>(['field2', 'field1']);
 
     expect(compositeFieldHolder.serialize()).toEqual(compositeFieldHolder2.serialize());
   });