@expo/entity 0.59.0 → 0.61.0

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

package/build/src/ReadonlyEntity.d.ts

@@ -1,12 +1,12 @@
-import { AuthorizationResultBasedEntityAssociationLoader } from './AuthorizationResultBasedEntityAssociationLoader';
-import { AuthorizationResultBasedEntityLoader } from './AuthorizationResultBasedEntityLoader';
-import { EnforcingEntityAssociationLoader } from './EnforcingEntityAssociationLoader';
-import { EnforcingEntityLoader } from './EnforcingEntityLoader';
-import { IEntityClass } from './Entity';
-import { EntityInvalidationUtils } from './EntityInvalidationUtils';
-import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
-import { EntityQueryContext } from './EntityQueryContext';
-import { ViewerContext } from './ViewerContext';
+import type { AuthorizationResultBasedEntityAssociationLoader } from './AuthorizationResultBasedEntityAssociationLoader.ts';
+import type { AuthorizationResultBasedEntityLoader } from './AuthorizationResultBasedEntityLoader.ts';
+import type { EnforcingEntityAssociationLoader } from './EnforcingEntityAssociationLoader.ts';
+import type { EnforcingEntityLoader } from './EnforcingEntityLoader.ts';
+import type { IEntityClass } from './Entity.ts';
+import type { EntityInvalidationUtils } from './EntityInvalidationUtils.ts';
+import type { EntityPrivacyPolicy } from './EntityPrivacyPolicy.ts';
+import type { EntityQueryContext } from './EntityQueryContext.ts';
+import type { ViewerContext } from './ViewerContext.ts';
 /**
  * A readonly entity exposes only the read functionality of an Entity. Used as the base
  * type for most entity operations excluding mutations.

package/build/src/ReadonlyEntity.js

@@ -1,12 +1,6 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReadonlyEntity = void 0;
-const invariant_1 = __importDefault(require("invariant"));
-const EntityAssociationLoader_1 = require("./EntityAssociationLoader");
-const EntityLoader_1 = require("./EntityLoader");
+import invariant from 'invariant';
+import { EntityAssociationLoader } from "./EntityAssociationLoader.js";
+import { EntityLoader } from "./EntityLoader.js";
 /**
  * A readonly entity exposes only the read functionality of an Entity. Used as the base
  * type for most entity operations excluding mutations.
@@ -15,7 +9,7 @@ const EntityLoader_1 = require("./EntityLoader");
  * - Entities representing SQL views.
  * - Entities representing immutable tables.
  */
-class ReadonlyEntity {
+export class ReadonlyEntity {
     viewerContext;
     id;
     databaseFields;
@@ -35,7 +29,7 @@ class ReadonlyEntity {
      * @internal
      */
     constructor({ viewerContext, id, databaseFields, selectedFields, }) {
-        (0, invariant_1.default)(id !== null && id !== undefined, 'id must be non-null');
+        invariant(id !== null && id !== undefined, 'id must be non-null');
         this.viewerContext = viewerContext;
         this.id = id;
         this.databaseFields = databaseFields;
@@ -63,13 +57,13 @@ class ReadonlyEntity {
      * @returns EnforcingEntityAssociationLoader for this entity
      */
     associationLoader(queryContext) {
-        return new EntityAssociationLoader_1.EntityAssociationLoader(this, queryContext).enforcing();
+        return new EntityAssociationLoader(this, queryContext).enforcing();
     }
     /**
      * @returns AuthorizationResultBasedEntityAssociationLoader for this entity
      */
     associationLoaderWithAuthorizationResults(queryContext) {
-        return new EntityAssociationLoader_1.EntityAssociationLoader(this, queryContext).withAuthorizationResults();
+        return new EntityAssociationLoader(this, queryContext).withAuthorizationResults();
     }
     /**
      * Get a underlying field from this entity's data
@@ -100,7 +94,7 @@ class ReadonlyEntity {
         .getViewerScopedEntityCompanionForClass(this)
         .getQueryContextProvider()
         .getQueryContext()) {
-        return new EntityLoader_1.EntityLoader(viewerContext, queryContext, this).enforcing();
+        return new EntityLoader(viewerContext, queryContext, this).enforcing();
     }
     /**
      * Vend loader for loading an entity in a given query context.
@@ -111,7 +105,7 @@ class ReadonlyEntity {
         .getViewerScopedEntityCompanionForClass(this)
         .getQueryContextProvider()
         .getQueryContext()) {
-        return new EntityLoader_1.EntityLoader(viewerContext, queryContext, this).withAuthorizationResults();
+        return new EntityLoader(viewerContext, queryContext, this).withAuthorizationResults();
     }
     /**
      * Utilities for entity invalidation.
@@ -124,5 +118,3 @@ class ReadonlyEntity {
             .invalidationUtils();
     }
 }
-exports.ReadonlyEntity = ReadonlyEntity;
-//# sourceMappingURL=ReadonlyEntity.js.map

package/build/src/ViewerContext.d.ts

@@ -1,9 +1,9 @@
-import { IEntityClass } from './Entity';
-import { DatabaseAdapterFlavor, EntityCompanionProvider } from './EntityCompanionProvider';
-import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
-import { EntityQueryContext, EntityTransactionalQueryContext, TransactionConfig } from './EntityQueryContext';
-import { ReadonlyEntity } from './ReadonlyEntity';
-import { ViewerScopedEntityCompanion } from './ViewerScopedEntityCompanion';
+import type { IEntityClass } from './Entity.ts';
+import type { DatabaseAdapterFlavor, EntityCompanionProvider } from './EntityCompanionProvider.ts';
+import type { EntityPrivacyPolicy } from './EntityPrivacyPolicy.ts';
+import type { EntityQueryContext, EntityTransactionalQueryContext, TransactionConfig } from './EntityQueryContext.ts';
+import type { ReadonlyEntity } from './ReadonlyEntity.ts';
+import type { ViewerScopedEntityCompanion } from './ViewerScopedEntityCompanion.ts';
 /**
  * A viewer context encapsulates all information necessary to evaluate an EntityPrivacyPolicy.
  *

package/build/src/ViewerContext.js

@@ -1,19 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ViewerContext = void 0;
-const ViewerScopedEntityCompanionProvider_1 = require("./ViewerScopedEntityCompanionProvider");
+import { ViewerScopedEntityCompanionProvider } from "./ViewerScopedEntityCompanionProvider.js";
 /**
  * A viewer context encapsulates all information necessary to evaluate an EntityPrivacyPolicy.
  *
  * In combination with an EntityCompanionProvider, a viewer context is the
  * entry point into the Entity framework.
  */
-class ViewerContext {
+export class ViewerContext {
     entityCompanionProvider;
     viewerScopedEntityCompanionProvider;
     constructor(entityCompanionProvider) {
         this.entityCompanionProvider = entityCompanionProvider;
-        this.viewerScopedEntityCompanionProvider = new ViewerScopedEntityCompanionProvider_1.ViewerScopedEntityCompanionProvider(entityCompanionProvider, this);
+        this.viewerScopedEntityCompanionProvider = new ViewerScopedEntityCompanionProvider(entityCompanionProvider, this);
     }
     get [Symbol.toStringTag]() {
         return this.constructor.name;
@@ -43,5 +40,3 @@ class ViewerContext {
             .runInTransactionIfNotInTransactionAsync(transactionScope, transactionConfig);
     }
 }
-exports.ViewerContext = ViewerContext;
-//# sourceMappingURL=ViewerContext.js.map

package/build/src/ViewerScopedEntityCompanion.d.ts

@@ -1,11 +1,11 @@
-import { EntityCompanion } from './EntityCompanion';
-import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
-import { EntityQueryContextProvider } from './EntityQueryContextProvider';
-import { ReadonlyEntity } from './ReadonlyEntity';
-import { ViewerContext } from './ViewerContext';
-import { ViewerScopedEntityLoaderFactory } from './ViewerScopedEntityLoaderFactory';
-import { ViewerScopedEntityMutatorFactory } from './ViewerScopedEntityMutatorFactory';
-import { IEntityMetricsAdapter } from './metrics/IEntityMetricsAdapter';
+import type { EntityCompanion } from './EntityCompanion.ts';
+import type { EntityPrivacyPolicy } from './EntityPrivacyPolicy.ts';
+import type { EntityQueryContextProvider } from './EntityQueryContextProvider.ts';
+import type { ReadonlyEntity } from './ReadonlyEntity.ts';
+import type { ViewerContext } from './ViewerContext.ts';
+import { ViewerScopedEntityLoaderFactory } from './ViewerScopedEntityLoaderFactory.ts';
+import { ViewerScopedEntityMutatorFactory } from './ViewerScopedEntityMutatorFactory.ts';
+import type { IEntityMetricsAdapter } from './metrics/IEntityMetricsAdapter.ts';
 /**
  * Provides a simpler API for loading and mutating entities by injecting the ViewerContext
  * from the viewer-scoped entity companion provider.