@expo/entity 0.60.0 → 0.62.0

package/build/src/EntityPrivacyPolicy.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityPrivacyPolicy = exports.EntityAuthorizationAction = exports.EntityPrivacyPolicyEvaluationMode = void 0;
-const EntityNotAuthorizedError_1 = require("./errors/EntityNotAuthorizedError");
-const IEntityMetricsAdapter_1 = require("./metrics/IEntityMetricsAdapter");
-const PrivacyPolicyRule_1 = require("./rules/PrivacyPolicyRule");
+import { EntityNotAuthorizedError } from "./errors/EntityNotAuthorizedError.js";
+import { EntityMetricsAuthorizationResult } from "./metrics/IEntityMetricsAdapter.js";
+import { RuleEvaluationResult } from "./rules/PrivacyPolicyRule.js";
 /**
  * Evaluation mode for a EntityPrivacyPolicy. Useful when transitioning to
  * using Entity for privacy.
  */
-var EntityPrivacyPolicyEvaluationMode;
+export var EntityPrivacyPolicyEvaluationMode;
 (function (EntityPrivacyPolicyEvaluationMode) {
     /**
      * Enforce this privacy policy. Throw upon denial.
@@ -22,14 +19,14 @@ var EntityPrivacyPolicyEvaluationMode;
      * Enforce this privacy policy. Throw and log upon denial.
      */
     EntityPrivacyPolicyEvaluationMode[EntityPrivacyPolicyEvaluationMode["ENFORCE_AND_LOG"] = 2] = "ENFORCE_AND_LOG";
-})(EntityPrivacyPolicyEvaluationMode || (exports.EntityPrivacyPolicyEvaluationMode = EntityPrivacyPolicyEvaluationMode = {}));
-var EntityAuthorizationAction;
+})(EntityPrivacyPolicyEvaluationMode || (EntityPrivacyPolicyEvaluationMode = {}));
+export var EntityAuthorizationAction;
 (function (EntityAuthorizationAction) {
     EntityAuthorizationAction[EntityAuthorizationAction["CREATE"] = 0] = "CREATE";
     EntityAuthorizationAction[EntityAuthorizationAction["READ"] = 1] = "READ";
     EntityAuthorizationAction[EntityAuthorizationAction["UPDATE"] = 2] = "UPDATE";
     EntityAuthorizationAction[EntityAuthorizationAction["DELETE"] = 3] = "DELETE";
-})(EntityAuthorizationAction || (exports.EntityAuthorizationAction = EntityAuthorizationAction = {}));
+})(EntityAuthorizationAction || (EntityAuthorizationAction = {}));
 /**
  * Privacy policy for an entity.
  *
@@ -51,7 +48,7 @@ var EntityAuthorizationAction;
  * return not authorized if all rules skip
  * ```
  */
-class EntityPrivacyPolicy {
+export class EntityPrivacyPolicy {
     /**
      * List of rules to evaluate for create authorization.
      */
@@ -143,19 +140,19 @@ class EntityPrivacyPolicy {
                     metricsAdapter.logAuthorizationEvent({
                         entityClassName: entity.constructor.name,
                         action,
-                        evaluationResult: IEntityMetricsAdapter_1.EntityMetricsAuthorizationResult.ALLOW,
+                        evaluationResult: EntityMetricsAuthorizationResult.ALLOW,
                         privacyPolicyEvaluationMode: privacyPolicyEvaluator.mode,
                     });
                     return result;
                 }
                 catch (e) {
-                    if (!(e instanceof EntityNotAuthorizedError_1.EntityNotAuthorizedError)) {
+                    if (!(e instanceof EntityNotAuthorizedError)) {
                         throw e;
                     }
                     metricsAdapter.logAuthorizationEvent({
                         entityClassName: entity.constructor.name,
                         action,
-                        evaluationResult: IEntityMetricsAdapter_1.EntityMetricsAuthorizationResult.DENY,
+                        evaluationResult: EntityMetricsAuthorizationResult.DENY,
                         privacyPolicyEvaluationMode: privacyPolicyEvaluator.mode,
                     });
                     throw e;
@@ -166,20 +163,20 @@ class EntityPrivacyPolicy {
                     metricsAdapter.logAuthorizationEvent({
                         entityClassName: entity.constructor.name,
                         action,
-                        evaluationResult: IEntityMetricsAdapter_1.EntityMetricsAuthorizationResult.ALLOW,
+                        evaluationResult: EntityMetricsAuthorizationResult.ALLOW,
                         privacyPolicyEvaluationMode: privacyPolicyEvaluator.mode,
                     });
                     return result;
                 }
                 catch (e) {
-                    if (!(e instanceof EntityNotAuthorizedError_1.EntityNotAuthorizedError)) {
+                    if (!(e instanceof EntityNotAuthorizedError)) {
                         throw e;
                     }
                     privacyPolicyEvaluator.denyHandler(e);
                     metricsAdapter.logAuthorizationEvent({
                         entityClassName: entity.constructor.name,
                         action,
-                        evaluationResult: IEntityMetricsAdapter_1.EntityMetricsAuthorizationResult.DENY,
+                        evaluationResult: EntityMetricsAuthorizationResult.DENY,
                         privacyPolicyEvaluationMode: privacyPolicyEvaluator.mode,
                     });
                     throw e;
@@ -190,20 +187,20 @@ class EntityPrivacyPolicy {
                     metricsAdapter.logAuthorizationEvent({
                         entityClassName: entity.constructor.name,
                         action,
-                        evaluationResult: IEntityMetricsAdapter_1.EntityMetricsAuthorizationResult.ALLOW,
+                        evaluationResult: EntityMetricsAuthorizationResult.ALLOW,
                         privacyPolicyEvaluationMode: privacyPolicyEvaluator.mode,
                     });
                     return result;
                 }
                 catch (e) {
-                    if (!(e instanceof EntityNotAuthorizedError_1.EntityNotAuthorizedError)) {
+                    if (!(e instanceof EntityNotAuthorizedError)) {
                         throw e;
                     }
                     privacyPolicyEvaluator.denyHandler(e);
                     metricsAdapter.logAuthorizationEvent({
                         entityClassName: entity.constructor.name,
                         action,
-                        evaluationResult: IEntityMetricsAdapter_1.EntityMetricsAuthorizationResult.DENY,
+                        evaluationResult: EntityMetricsAuthorizationResult.DENY,
                         privacyPolicyEvaluationMode: privacyPolicyEvaluator.mode,
                     });
                     return entity;
@@ -215,18 +212,16 @@ class EntityPrivacyPolicy {
             const rule = ruleset[i];
             const ruleEvaluationResult = await rule.evaluateAsync(viewerContext, queryContext, { ...evaluationContext, action }, entity);
             switch (ruleEvaluationResult) {
-                case PrivacyPolicyRule_1.RuleEvaluationResult.DENY:
-                    throw new EntityNotAuthorizedError_1.EntityNotAuthorizedError(entity, viewerContext, action, i);
-                case PrivacyPolicyRule_1.RuleEvaluationResult.SKIP:
+                case RuleEvaluationResult.DENY:
+                    throw new EntityNotAuthorizedError(entity, viewerContext, action, i);
+                case RuleEvaluationResult.SKIP:
                     continue;
-                case PrivacyPolicyRule_1.RuleEvaluationResult.ALLOW:
+                case RuleEvaluationResult.ALLOW:
                     return entity;
                 default:
                     throw new Error(`Invalid RuleEvaluationResult returned from rule: ${entity} (viewer = ${viewerContext}, action = ${EntityAuthorizationAction[action]}, ruleIndex = ${i})`);
             }
         }
-        throw new EntityNotAuthorizedError_1.EntityNotAuthorizedError(entity, viewerContext, action, -1);
+        throw new EntityNotAuthorizedError(entity, viewerContext, action, -1);
     }
 }
-exports.EntityPrivacyPolicy = EntityPrivacyPolicy;
-//# sourceMappingURL=EntityPrivacyPolicy.js.map

package/build/src/EntityQueryContext.d.ts

@@ -1,4 +1,4 @@
-import { EntityQueryContextProvider } from './EntityQueryContextProvider';
+import type { EntityQueryContextProvider } from './EntityQueryContextProvider.ts';
 export type PostCommitCallback = (...args: any) => Promise<any>;
 export type PreCommitCallback = (queryContext: EntityTransactionalQueryContext, ...args: any) => Promise<any>;
 export declare enum TransactionIsolationLevel {

package/build/src/EntityQueryContext.js

@@ -1,22 +1,16 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityNestedTransactionalQueryContext = exports.EntityTransactionalQueryContext = exports.EntityNonTransactionalQueryContext = exports.EntityQueryContext = exports.TransactionalDataLoaderMode = exports.TransactionIsolationLevel = void 0;
-const assert_1 = __importDefault(require("assert"));
-var TransactionIsolationLevel;
+import assert from 'assert';
+export var TransactionIsolationLevel;
 (function (TransactionIsolationLevel) {
     TransactionIsolationLevel["READ_COMMITTED"] = "READ_COMMITTED";
     TransactionIsolationLevel["REPEATABLE_READ"] = "REPEATABLE_READ";
     TransactionIsolationLevel["SERIALIZABLE"] = "SERIALIZABLE";
-})(TransactionIsolationLevel || (exports.TransactionIsolationLevel = TransactionIsolationLevel = {}));
-var TransactionalDataLoaderMode;
+})(TransactionIsolationLevel || (TransactionIsolationLevel = {}));
+export var TransactionalDataLoaderMode;
 (function (TransactionalDataLoaderMode) {
     TransactionalDataLoaderMode["ENABLED"] = "ENABLED";
     TransactionalDataLoaderMode["ENABLED_BATCH_ONLY"] = "ENABLED_BATCH_ONLY";
     TransactionalDataLoaderMode["DISABLED"] = "DISABLED";
-})(TransactionalDataLoaderMode || (exports.TransactionalDataLoaderMode = TransactionalDataLoaderMode = {}));
+})(TransactionalDataLoaderMode || (TransactionalDataLoaderMode = {}));
 /**
  * Entity framework representation of transactional and non-transactional database
  * query execution units.
@@ -24,7 +18,7 @@ var TransactionalDataLoaderMode;
  * The behavior of EntityMutator and EntityLoader
  * differs when in a transactional context.
  */
-class EntityQueryContext {
+export class EntityQueryContext {
     queryInterface;
     constructor(queryInterface) {
         this.queryInterface = queryInterface;
@@ -33,14 +27,13 @@ class EntityQueryContext {
         return this.queryInterface;
     }
 }
-exports.EntityQueryContext = EntityQueryContext;
 /**
  * Entity framework representation of a non-transactional query execution unit.
  * When supplied to EntityMutator and EntityLoader methods, they will be
  * run independently of any running transaction (though mutations start their own
  * independent transactions internally when not being run in a transaction).
  */
-class EntityNonTransactionalQueryContext extends EntityQueryContext {
+export class EntityNonTransactionalQueryContext extends EntityQueryContext {
     entityQueryContextProvider;
     constructor(queryInterface, entityQueryContextProvider) {
         super(queryInterface);
@@ -53,13 +46,12 @@ class EntityNonTransactionalQueryContext extends EntityQueryContext {
         return await this.entityQueryContextProvider.runInTransactionAsync(transactionScope, transactionConfig);
     }
 }
-exports.EntityNonTransactionalQueryContext = EntityNonTransactionalQueryContext;
 /**
  * Entity framework representation of a transactional query execution unit. When supplied
  * to EntityMutator and EntityLoader methods, those methods and their
  * dependent triggers and validators will run within the transaction.
  */
-class EntityTransactionalQueryContext extends EntityQueryContext {
+export class EntityTransactionalQueryContext extends EntityQueryContext {
     entityQueryContextProvider;
     transactionId;
     transactionalDataLoaderMode;
@@ -89,7 +81,7 @@ class EntityTransactionalQueryContext extends EntityQueryContext {
      *                with higher numbers running later than lower numbers.
      */
     appendPreCommitCallback(callback, order) {
-        (0, assert_1.default)(order >= Number.MIN_SAFE_INTEGER && order <= Number.MAX_SAFE_INTEGER, `Invalid order specified: ${order}`);
+        assert(order >= Number.MIN_SAFE_INTEGER && order <= Number.MAX_SAFE_INTEGER, `Invalid order specified: ${order}`);
         this.preCommitCallbacks.push({ callback, order });
     }
     /**
@@ -138,14 +130,13 @@ class EntityTransactionalQueryContext extends EntityQueryContext {
         return false;
     }
     async runInTransactionIfNotInTransactionAsync(transactionScope, transactionConfig) {
-        (0, assert_1.default)(transactionConfig === undefined, 'Should not pass transactionConfig to a nested transaction');
+        assert(transactionConfig === undefined, 'Should not pass transactionConfig to a nested transaction');
         return await transactionScope(this);
     }
     async runInNestedTransactionAsync(transactionScope) {
         return await this.entityQueryContextProvider.runInNestedTransactionAsync(this, transactionScope);
     }
 }
-exports.EntityTransactionalQueryContext = EntityTransactionalQueryContext;
 /**
  * Entity framework representation of a nested transactional query execution unit. When supplied
  * to EntityMutator and EntityLoader methods, those methods and their
@@ -154,7 +145,7 @@ exports.EntityTransactionalQueryContext = EntityTransactionalQueryContext;
  * This exists to forward post-commit callbacks to the parent query context but only after
  * successful commit of the nested transaction.
  */
-class EntityNestedTransactionalQueryContext extends EntityTransactionalQueryContext {
+export class EntityNestedTransactionalQueryContext extends EntityTransactionalQueryContext {
     parentQueryContext;
     postCommitInvalidationCallbacksToTransfer = [];
     postCommitCallbacksToTransfer = [];
@@ -208,5 +199,3 @@ class EntityNestedTransactionalQueryContext extends EntityTransactionalQueryCont
         }
     }
 }
-exports.EntityNestedTransactionalQueryContext = EntityNestedTransactionalQueryContext;
-//# sourceMappingURL=EntityQueryContext.js.map

package/build/src/EntityQueryContextProvider.d.ts

@@ -1,4 +1,5 @@
-import { EntityNestedTransactionalQueryContext, EntityNonTransactionalQueryContext, EntityTransactionalQueryContext, TransactionConfig, TransactionalDataLoaderMode } from './EntityQueryContext';
+import type { TransactionConfig } from './EntityQueryContext.ts';
+import { EntityNestedTransactionalQueryContext, EntityNonTransactionalQueryContext, EntityTransactionalQueryContext, TransactionalDataLoaderMode } from './EntityQueryContext.ts';
 /**
  * A query context provider vends transactional and non-transactional query contexts.
  */

package/build/src/EntityQueryContextProvider.js

@@ -1,23 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityQueryContextProvider = void 0;
-const node_crypto_1 = require("node:crypto");
-const EntityQueryContext_1 = require("./EntityQueryContext");
+import { randomUUID } from 'node:crypto';
+import { EntityNestedTransactionalQueryContext, EntityNonTransactionalQueryContext, EntityTransactionalQueryContext, TransactionalDataLoaderMode, } from "./EntityQueryContext.js";
 /**
  * A query context provider vends transactional and non-transactional query contexts.
  */
-class EntityQueryContextProvider {
+export class EntityQueryContextProvider {
     /**
      * Vend a regular (non-transactional) entity query context.
      */
     getQueryContext() {
-        return new EntityQueryContext_1.EntityNonTransactionalQueryContext(this.getQueryInterface(), this);
+        return new EntityNonTransactionalQueryContext(this.getQueryInterface(), this);
     }
     /**
      * @returns true if the transactional dataloader should be disabled for all transactions.
      */
     defaultTransactionalDataLoaderMode() {
-        return EntityQueryContext_1.TransactionalDataLoaderMode.ENABLED;
+        return TransactionalDataLoaderMode.ENABLED;
     }
     /**
      * Start a transaction and execute the provided transaction-scoped closure within the transaction.
@@ -25,7 +22,7 @@ class EntityQueryContextProvider {
      */
     async runInTransactionAsync(transactionScope, transactionConfig) {
         const [returnedValue, queryContext] = await this.createTransactionRunner(transactionConfig)(async (queryInterface) => {
-            const queryContext = new EntityQueryContext_1.EntityTransactionalQueryContext(queryInterface, this, (0, node_crypto_1.randomUUID)(), transactionConfig?.transactionalDataLoaderMode ?? this.defaultTransactionalDataLoaderMode());
+            const queryContext = new EntityTransactionalQueryContext(queryInterface, this, randomUUID(), transactionConfig?.transactionalDataLoaderMode ?? this.defaultTransactionalDataLoaderMode());
             const result = await transactionScope(queryContext);
             await queryContext.runPreCommitCallbacksAsync();
             return [result, queryContext];
@@ -41,7 +38,7 @@ class EntityQueryContextProvider {
      */
     async runInNestedTransactionAsync(outerQueryContext, transactionScope) {
         const [returnedValue, innerQueryContext] = await this.createNestedTransactionRunner(outerQueryContext.getQueryInterface())(async (innerQueryInterface) => {
-            const innerQueryContext = new EntityQueryContext_1.EntityNestedTransactionalQueryContext(innerQueryInterface, outerQueryContext, this, (0, node_crypto_1.randomUUID)(), outerQueryContext.transactionalDataLoaderMode);
+            const innerQueryContext = new EntityNestedTransactionalQueryContext(innerQueryInterface, outerQueryContext, this, randomUUID(), outerQueryContext.transactionalDataLoaderMode);
             const result = await transactionScope(innerQueryContext);
             await innerQueryContext.runPreCommitCallbacksAsync();
             return [result, innerQueryContext];
@@ -51,5 +48,3 @@ class EntityQueryContextProvider {
         return returnedValue;
     }
 }
-exports.EntityQueryContextProvider = EntityQueryContextProvider;
-//# sourceMappingURL=EntityQueryContextProvider.js.map

package/build/src/EntitySecondaryCacheLoader.d.ts

@@ -1,10 +1,10 @@
-import { Result } from '@expo/results';
-import { IEntityClass } from './Entity';
-import { EntityConstructionUtils } from './EntityConstructionUtils';
-import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
-import { EntityQueryContext } from './EntityQueryContext';
-import { ReadonlyEntity } from './ReadonlyEntity';
-import { ViewerContext } from './ViewerContext';
+import type { Result } from '@expo/results';
+import type { IEntityClass } from './Entity.ts';
+import type { EntityConstructionUtils } from './EntityConstructionUtils.ts';
+import type { EntityPrivacyPolicy } from './EntityPrivacyPolicy.ts';
+import type { EntityQueryContext } from './EntityQueryContext.ts';
+import type { ReadonlyEntity } from './ReadonlyEntity.ts';
+import type { ViewerContext } from './ViewerContext.ts';
 /**
  * An interface that knows how to load many objects from a cache by load params and invalidate
  * those same load params.

package/build/src/EntitySecondaryCacheLoader.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntitySecondaryCacheLoader = void 0;
-const maps_1 = require("./utils/collections/maps");
+import { mapMap } from "./utils/collections/maps.js";
 /**
  * A secondary cache loader allows for arbitrary cache keying for load params, which are a set of params used to load
  * a single entity field object.
@@ -13,7 +10,7 @@ const maps_1 = require("./utils/collections/maps");
  * due to use of a non-unique-field-based EntityLoader method like `loadManyByFieldEqualityConjunctionAsync` or
  * `loadManyByRawWhereClauseAsync`.
  */
-class EntitySecondaryCacheLoader {
+export class EntitySecondaryCacheLoader {
     secondaryEntityCache;
     constructionUtils;
     constructor(secondaryEntityCache, constructionUtils) {
@@ -28,8 +25,8 @@ class EntitySecondaryCacheLoader {
     async loadManyAsync(loadParamsArray) {
         const loadParamsToFieldObjects = await this.secondaryEntityCache.loadManyThroughAsync(loadParamsArray, this.fetchObjectsFromDatabaseAsync.bind(this));
         // convert value to and from array to reuse complex code
-        const entitiesMap = await this.constructionUtils.constructAndAuthorizeEntitiesAsync((0, maps_1.mapMap)(loadParamsToFieldObjects, (fieldObject) => (fieldObject ? [fieldObject] : [])));
-        return (0, maps_1.mapMap)(entitiesMap, (fieldObjects) => fieldObjects[0] ?? null);
+        const entitiesMap = await this.constructionUtils.constructAndAuthorizeEntitiesAsync(mapMap(loadParamsToFieldObjects, (fieldObject) => (fieldObject ? [fieldObject] : [])));
+        return mapMap(entitiesMap, (fieldObjects) => fieldObjects[0] ?? null);
     }
     /**
      * Invalidate the cache for objects cached by loadParams.
@@ -57,5 +54,3 @@ class EntitySecondaryCacheLoader {
             .constructionUtils(queryContext, { previousValue: null, cascadingDeleteCause: null });
     }
 }
-exports.EntitySecondaryCacheLoader = EntitySecondaryCacheLoader;
-//# sourceMappingURL=EntitySecondaryCacheLoader.js.map

package/build/src/EntityUpdater.d.ts

@@ -1,10 +1,10 @@
-import { AuthorizationResultBasedUpdateMutator } from './AuthorizationResultBasedEntityMutator';
-import { EnforcingEntityUpdater } from './EnforcingEntityUpdater';
-import { IEntityClass } from './Entity';
-import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
-import { EntityQueryContext } from './EntityQueryContext';
-import { ReadonlyEntity } from './ReadonlyEntity';
-import { ViewerContext } from './ViewerContext';
+import type { AuthorizationResultBasedUpdateMutator } from './AuthorizationResultBasedEntityMutator.ts';
+import { EnforcingEntityUpdater } from './EnforcingEntityUpdater.ts';
+import type { IEntityClass } from './Entity.ts';
+import type { EntityPrivacyPolicy } from './EntityPrivacyPolicy.ts';
+import type { EntityQueryContext } from './EntityQueryContext.ts';
+import type { ReadonlyEntity } from './ReadonlyEntity.ts';
+import type { ViewerContext } from './ViewerContext.ts';
 /**
  * The primary interface for updating entities.
  */

package/build/src/EntityUpdater.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityUpdater = void 0;
-const EnforcingEntityUpdater_1 = require("./EnforcingEntityUpdater");
+import { EnforcingEntityUpdater } from "./EnforcingEntityUpdater.js";
 /**
  * The primary interface for updating entities.
  */
-class EntityUpdater {
+export class EntityUpdater {
     existingEntity;
     queryContext;
     entityClass;
@@ -19,7 +16,7 @@ class EntityUpdater {
      * guaranteed to be successful and will throw otherwise.
      */
     enforcing() {
-        return new EnforcingEntityUpdater_1.EnforcingEntityUpdater(this.withAuthorizationResults());
+        return new EnforcingEntityUpdater(this.withAuthorizationResults());
     }
     /**
      * Authorization-result-based entity updater. All updates through this
@@ -34,5 +31,3 @@ class EntityUpdater {
             .forUpdate(this.existingEntity, this.queryContext, /* cascadingDeleteCause */ null);
     }
 }
-exports.EntityUpdater = EntityUpdater;
-//# sourceMappingURL=EntityUpdater.js.map

package/build/src/GenericEntityCacheAdapter.d.ts

@@ -1,7 +1,7 @@
-import { IEntityCacheAdapter } from './IEntityCacheAdapter';
-import { IEntityGenericCacher } from './IEntityGenericCacher';
-import { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces';
-import { CacheLoadResult } from './internal/ReadThroughEntityCache';
+import type { IEntityCacheAdapter } from './IEntityCacheAdapter.ts';
+import type { IEntityGenericCacher } from './IEntityGenericCacher.ts';
+import type { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces.ts';
+import type { CacheLoadResult } from './internal/ReadThroughEntityCache.ts';
 /**
  * A standard IEntityCacheAdapter that coordinates caching through an IEntityGenericCacher.
  */

package/build/src/GenericEntityCacheAdapter.js

@@ -1,15 +1,9 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GenericEntityCacheAdapter = void 0;
-const invariant_1 = __importDefault(require("invariant"));
-const maps_1 = require("./utils/collections/maps");
+import invariant from 'invariant';
+import { mapKeys } from "./utils/collections/maps.js";
 /**
  * A standard IEntityCacheAdapter that coordinates caching through an IEntityGenericCacher.
  */
-class GenericEntityCacheAdapter {
+export class GenericEntityCacheAdapter {
     genericCacher;
     constructor(genericCacher) {
         this.genericCacher = genericCacher;
@@ -20,13 +14,13 @@ class GenericEntityCacheAdapter {
         const result = key.vendNewLoadValueMap();
         for (const [redisCacheKey, cacheResult] of cacheResults) {
             const fieldValue = redisCacheKeyToFieldValueMapping.get(redisCacheKey);
-            (0, invariant_1.default)(fieldValue !== undefined, 'Unspecified cache key %s returned from generic cacher', redisCacheKey);
+            invariant(fieldValue !== undefined, 'Unspecified cache key %s returned from generic cacher', redisCacheKey);
             result.set(fieldValue, cacheResult);
         }
         return result;
     }
     async cacheManyAsync(key, objectMap) {
-        await this.genericCacher.cacheManyAsync((0, maps_1.mapKeys)(objectMap, (value) => this.genericCacher.makeCacheKeyForStorage(key, value)));
+        await this.genericCacher.cacheManyAsync(mapKeys(objectMap, (value) => this.genericCacher.makeCacheKeyForStorage(key, value)));
     }
     async cacheDBMissesAsync(key, values) {
         await this.genericCacher.cacheDBMissesAsync(values.map((value) => this.genericCacher.makeCacheKeyForStorage(key, value)));
@@ -35,5 +29,3 @@ class GenericEntityCacheAdapter {
         await this.genericCacher.invalidateManyAsync(values.flatMap((value) => this.genericCacher.makeCacheKeysForInvalidation(key, value)));
     }
 }
-exports.GenericEntityCacheAdapter = GenericEntityCacheAdapter;
-//# sourceMappingURL=GenericEntityCacheAdapter.js.map

package/build/src/GenericSecondaryEntityCache.d.ts

@@ -1,5 +1,5 @@
-import { ISecondaryEntityCache } from './EntitySecondaryCacheLoader';
-import { IEntityGenericCacher } from './IEntityGenericCacher';
+import type { ISecondaryEntityCache } from './EntitySecondaryCacheLoader.ts';
+import type { IEntityGenericCacher } from './IEntityGenericCacher.ts';
 /**
  * A custom secondary read-through entity cache is a way to add a custom second layer of caching for a particular
  * single entity load. One common way this may be used is to add a second layer of caching in a hot path that makes

package/build/src/GenericSecondaryEntityCache.js

@@ -1,18 +1,12 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GenericSecondaryEntityCache = void 0;
-const invariant_1 = __importDefault(require("invariant"));
-const ReadThroughEntityCache_1 = require("./internal/ReadThroughEntityCache");
-const maps_1 = require("./utils/collections/maps");
+import invariant from 'invariant';
+import { CacheStatus } from "./internal/ReadThroughEntityCache.js";
+import { filterMap, zipToMap } from "./utils/collections/maps.js";
 /**
  * A custom secondary read-through entity cache is a way to add a custom second layer of caching for a particular
  * single entity load. One common way this may be used is to add a second layer of caching in a hot path that makes
  * a call to EntityLoader.loadManyByFieldEqualityConjunctionAsync is guaranteed to return at most one entity.
  */
-class GenericSecondaryEntityCache {
+export class GenericSecondaryEntityCache {
     cacher;
     constructCacheKey;
     constructor(cacher, constructCacheKey) {
@@ -21,16 +15,16 @@ class GenericSecondaryEntityCache {
     }
     async loadManyThroughAsync(loadParamsArray, fetcher) {
         const cacheKeys = loadParamsArray.map(this.constructCacheKey);
-        const cacheKeyToLoadParamsMap = (0, maps_1.zipToMap)(cacheKeys, loadParamsArray);
+        const cacheKeyToLoadParamsMap = zipToMap(cacheKeys, loadParamsArray);
         const cacheLoadResults = await this.cacher.loadManyAsync(cacheKeys);
-        (0, invariant_1.default)(cacheLoadResults.size === loadParamsArray.length, `${this.constructor.name} loadMany should return a result for each key`);
-        const cacheKeysToFetch = Array.from((0, maps_1.filterMap)(cacheLoadResults, (cacheLoadResult) => cacheLoadResult.status === ReadThroughEntityCache_1.CacheStatus.MISS).keys());
+        invariant(cacheLoadResults.size === loadParamsArray.length, `${this.constructor.name} loadMany should return a result for each key`);
+        const cacheKeysToFetch = Array.from(filterMap(cacheLoadResults, (cacheLoadResult) => cacheLoadResult.status === CacheStatus.MISS).keys());
         // put cache hits in result map
         const results = new Map();
         cacheLoadResults.forEach((cacheLoadResult, cacheKey) => {
-            if (cacheLoadResult.status === ReadThroughEntityCache_1.CacheStatus.HIT) {
+            if (cacheLoadResult.status === CacheStatus.HIT) {
                 const loadParams = cacheKeyToLoadParamsMap.get(cacheKey);
-                (0, invariant_1.default)(loadParams !== undefined, 'load params should be in cache key map');
+                invariant(loadParams !== undefined, 'load params should be in cache key map');
                 results.set(loadParams, cacheLoadResult.item);
             }
         });
@@ -38,7 +32,7 @@ class GenericSecondaryEntityCache {
         if (cacheKeysToFetch.length > 0) {
             const loadParamsToFetch = cacheKeysToFetch.map((cacheKey) => {
                 const loadParams = cacheKeyToLoadParamsMap.get(cacheKey);
-                (0, invariant_1.default)(loadParams !== undefined, 'load params should be in cache key map');
+                invariant(loadParams !== undefined, 'load params should be in cache key map');
                 return loadParams;
             });
             const fetchResults = await fetcher(loadParamsToFetch);
@@ -73,5 +67,3 @@ class GenericSecondaryEntityCache {
         return this.cacher.invalidateManyAsync(cacheKeys);
     }
 }
-exports.GenericSecondaryEntityCache = GenericSecondaryEntityCache;
-//# sourceMappingURL=GenericSecondaryEntityCache.js.map

package/build/src/IEntityCacheAdapter.d.ts

@@ -1,5 +1,5 @@
-import { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces';
-import { CacheLoadResult } from './internal/ReadThroughEntityCache';
+import type { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces.ts';
+import type { CacheLoadResult } from './internal/ReadThroughEntityCache.ts';
 /**
  * A cache adapter is an interface by which objects can be
  * cached, fetched from cache, and removed from cache (invalidated).

package/build/src/IEntityCacheAdapter.js

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

package/build/src/IEntityCacheAdapterProvider.d.ts

@@ -1,5 +1,5 @@
-import { EntityConfiguration } from './EntityConfiguration';
-import { IEntityCacheAdapter } from './IEntityCacheAdapter';
+import type { EntityConfiguration } from './EntityConfiguration.ts';
+import type { IEntityCacheAdapter } from './IEntityCacheAdapter.ts';
 /**
  * A cache adapter provider vends cache adapters for a particular cache adapter type.
  * Allows for passing global configuration to cache adapters.

package/build/src/IEntityCacheAdapterProvider.js

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

package/build/src/IEntityDatabaseAdapterProvider.d.ts

@@ -1,5 +1,5 @@
-import { EntityConfiguration } from './EntityConfiguration';
-import { EntityDatabaseAdapter } from './EntityDatabaseAdapter';
+import type { EntityConfiguration } from './EntityConfiguration.ts';
+import type { EntityDatabaseAdapter } from './EntityDatabaseAdapter.ts';
 /**
  * A database adapter provider vends database adapters for a particular database adapter type.
  * Allows for passing global configuration to databse adapters, making testing easier.

package/build/src/IEntityDatabaseAdapterProvider.js

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

package/build/src/IEntityGenericCacher.d.ts

@@ -1,5 +1,5 @@
-import { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces';
-import { CacheLoadResult } from './internal/ReadThroughEntityCache';
+import type { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces.ts';
+import type { CacheLoadResult } from './internal/ReadThroughEntityCache.ts';
 /**
  * A generic cacher stores and loads key-value pairs. It also supports negative caching - it stores the absence
  * of keys that don't exist in the backing datastore. It is also responsible for cache key creation.

package/build/src/IEntityGenericCacher.js

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