@expo/entity 0.59.0 → 0.61.0

package/build/src/ViewerScopedEntityCompanion.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ViewerScopedEntityCompanion = void 0;
-const ViewerScopedEntityLoaderFactory_1 = require("./ViewerScopedEntityLoaderFactory");
-const ViewerScopedEntityMutatorFactory_1 = require("./ViewerScopedEntityMutatorFactory");
+import { ViewerScopedEntityLoaderFactory } from "./ViewerScopedEntityLoaderFactory.js";
+import { ViewerScopedEntityMutatorFactory } from "./ViewerScopedEntityMutatorFactory.js";
 /**
  * Provides a simpler API for loading and mutating entities by injecting the ViewerContext
  * from the viewer-scoped entity companion provider.
  */
-class ViewerScopedEntityCompanion {
+export class ViewerScopedEntityCompanion {
     entityCompanion;
     viewerContext;
     constructor(entityCompanion, viewerContext) {
@@ -18,13 +15,13 @@ class ViewerScopedEntityCompanion {
      * Vend a viewer-scoped entity loader.
      */
     getLoaderFactory() {
-        return new ViewerScopedEntityLoaderFactory_1.ViewerScopedEntityLoaderFactory(this.entityCompanion.getLoaderFactory(), this.viewerContext);
+        return new ViewerScopedEntityLoaderFactory(this.entityCompanion.getLoaderFactory(), this.viewerContext);
     }
     /**
      * Vend a viewer-scoped entity mutator factory.
      */
     getMutatorFactory() {
-        return new ViewerScopedEntityMutatorFactory_1.ViewerScopedEntityMutatorFactory(this.entityCompanion.getMutatorFactory(), this.viewerContext);
+        return new ViewerScopedEntityMutatorFactory(this.entityCompanion.getMutatorFactory(), this.viewerContext);
     }
     /**
      * Get the query context provider for this entity.
@@ -39,5 +36,3 @@ class ViewerScopedEntityCompanion {
         return this.entityCompanion.getMetricsAdapter();
     }
 }
-exports.ViewerScopedEntityCompanion = ViewerScopedEntityCompanion;
-//# sourceMappingURL=ViewerScopedEntityCompanion.js.map

package/build/src/ViewerScopedEntityCompanionProvider.d.ts

@@ -1,9 +1,9 @@
-import { IEntityClass } from './Entity';
-import { EntityCompanionProvider } from './EntityCompanionProvider';
-import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
-import { ReadonlyEntity } from './ReadonlyEntity';
-import { ViewerContext } from './ViewerContext';
-import { ViewerScopedEntityCompanion } from './ViewerScopedEntityCompanion';
+import type { IEntityClass } from './Entity.ts';
+import type { EntityCompanionProvider } from './EntityCompanionProvider.ts';
+import type { EntityPrivacyPolicy } from './EntityPrivacyPolicy.ts';
+import type { ReadonlyEntity } from './ReadonlyEntity.ts';
+import type { ViewerContext } from './ViewerContext.ts';
+import { ViewerScopedEntityCompanion } from './ViewerScopedEntityCompanion.ts';
 /**
  * Provides viewer-scoped entity companions providers for a simpler API.
  */

package/build/src/ViewerScopedEntityCompanionProvider.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ViewerScopedEntityCompanionProvider = void 0;
-const ViewerScopedEntityCompanion_1 = require("./ViewerScopedEntityCompanion");
+import { ViewerScopedEntityCompanion } from "./ViewerScopedEntityCompanion.js";
 /**
  * Provides viewer-scoped entity companions providers for a simpler API.
  */
-class ViewerScopedEntityCompanionProvider {
+export class ViewerScopedEntityCompanionProvider {
     entityCompanionProvider;
     viewerContext;
     constructor(entityCompanionProvider, viewerContext) {
@@ -19,8 +16,6 @@ class ViewerScopedEntityCompanionProvider {
      * @param entityClass - entity class to load
      */
     getViewerScopedCompanionForEntity(entityClass) {
-        return new ViewerScopedEntityCompanion_1.ViewerScopedEntityCompanion(this.entityCompanionProvider.getCompanionForEntity(entityClass), this.viewerContext);
+        return new ViewerScopedEntityCompanion(this.entityCompanionProvider.getCompanionForEntity(entityClass), this.viewerContext);
     }
 }
-exports.ViewerScopedEntityCompanionProvider = ViewerScopedEntityCompanionProvider;
-//# sourceMappingURL=ViewerScopedEntityCompanionProvider.js.map

package/build/src/ViewerScopedEntityLoaderFactory.d.ts

@@ -1,11 +1,11 @@
-import { AuthorizationResultBasedEntityLoader } from './AuthorizationResultBasedEntityLoader';
-import { EntityConstructionUtils } from './EntityConstructionUtils';
-import { EntityInvalidationUtils } from './EntityInvalidationUtils';
-import { EntityLoaderFactory } from './EntityLoaderFactory';
-import { EntityPrivacyPolicy, EntityPrivacyPolicyEvaluationContext } from './EntityPrivacyPolicy';
-import { EntityQueryContext } from './EntityQueryContext';
-import { ReadonlyEntity } from './ReadonlyEntity';
-import { ViewerContext } from './ViewerContext';
+import type { AuthorizationResultBasedEntityLoader } from './AuthorizationResultBasedEntityLoader.ts';
+import type { EntityConstructionUtils } from './EntityConstructionUtils.ts';
+import type { EntityInvalidationUtils } from './EntityInvalidationUtils.ts';
+import type { EntityLoaderFactory } from './EntityLoaderFactory.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';
 /**
  * Provides a cleaner API for loading entities by passing through the ViewerContext.
  */

package/build/src/ViewerScopedEntityLoaderFactory.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ViewerScopedEntityLoaderFactory = void 0;
 /**
  * Provides a cleaner API for loading entities by passing through the ViewerContext.
  */
-class ViewerScopedEntityLoaderFactory {
+export class ViewerScopedEntityLoaderFactory {
     entityLoaderFactory;
     viewerContext;
     constructor(entityLoaderFactory, viewerContext) {
@@ -21,5 +18,3 @@ class ViewerScopedEntityLoaderFactory {
         return this.entityLoaderFactory.forLoad(this.viewerContext, queryContext, privacyPolicyEvaluationContext);
     }
 }
-exports.ViewerScopedEntityLoaderFactory = ViewerScopedEntityLoaderFactory;
-//# sourceMappingURL=ViewerScopedEntityLoaderFactory.js.map

package/build/src/ViewerScopedEntityMutatorFactory.d.ts

@@ -1,10 +1,10 @@
-import { AuthorizationResultBasedCreateMutator, AuthorizationResultBasedDeleteMutator, AuthorizationResultBasedUpdateMutator } from './AuthorizationResultBasedEntityMutator';
-import { EntityCascadingDeletionInfo } from './EntityMutationInfo';
-import { EntityMutatorFactory } from './EntityMutatorFactory';
-import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
-import { EntityQueryContext } from './EntityQueryContext';
-import { ReadonlyEntity } from './ReadonlyEntity';
-import { ViewerContext } from './ViewerContext';
+import type { AuthorizationResultBasedCreateMutator, AuthorizationResultBasedDeleteMutator, AuthorizationResultBasedUpdateMutator } from './AuthorizationResultBasedEntityMutator.ts';
+import type { EntityCascadingDeletionInfo } from './EntityMutationInfo.ts';
+import type { EntityMutatorFactory } from './EntityMutatorFactory.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';
 /**
  * Provides a cleaner API for mutating entities by passing through the ViewerContext.
  */

package/build/src/ViewerScopedEntityMutatorFactory.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ViewerScopedEntityMutatorFactory = void 0;
 /**
  * Provides a cleaner API for mutating entities by passing through the ViewerContext.
  */
-class ViewerScopedEntityMutatorFactory {
+export class ViewerScopedEntityMutatorFactory {
     entityMutatorFactory;
     viewerContext;
     constructor(entityMutatorFactory, viewerContext) {
@@ -21,5 +18,3 @@ class ViewerScopedEntityMutatorFactory {
         return this.entityMutatorFactory.forDelete(existingEntity, queryContext, cascadingDeleteCause);
     }
 }
-exports.ViewerScopedEntityMutatorFactory = ViewerScopedEntityMutatorFactory;
-//# sourceMappingURL=ViewerScopedEntityMutatorFactory.js.map

package/build/src/entityUtils.d.ts

@@ -1,4 +1,4 @@
-import { Result, Success, Failure } from '@expo/results';
+import type { Result, Success, Failure } from '@expo/results';
 /**
  * Enforce an array of results resolved from supplied promise.
  * @param resultsPromise - promise returning an array of results to enforce

package/build/src/entityUtils.js

@@ -1,20 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pick = exports.partitionErrors = exports.partitionArray = exports.failedResultsFilterMap = exports.successfulResultsFilterMap = exports.failedResults = exports.successfulResults = exports.enforceResultsAsync = void 0;
 /**
  * Enforce an array of results resolved from supplied promise.
  * @param resultsPromise - promise returning an array of results to enforce
  */
-const enforceResultsAsync = async (resultsPromise) => {
+export const enforceResultsAsync = async (resultsPromise) => {
     const results = await resultsPromise;
     return results.map((result) => result.enforceValue());
 };
-exports.enforceResultsAsync = enforceResultsAsync;
 /**
  * Filter out unsuccessful results.
  * @param results - array of results to filter
  */
-const successfulResults = (results) => {
+export const successfulResults = (results) => {
     const ret = [];
     for (const result of results) {
         if (result.ok) {
@@ -23,12 +19,11 @@ const successfulResults = (results) => {
     }
     return ret;
 };
-exports.successfulResults = successfulResults;
 /**
  * Filter out successful results.
  * @param results - array of results to filter
  */
-const failedResults = (results) => {
+export const failedResults = (results) => {
     const ret = [];
     for (const result of results) {
         if (!result.ok) {
@@ -37,12 +32,11 @@ const failedResults = (results) => {
     }
     return ret;
 };
-exports.failedResults = failedResults;
 /**
  * Filter out failed results from a map with result values.
  * @param results - map of results to filter.
  */
-const successfulResultsFilterMap = (results) => {
+export const successfulResultsFilterMap = (results) => {
     const ret = new Map();
     for (const [k, result] of results) {
         if (result.ok) {
@@ -51,12 +45,11 @@ const successfulResultsFilterMap = (results) => {
     }
     return ret;
 };
-exports.successfulResultsFilterMap = successfulResultsFilterMap;
 /**
  * Filter out successful results from a map with result values.
  * @param results - map of results to filter.
  */
-const failedResultsFilterMap = (results) => {
+export const failedResultsFilterMap = (results) => {
     const ret = new Map();
     for (const [k, result] of results) {
         if (!result.ok) {
@@ -65,13 +58,12 @@ const failedResultsFilterMap = (results) => {
     }
     return ret;
 };
-exports.failedResultsFilterMap = failedResultsFilterMap;
 /**
  * Partition an array of values into two arrays based on evaluation of a binary predicate.
  * @param values - array of values to partition
  * @param predicate - binary predicate to evaluate partition group of each value
  */
-const partitionArray = (values, predicate) => {
+export const partitionArray = (values, predicate) => {
     const ts = [];
     const us = [];
     for (const value of values) {
@@ -84,20 +76,18 @@ const partitionArray = (values, predicate) => {
     }
     return [ts, us];
 };
-exports.partitionArray = partitionArray;
 /**
  * Partition array of values and errors into an array of values and an array of errors.
  * @param valuesAndErrors - array of values and errors
  */
-const partitionErrors = (valuesAndErrors) => {
-    const [errors, values] = (0, exports.partitionArray)(valuesAndErrors, isError);
+export const partitionErrors = (valuesAndErrors) => {
+    const [errors, values] = partitionArray(valuesAndErrors, isError);
     return [values, errors];
 };
-exports.partitionErrors = partitionErrors;
 const isError = (value) => {
     return value instanceof Error;
 };
-const pick = (object, props) => {
+export const pick = (object, props) => {
     const result = {};
     for (const prop of props) {
         if (object.hasOwnProperty(prop)) {
@@ -106,5 +96,3 @@ const pick = (object, props) => {
     }
     return result;
 };
-exports.pick = pick;
-//# sourceMappingURL=entityUtils.js.map

package/build/src/errors/EntityCacheAdapterError.d.ts

@@ -1,4 +1,4 @@
-import { EntityError, EntityErrorCode, EntityErrorState } from './EntityError';
+import { EntityError, EntityErrorCode, EntityErrorState } from './EntityError.ts';
 /**
  * Base class for errors thrown by the entity cache adapter.
  */

package/build/src/errors/EntityCacheAdapterError.js

@@ -1,30 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityCacheAdapterTransientError = exports.EntityCacheAdapterError = void 0;
-const EntityError_1 = require("./EntityError");
+import { EntityError, EntityErrorCode, EntityErrorState } from "./EntityError.js";
 /**
  * Base class for errors thrown by the entity cache adapter.
  */
-class EntityCacheAdapterError extends EntityError_1.EntityError {
+export class EntityCacheAdapterError extends EntityError {
     static {
         this.prototype.name = 'EntityCacheAdapterError';
     }
 }
-exports.EntityCacheAdapterError = EntityCacheAdapterError;
 /**
  * Error thrown when a transient error occurs in the entity cache adapter.
  * Transient errors may succeed if retried.
  */
-class EntityCacheAdapterTransientError extends EntityCacheAdapterError {
+export class EntityCacheAdapterTransientError extends EntityCacheAdapterError {
     static {
         this.prototype.name = 'EntityCacheAdapterTransientError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.TRANSIENT;
+        return EntityErrorState.TRANSIENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_CACHE_ADAPTER_TRANSIENT;
+        return EntityErrorCode.ERR_ENTITY_CACHE_ADAPTER_TRANSIENT;
     }
 }
-exports.EntityCacheAdapterTransientError = EntityCacheAdapterTransientError;
-//# sourceMappingURL=EntityCacheAdapterError.js.map

package/build/src/errors/EntityDatabaseAdapterError.d.ts

@@ -1,4 +1,4 @@
-import { EntityError, EntityErrorCode, EntityErrorState } from './EntityError';
+import { EntityError, EntityErrorCode, EntityErrorState } from './EntityError.ts';
 /**
  * Base class for all errors related to the database adapter.
  */

package/build/src/errors/EntityDatabaseAdapterError.js

@@ -1,225 +1,207 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityDatabaseAdapterPaginationCursorInvalidError = exports.EntityDatabaseAdapterExcessiveDeleteResultError = exports.EntityDatabaseAdapterEmptyUpdateResultError = exports.EntityDatabaseAdapterExcessiveUpdateResultError = exports.EntityDatabaseAdapterEmptyInsertResultError = exports.EntityDatabaseAdapterExcessiveInsertResultError = exports.EntityDatabaseAdapterUniqueConstraintError = exports.EntityDatabaseAdapterNotNullConstraintError = exports.EntityDatabaseAdapterForeignKeyConstraintError = exports.EntityDatabaseAdapterExclusionConstraintError = exports.EntityDatabaseAdapterCheckConstraintError = exports.EntityDatabaseAdapterUnknownError = exports.EntityDatabaseAdapterTransientError = exports.EntityDatabaseAdapterError = void 0;
-const EntityError_1 = require("./EntityError");
+import { EntityError, EntityErrorCode, EntityErrorState } from "./EntityError.js";
 /**
  * Base class for all errors related to the database adapter.
  */
-class EntityDatabaseAdapterError extends EntityError_1.EntityError {
+export class EntityDatabaseAdapterError extends EntityError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterError';
     }
 }
-exports.EntityDatabaseAdapterError = EntityDatabaseAdapterError;
 /**
  * Thrown when a transient error occurrs within the database adapter.
  * Transient errors may succeed if retried.
  */
-class EntityDatabaseAdapterTransientError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterTransientError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterTransientError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.TRANSIENT;
+        return EntityErrorState.TRANSIENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_TRANSIENT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_TRANSIENT;
     }
 }
-exports.EntityDatabaseAdapterTransientError = EntityDatabaseAdapterTransientError;
 /**
  * Thrown when an unknown error occurrs within the database adapter.
  * This is a catch-all error class for DBMS-specific errors that do not fit into other categories.
  */
-class EntityDatabaseAdapterUnknownError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterUnknownError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterUnknownError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.UNKNOWN;
+        return EntityErrorState.UNKNOWN;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_UNKNOWN;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_UNKNOWN;
     }
 }
-exports.EntityDatabaseAdapterUnknownError = EntityDatabaseAdapterUnknownError;
 /**
  * Thrown when a check constraint is violated within the database adapter.
  * This indicates that a value being inserted or updated does not satisfy a defined data integrity constraint.
  */
-class EntityDatabaseAdapterCheckConstraintError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterCheckConstraintError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterCheckConstraintError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_CHECK_CONSTRAINT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_CHECK_CONSTRAINT;
     }
 }
-exports.EntityDatabaseAdapterCheckConstraintError = EntityDatabaseAdapterCheckConstraintError;
 /**
  * Thrown when an exclusion constraint is violated within the database adapter.
  * This indicates that a value being inserted or updated conflicts with an existing value based on a defined exclusion constraint.
  */
-class EntityDatabaseAdapterExclusionConstraintError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterExclusionConstraintError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterExclusionConstraintError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCLUSION_CONSTRAINT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCLUSION_CONSTRAINT;
     }
 }
-exports.EntityDatabaseAdapterExclusionConstraintError = EntityDatabaseAdapterExclusionConstraintError;
 /**
  * Thrown when a foreign key constraint is violated within the database adapter.
  * This indicates that a value being inserted, updated, or deleted references a non-existent value in a related table
  * or is referenced in a related table.
  */
-class EntityDatabaseAdapterForeignKeyConstraintError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterForeignKeyConstraintError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterForeignKeyConstraintError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_FOREIGN_KEY_CONSTRAINT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_FOREIGN_KEY_CONSTRAINT;
     }
 }
-exports.EntityDatabaseAdapterForeignKeyConstraintError = EntityDatabaseAdapterForeignKeyConstraintError;
 /**
  * Thrown when a not-null constraint is violated within the database adapter.
  * This indicates that a null value is being inserted or updated into a column that does not allow null values.
  */
-class EntityDatabaseAdapterNotNullConstraintError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterNotNullConstraintError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterNotNullConstraintError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_NOT_NULL_CONSTRAINT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_NOT_NULL_CONSTRAINT;
     }
 }
-exports.EntityDatabaseAdapterNotNullConstraintError = EntityDatabaseAdapterNotNullConstraintError;
 /**
  * Thrown when a unique constraint is violated within the database adapter.
  * This indicates that a value being inserted or updated duplicates an existing value in a column or set of columns
  * that require unique values.
  */
-class EntityDatabaseAdapterUniqueConstraintError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterUniqueConstraintError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterUniqueConstraintError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_UNIQUE_CONSTRAINT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_UNIQUE_CONSTRAINT;
     }
 }
-exports.EntityDatabaseAdapterUniqueConstraintError = EntityDatabaseAdapterUniqueConstraintError;
 /**
  * Thrown when an insert operation returns more results than expected. Only one row is expected.
  * These should never happen with a properly implemented database adapter unless the underlying database has nonstandard
  * triggers or something similar.
  */
-class EntityDatabaseAdapterExcessiveInsertResultError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterExcessiveInsertResultError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterExcessiveInsertResultError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_INSERT_RESULT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_INSERT_RESULT;
     }
 }
-exports.EntityDatabaseAdapterExcessiveInsertResultError = EntityDatabaseAdapterExcessiveInsertResultError;
 /**
  * Thrown when an insert operation returns no results. One row is expected.
  * These should never happen with a properly implemented database adapter unless the underlying database has nonstandard
  * triggers or something similar.
  */
-class EntityDatabaseAdapterEmptyInsertResultError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterEmptyInsertResultError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterEmptyInsertResultError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EMPTY_INSERT_RESULT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EMPTY_INSERT_RESULT;
     }
 }
-exports.EntityDatabaseAdapterEmptyInsertResultError = EntityDatabaseAdapterEmptyInsertResultError;
 /**
  * Thrown when an update operation returns more results than expected. Only one row is expected.
  * These should never happen with a properly implemented database adapter unless the underlying table has a non-unique
  * primary key column.
  */
-class EntityDatabaseAdapterExcessiveUpdateResultError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterExcessiveUpdateResultError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterExcessiveUpdateResultError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_UPDATE_RESULT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_UPDATE_RESULT;
     }
 }
-exports.EntityDatabaseAdapterExcessiveUpdateResultError = EntityDatabaseAdapterExcessiveUpdateResultError;
 /**
  * Thrown when an update operation returns no results. One row is expected.
  * This most often happens when attempting to update a non-existent row, often indicating that the row
  * was deleted by a different process between fetching and updating it in this process.
  */
-class EntityDatabaseAdapterEmptyUpdateResultError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterEmptyUpdateResultError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterEmptyUpdateResultError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EMPTY_UPDATE_RESULT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EMPTY_UPDATE_RESULT;
     }
 }
-exports.EntityDatabaseAdapterEmptyUpdateResultError = EntityDatabaseAdapterEmptyUpdateResultError;
 /**
  * Thrown when a delete operation returns more results than expected. Only one row is expected.
  * These should never happen with a properly implemented database adapter unless the underlying table has a non-unique
  * primary key column.
  */
-class EntityDatabaseAdapterExcessiveDeleteResultError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterExcessiveDeleteResultError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterExcessiveDeleteResultError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_DELETE_RESULT;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_DELETE_RESULT;
     }
 }
-exports.EntityDatabaseAdapterExcessiveDeleteResultError = EntityDatabaseAdapterExcessiveDeleteResultError;
-class EntityDatabaseAdapterPaginationCursorInvalidError extends EntityDatabaseAdapterError {
+export class EntityDatabaseAdapterPaginationCursorInvalidError extends EntityDatabaseAdapterError {
     static {
         this.prototype.name = 'EntityDatabaseAdapterPaginationCursorError';
     }
     get state() {
-        return EntityError_1.EntityErrorState.PERMANENT;
+        return EntityErrorState.PERMANENT;
     }
     get code() {
-        return EntityError_1.EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_PAGINATION_CURSOR_INVALID;
+        return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_PAGINATION_CURSOR_INVALID;
     }
 }
-exports.EntityDatabaseAdapterPaginationCursorInvalidError = EntityDatabaseAdapterPaginationCursorInvalidError;
-//# sourceMappingURL=EntityDatabaseAdapterError.js.map

package/build/src/errors/EntityError.js

@@ -1,19 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityError = exports.EntityErrorCode = exports.EntityErrorState = void 0;
 /**
  * The state of an entity error, indicating whether it may be transient/retryable.
  */
-var EntityErrorState;
+export var EntityErrorState;
 (function (EntityErrorState) {
     EntityErrorState[EntityErrorState["UNKNOWN"] = 0] = "UNKNOWN";
     EntityErrorState[EntityErrorState["TRANSIENT"] = 1] = "TRANSIENT";
     EntityErrorState[EntityErrorState["PERMANENT"] = 2] = "PERMANENT";
-})(EntityErrorState || (exports.EntityErrorState = EntityErrorState = {}));
+})(EntityErrorState || (EntityErrorState = {}));
 /**
  * Error code for an entity error. Each error code should map to a specific class of Entity error.
  */
-var EntityErrorCode;
+export var EntityErrorCode;
 (function (EntityErrorCode) {
     EntityErrorCode["ERR_ENTITY_NOT_AUTHORIZED"] = "ERR_ENTITY_NOT_AUTHORIZED";
     EntityErrorCode["ERR_ENTITY_NOT_FOUND"] = "ERR_ENTITY_NOT_FOUND";
@@ -32,11 +29,11 @@ var EntityErrorCode;
     EntityErrorCode["ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_DELETE_RESULT"] = "ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_DELETE_RESULT";
     EntityErrorCode["ERR_ENTITY_CACHE_ADAPTER_TRANSIENT"] = "ERR_ENTITY_CACHE_ADAPTER_TRANSIENT";
     EntityErrorCode["ERR_ENTITY_DATABASE_ADAPTER_PAGINATION_CURSOR_INVALID"] = "ERR_ENTITY_DATABASE_ADAPTER_PAGINATION_CURSOR_INVALID";
-})(EntityErrorCode || (exports.EntityErrorCode = EntityErrorCode = {}));
+})(EntityErrorCode || (EntityErrorCode = {}));
 /**
  * Base class for all known errors thrown by the entity system.
  */
-class EntityError extends Error {
+export class EntityError extends Error {
     static {
         this.prototype.name = 'EntityError';
     }
@@ -44,5 +41,3 @@ class EntityError extends Error {
         super(message, { cause });
     }
 }
-exports.EntityError = EntityError;
-//# sourceMappingURL=EntityError.js.map

package/build/src/errors/EntityInvalidFieldValueError.d.ts

@@ -1,8 +1,8 @@
-import { IEntityClass } from '../Entity';
-import { EntityPrivacyPolicy } from '../EntityPrivacyPolicy';
-import { ReadonlyEntity } from '../ReadonlyEntity';
-import { ViewerContext } from '../ViewerContext';
-import { EntityError, EntityErrorCode, EntityErrorState } from './EntityError';
+import type { IEntityClass } from '../Entity.ts';
+import type { EntityPrivacyPolicy } from '../EntityPrivacyPolicy.ts';
+import type { ReadonlyEntity } from '../ReadonlyEntity.ts';
+import type { ViewerContext } from '../ViewerContext.ts';
+import { EntityError, EntityErrorCode, EntityErrorState } from './EntityError.ts';
 /**
  * Error thrown when an entity field has an invalid value, either during load or mutation.
  */