@mikro-orm/core 7.0.2 → 7.0.3-dev.0

package/hydration/Hydrator.d.ts

@@ -5,46 +5,21 @@ 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;
-  }
-  /**
-   * @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);
+    metadata;
+    platform;
+    config;
+    running = false;
+    constructor(metadata, platform, config) {
+        this.metadata = metadata;
+        this.platform = platform;
+        this.config = config;
     }
-    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]);
+    /**
+     * @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];
     }
-    return meta.hydrateProps;
-  }
-  hydrateProperty(entity, prop, data, factory, newEntity, convertCustomTypes) {
-    entity[prop.name] = data[prop.name];
-  }
 }

package/hydration/ObjectHydrator.d.ts

@@ -1,57 +1,24 @@
 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 {};