@mikro-orm/core 7.0.4-dev.8 → 7.0.4

package/hydration/Hydrator.d.ts

@@ -5,21 +5,46 @@ import type { MetadataStorage } from '../metadata/MetadataStorage.js';
 import type { Configuration } from '../utils/Configuration.js';
 /** Abstract base class for hydrating entity instances from raw database data. */
 export declare abstract class Hydrator implements IHydrator {
-    protected readonly metadata: MetadataStorage;
-    protected readonly platform: Platform;
-    protected readonly config: Configuration;
-    protected running: boolean;
-    constructor(metadata: MetadataStorage, platform: Platform, config: Configuration);
-    /**
-     * @inheritDoc
-     */
-    hydrate<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, type: 'full' | 'reference', newEntity?: boolean, convertCustomTypes?: boolean, schema?: string, parentSchema?: string): void;
-    /**
-     * @inheritDoc
-     */
-    hydrateReference<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, convertCustomTypes?: boolean, schema?: string, parentSchema?: string): void;
-    /** Returns whether the hydrator is currently in the middle of hydrating an entity. */
-    isRunning(): boolean;
-    protected getProperties<T extends object>(meta: EntityMetadata<T>, type: 'full' | 'reference'): EntityProperty<T>[];
-    protected hydrateProperty<T extends object>(entity: T, prop: EntityProperty<T>, data: EntityData<T>, factory: EntityFactory, newEntity?: boolean, convertCustomTypes?: boolean): void;
+  protected readonly metadata: MetadataStorage;
+  protected readonly platform: Platform;
+  protected readonly config: Configuration;
+  protected running: boolean;
+  constructor(metadata: MetadataStorage, platform: Platform, config: Configuration);
+  /**
+   * @inheritDoc
+   */
+  hydrate<T extends object>(
+    entity: T,
+    meta: EntityMetadata<T>,
+    data: EntityData<T>,
+    factory: EntityFactory,
+    type: 'full' | 'reference',
+    newEntity?: boolean,
+    convertCustomTypes?: boolean,
+    schema?: string,
+    parentSchema?: string,
+  ): void;
+  /**
+   * @inheritDoc
+   */
+  hydrateReference<T extends object>(
+    entity: T,
+    meta: EntityMetadata<T>,
+    data: EntityData<T>,
+    factory: EntityFactory,
+    convertCustomTypes?: boolean,
+    schema?: string,
+    parentSchema?: string,
+  ): void;
+  /** Returns whether the hydrator is currently in the middle of hydrating an entity. */
+  isRunning(): boolean;
+  protected getProperties<T extends object>(meta: EntityMetadata<T>, type: 'full' | 'reference'): EntityProperty<T>[];
+  protected hydrateProperty<T extends object>(
+    entity: T,
+    prop: EntityProperty<T>,
+    data: EntityData<T>,
+    factory: EntityFactory,
+    newEntity?: boolean,
+    convertCustomTypes?: boolean,
+  ): void;
 }

package/hydration/Hydrator.js

@@ -1,49 +1,49 @@
 /** Abstract base class for hydrating entity instances from raw database data. */
 /* v8 ignore next */
 export class Hydrator {
-    metadata;
-    platform;
-    config;
-    running = false;
-    constructor(metadata, platform, config) {
-        this.metadata = metadata;
-        this.platform = platform;
-        this.config = config;
+  metadata;
+  platform;
+  config;
+  running = false;
+  constructor(metadata, platform, config) {
+    this.metadata = metadata;
+    this.platform = platform;
+    this.config = config;
+  }
+  /**
+   * @inheritDoc
+   */
+  hydrate(entity, meta, data, factory, type, newEntity = false, convertCustomTypes = false, schema, parentSchema) {
+    // the running state is used to consider propagation as hydration, saving the values directly to the entity data,
+    // but we don't want that for new entities, their propagation should result in entity updates when flushing
+    this.running = !newEntity;
+    const props = this.getProperties(meta, type);
+    for (const prop of props) {
+      this.hydrateProperty(entity, prop, data, factory, newEntity, convertCustomTypes);
     }
-    /**
-     * @inheritDoc
-     */
-    hydrate(entity, meta, data, factory, type, newEntity = false, convertCustomTypes = false, schema, parentSchema) {
-        // the running state is used to consider propagation as hydration, saving the values directly to the entity data,
-        // but we don't want that for new entities, their propagation should result in entity updates when flushing
-        this.running = !newEntity;
-        const props = this.getProperties(meta, type);
-        for (const prop of props) {
-            this.hydrateProperty(entity, prop, data, factory, newEntity, convertCustomTypes);
-        }
-        this.running = false;
-    }
-    /**
-     * @inheritDoc
-     */
-    hydrateReference(entity, meta, data, factory, convertCustomTypes, schema, parentSchema) {
-        this.running = true;
-        meta.primaryKeys.forEach(pk => {
-            this.hydrateProperty(entity, meta.properties[pk], data, factory, false, convertCustomTypes);
-        });
-        this.running = false;
-    }
-    /** Returns whether the hydrator is currently in the middle of hydrating an entity. */
-    isRunning() {
-        return this.running;
-    }
-    getProperties(meta, type) {
-        if (type === 'reference') {
-            return meta.primaryKeys.map(pk => meta.properties[pk]);
-        }
-        return meta.hydrateProps;
-    }
-    hydrateProperty(entity, prop, data, factory, newEntity, convertCustomTypes) {
-        entity[prop.name] = data[prop.name];
+    this.running = false;
+  }
+  /**
+   * @inheritDoc
+   */
+  hydrateReference(entity, meta, data, factory, convertCustomTypes, schema, parentSchema) {
+    this.running = true;
+    meta.primaryKeys.forEach(pk => {
+      this.hydrateProperty(entity, meta.properties[pk], data, factory, false, convertCustomTypes);
+    });
+    this.running = false;
+  }
+  /** Returns whether the hydrator is currently in the middle of hydrating an entity. */
+  isRunning() {
+    return this.running;
+  }
+  getProperties(meta, type) {
+    if (type === 'reference') {
+      return meta.primaryKeys.map(pk => meta.properties[pk]);
     }
+    return meta.hydrateProps;
+  }
+  hydrateProperty(entity, prop, data, factory, newEntity, convertCustomTypes) {
+    entity[prop.name] = data[prop.name];
+  }
 }

package/hydration/ObjectHydrator.d.ts

@@ -1,24 +1,57 @@
 import type { EntityData, EntityMetadata } from '../typings.js';
 import { Hydrator } from './Hydrator.js';
 import type { EntityFactory } from '../entity/EntityFactory.js';
-type EntityHydrator<T extends object> = (entity: T, data: EntityData<T>, factory: EntityFactory, newEntity: boolean, convertCustomTypes: boolean, schema?: string, parentSchema?: string, normalizeAccessors?: boolean) => void;
+type EntityHydrator<T extends object> = (
+  entity: T,
+  data: EntityData<T>,
+  factory: EntityFactory,
+  newEntity: boolean,
+  convertCustomTypes: boolean,
+  schema?: string,
+  parentSchema?: string,
+  normalizeAccessors?: boolean,
+) => void;
 /** @internal JIT-compiled hydrator that converts raw database rows into entity instances with optimized generated code. */
 export declare class ObjectHydrator extends Hydrator {
-    #private;
-    /**
-     * @inheritDoc
-     */
-    hydrate<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, type: 'full' | 'reference', newEntity?: boolean, convertCustomTypes?: boolean, schema?: string, parentSchema?: string, normalizeAccessors?: boolean): void;
-    /**
-     * @inheritDoc
-     */
-    hydrateReference<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, convertCustomTypes?: boolean, schema?: string, parentSchema?: string, normalizeAccessors?: boolean): void;
-    /**
-     * @internal Highly performance-sensitive method.
-     */
-    getEntityHydrator<T extends object>(meta: EntityMetadata<T>, type: 'full' | 'reference', normalizeAccessors?: boolean): EntityHydrator<T>;
-    private createCollectionItemMapper;
-    private wrap;
-    private safeKey;
+  #private;
+  /**
+   * @inheritDoc
+   */
+  hydrate<T extends object>(
+    entity: T,
+    meta: EntityMetadata<T>,
+    data: EntityData<T>,
+    factory: EntityFactory,
+    type: 'full' | 'reference',
+    newEntity?: boolean,
+    convertCustomTypes?: boolean,
+    schema?: string,
+    parentSchema?: string,
+    normalizeAccessors?: boolean,
+  ): void;
+  /**
+   * @inheritDoc
+   */
+  hydrateReference<T extends object>(
+    entity: T,
+    meta: EntityMetadata<T>,
+    data: EntityData<T>,
+    factory: EntityFactory,
+    convertCustomTypes?: boolean,
+    schema?: string,
+    parentSchema?: string,
+    normalizeAccessors?: boolean,
+  ): void;
+  /**
+   * @internal Highly performance-sensitive method.
+   */
+  getEntityHydrator<T extends object>(
+    meta: EntityMetadata<T>,
+    type: 'full' | 'reference',
+    normalizeAccessors?: boolean,
+  ): EntityHydrator<T>;
+  private createCollectionItemMapper;
+  private wrap;
+  private safeKey;
 }
 export {};