@expo/entity 0.60.0 → 0.61.0

package/build/src/EntityCompanionProvider.d.ts

@@ -1,15 +1,16 @@
-import { IEntityClass } from './Entity';
-import { EntityCompanion, IPrivacyPolicyClass } from './EntityCompanion';
-import { EntityConfiguration } from './EntityConfiguration';
-import { EntityMutationTriggerConfiguration } from './EntityMutationTriggerConfiguration';
-import { EntityMutationValidatorConfiguration } from './EntityMutationValidatorConfiguration';
-import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
-import { EntityQueryContextProvider } from './EntityQueryContextProvider';
-import { IEntityCacheAdapterProvider } from './IEntityCacheAdapterProvider';
-import { IEntityDatabaseAdapterProvider } from './IEntityDatabaseAdapterProvider';
-import { ReadonlyEntity } from './ReadonlyEntity';
-import { ViewerContext } from './ViewerContext';
-import { IEntityMetricsAdapter } from './metrics/IEntityMetricsAdapter';
+import type { IEntityClass } from './Entity.ts';
+import type { IPrivacyPolicyClass } from './EntityCompanion.ts';
+import { EntityCompanion } from './EntityCompanion.ts';
+import type { EntityConfiguration } from './EntityConfiguration.ts';
+import type { EntityMutationTriggerConfiguration } from './EntityMutationTriggerConfiguration.ts';
+import type { EntityMutationValidatorConfiguration } from './EntityMutationValidatorConfiguration.ts';
+import type { EntityPrivacyPolicy } from './EntityPrivacyPolicy.ts';
+import type { EntityQueryContextProvider } from './EntityQueryContextProvider.ts';
+import type { IEntityCacheAdapterProvider } from './IEntityCacheAdapterProvider.ts';
+import type { IEntityDatabaseAdapterProvider } from './IEntityDatabaseAdapterProvider.ts';
+import type { ReadonlyEntity } from './ReadonlyEntity.ts';
+import type { ViewerContext } from './ViewerContext.ts';
+import type { IEntityMetricsAdapter } from './metrics/IEntityMetricsAdapter.ts';
 /**
  * Backing database and transaction type for an entity. The definitions and implementations
  * are provided by injection in the root EntityCompanionProvider to allow for mocking and sharing.

package/build/src/EntityCompanionProvider.js

@@ -1,13 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityCompanionProvider = void 0;
-const invariant_1 = __importDefault(require("invariant"));
-const EntityCompanion_1 = require("./EntityCompanion");
-const EntityTableDataCoordinator_1 = require("./internal/EntityTableDataCoordinator");
-const maps_1 = require("./utils/collections/maps");
+import invariant from 'invariant';
+import { EntityCompanion } from "./EntityCompanion.js";
+import { EntityTableDataCoordinator } from "./internal/EntityTableDataCoordinator.js";
+import { computeIfAbsent } from "./utils/collections/maps.js";
 /**
  * An instance of the Entity framework.
  *
@@ -17,7 +11,7 @@ const maps_1 = require("./utils/collections/maps");
  * Internally, this is a lazy entity companion factory that instantiates and caches one
  * EntityCompanion for each type of Entity.
  */
-class EntityCompanionProvider {
+export class EntityCompanionProvider {
     metricsAdapter;
     databaseAdapterFlavors;
     cacheAdapterFlavors;
@@ -45,26 +39,24 @@ class EntityCompanionProvider {
      * @param entityClass - entity class to load
      */
     getCompanionForEntity(entityClass) {
-        const entityCompanionDefinition = (0, maps_1.computeIfAbsent)(this.companionDefinitionMap, entityClass.name, () => entityClass.defineCompanionDefinition());
+        const entityCompanionDefinition = computeIfAbsent(this.companionDefinitionMap, entityClass.name, () => entityClass.defineCompanionDefinition());
         const tableDataCoordinator = this.getTableDataCoordinatorForEntity(entityCompanionDefinition.entityConfiguration, entityClass.name);
-        return (0, maps_1.computeIfAbsent)(this.companionMap, entityClass.name, () => {
-            return new EntityCompanion_1.EntityCompanion(this, entityCompanionDefinition, tableDataCoordinator, this.metricsAdapter);
+        return computeIfAbsent(this.companionMap, entityClass.name, () => {
+            return new EntityCompanion(this, entityCompanionDefinition, tableDataCoordinator, this.metricsAdapter);
         });
     }
     getQueryContextProviderForDatabaseAdapterFlavor(databaseAdapterFlavor) {
         const entityDatabaseAdapterFlavor = this.databaseAdapterFlavors.get(databaseAdapterFlavor);
-        (0, invariant_1.default)(entityDatabaseAdapterFlavor, `No database adapter configuration found for flavor: ${databaseAdapterFlavor}`);
+        invariant(entityDatabaseAdapterFlavor, `No database adapter configuration found for flavor: ${databaseAdapterFlavor}`);
         return entityDatabaseAdapterFlavor.queryContextProvider;
     }
     getTableDataCoordinatorForEntity(entityConfiguration, entityClassName) {
-        return (0, maps_1.computeIfAbsent)(this.tableDataCoordinatorMap, entityConfiguration.tableName, () => {
+        return computeIfAbsent(this.tableDataCoordinatorMap, entityConfiguration.tableName, () => {
             const entityDatabaseAdapterFlavor = this.databaseAdapterFlavors.get(entityConfiguration.databaseAdapterFlavor);
-            (0, invariant_1.default)(entityDatabaseAdapterFlavor, `No database adapter configuration found for flavor: ${entityConfiguration.databaseAdapterFlavor}`);
+            invariant(entityDatabaseAdapterFlavor, `No database adapter configuration found for flavor: ${entityConfiguration.databaseAdapterFlavor}`);
             const entityCacheAdapterFlavor = this.cacheAdapterFlavors.get(entityConfiguration.cacheAdapterFlavor);
-            (0, invariant_1.default)(entityCacheAdapterFlavor, `No cache adapter configuration found for flavor: ${entityConfiguration.cacheAdapterFlavor}`);
-            return new EntityTableDataCoordinator_1.EntityTableDataCoordinator(entityConfiguration, entityDatabaseAdapterFlavor.adapterProvider, entityCacheAdapterFlavor.cacheAdapterProvider, entityDatabaseAdapterFlavor.queryContextProvider, this.metricsAdapter, entityClassName);
+            invariant(entityCacheAdapterFlavor, `No cache adapter configuration found for flavor: ${entityConfiguration.cacheAdapterFlavor}`);
+            return new EntityTableDataCoordinator(entityConfiguration, entityDatabaseAdapterFlavor.adapterProvider, entityCacheAdapterFlavor.cacheAdapterProvider, entityDatabaseAdapterFlavor.queryContextProvider, this.metricsAdapter, entityClassName);
         });
     }
 }
-exports.EntityCompanionProvider = EntityCompanionProvider;
-//# sourceMappingURL=EntityCompanionProvider.js.map

package/build/src/EntityConfiguration.d.ts

@@ -1,7 +1,7 @@
-import { IEntityClass } from './Entity';
-import { CacheAdapterFlavor, DatabaseAdapterFlavor } from './EntityCompanionProvider';
-import { EntityFieldDefinition } from './EntityFieldDefinition';
-import { CompositeFieldHolder } from './internal/CompositeFieldHolder';
+import type { IEntityClass } from './Entity.ts';
+import type { CacheAdapterFlavor, DatabaseAdapterFlavor } from './EntityCompanionProvider.ts';
+import type { EntityFieldDefinition } from './EntityFieldDefinition.ts';
+import { CompositeFieldHolder } from './internal/CompositeFieldHolder.ts';
 /**
  * A composite field is an unordered set of fields by which entities can be loaded in a batched
  * and (optionally) cached manner akin to how normal fieldName loads are batched and (optionally) cached.

package/build/src/EntityConfiguration.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.EntityConfiguration = exports.CompositeFieldInfo = void 0;
-const invariant_1 = __importDefault(require("invariant"));
-const CompositeFieldHolder_1 = require("./internal/CompositeFieldHolder");
-const maps_1 = require("./utils/collections/maps");
+import invariant from 'invariant';
+import { CompositeFieldHolder } from "./internal/CompositeFieldHolder.js";
+import { invertMap, mapMap, reduceMap } from "./utils/collections/maps.js";
 /**
  * Helper class to validate and store composite field information.
  */
-class CompositeFieldInfo {
+export class CompositeFieldInfo {
     compositeFieldInfoMap;
     constructor(compositeFieldsDefinitions) {
         this.compositeFieldInfoMap = new Map(compositeFieldsDefinitions.map((keyDefinition) => {
-            (0, invariant_1.default)(keyDefinition.compositeField.length >= 2, 'Composite field must have at least two sub-fields');
-            (0, invariant_1.default)(keyDefinition.compositeField.length === new Set(keyDefinition.compositeField).size, 'Composite field must have unique sub-fields');
-            const compositeFieldHolder = new CompositeFieldHolder_1.CompositeFieldHolder(keyDefinition.compositeField);
+            invariant(keyDefinition.compositeField.length >= 2, 'Composite field must have at least two sub-fields');
+            invariant(keyDefinition.compositeField.length === new Set(keyDefinition.compositeField).size, 'Composite field must have unique sub-fields');
+            const compositeFieldHolder = new CompositeFieldHolder(keyDefinition.compositeField);
             return [
                 compositeFieldHolder.serialize(),
                 { compositeFieldHolder, cache: keyDefinition.cache ?? false },
@@ -24,23 +18,22 @@ class CompositeFieldInfo {
         }));
     }
     getCompositeFieldHolderForCompositeField(compositeField) {
-        return this.compositeFieldInfoMap.get(new CompositeFieldHolder_1.CompositeFieldHolder(compositeField).serialize())?.compositeFieldHolder;
+        return this.compositeFieldInfoMap.get(new CompositeFieldHolder(compositeField).serialize())?.compositeFieldHolder;
     }
     getAllCompositeFieldHolders() {
         return Array.from(this.compositeFieldInfoMap.values()).map((v) => v.compositeFieldHolder);
     }
     canCacheCompositeField(compositeField) {
-        const compositeFieldInfo = this.compositeFieldInfoMap.get(new CompositeFieldHolder_1.CompositeFieldHolder(compositeField).serialize());
-        (0, invariant_1.default)(compositeFieldInfo, `Composite field (${compositeField.join(',')}) not found in entity configuration`);
+        const compositeFieldInfo = this.compositeFieldInfoMap.get(new CompositeFieldHolder(compositeField).serialize());
+        invariant(compositeFieldInfo, `Composite field (${compositeField.join(',')}) not found in entity configuration`);
         return compositeFieldInfo.cache;
     }
 }
-exports.CompositeFieldInfo = CompositeFieldInfo;
 /**
  * The data storage configuration for a type of Entity. Contains information relating to IDs,
  * cachable fields, field mappings, and types of cache and database adapter.
  */
-class EntityConfiguration {
+export class EntityConfiguration {
     idField;
     tableName;
     cacheableKeys;
@@ -66,7 +59,7 @@ class EntityConfiguration {
         this.cacheableKeys = EntityConfiguration.computeCacheableKeys(this.schema);
         this.compositeFieldInfo = new CompositeFieldInfo(compositeFieldDefinitions ?? []);
         this.entityToDBFieldsKeyMapping = EntityConfiguration.computeEntityToDBFieldsKeyMapping(this.schema);
-        this.dbToEntityFieldsKeyMapping = (0, maps_1.invertMap)(this.entityToDBFieldsKeyMapping);
+        this.dbToEntityFieldsKeyMapping = invertMap(this.entityToDBFieldsKeyMapping);
     }
     static validateSchema(schema) {
         const disallowedFieldsKeys = Object.getOwnPropertyNames(Object.prototype);
@@ -77,7 +70,7 @@ class EntityConfiguration {
         }
     }
     static computeCacheableKeys(schema) {
-        return (0, maps_1.reduceMap)(schema, (acc, v, k) => {
+        return reduceMap(schema, (acc, v, k) => {
             if (v.cache) {
                 acc.add(k);
             }
@@ -85,8 +78,6 @@ class EntityConfiguration {
         }, new Set());
     }
     static computeEntityToDBFieldsKeyMapping(schema) {
-        return (0, maps_1.mapMap)(schema, (v) => v.columnName);
+        return mapMap(schema, (v) => v.columnName);
     }
 }
-exports.EntityConfiguration = EntityConfiguration;
-//# sourceMappingURL=EntityConfiguration.js.map

package/build/src/EntityConstructionUtils.d.ts

@@ -1,11 +1,11 @@
-import { Result } from '@expo/results';
-import { IEntityClass } from './Entity';
-import { EntityConfiguration } from './EntityConfiguration';
-import { EntityPrivacyPolicy, EntityPrivacyPolicyEvaluationContext } from './EntityPrivacyPolicy';
-import { EntityQueryContext } from './EntityQueryContext';
-import { ReadonlyEntity } from './ReadonlyEntity';
-import { ViewerContext } from './ViewerContext';
-import { IEntityMetricsAdapter } from './metrics/IEntityMetricsAdapter';
+import type { Result } from '@expo/results';
+import type { IEntityClass } from './Entity.ts';
+import type { EntityConfiguration } from './EntityConfiguration.ts';
+import type { EntityPrivacyPolicy, EntityPrivacyPolicyEvaluationContext } from './EntityPrivacyPolicy.ts';
+import type { EntityQueryContext } from './EntityQueryContext.ts';
+import type { ReadonlyEntity } from './ReadonlyEntity.ts';
+import type { ViewerContext } from './ViewerContext.ts';
+import type { IEntityMetricsAdapter } from './metrics/IEntityMetricsAdapter.ts';
 /**
  * Common entity loader utilities for entity construction and authorization.
  * Methods are exposed publicly since in rare cases they may need to be called manually.

package/build/src/EntityConstructionUtils.js

@@ -1,20 +1,14 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityConstructionUtils = void 0;
-const results_1 = require("@expo/results");
-const invariant_1 = __importDefault(require("invariant"));
-const nullthrows_1 = __importDefault(require("nullthrows"));
-const entityUtils_1 = require("./entityUtils");
-const EntityInvalidFieldValueError_1 = require("./errors/EntityInvalidFieldValueError");
-const maps_1 = require("./utils/collections/maps");
+import nullthrows from '@expo/nullthrows';
+import { asyncResult, result } from '@expo/results';
+import invariant from 'invariant';
+import { pick } from "./entityUtils.js";
+import { EntityInvalidFieldValueError } from "./errors/EntityInvalidFieldValueError.js";
+import { mapMapAsync } from "./utils/collections/maps.js";
 /**
  * Common entity loader utilities for entity construction and authorization.
  * Methods are exposed publicly since in rare cases they may need to be called manually.
  */
-class EntityConstructionUtils {
+export class EntityConstructionUtils {
     viewerContext;
     queryContext;
     privacyPolicyEvaluationContext;
@@ -41,9 +35,9 @@ class EntityConstructionUtils {
      */
     constructEntity(fieldsObject) {
         const idField = this.entityConfiguration.idField;
-        const id = (0, nullthrows_1.default)(fieldsObject[idField], 'must provide ID to create an entity');
+        const id = nullthrows(fieldsObject[idField], 'must provide ID to create an entity');
         const entitySelectedFields = this.entitySelectedFields ?? Array.from(this.entityConfiguration.schema.keys());
-        const selectedFields = (0, entityUtils_1.pick)(fieldsObject, entitySelectedFields);
+        const selectedFields = pick(fieldsObject, entitySelectedFields);
         return new this.entityClass({
             viewerContext: this.viewerContext,
             id: id,
@@ -58,7 +52,7 @@ class EntityConstructionUtils {
      * @param map - map from an arbitrary key type to an array of entity field objects
      */
     async constructAndAuthorizeEntitiesAsync(map) {
-        return await (0, maps_1.mapMapAsync)(map, async (fieldObjects) => {
+        return await mapMapAsync(map, async (fieldObjects) => {
             return await this.constructAndAuthorizeEntitiesArrayAsync(fieldObjects);
         });
     }
@@ -76,7 +70,7 @@ class EntityConstructionUtils {
         if (!uncheckedEntityResult.ok) {
             return uncheckedEntityResult;
         }
-        return await (0, results_1.asyncResult)(this.privacyPolicy.authorizeReadAsync(this.viewerContext, this.queryContext, this.privacyPolicyEvaluationContext, uncheckedEntityResult.value, this.metricsAdapter));
+        return await asyncResult(this.privacyPolicy.authorizeReadAsync(this.viewerContext, this.queryContext, this.privacyPolicyEvaluationContext, uncheckedEntityResult.value, this.metricsAdapter));
     }
     async constructAndAuthorizeEntityAsync(fieldsObject) {
         const uncheckedEntityResult = this.tryConstructEntity(fieldsObject);
@@ -91,11 +85,11 @@ class EntityConstructionUtils {
      */
     validateFieldAndValues(fieldName, fieldValues) {
         const fieldDefinition = this.entityConfiguration.schema.get(fieldName);
-        (0, invariant_1.default)(fieldDefinition, `must have field definition for field = ${String(fieldName)}`);
+        invariant(fieldDefinition, `must have field definition for field = ${String(fieldName)}`);
         for (const fieldValue of fieldValues) {
             const isInputValid = fieldDefinition.validateInputValue(fieldValue);
             if (!isInputValid) {
-                throw new EntityInvalidFieldValueError_1.EntityInvalidFieldValueError(this.entityClass, fieldName, fieldValue);
+                throw new EntityInvalidFieldValueError(this.entityClass, fieldName, fieldValue);
             }
         }
     }
@@ -104,15 +98,13 @@ class EntityConstructionUtils {
     }
     tryConstructEntity(fieldsObject) {
         try {
-            return (0, results_1.result)(this.constructEntity(fieldsObject));
+            return result(this.constructEntity(fieldsObject));
         }
         catch (e) {
             if (!(e instanceof Error)) {
                 throw e;
             }
-            return (0, results_1.result)(e);
+            return result(e);
         }
     }
 }
-exports.EntityConstructionUtils = EntityConstructionUtils;
-//# sourceMappingURL=EntityConstructionUtils.js.map

package/build/src/EntityCreator.d.ts

@@ -1,10 +1,10 @@
-import { AuthorizationResultBasedCreateMutator } from './AuthorizationResultBasedEntityMutator';
-import { EnforcingEntityCreator } from './EnforcingEntityCreator';
-import { IEntityClass } from './Entity';
-import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
-import { EntityQueryContext } from './EntityQueryContext';
-import { ReadonlyEntity } from './ReadonlyEntity';
-import { ViewerContext } from './ViewerContext';
+import type { AuthorizationResultBasedCreateMutator } from './AuthorizationResultBasedEntityMutator.ts';
+import { EnforcingEntityCreator } from './EnforcingEntityCreator.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 creating entities.
  */

package/build/src/EntityCreator.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityCreator = void 0;
-const EnforcingEntityCreator_1 = require("./EnforcingEntityCreator");
+import { EnforcingEntityCreator } from "./EnforcingEntityCreator.js";
 /**
  * The primary interface for creating entities.
  */
-class EntityCreator {
+export class EntityCreator {
     viewerContext;
     queryContext;
     entityClass;
@@ -19,7 +16,7 @@ class EntityCreator {
      * guaranteed to be successful and will throw otherwise.
      */
     enforcing() {
-        return new EnforcingEntityCreator_1.EnforcingEntityCreator(this.withAuthorizationResults());
+        return new EnforcingEntityCreator(this.withAuthorizationResults());
     }
     /**
      * Authorization-result-based entity creator. All creates through this
@@ -33,5 +30,3 @@ class EntityCreator {
             .forCreate(this.queryContext);
     }
 }
-exports.EntityCreator = EntityCreator;
-//# sourceMappingURL=EntityCreator.js.map

package/build/src/EntityDatabaseAdapter.d.ts

@@ -1,7 +1,7 @@
-import { EntityConfiguration } from './EntityConfiguration';
-import { EntityQueryContext } from './EntityQueryContext';
-import { FieldTransformerMap } from './internal/EntityFieldTransformationUtils';
-import { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces';
+import type { EntityConfiguration } from './EntityConfiguration.ts';
+import type { EntityQueryContext } from './EntityQueryContext.ts';
+import type { FieldTransformerMap } from './internal/EntityFieldTransformationUtils.ts';
+import type { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces.ts';
 /**
  * A database adapter is an interface by which entity objects can be
  * fetched, inserted, updated, and deleted from a database. This base class

package/build/src/EntityDatabaseAdapter.js

@@ -1,19 +1,13 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityDatabaseAdapter = void 0;
-const invariant_1 = __importDefault(require("invariant"));
-const EntityDatabaseAdapterError_1 = require("./errors/EntityDatabaseAdapterError");
-const EntityFieldTransformationUtils_1 = require("./internal/EntityFieldTransformationUtils");
+import invariant from 'invariant';
+import { EntityDatabaseAdapterEmptyInsertResultError, EntityDatabaseAdapterEmptyUpdateResultError, EntityDatabaseAdapterExcessiveDeleteResultError, EntityDatabaseAdapterExcessiveInsertResultError, EntityDatabaseAdapterExcessiveUpdateResultError, } from "./errors/EntityDatabaseAdapterError.js";
+import { getDatabaseFieldForEntityField, transformDatabaseObjectToFields, transformFieldsToDatabaseObject, } from "./internal/EntityFieldTransformationUtils.js";
 /**
  * A database adapter is an interface by which entity objects can be
  * fetched, inserted, updated, and deleted from a database. This base class
  * handles all entity field transformation. Subclasses are responsible for
  * implementing database-specific logic for a type of database.
  */
-class EntityDatabaseAdapter {
+export class EntityDatabaseAdapter {
     entityConfiguration;
     fieldTransformerMap;
     constructor(entityConfiguration) {
@@ -32,16 +26,16 @@ class EntityDatabaseAdapter {
         const keyDatabaseColumns = key.getDatabaseColumns(this.entityConfiguration);
         const valueDatabaseValues = values.map((value) => key.getDatabaseValues(value));
         const results = await this.fetchManyWhereInternalAsync(queryContext.getQueryInterface(), this.entityConfiguration.tableName, keyDatabaseColumns, valueDatabaseValues);
-        const objects = results.map((result) => (0, EntityFieldTransformationUtils_1.transformDatabaseObjectToFields)(this.entityConfiguration, this.fieldTransformerMap, result));
+        const objects = results.map((result) => transformDatabaseObjectToFields(this.entityConfiguration, this.fieldTransformerMap, result));
         const objectMap = key.vendNewLoadValueMap();
         for (const value of values) {
             objectMap.set(value, []);
         }
         objects.forEach((object) => {
             const objectMapKeyForObject = key.getLoadValueForObject(object);
-            (0, invariant_1.default)(objectMapKeyForObject !== null, `One or more fields from the object is invalid for key ${key}; ${JSON.stringify(object)}. This may indicate a faulty database adapter implementation.`);
+            invariant(objectMapKeyForObject !== null, `One or more fields from the object is invalid for key ${key}; ${JSON.stringify(object)}. This may indicate a faulty database adapter implementation.`);
             const objectList = objectMap.get(objectMapKeyForObject);
-            (0, invariant_1.default)(objectList !== undefined, `Unexpected object field value during database result transformation: ${objectMapKeyForObject}. This should never happen.`);
+            invariant(objectList !== undefined, `Unexpected object field value during database result transformation: ${objectMapKeyForObject}. This should never happen.`);
             objectList.push(object);
         });
         return objectMap;
@@ -63,7 +57,7 @@ class EntityDatabaseAdapter {
         if (!result) {
             return null;
         }
-        return (0, EntityFieldTransformationUtils_1.transformDatabaseObjectToFields)(this.entityConfiguration, this.fieldTransformerMap, result);
+        return transformDatabaseObjectToFields(this.entityConfiguration, this.fieldTransformerMap, result);
     }
     /**
      * Insert an object.
@@ -73,18 +67,18 @@ class EntityDatabaseAdapter {
      * @returns the inserted object
      */
     async insertAsync(queryContext, object) {
-        const dbObject = (0, EntityFieldTransformationUtils_1.transformFieldsToDatabaseObject)(this.entityConfiguration, this.fieldTransformerMap, object);
+        const dbObject = transformFieldsToDatabaseObject(this.entityConfiguration, this.fieldTransformerMap, object);
         const results = await this.insertInternalAsync(queryContext.getQueryInterface(), this.entityConfiguration.tableName, dbObject);
         // These should never happen with a properly implemented database adapter unless the underlying database has weird triggers
         // or something.
         // These errors are exposed to help application developers detect and diagnose such issues.
         if (results.length > 1) {
-            throw new EntityDatabaseAdapterError_1.EntityDatabaseAdapterExcessiveInsertResultError(`Excessive results from database adapter insert: ${this.entityConfiguration.tableName}`);
+            throw new EntityDatabaseAdapterExcessiveInsertResultError(`Excessive results from database adapter insert: ${this.entityConfiguration.tableName}`);
         }
         else if (results.length === 0) {
-            throw new EntityDatabaseAdapterError_1.EntityDatabaseAdapterEmptyInsertResultError(`Empty results from database adapter insert: ${this.entityConfiguration.tableName}`);
+            throw new EntityDatabaseAdapterEmptyInsertResultError(`Empty results from database adapter insert: ${this.entityConfiguration.tableName}`);
         }
-        return (0, EntityFieldTransformationUtils_1.transformDatabaseObjectToFields)(this.entityConfiguration, this.fieldTransformerMap, results[0]);
+        return transformDatabaseObjectToFields(this.entityConfiguration, this.fieldTransformerMap, results[0]);
     }
     /**
      * Update an object.
@@ -96,19 +90,19 @@ class EntityDatabaseAdapter {
      * @returns the updated object
      */
     async updateAsync(queryContext, idField, id, object) {
-        const idColumn = (0, EntityFieldTransformationUtils_1.getDatabaseFieldForEntityField)(this.entityConfiguration, idField);
-        const dbObject = (0, EntityFieldTransformationUtils_1.transformFieldsToDatabaseObject)(this.entityConfiguration, this.fieldTransformerMap, object);
+        const idColumn = getDatabaseFieldForEntityField(this.entityConfiguration, idField);
+        const dbObject = transformFieldsToDatabaseObject(this.entityConfiguration, this.fieldTransformerMap, object);
         const results = await this.updateInternalAsync(queryContext.getQueryInterface(), this.entityConfiguration.tableName, idColumn, id, dbObject);
         if (results.length > 1) {
             // This should never happen with a properly implemented database adapter unless the underlying table has a non-unique
             // primary key column.
-            throw new EntityDatabaseAdapterError_1.EntityDatabaseAdapterExcessiveUpdateResultError(`Excessive results from database adapter update: ${this.entityConfiguration.tableName}(id = ${id})`);
+            throw new EntityDatabaseAdapterExcessiveUpdateResultError(`Excessive results from database adapter update: ${this.entityConfiguration.tableName}(id = ${id})`);
         }
         else if (results.length === 0) {
             // This happens when the object to update does not exist. It may have been deleted by another process.
-            throw new EntityDatabaseAdapterError_1.EntityDatabaseAdapterEmptyUpdateResultError(`Empty results from database adapter update: ${this.entityConfiguration.tableName}(id = ${id})`);
+            throw new EntityDatabaseAdapterEmptyUpdateResultError(`Empty results from database adapter update: ${this.entityConfiguration.tableName}(id = ${id})`);
         }
-        return (0, EntityFieldTransformationUtils_1.transformDatabaseObjectToFields)(this.entityConfiguration, this.fieldTransformerMap, results[0]);
+        return transformDatabaseObjectToFields(this.entityConfiguration, this.fieldTransformerMap, results[0]);
     }
     /**
      * Delete an object by ID.
@@ -118,12 +112,10 @@ class EntityDatabaseAdapter {
      * @param id - the value of the ID field in the object
      */
     async deleteAsync(queryContext, idField, id) {
-        const idColumn = (0, EntityFieldTransformationUtils_1.getDatabaseFieldForEntityField)(this.entityConfiguration, idField);
+        const idColumn = getDatabaseFieldForEntityField(this.entityConfiguration, idField);
         const numDeleted = await this.deleteInternalAsync(queryContext.getQueryInterface(), this.entityConfiguration.tableName, idColumn, id);
         if (numDeleted > 1) {
-            throw new EntityDatabaseAdapterError_1.EntityDatabaseAdapterExcessiveDeleteResultError(`Excessive deletions from database adapter delete: ${this.entityConfiguration.tableName}(id = ${id})`);
+            throw new EntityDatabaseAdapterExcessiveDeleteResultError(`Excessive deletions from database adapter delete: ${this.entityConfiguration.tableName}(id = ${id})`);
         }
     }
 }
-exports.EntityDatabaseAdapter = EntityDatabaseAdapter;
-//# sourceMappingURL=EntityDatabaseAdapter.js.map

package/build/src/EntityDeleter.d.ts

@@ -1,10 +1,10 @@
-import { AuthorizationResultBasedDeleteMutator } from './AuthorizationResultBasedEntityMutator';
-import { EnforcingEntityDeleter } from './EnforcingEntityDeleter';
-import { IEntityClass } from './Entity';
-import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
-import { EntityQueryContext } from './EntityQueryContext';
-import { ReadonlyEntity } from './ReadonlyEntity';
-import { ViewerContext } from './ViewerContext';
+import type { AuthorizationResultBasedDeleteMutator } from './AuthorizationResultBasedEntityMutator.ts';
+import { EnforcingEntityDeleter } from './EnforcingEntityDeleter.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 deleting entities.
  */

package/build/src/EntityDeleter.js

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

package/build/src/EntityFieldDefinition.d.ts

@@ -1,7 +1,7 @@
-import { IEntityClass } from './Entity';
-import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
-import { ReadonlyEntity } from './ReadonlyEntity';
-import { ViewerContext } from './ViewerContext';
+import type { IEntityClass } from './Entity.ts';
+import type { EntityPrivacyPolicy } from './EntityPrivacyPolicy.ts';
+import type { ReadonlyEntity } from './ReadonlyEntity.ts';
+import type { ViewerContext } from './ViewerContext.ts';
 export declare enum EntityEdgeDeletionBehavior {
     /**
      * Invalidate the cache for all entities that reference the entity

package/build/src/EntityFieldDefinition.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityFieldDefinition = exports.EntityEdgeDeletionAuthorizationInferenceBehavior = exports.EntityEdgeDeletionBehavior = void 0;
-var EntityEdgeDeletionBehavior;
+export var EntityEdgeDeletionBehavior;
 (function (EntityEdgeDeletionBehavior) {
     /**
      * Invalidate the cache for all entities that reference the entity
@@ -30,8 +27,8 @@ var EntityEdgeDeletionBehavior;
      * This will also invalidate the cached referencing entities.
      */
     EntityEdgeDeletionBehavior[EntityEdgeDeletionBehavior["SET_NULL"] = 3] = "SET_NULL";
-})(EntityEdgeDeletionBehavior || (exports.EntityEdgeDeletionBehavior = EntityEdgeDeletionBehavior = {}));
-var EntityEdgeDeletionAuthorizationInferenceBehavior;
+})(EntityEdgeDeletionBehavior || (EntityEdgeDeletionBehavior = {}));
+export var EntityEdgeDeletionAuthorizationInferenceBehavior;
 (function (EntityEdgeDeletionAuthorizationInferenceBehavior) {
     /**
      * Authorization to delete (when CASCADE_DELETE_INVALIDATE_CACHE_ONLY or CASCADE_DELETE) or update
@@ -58,12 +55,12 @@ var EntityEdgeDeletionAuthorizationInferenceBehavior;
      * of canViewerDeleteAsync. Each entity being deleted will still check deletion privacy during actual deletion.
      */
     EntityEdgeDeletionAuthorizationInferenceBehavior[EntityEdgeDeletionAuthorizationInferenceBehavior["ONE_IMPLIES_ALL"] = 1] = "ONE_IMPLIES_ALL";
-})(EntityEdgeDeletionAuthorizationInferenceBehavior || (exports.EntityEdgeDeletionAuthorizationInferenceBehavior = EntityEdgeDeletionAuthorizationInferenceBehavior = {}));
+})(EntityEdgeDeletionAuthorizationInferenceBehavior || (EntityEdgeDeletionAuthorizationInferenceBehavior = {}));
 /**
  * Definition for a field referencing a column in the underlying database. Specifies things like
  * cache behavior and associations, and handles input validation.
  */
-class EntityFieldDefinition {
+export class EntityFieldDefinition {
     columnName;
     cache;
     association;
@@ -90,5 +87,3 @@ class EntityFieldDefinition {
         return this.validateInputValueInternal(value);
     }
 }
-exports.EntityFieldDefinition = EntityFieldDefinition;
-//# sourceMappingURL=EntityFieldDefinition.js.map

package/build/src/EntityFields.d.ts

@@ -1,4 +1,5 @@
-import { EntityFieldDefinition, EntityFieldDefinitionOptions, EntityFieldDefinitionOptionsExplicitCache } from './EntityFieldDefinition';
+import type { EntityFieldDefinitionOptions, EntityFieldDefinitionOptionsExplicitCache } from './EntityFieldDefinition.ts';
+import { EntityFieldDefinition } from './EntityFieldDefinition.ts';
 /**
  * EntityFieldDefinition for a column with a JS string type.
  */