@expo/entity 0.49.0 → 0.50.0

package/build/src/EntityMutationValidator.js

@@ -1,4 +1,5 @@
 "use strict";
+/* c8 ignore start - abstract class only */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityMutationValidator = void 0;
 /**
@@ -8,4 +9,5 @@ exports.EntityMutationValidator = void 0;
 class EntityMutationValidator {
 }
 exports.EntityMutationValidator = EntityMutationValidator;
+/* c8 ignore stop - abstract class only */
 //# sourceMappingURL=EntityMutationValidator.js.map

package/build/src/EntityMutationValidator.js.map

@@ -1 +1 @@
-{"version":3,"file":"EntityMutationValidator.js","sourceRoot":"","sources":["../../src/EntityMutationValidator.ts"],"names":[],"mappings":";;;AAKA;;;GAGG;AACH,MAAsB,uBAAuB;CAmB5C;AAnBD,0DAmBC"}
+{"version":3,"file":"EntityMutationValidator.js","sourceRoot":"","sources":["../../src/EntityMutationValidator.ts"],"names":[],"mappings":";AAAA,2CAA2C;;;AAO3C;;;GAGG;AACH,MAAsB,uBAAuB;CAmB5C;AAnBD,0DAmBC;AAED,0CAA0C"}

package/build/src/IEntityCacheAdapter.js

@@ -1,3 +1,5 @@
 "use strict";
+/* c8 ignore start - interface only */
 Object.defineProperty(exports, "__esModule", { value: true });
+/* c8 ignore stop - interface only */
 //# sourceMappingURL=IEntityCacheAdapter.js.map

package/build/src/IEntityCacheAdapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"IEntityCacheAdapter.js","sourceRoot":"","sources":["../../src/IEntityCacheAdapter.ts"],"names":[],"mappings":""}
+{"version":3,"file":"IEntityCacheAdapter.js","sourceRoot":"","sources":["../../src/IEntityCacheAdapter.ts"],"names":[],"mappings":";AAAA,sCAAsC;;AAwEtC,qCAAqC"}

package/build/src/IEntityCacheAdapterProvider.js

@@ -1,3 +1,5 @@
 "use strict";
+/* c8 ignore start - interface only */
 Object.defineProperty(exports, "__esModule", { value: true });
+/* c8 ignore stop - interface only */
 //# sourceMappingURL=IEntityCacheAdapterProvider.js.map

package/build/src/IEntityCacheAdapterProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"IEntityCacheAdapterProvider.js","sourceRoot":"","sources":["../../src/IEntityCacheAdapterProvider.ts"],"names":[],"mappings":""}
+{"version":3,"file":"IEntityCacheAdapterProvider.js","sourceRoot":"","sources":["../../src/IEntityCacheAdapterProvider.ts"],"names":[],"mappings":";AAAA,sCAAsC;;AAkBtC,qCAAqC"}

package/build/src/IEntityDatabaseAdapterProvider.js

@@ -1,3 +1,5 @@
 "use strict";
+/* c8 ignore start - interface only */
 Object.defineProperty(exports, "__esModule", { value: true });
+/* c8 ignore stop - interface only */
 //# sourceMappingURL=IEntityDatabaseAdapterProvider.js.map

package/build/src/IEntityDatabaseAdapterProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"IEntityDatabaseAdapterProvider.js","sourceRoot":"","sources":["../../src/IEntityDatabaseAdapterProvider.ts"],"names":[],"mappings":""}
+{"version":3,"file":"IEntityDatabaseAdapterProvider.js","sourceRoot":"","sources":["../../src/IEntityDatabaseAdapterProvider.ts"],"names":[],"mappings":";AAAA,sCAAsC;;AAkBtC,qCAAqC"}

package/build/src/IEntityGenericCacher.js

@@ -1,3 +1,5 @@
 "use strict";
+/* c8 ignore start - interface only */
 Object.defineProperty(exports, "__esModule", { value: true });
+/* c8 ignore stop - interface only */
 //# sourceMappingURL=IEntityGenericCacher.js.map

package/build/src/IEntityGenericCacher.js.map

@@ -1 +1 @@
-{"version":3,"file":"IEntityGenericCacher.js","sourceRoot":"","sources":["../../src/IEntityGenericCacher.ts"],"names":[],"mappings":""}
+{"version":3,"file":"IEntityGenericCacher.js","sourceRoot":"","sources":["../../src/IEntityGenericCacher.ts"],"names":[],"mappings":";AAAA,sCAAsC;;AA4EtC,qCAAqC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/entity",
-  "version": "0.49.0",
+  "version": "0.50.0",
   "description": "A privacy-first data model",
   "files": [
     "build",
@@ -44,5 +44,5 @@
     "uuid": "^8.3.0",
     "uuidv7": "^1.0.0"
   },
-  "gitHead": "4ab2cf1cc498f0e06bdb0f792a08aca3f49d27fc"
+  "gitHead": "59e024eb19fd7a6f6d0b8f1577970b26049bc411"
 }

package/src/EntityMutationValidator.ts

@@ -1,3 +1,5 @@
+/* c8 ignore start - abstract class only */
+
 import { EntityValidatorMutationInfo } from './EntityMutationInfo';
 import { EntityTransactionalQueryContext } from './EntityQueryContext';
 import { ReadonlyEntity } from './ReadonlyEntity';
@@ -27,3 +29,5 @@ export abstract class EntityMutationValidator<
     >,
   ): Promise<void>;
 }
+
+/* c8 ignore stop - abstract class only */

package/src/IEntityCacheAdapter.ts

@@ -1,3 +1,5 @@
+/* c8 ignore start - interface only */
+
 import { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces';
 import { CacheLoadResult } from './internal/ReadThroughEntityCache';
 
@@ -67,3 +69,5 @@ export interface IEntityCacheAdapter<
     values: readonly TLoadValue[],
   ): Promise<void>;
 }
+
+/* c8 ignore stop - interface only */

package/src/IEntityCacheAdapterProvider.ts

@@ -1,3 +1,5 @@
+/* c8 ignore start - interface only */
+
 import { EntityConfiguration } from './EntityConfiguration';
 import { IEntityCacheAdapter } from './IEntityCacheAdapter';
 
@@ -13,3 +15,5 @@ export interface IEntityCacheAdapterProvider {
     entityConfiguration: EntityConfiguration<TFields, TIDField>,
   ): IEntityCacheAdapter<TFields, TIDField>;
 }
+
+/* c8 ignore stop - interface only */

package/src/IEntityDatabaseAdapterProvider.ts

@@ -1,3 +1,5 @@
+/* c8 ignore start - interface only */
+
 import { EntityConfiguration } from './EntityConfiguration';
 import { EntityDatabaseAdapter } from './EntityDatabaseAdapter';
 
@@ -13,3 +15,5 @@ export interface IEntityDatabaseAdapterProvider {
     entityConfiguration: EntityConfiguration<TFields, TIDField>,
   ): EntityDatabaseAdapter<TFields, TIDField>;
 }
+
+/* c8 ignore stop - interface only */

package/src/IEntityGenericCacher.ts

@@ -1,3 +1,5 @@
+/* c8 ignore start - interface only */
+
 import { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces';
 import { CacheLoadResult } from './internal/ReadThroughEntityCache';
 
@@ -71,3 +73,5 @@ export interface IEntityGenericCacher<
     value: TLoadValue,
   ): readonly string[];
 }
+
+/* c8 ignore stop - interface only */

package/src/__tests__/GenericEntityCacheAdapter-test.ts

@@ -3,6 +3,7 @@ import { anything, deepEqual, instance, mock, verify, when } from 'ts-mockito';
 
 import { GenericEntityCacheAdapter } from '../GenericEntityCacheAdapter';
 import { IEntityGenericCacher } from '../IEntityGenericCacher';
+import { EntityCacheAdapterTransientError } from '../errors/EntityCacheAdapterError';
 import { CacheStatus } from '../internal/ReadThroughEntityCache';
 import {
   SingleFieldHolder,
@@ -68,6 +69,29 @@ describe(GenericEntityCacheAdapter, () => {
       );
       expect(results).toEqual(new SingleFieldValueHolderMap(new Map()));
     });
+
+    it('rethrows EntityCacheAdapterTransientError from underlying cacher', async () => {
+      const mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
+      when(
+        mockGenericCacher.makeCacheKeyForStorage(
+          deepEqualEntityAware(new SingleFieldHolder('id')),
+          anything(),
+        ),
+      ).thenCall((fieldHolder, fieldValueHolder) => {
+        return `${fieldHolder.fieldName}.${fieldValueHolder.fieldValue}`;
+      });
+      const expectedError = new EntityCacheAdapterTransientError('Transient error');
+      when(mockGenericCacher.loadManyAsync(deepEqual(['id.wat']))).thenReject(expectedError);
+
+      const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
+      await expect(
+        cacheAdapter.loadManyAsync(new SingleFieldHolder('id'), [
+          new SingleFieldValueHolder('wat'),
+        ]),
+      ).rejects.toThrow(expectedError);
+
+      verify(mockGenericCacher.loadManyAsync(anything())).once();
+    });
   });
 
   describe('cacheManyAsync', () => {

package/src/__tests__/GenericSecondaryEntityCache-test.ts

@@ -0,0 +1,180 @@
+import { describe, it, expect } from '@jest/globals';
+import nullthrows from 'nullthrows';
+
+import { EntitySecondaryCacheLoader } from '../EntitySecondaryCacheLoader';
+import { GenericSecondaryEntityCache } from '../GenericSecondaryEntityCache';
+import { IEntityGenericCacher } from '../IEntityGenericCacher';
+import { ViewerContext } from '../ViewerContext';
+import { IEntityLoadKey, IEntityLoadValue } from '../internal/EntityLoadInterfaces';
+import { CacheLoadResult, CacheStatus } from '../internal/ReadThroughEntityCache';
+import {
+  TestEntity,
+  TestEntityPrivacyPolicy,
+  TestFields,
+} from '../utils/__testfixtures__/TestEntity';
+import { createUnitTestEntityCompanionProvider } from '../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
+import { mapMapAsync } from '../utils/collections/maps';
+
+type TestLoadParams = { intValue: number };
+
+const DOES_NOT_EXIST = Symbol('doesNotExist');
+
+class TestGenericCacher implements IEntityGenericCacher<TestFields, 'customIdField'> {
+  private readonly localMemoryCache = new Map<
+    string,
+    Readonly<TestFields> | typeof DOES_NOT_EXIST
+  >();
+
+  public async loadManyAsync(
+    keys: readonly string[],
+  ): Promise<ReadonlyMap<string, CacheLoadResult<TestFields>>> {
+    const cacheResults = new Map<string, CacheLoadResult<TestFields>>();
+    for (const key of keys) {
+      const cacheResult = this.localMemoryCache.get(key);
+      if (cacheResult === DOES_NOT_EXIST) {
+        cacheResults.set(key, {
+          status: CacheStatus.NEGATIVE,
+        });
+      } else if (cacheResult) {
+        cacheResults.set(key, {
+          status: CacheStatus.HIT,
+          item: cacheResult as unknown as TestFields,
+        });
+      } else {
+        cacheResults.set(key, {
+          status: CacheStatus.MISS,
+        });
+      }
+    }
+    return cacheResults;
+  }
+
+  public async cacheManyAsync(objectMap: ReadonlyMap<string, Readonly<TestFields>>): Promise<void> {
+    for (const [key, item] of objectMap) {
+      this.localMemoryCache.set(key, item);
+    }
+  }
+
+  public async cacheDBMissesAsync(keys: readonly string[]): Promise<void> {
+    for (const key of keys) {
+      this.localMemoryCache.set(key, DOES_NOT_EXIST);
+    }
+  }
+
+  public async invalidateManyAsync(keys: readonly string[]): Promise<void> {
+    for (const key of keys) {
+      this.localMemoryCache.delete(key);
+    }
+  }
+
+  makeCacheKeyForStorage<
+    TLoadKey extends IEntityLoadKey<TestFields, 'customIdField', TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(_key: TLoadKey, _value: TLoadValue): string {
+    throw new Error('Method not used by this test.');
+  }
+
+  makeCacheKeysForInvalidation<
+    TLoadKey extends IEntityLoadKey<TestFields, 'customIdField', TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(_key: TLoadKey, _value: TLoadValue): readonly string[] {
+    throw new Error('Method not used by this test.');
+  }
+}
+
+class TestSecondaryEntityCache<
+  TFields extends Record<string, any>,
+  TIDField extends keyof TFields,
+  TLoadParams,
+> extends GenericSecondaryEntityCache<TFields, TIDField, TLoadParams> {}
+
+class TestSecondaryCacheLoader extends EntitySecondaryCacheLoader<
+  TestLoadParams,
+  TestFields,
+  'customIdField',
+  ViewerContext,
+  TestEntity,
+  TestEntityPrivacyPolicy
+> {
+  public databaseLoadCount = 0;
+
+  protected override async fetchObjectsFromDatabaseAsync(
+    loadParamsArray: readonly Readonly<TestLoadParams>[],
+  ): Promise<ReadonlyMap<Readonly<Readonly<TestLoadParams>>, Readonly<TestFields> | null>> {
+    this.databaseLoadCount += loadParamsArray.length;
+
+    const emptyMap = new Map(loadParamsArray.map((p) => [p, null]));
+    return await mapMapAsync(emptyMap, async (_value, loadParams) => {
+      return (
+        (
+          await this.entityLoader.loadManyByFieldEqualityConjunctionAsync([
+            { fieldName: 'intField', fieldValue: loadParams.intValue },
+          ])
+        )[0]
+          ?.enforceValue()
+          ?.getAllFields() ?? null
+      );
+    });
+  }
+}
+
+describe(GenericSecondaryEntityCache, () => {
+  it('Loads through secondary loader, caches, and invalidates', async () => {
+    const viewerContext = new ViewerContext(createUnitTestEntityCompanionProvider());
+
+    const createdEntity = await TestEntity.creator(viewerContext)
+      .setField('intField', 1)
+      .createAsync();
+
+    const secondaryCacheLoader = new TestSecondaryCacheLoader(
+      new TestSecondaryEntityCache(
+        new TestGenericCacher(),
+        (params) => `intValue.${params.intValue}`,
+      ),
+      TestEntity.loaderWithAuthorizationResults(viewerContext),
+    );
+
+    const loadParams = { intValue: 1 };
+    const results = await secondaryCacheLoader.loadManyAsync([loadParams]);
+    expect(nullthrows(results.get(loadParams)).enforceValue().getID()).toEqual(
+      createdEntity.getID(),
+    );
+
+    expect(secondaryCacheLoader.databaseLoadCount).toEqual(1);
+
+    const results2 = await secondaryCacheLoader.loadManyAsync([loadParams]);
+    expect(nullthrows(results2.get(loadParams)).enforceValue().getID()).toEqual(
+      createdEntity.getID(),
+    );
+
+    expect(secondaryCacheLoader.databaseLoadCount).toEqual(1);
+
+    await secondaryCacheLoader.invalidateManyAsync([loadParams]);
+
+    const results3 = await secondaryCacheLoader.loadManyAsync([loadParams]);
+    expect(nullthrows(results3.get(loadParams)).enforceValue().getID()).toEqual(
+      createdEntity.getID(),
+    );
+
+    expect(secondaryCacheLoader.databaseLoadCount).toEqual(2);
+  });
+
+  it('correctly handles uncached and unfetchable load params', async () => {
+    const viewerContext = new ViewerContext(createUnitTestEntityCompanionProvider());
+
+    const secondaryCacheLoader = new TestSecondaryCacheLoader(
+      new TestSecondaryEntityCache(
+        new TestGenericCacher(),
+        (params) => `intValue.${params.intValue}`,
+      ),
+      TestEntity.loaderWithAuthorizationResults(viewerContext),
+    );
+
+    const loadParams = { intValue: 2 };
+    const results = await secondaryCacheLoader.loadManyAsync([loadParams]);
+    expect(results.size).toBe(1);
+    expect(results.get(loadParams)).toBe(null);
+  });
+});

package/src/utils/__testfixtures__/StubDatabaseAdapter.ts

@@ -234,7 +234,13 @@ export class StubDatabaseAdapter<
     const objectIndex = objectCollection.findIndex((obj) => {
       return obj[tableIdField] === id;
     });
-    invariant(objectIndex >= 0, 'should exist');
+
+    // SQL updates to a nonexistent row succeed but affect 0 rows,
+    // mirror that behavior here for better test simulation
+    if (objectIndex < 0) {
+      return [];
+    }
+
     objectCollection[objectIndex] = {
       ...objectCollection[objectIndex],
       ...object,
@@ -253,9 +259,13 @@ export class StubDatabaseAdapter<
     const objectIndex = objectCollection.findIndex((obj) => {
       return obj[tableIdField] === id;
     });
+
+    // SQL deletes to a nonexistent row succeed and affect 0 rows,
+    // mirror that behavior here for better test simulation
     if (objectIndex < 0) {
       return 0;
     }
+
     objectCollection.splice(objectIndex, 1);
     return 1;
   }