@expo/entity 0.53.0 → 0.54.0

package/src/errors/EntityDatabaseAdapterError.ts

@@ -3,15 +3,28 @@ import { EntityError, EntityErrorCode, EntityErrorState } from './EntityError';
 /**
  * Base class for all errors related to the database adapter.
  */
-export abstract class EntityDatabaseAdapterError extends EntityError {}
+export abstract class EntityDatabaseAdapterError extends EntityError {
+  static {
+    this.prototype.name = 'EntityDatabaseAdapterError';
+  }
+}
 
 /**
  * Thrown when a transient error occurrs within the database adapter.
  * Transient errors may succeed if retried.
  */
 export class EntityDatabaseAdapterTransientError extends EntityDatabaseAdapterError {
-  public readonly state = EntityErrorState.TRANSIENT;
-  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_TRANSIENT;
+  static {
+    this.prototype.name = 'EntityDatabaseAdapterTransientError';
+  }
+
+  get state(): EntityErrorState.TRANSIENT {
+    return EntityErrorState.TRANSIENT;
+  }
+
+  get code(): EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_TRANSIENT {
+    return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_TRANSIENT;
+  }
 }
 
 /**
@@ -19,8 +32,17 @@ export class EntityDatabaseAdapterTransientError extends EntityDatabaseAdapterEr
  * This is a catch-all error class for DBMS-specific errors that do not fit into other categories.
  */
 export class EntityDatabaseAdapterUnknownError extends EntityDatabaseAdapterError {
-  public readonly state = EntityErrorState.UNKNOWN;
-  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_UNKNOWN;
+  static {
+    this.prototype.name = 'EntityDatabaseAdapterUnknownError';
+  }
+
+  get state(): EntityErrorState.UNKNOWN {
+    return EntityErrorState.UNKNOWN;
+  }
+
+  get code(): EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_UNKNOWN {
+    return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_UNKNOWN;
+  }
 }
 
 /**
@@ -28,8 +50,17 @@ export class EntityDatabaseAdapterUnknownError extends EntityDatabaseAdapterErro
  * This indicates that a value being inserted or updated does not satisfy a defined data integrity constraint.
  */
 export class EntityDatabaseAdapterCheckConstraintError extends EntityDatabaseAdapterError {
-  public readonly state = EntityErrorState.PERMANENT;
-  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_CHECK_CONSTRAINT;
+  static {
+    this.prototype.name = 'EntityDatabaseAdapterCheckConstraintError';
+  }
+
+  get state(): EntityErrorState.PERMANENT {
+    return EntityErrorState.PERMANENT;
+  }
+
+  get code(): EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_CHECK_CONSTRAINT {
+    return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_CHECK_CONSTRAINT;
+  }
 }
 
 /**
@@ -37,8 +68,17 @@ export class EntityDatabaseAdapterCheckConstraintError extends EntityDatabaseAda
  * This indicates that a value being inserted or updated conflicts with an existing value based on a defined exclusion constraint.
  */
 export class EntityDatabaseAdapterExclusionConstraintError extends EntityDatabaseAdapterError {
-  public readonly state = EntityErrorState.PERMANENT;
-  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCLUSION_CONSTRAINT;
+  static {
+    this.prototype.name = 'EntityDatabaseAdapterExclusionConstraintError';
+  }
+
+  get state(): EntityErrorState.PERMANENT {
+    return EntityErrorState.PERMANENT;
+  }
+
+  get code(): EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCLUSION_CONSTRAINT {
+    return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCLUSION_CONSTRAINT;
+  }
 }
 
 /**
@@ -47,8 +87,17 @@ export class EntityDatabaseAdapterExclusionConstraintError extends EntityDatabas
  * or is referenced in a related table.
  */
 export class EntityDatabaseAdapterForeignKeyConstraintError extends EntityDatabaseAdapterError {
-  public readonly state = EntityErrorState.PERMANENT;
-  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_FOREIGN_KEY_CONSTRAINT;
+  static {
+    this.prototype.name = 'EntityDatabaseAdapterForeignKeyConstraintError';
+  }
+
+  get state(): EntityErrorState.PERMANENT {
+    return EntityErrorState.PERMANENT;
+  }
+
+  get code(): EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_FOREIGN_KEY_CONSTRAINT {
+    return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_FOREIGN_KEY_CONSTRAINT;
+  }
 }
 
 /**
@@ -56,8 +105,17 @@ export class EntityDatabaseAdapterForeignKeyConstraintError extends EntityDataba
  * This indicates that a null value is being inserted or updated into a column that does not allow null values.
  */
 export class EntityDatabaseAdapterNotNullConstraintError extends EntityDatabaseAdapterError {
-  public readonly state = EntityErrorState.PERMANENT;
-  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_NOT_NULL_CONSTRAINT;
+  static {
+    this.prototype.name = 'EntityDatabaseAdapterNotNullConstraintError';
+  }
+
+  get state(): EntityErrorState.PERMANENT {
+    return EntityErrorState.PERMANENT;
+  }
+
+  get code(): EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_NOT_NULL_CONSTRAINT {
+    return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_NOT_NULL_CONSTRAINT;
+  }
 }
 
 /**
@@ -66,8 +124,17 @@ export class EntityDatabaseAdapterNotNullConstraintError extends EntityDatabaseA
  * that require unique values.
  */
 export class EntityDatabaseAdapterUniqueConstraintError extends EntityDatabaseAdapterError {
-  public readonly state = EntityErrorState.PERMANENT;
-  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_UNIQUE_CONSTRAINT;
+  static {
+    this.prototype.name = 'EntityDatabaseAdapterUniqueConstraintError';
+  }
+
+  get state(): EntityErrorState.PERMANENT {
+    return EntityErrorState.PERMANENT;
+  }
+
+  get code(): EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_UNIQUE_CONSTRAINT {
+    return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_UNIQUE_CONSTRAINT;
+  }
 }
 
 /**
@@ -76,8 +143,17 @@ export class EntityDatabaseAdapterUniqueConstraintError extends EntityDatabaseAd
  * triggers or something similar.
  */
 export class EntityDatabaseAdapterExcessiveInsertResultError extends EntityDatabaseAdapterError {
-  public readonly state = EntityErrorState.PERMANENT;
-  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_INSERT_RESULT;
+  static {
+    this.prototype.name = 'EntityDatabaseAdapterExcessiveInsertResultError';
+  }
+
+  get state(): EntityErrorState.PERMANENT {
+    return EntityErrorState.PERMANENT;
+  }
+
+  get code(): EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_INSERT_RESULT {
+    return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_INSERT_RESULT;
+  }
 }
 
 /**
@@ -86,8 +162,17 @@ export class EntityDatabaseAdapterExcessiveInsertResultError extends EntityDatab
  * triggers or something similar.
  */
 export class EntityDatabaseAdapterEmptyInsertResultError extends EntityDatabaseAdapterError {
-  public readonly state = EntityErrorState.PERMANENT;
-  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EMPTY_INSERT_RESULT;
+  static {
+    this.prototype.name = 'EntityDatabaseAdapterEmptyInsertResultError';
+  }
+
+  get state(): EntityErrorState.PERMANENT {
+    return EntityErrorState.PERMANENT;
+  }
+
+  get code(): EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EMPTY_INSERT_RESULT {
+    return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EMPTY_INSERT_RESULT;
+  }
 }
 
 /**
@@ -96,8 +181,17 @@ export class EntityDatabaseAdapterEmptyInsertResultError extends EntityDatabaseA
  * primary key column.
  */
 export class EntityDatabaseAdapterExcessiveUpdateResultError extends EntityDatabaseAdapterError {
-  public readonly state = EntityErrorState.PERMANENT;
-  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_UPDATE_RESULT;
+  static {
+    this.prototype.name = 'EntityDatabaseAdapterExcessiveUpdateResultError';
+  }
+
+  get state(): EntityErrorState.PERMANENT {
+    return EntityErrorState.PERMANENT;
+  }
+
+  get code(): EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_UPDATE_RESULT {
+    return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_UPDATE_RESULT;
+  }
 }
 
 /**
@@ -106,8 +200,17 @@ export class EntityDatabaseAdapterExcessiveUpdateResultError extends EntityDatab
  * was deleted by a different process between fetching and updating it in this process.
  */
 export class EntityDatabaseAdapterEmptyUpdateResultError extends EntityDatabaseAdapterError {
-  public readonly state = EntityErrorState.PERMANENT;
-  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EMPTY_UPDATE_RESULT;
+  static {
+    this.prototype.name = 'EntityDatabaseAdapterEmptyUpdateResultError';
+  }
+
+  get state(): EntityErrorState.PERMANENT {
+    return EntityErrorState.PERMANENT;
+  }
+
+  get code(): EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EMPTY_UPDATE_RESULT {
+    return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EMPTY_UPDATE_RESULT;
+  }
 }
 
 /**
@@ -116,6 +219,15 @@ export class EntityDatabaseAdapterEmptyUpdateResultError extends EntityDatabaseA
  * primary key column.
  */
 export class EntityDatabaseAdapterExcessiveDeleteResultError extends EntityDatabaseAdapterError {
-  public readonly state = EntityErrorState.PERMANENT;
-  public readonly code = EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_DELETE_RESULT;
+  static {
+    this.prototype.name = 'EntityDatabaseAdapterExcessiveDeleteResultError';
+  }
+
+  get state(): EntityErrorState.PERMANENT {
+    return EntityErrorState.PERMANENT;
+  }
+
+  get code(): EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_DELETE_RESULT {
+    return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_DELETE_RESULT;
+  }
 }

package/src/errors/EntityError.ts

@@ -1,5 +1,3 @@
-import ES6Error from 'es6-error';
-
 /**
  * The state of an entity error, indicating whether it may be transient/retryable.
  */
@@ -34,14 +32,15 @@ export enum EntityErrorCode {
 /**
  * Base class for all known errors thrown by the entity system.
  */
-export abstract class EntityError extends ES6Error {
+export abstract class EntityError extends Error {
+  static {
+    this.prototype.name = 'EntityError';
+  }
+
   public abstract readonly state: EntityErrorState;
   public abstract readonly code: EntityErrorCode;
 
-  constructor(
-    message: string,
-    public override readonly cause?: Error,
-  ) {
-    super(message);
+  constructor(message: string, cause?: Error) {
+    super(message, { cause });
   }
 }

package/src/errors/EntityInvalidFieldValueError.ts

@@ -22,8 +22,17 @@ export class EntityInvalidFieldValueError<
   N extends keyof TFields,
   TSelectedFields extends keyof TFields = keyof TFields,
 > extends EntityError {
-  public readonly state = EntityErrorState.PERMANENT;
-  public readonly code = EntityErrorCode.ERR_ENTITY_INVALID_FIELD_VALUE;
+  static {
+    this.prototype.name = 'EntityInvalidFieldValueError';
+  }
+
+  get state(): EntityErrorState.PERMANENT {
+    return EntityErrorState.PERMANENT;
+  }
+
+  get code(): EntityErrorCode.ERR_ENTITY_INVALID_FIELD_VALUE {
+    return EntityErrorCode.ERR_ENTITY_INVALID_FIELD_VALUE;
+  }
 
   constructor(
     entityClass: IEntityClass<

package/src/errors/EntityNotAuthorizedError.ts

@@ -13,8 +13,17 @@ export class EntityNotAuthorizedError<
   TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TSelectedFields extends keyof TFields = keyof TFields,
 > extends EntityError {
-  public readonly state = EntityErrorState.PERMANENT;
-  public readonly code = EntityErrorCode.ERR_ENTITY_NOT_AUTHORIZED;
+  static {
+    this.prototype.name = 'EntityNotAuthorizedError';
+  }
+
+  get state(): EntityErrorState.PERMANENT {
+    return EntityErrorState.PERMANENT;
+  }
+
+  get code(): EntityErrorCode.ERR_ENTITY_NOT_AUTHORIZED {
+    return EntityErrorCode.ERR_ENTITY_NOT_AUTHORIZED;
+  }
 
   public readonly entityClassName: string;
 

package/src/errors/EntityNotFoundError.ts

@@ -49,8 +49,17 @@ export class EntityNotFoundError<
   N extends keyof TFields,
   TSelectedFields extends keyof TFields = keyof TFields,
 > extends EntityError {
-  public readonly state = EntityErrorState.PERMANENT;
-  public readonly code = EntityErrorCode.ERR_ENTITY_NOT_FOUND;
+  static {
+    this.prototype.name = 'EntityNotFoundError';
+  }
+
+  get state(): EntityErrorState.PERMANENT {
+    return EntityErrorState.PERMANENT;
+  }
+
+  get code(): EntityErrorCode.ERR_ENTITY_NOT_FOUND {
+    return EntityErrorCode.ERR_ENTITY_NOT_FOUND;
+  }
 
   constructor(message: string);
   constructor(

package/src/errors/__tests__/EntityDatabaseAdapterError-test.ts

@@ -2,7 +2,12 @@ import { describe, expect, it } from '@jest/globals';
 
 import {
   EntityDatabaseAdapterCheckConstraintError,
+  EntityDatabaseAdapterEmptyInsertResultError,
+  EntityDatabaseAdapterEmptyUpdateResultError,
   EntityDatabaseAdapterError,
+  EntityDatabaseAdapterExcessiveDeleteResultError,
+  EntityDatabaseAdapterExcessiveInsertResultError,
+  EntityDatabaseAdapterExcessiveUpdateResultError,
   EntityDatabaseAdapterExclusionConstraintError,
   EntityDatabaseAdapterForeignKeyConstraintError,
   EntityDatabaseAdapterNotNullConstraintError,
@@ -10,20 +15,72 @@ import {
   EntityDatabaseAdapterUniqueConstraintError,
   EntityDatabaseAdapterUnknownError,
 } from '../EntityDatabaseAdapterError';
+import { EntityErrorCode, EntityErrorState } from '../EntityError';
 
 describe(EntityDatabaseAdapterError, () => {
   // necessary for coverage within the entity package since these errors are
   // currently only ever instantiated by database adapter implementations
-  it('instantiates all errors successfully', () => {
-    const errors = [
-      new EntityDatabaseAdapterTransientError('test'),
-      new EntityDatabaseAdapterUnknownError('test'),
-      new EntityDatabaseAdapterCheckConstraintError('test'),
-      new EntityDatabaseAdapterExclusionConstraintError('test'),
-      new EntityDatabaseAdapterForeignKeyConstraintError('test'),
-      new EntityDatabaseAdapterNotNullConstraintError('test'),
-      new EntityDatabaseAdapterUniqueConstraintError('test'),
-    ];
-    expect(errors).not.toBeFalsy();
+  it('instantiates all errors with correct state and code', () => {
+    const transientError = new EntityDatabaseAdapterTransientError('test');
+    expect(transientError.state).toBe(EntityErrorState.TRANSIENT);
+    expect(transientError.code).toBe(EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_TRANSIENT);
+
+    const unknownError = new EntityDatabaseAdapterUnknownError('test');
+    expect(unknownError.state).toBe(EntityErrorState.UNKNOWN);
+    expect(unknownError.code).toBe(EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_UNKNOWN);
+
+    const checkError = new EntityDatabaseAdapterCheckConstraintError('test');
+    expect(checkError.state).toBe(EntityErrorState.PERMANENT);
+    expect(checkError.code).toBe(EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_CHECK_CONSTRAINT);
+
+    const exclusionError = new EntityDatabaseAdapterExclusionConstraintError('test');
+    expect(exclusionError.state).toBe(EntityErrorState.PERMANENT);
+    expect(exclusionError.code).toBe(
+      EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCLUSION_CONSTRAINT,
+    );
+
+    const foreignKeyError = new EntityDatabaseAdapterForeignKeyConstraintError('test');
+    expect(foreignKeyError.state).toBe(EntityErrorState.PERMANENT);
+    expect(foreignKeyError.code).toBe(
+      EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_FOREIGN_KEY_CONSTRAINT,
+    );
+
+    const notNullError = new EntityDatabaseAdapterNotNullConstraintError('test');
+    expect(notNullError.state).toBe(EntityErrorState.PERMANENT);
+    expect(notNullError.code).toBe(EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_NOT_NULL_CONSTRAINT);
+
+    const uniqueError = new EntityDatabaseAdapterUniqueConstraintError('test');
+    expect(uniqueError.state).toBe(EntityErrorState.PERMANENT);
+    expect(uniqueError.code).toBe(EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_UNIQUE_CONSTRAINT);
+
+    const excessiveInsertError = new EntityDatabaseAdapterExcessiveInsertResultError('test');
+    expect(excessiveInsertError.state).toBe(EntityErrorState.PERMANENT);
+    expect(excessiveInsertError.code).toBe(
+      EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_INSERT_RESULT,
+    );
+
+    const emptyInsertError = new EntityDatabaseAdapterEmptyInsertResultError('test');
+    expect(emptyInsertError.state).toBe(EntityErrorState.PERMANENT);
+    expect(emptyInsertError.code).toBe(
+      EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EMPTY_INSERT_RESULT,
+    );
+
+    const excessiveUpdateError = new EntityDatabaseAdapterExcessiveUpdateResultError('test');
+    expect(excessiveUpdateError.state).toBe(EntityErrorState.PERMANENT);
+    expect(excessiveUpdateError.code).toBe(
+      EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_UPDATE_RESULT,
+    );
+
+    const emptyUpdateError = new EntityDatabaseAdapterEmptyUpdateResultError('test');
+    expect(emptyUpdateError.state).toBe(EntityErrorState.PERMANENT);
+    expect(emptyUpdateError.code).toBe(
+      EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EMPTY_UPDATE_RESULT,
+    );
+
+    const excessiveDeleteError = new EntityDatabaseAdapterExcessiveDeleteResultError('test');
+    expect(excessiveDeleteError.state).toBe(EntityErrorState.PERMANENT);
+    expect(excessiveDeleteError.code).toBe(
+      EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_DELETE_RESULT,
+    );
   });
 });

package/src/errors/__tests__/EntityError-test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from '@jest/globals';
+
+import { EntityCacheAdapterTransientError } from '../EntityCacheAdapterError';
+import { EntityErrorCode, EntityErrorState } from '../EntityError';
+import { EntityInvalidFieldValueError } from '../EntityInvalidFieldValueError';
+import { EntityNotAuthorizedError } from '../EntityNotAuthorizedError';
+import { EntityNotFoundError } from '../EntityNotFoundError';
+
+describe('EntityError subclasses', () => {
+  it('EntityNotFoundError has correct state and code', () => {
+    const error = new EntityNotFoundError('not found');
+    expect(error.state).toBe(EntityErrorState.PERMANENT);
+    expect(error.code).toBe(EntityErrorCode.ERR_ENTITY_NOT_FOUND);
+  });
+
+  it('EntityNotAuthorizedError has correct state and code', () => {
+    const mockEntity = { constructor: { name: 'TestEntity' }, toString: () => 'TestEntity' } as any;
+    const mockViewerContext = { toString: () => 'TestViewer' } as any;
+    const error = new EntityNotAuthorizedError(mockEntity, mockViewerContext, 0, 0);
+    expect(error.state).toBe(EntityErrorState.PERMANENT);
+    expect(error.code).toBe(EntityErrorCode.ERR_ENTITY_NOT_AUTHORIZED);
+  });
+
+  it('EntityInvalidFieldValueError has correct state and code', () => {
+    const mockEntityClass = { name: 'TestEntity' } as any;
+    const error = new EntityInvalidFieldValueError(mockEntityClass, 'testField', 'badValue');
+    expect(error.state).toBe(EntityErrorState.PERMANENT);
+    expect(error.code).toBe(EntityErrorCode.ERR_ENTITY_INVALID_FIELD_VALUE);
+  });
+
+  it('EntityCacheAdapterTransientError has correct state and code', () => {
+    const error = new EntityCacheAdapterTransientError('cache error');
+    expect(error.state).toBe(EntityErrorState.TRANSIENT);
+    expect(error.code).toBe(EntityErrorCode.ERR_ENTITY_CACHE_ADAPTER_TRANSIENT);
+  });
+});

package/src/internal/CompositeFieldHolder.ts

@@ -32,14 +32,12 @@ export type SerializedCompositeFieldHolder = string & {
 export class CompositeFieldHolder<
   TFields extends Record<string, any>,
   TIDField extends keyof TFields,
-> implements
-    IEntityLoadKey<
-      TFields,
-      TIDField,
-      SerializedCompositeFieldValueHolder,
-      CompositeFieldValueHolder<TFields, EntityCompositeField<TFields>>
-    >
-{
+> implements IEntityLoadKey<
+  TFields,
+  TIDField,
+  SerializedCompositeFieldValueHolder,
+  CompositeFieldValueHolder<TFields, EntityCompositeField<TFields>>
+> {
   public readonly compositeField: EntityCompositeField<TFields>;
 
   constructor(compositeFieldInput: EntityCompositeField<TFields>) {
@@ -174,8 +172,7 @@ export type SerializedCompositeFieldValueHolder = string & {
 export class CompositeFieldValueHolder<
   TFields extends Record<string, any>,
   TCompositeField extends EntityCompositeField<TFields>,
-> implements IEntityLoadValue<SerializedCompositeFieldValueHolder>
-{
+> implements IEntityLoadValue<SerializedCompositeFieldValueHolder> {
   constructor(
     public readonly compositeFieldValue: EntityCompositeFieldValue<TFields, TCompositeField>,
   ) {}

package/src/internal/CompositeFieldValueMap.ts

@@ -11,8 +11,7 @@ export class CompositeFieldValueMap<
   TFields extends Record<string, any>,
   N extends EntityCompositeField<TFields>,
   TOutput,
-> implements ReadonlyMap<EntityCompositeFieldValue<TFields, N>, TOutput>
-{
+> implements ReadonlyMap<EntityCompositeFieldValue<TFields, N>, TOutput> {
   private readonly map: Map<SerializedCompositeFieldValueHolder, TOutput>;
 
   constructor(entries: [CompositeFieldValueHolder<TFields, N>, TOutput][]) {

package/src/internal/SingleFieldHolder.ts

@@ -18,9 +18,12 @@ export class SingleFieldHolder<
   TFields extends Record<string, any>,
   TIDField extends keyof TFields,
   N extends keyof TFields,
-> implements
-    IEntityLoadKey<TFields, TIDField, NonNullable<TFields[N]>, SingleFieldValueHolder<TFields, N>>
-{
+> implements IEntityLoadKey<
+  TFields,
+  TIDField,
+  NonNullable<TFields[N]>,
+  SingleFieldValueHolder<TFields, N>
+> {
   constructor(public readonly fieldName: N) {}
 
   toString(): string {
@@ -102,9 +105,10 @@ export class SingleFieldHolder<
  *
  * @internal
  */
-export class SingleFieldValueHolder<TFields extends Record<string, any>, N extends keyof TFields>
-  implements IEntityLoadValue<NonNullable<TFields[N]>>
-{
+export class SingleFieldValueHolder<
+  TFields extends Record<string, any>,
+  N extends keyof TFields,
+> implements IEntityLoadValue<NonNullable<TFields[N]>> {
   constructor(public readonly fieldValue: NonNullable<TFields[N]>) {}
 
   toString(): string {