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

package/serialization/SerializationContext.js

@@ -6,120 +6,120 @@ import { helper } from '../entity/wrap.js';
  * are defined in populate hint). If not, we proceed and call `leave` afterwards.
  */
 export class SerializationContext {
-  path = [];
-  visited = new Set();
-  #entities = new Set();
-  #populate;
-  #fields;
-  #exclude;
-  constructor(populate = [], fields, exclude) {
-    this.#populate = populate;
-    this.#fields = fields;
-    this.#exclude = exclude;
-  }
-  /**
-   * Returns true when there is a cycle detected.
-   */
-  visit(entityName, prop) {
-    if (!this.path.find(([cls, item]) => entityName === cls && prop === item)) {
-      this.path.push([entityName, prop]);
-      return false;
+    path = [];
+    visited = new Set();
+    #entities = new Set();
+    #populate;
+    #fields;
+    #exclude;
+    constructor(populate = [], fields, exclude) {
+        this.#populate = populate;
+        this.#fields = fields;
+        this.#exclude = exclude;
     }
-    // check if the path is explicitly populated
-    if (!this.isMarkedAsPopulated(entityName, prop)) {
-      return true;
-    }
-    this.path.push([entityName, prop]);
-    return false;
-  }
-  /** Removes the last entry from the visit path after processing a property. */
-  leave(entityName, prop) {
-    const last = this.path.pop();
-    /* v8 ignore next */
-    if (last?.[0] !== entityName || last[1] !== prop) {
-      throw new Error(`Trying to leave wrong property: ${entityName}.${prop} instead of ${last?.join('.')}`);
+    /**
+     * Returns true when there is a cycle detected.
+     */
+    visit(entityName, prop) {
+        if (!this.path.find(([cls, item]) => entityName === cls && prop === item)) {
+            this.path.push([entityName, prop]);
+            return false;
+        }
+        // check if the path is explicitly populated
+        if (!this.isMarkedAsPopulated(entityName, prop)) {
+            return true;
+        }
+        this.path.push([entityName, prop]);
+        return false;
     }
-  }
-  /** Cleans up the serialization context by removing root references from all tracked entities. */
-  close() {
-    for (const entity of this.#entities) {
-      delete helper(entity).__serializationContext.root;
+    /** Removes the last entry from the visit path after processing a property. */
+    leave(entityName, prop) {
+        const last = this.path.pop();
+        /* v8 ignore next */
+        if (last?.[0] !== entityName || last[1] !== prop) {
+            throw new Error(`Trying to leave wrong property: ${entityName}.${prop} instead of ${last?.join('.')}`);
+        }
     }
-  }
-  /**
-   * When initializing new context, we need to propagate it to the whole entity graph recursively.
-   */
-  static propagate(root, entity, isVisible) {
-    root.register(entity);
-    const meta = helper(entity).__meta;
-    for (const key of Object.keys(entity)) {
-      if (!isVisible(meta, key)) {
-        continue;
-      }
-      const target = entity[key];
-      if (Utils.isEntity(target, true)) {
-        if (!target.__helper.__serializationContext.root) {
-          this.propagate(root, target, isVisible);
+    /** Cleans up the serialization context by removing root references from all tracked entities. */
+    close() {
+        for (const entity of this.#entities) {
+            delete helper(entity).__serializationContext.root;
         }
-        continue;
-      }
-      if (Utils.isCollection(target)) {
-        for (const item of target.getItems(false)) {
-          if (!item.__helper.__serializationContext.root) {
-            this.propagate(root, item, isVisible);
-          }
+    }
+    /**
+     * When initializing new context, we need to propagate it to the whole entity graph recursively.
+     */
+    static propagate(root, entity, isVisible) {
+        root.register(entity);
+        const meta = helper(entity).__meta;
+        for (const key of Object.keys(entity)) {
+            if (!isVisible(meta, key)) {
+                continue;
+            }
+            const target = entity[key];
+            if (Utils.isEntity(target, true)) {
+                if (!target.__helper.__serializationContext.root) {
+                    this.propagate(root, target, isVisible);
+                }
+                continue;
+            }
+            if (Utils.isCollection(target)) {
+                for (const item of target.getItems(false)) {
+                    if (!item.__helper.__serializationContext.root) {
+                        this.propagate(root, item, isVisible);
+                    }
+                }
+            }
         }
-      }
     }
-  }
-  /** Checks whether a property is explicitly listed in the populate hints for the current path. */
-  isMarkedAsPopulated(entityName, prop) {
-    let populate = this.#populate ?? [];
-    for (const segment of this.path) {
-      const hints = populate.filter(p => p.field === segment[1]);
-      if (hints.length > 0) {
-        const childHints = [];
-        for (const hint of hints) {
-          // we need to check for cycles here too, as we could fall into endless loops for bidirectional relations
-          if (hint.all) {
-            return !this.path.find(([cls, item]) => entityName === cls && prop === item);
-          }
-          if (hint.children) {
-            childHints.push(...hint.children);
-          }
+    /** Checks whether a property is explicitly listed in the populate hints for the current path. */
+    isMarkedAsPopulated(entityName, prop) {
+        let populate = this.#populate ?? [];
+        for (const segment of this.path) {
+            const hints = populate.filter(p => p.field === segment[1]);
+            if (hints.length > 0) {
+                const childHints = [];
+                for (const hint of hints) {
+                    // we need to check for cycles here too, as we could fall into endless loops for bidirectional relations
+                    if (hint.all) {
+                        return !this.path.find(([cls, item]) => entityName === cls && prop === item);
+                    }
+                    if (hint.children) {
+                        childHints.push(...hint.children);
+                    }
+                }
+                populate = childHints;
+            }
         }
-        populate = childHints;
-      }
+        return !!populate?.some(p => p.field === prop);
     }
-    return !!populate?.some(p => p.field === prop);
-  }
-  /** Checks whether a property is excluded from serialization via the exclude list. */
-  isExcluded(entityName, prop) {
-    if (!this.#exclude || this.#exclude.length === 0) {
-      return false;
+    /** Checks whether a property is excluded from serialization via the exclude list. */
+    isExcluded(entityName, prop) {
+        if (!this.#exclude || this.#exclude.length === 0) {
+            return false;
+        }
+        const fullPath = this.path.map(segment => segment[1] + '.').join('') + prop;
+        return this.#exclude.includes(fullPath);
     }
-    const fullPath = this.path.map(segment => segment[1] + '.').join('') + prop;
-    return this.#exclude.includes(fullPath);
-  }
-  /** Checks whether a property is included in the partial fields selection for the current path. */
-  isPartiallyLoaded(entityName, prop) {
-    if (!this.#fields) {
-      return true;
+    /** Checks whether a property is included in the partial fields selection for the current path. */
+    isPartiallyLoaded(entityName, prop) {
+        if (!this.#fields) {
+            return true;
+        }
+        let fields = [...this.#fields];
+        for (const segment of this.path) {
+            /* v8 ignore next */
+            if (fields.length === 0) {
+                return true;
+            }
+            fields = fields
+                .filter(field => field.startsWith(`${segment[1]}.`) || field === '*')
+                .map(field => (field === '*' ? field : field.substring(segment[1].length + 1)));
+        }
+        return fields.some(p => p === prop || p === '*');
     }
-    let fields = [...this.#fields];
-    for (const segment of this.path) {
-      /* v8 ignore next */
-      if (fields.length === 0) {
-        return true;
-      }
-      fields = fields
-        .filter(field => field.startsWith(`${segment[1]}.`) || field === '*')
-        .map(field => (field === '*' ? field : field.substring(segment[1].length + 1)));
+    register(entity) {
+        helper(entity).__serializationContext.root = this;
+        this.#entities.add(entity);
     }
-    return fields.some(p => p === prop || p === '*');
-  }
-  register(entity) {
-    helper(entity).__serializationContext.root = this;
-    this.#entities.add(entity);
-  }
 }

package/types/ArrayType.d.ts

@@ -3,12 +3,12 @@ import type { EntityProperty } from '../typings.js';
 import type { Platform } from '../platforms/Platform.js';
 /** Maps a database text/array column to a JS array, using platform-specific marshalling (e.g., PostgreSQL arrays or comma-separated strings). */
 export declare class ArrayType<T = string> extends Type<T[] | null, string | null> {
-  private readonly toJsValue;
-  private readonly toDbValue;
-  constructor(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string);
-  convertToDatabaseValue(value: T[] | null, platform: Platform, context?: TransformContext): string | null;
-  convertToJSValue(value: T[] | string | null, platform: Platform): T[] | null;
-  compareAsType(): string;
-  toJSON(value: T[]): T[];
-  getColumnType(prop: EntityProperty, platform: Platform): string;
+    private readonly toJsValue;
+    private readonly toDbValue;
+    constructor(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string);
+    convertToDatabaseValue(value: T[] | null, platform: Platform, context?: TransformContext): string | null;
+    convertToJSValue(value: T[] | string | null, platform: Platform): T[] | null;
+    compareAsType(): string;
+    toJSON(value: T[]): T[];
+    getColumnType(prop: EntityProperty, platform: Platform): string;
 }

package/types/ArrayType.js

@@ -2,42 +2,42 @@ import { Type } from './Type.js';
 import { ValidationError } from '../errors.js';
 /** Maps a database text/array column to a JS array, using platform-specific marshalling (e.g., PostgreSQL arrays or comma-separated strings). */
 export class ArrayType extends Type {
-  toJsValue;
-  toDbValue;
-  constructor(toJsValue = i => i, toDbValue = i => i) {
-    super();
-    this.toJsValue = toJsValue;
-    this.toDbValue = toDbValue;
-  }
-  convertToDatabaseValue(value, platform, context) {
-    if (!value) {
-      return value;
+    toJsValue;
+    toDbValue;
+    constructor(toJsValue = i => i, toDbValue = i => i) {
+        super();
+        this.toJsValue = toJsValue;
+        this.toDbValue = toDbValue;
     }
-    if (Array.isArray(value)) {
-      return platform.marshallArray(value.map(i => this.toDbValue(i)));
+    convertToDatabaseValue(value, platform, context) {
+        if (!value) {
+            return value;
+        }
+        if (Array.isArray(value)) {
+            return platform.marshallArray(value.map(i => this.toDbValue(i)));
+        }
+        /* v8 ignore next */
+        if (context?.fromQuery) {
+            return value;
+        }
+        throw ValidationError.invalidType(ArrayType, value, 'JS');
     }
-    /* v8 ignore next */
-    if (context?.fromQuery) {
-      return value;
+    convertToJSValue(value, platform) {
+        if (value == null) {
+            return value;
+        }
+        if (typeof value === 'string') {
+            value = platform.unmarshallArray(value);
+        }
+        return value.map(i => this.toJsValue(i));
     }
-    throw ValidationError.invalidType(ArrayType, value, 'JS');
-  }
-  convertToJSValue(value, platform) {
-    if (value == null) {
-      return value;
+    compareAsType() {
+        return 'string[]';
     }
-    if (typeof value === 'string') {
-      value = platform.unmarshallArray(value);
+    toJSON(value) {
+        return value;
+    }
+    getColumnType(prop, platform) {
+        return platform.getArrayDeclarationSQL();
     }
-    return value.map(i => this.toJsValue(i));
-  }
-  compareAsType() {
-    return 'string[]';
-  }
-  toJSON(value) {
-    return value;
-  }
-  getColumnType(prop, platform) {
-    return platform.getArrayDeclarationSQL();
-  }
 }

package/types/BigIntType.d.ts

@@ -5,22 +5,15 @@ import type { EntityProperty } from '../typings.js';
  * This type will automatically convert string values returned from the database to native JS bigints (default)
  * or numbers (safe only for values up to `Number.MAX_SAFE_INTEGER`), or strings, depending on the `mode`.
  */
-export declare class BigIntType<Mode extends 'bigint' | 'number' | 'string' = 'bigint'> extends Type<
-  JSTypeByMode<Mode> | null | undefined,
-  string | null | undefined
-> {
-  mode?: Mode | undefined;
-  constructor(mode?: Mode | undefined);
-  convertToDatabaseValue(value: JSTypeByMode<Mode> | null | undefined): string | null | undefined;
-  convertToJSValue(value: string | bigint | null | undefined): JSTypeByMode<Mode> | null | undefined;
-  toJSON(value: JSTypeByMode<Mode> | null | undefined): JSTypeByMode<Mode> | null | undefined;
-  getColumnType(prop: EntityProperty, platform: Platform): string;
-  compareAsType(): string;
-  compareValues(a: string, b: string): boolean;
+export declare class BigIntType<Mode extends 'bigint' | 'number' | 'string' = 'bigint'> extends Type<JSTypeByMode<Mode> | null | undefined, string | null | undefined> {
+    mode?: Mode | undefined;
+    constructor(mode?: Mode | undefined);
+    convertToDatabaseValue(value: JSTypeByMode<Mode> | null | undefined): string | null | undefined;
+    convertToJSValue(value: string | bigint | null | undefined): JSTypeByMode<Mode> | null | undefined;
+    toJSON(value: JSTypeByMode<Mode> | null | undefined): JSTypeByMode<Mode> | null | undefined;
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    compareAsType(): string;
+    compareValues(a: string, b: string): boolean;
 }
-type JSTypeByMode<Mode extends 'bigint' | 'number' | 'string'> = Mode extends 'bigint'
-  ? bigint
-  : Mode extends 'number'
-    ? number
-    : string;
+type JSTypeByMode<Mode extends 'bigint' | 'number' | 'string'> = Mode extends 'bigint' ? bigint : Mode extends 'number' ? number : string;
 export {};

package/types/BigIntType.js

@@ -4,45 +4,45 @@ import { Type } from './Type.js';
  * or numbers (safe only for values up to `Number.MAX_SAFE_INTEGER`), or strings, depending on the `mode`.
  */
 export class BigIntType extends Type {
-  mode;
-  constructor(mode) {
-    super();
-    this.mode = mode;
-  }
-  convertToDatabaseValue(value) {
-    if (value == null) {
-      return value;
+    mode;
+    constructor(mode) {
+        super();
+        this.mode = mode;
     }
-    return '' + value;
-  }
-  convertToJSValue(value) {
-    /* v8 ignore next */
-    if (value == null) {
-      return value;
+    convertToDatabaseValue(value) {
+        if (value == null) {
+            return value;
+        }
+        return '' + value;
     }
-    switch (this.mode) {
-      case 'number':
-        return Number(value);
-      case 'string':
-        return String(value);
-      case 'bigint':
-      default:
-        return BigInt(String(value));
+    convertToJSValue(value) {
+        /* v8 ignore next */
+        if (value == null) {
+            return value;
+        }
+        switch (this.mode) {
+            case 'number':
+                return Number(value);
+            case 'string':
+                return String(value);
+            case 'bigint':
+            default:
+                return BigInt(String(value));
+        }
     }
-  }
-  toJSON(value) {
-    if (this.mode === 'number') {
-      return value;
+    toJSON(value) {
+        if (this.mode === 'number') {
+            return value;
+        }
+        return this.convertToDatabaseValue(value);
+    }
+    getColumnType(prop, platform) {
+        return platform.getBigIntTypeDeclarationSQL(prop);
+    }
+    compareAsType() {
+        return this.mode ?? 'bigint';
+    }
+    compareValues(a, b) {
+        return String(a) === String(b);
     }
-    return this.convertToDatabaseValue(value);
-  }
-  getColumnType(prop, platform) {
-    return platform.getBigIntTypeDeclarationSQL(prop);
-  }
-  compareAsType() {
-    return this.mode ?? 'bigint';
-  }
-  compareValues(a, b) {
-    return String(a) === String(b);
-  }
 }

package/types/BlobType.d.ts

@@ -3,7 +3,7 @@ import type { Platform } from '../platforms/Platform.js';
 import type { EntityProperty } from '../typings.js';
 /** Maps a database BLOB/BYTEA column to a Node.js `Buffer`. */
 export declare class BlobType extends Uint8ArrayType {
-  convertToJSValue(value: Buffer): Buffer | null;
-  compareAsType(): string;
-  getColumnType(prop: EntityProperty, platform: Platform): string;
+    convertToJSValue(value: Buffer): Buffer | null;
+    compareAsType(): string;
+    getColumnType(prop: EntityProperty, platform: Platform): string;
 }

package/types/BlobType.js

@@ -1,19 +1,19 @@
 import { Uint8ArrayType } from './Uint8ArrayType.js';
 /** Maps a database BLOB/BYTEA column to a Node.js `Buffer`. */
 export class BlobType extends Uint8ArrayType {
-  convertToJSValue(value) {
-    if (value instanceof Buffer || !value) {
-      return value;
+    convertToJSValue(value) {
+        if (value instanceof Buffer || !value) {
+            return value;
+        }
+        if (value.buffer instanceof Buffer) {
+            return value.buffer;
+        }
+        return Buffer.from(value);
     }
-    if (value.buffer instanceof Buffer) {
-      return value.buffer;
+    compareAsType() {
+        return 'Buffer';
+    }
+    getColumnType(prop, platform) {
+        return platform.getBlobDeclarationSQL();
     }
-    return Buffer.from(value);
-  }
-  compareAsType() {
-    return 'Buffer';
-  }
-  getColumnType(prop, platform) {
-    return platform.getBlobDeclarationSQL();
-  }
 }

package/types/BooleanType.d.ts

@@ -3,8 +3,8 @@ import type { Platform } from '../platforms/Platform.js';
 import type { EntityProperty } from '../typings.js';
 /** Maps a database BOOLEAN/TINYINT(1) column to a JS `boolean`. */
 export declare class BooleanType extends Type<boolean | null | undefined, boolean | null | undefined> {
-  getColumnType(prop: EntityProperty, platform: Platform): string;
-  compareAsType(): string;
-  convertToJSValue(value: boolean | null | undefined): boolean | null | undefined;
-  ensureComparable(): boolean;
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    compareAsType(): string;
+    convertToJSValue(value: boolean | null | undefined): boolean | null | undefined;
+    ensureComparable(): boolean;
 }

package/types/BooleanType.js

@@ -1,16 +1,16 @@
 import { Type } from './Type.js';
 /** Maps a database BOOLEAN/TINYINT(1) column to a JS `boolean`. */
 export class BooleanType extends Type {
-  getColumnType(prop, platform) {
-    return platform.getBooleanTypeDeclarationSQL();
-  }
-  compareAsType() {
-    return 'boolean';
-  }
-  convertToJSValue(value) {
-    return Boolean(value);
-  }
-  ensureComparable() {
-    return false;
-  }
+    getColumnType(prop, platform) {
+        return platform.getBooleanTypeDeclarationSQL();
+    }
+    compareAsType() {
+        return 'boolean';
+    }
+    convertToJSValue(value) {
+        return Boolean(value);
+    }
+    ensureComparable() {
+        return false;
+    }
 }

package/types/CharacterType.d.ts

@@ -3,6 +3,6 @@ import type { Platform } from '../platforms/Platform.js';
 import type { EntityProperty } from '../typings.js';
 /** Maps a database CHAR (fixed-length) column to a JS `string`. */
 export declare class CharacterType extends StringType {
-  getColumnType(prop: EntityProperty, platform: Platform): string;
-  getDefaultLength(platform: Platform): number;
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    getDefaultLength(platform: Platform): number;
 }

package/types/CharacterType.js

@@ -1,10 +1,10 @@
 import { StringType } from './StringType.js';
 /** Maps a database CHAR (fixed-length) column to a JS `string`. */
 export class CharacterType extends StringType {
-  getColumnType(prop, platform) {
-    return platform.getCharTypeDeclarationSQL(prop);
-  }
-  getDefaultLength(platform) {
-    return platform.getDefaultCharLength();
-  }
+    getColumnType(prop, platform) {
+        return platform.getCharTypeDeclarationSQL(prop);
+    }
+    getDefaultLength(platform) {
+        return platform.getDefaultCharLength();
+    }
 }

package/types/DateTimeType.d.ts

@@ -3,9 +3,9 @@ import type { Platform } from '../platforms/Platform.js';
 import type { EntityProperty } from '../typings.js';
 /** Maps a database DATETIME/TIMESTAMP column to a JS `Date` object. */
 export declare class DateTimeType extends Type<Date, string> {
-  getColumnType(prop: EntityProperty, platform: Platform): string;
-  compareAsType(): string;
-  get runtimeType(): string;
-  ensureComparable(): boolean;
-  getDefaultLength(platform: Platform): number;
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    compareAsType(): string;
+    get runtimeType(): string;
+    ensureComparable(): boolean;
+    getDefaultLength(platform: Platform): number;
 }

package/types/DateTimeType.js

@@ -1,19 +1,19 @@
 import { Type } from './Type.js';
 /** Maps a database DATETIME/TIMESTAMP column to a JS `Date` object. */
 export class DateTimeType extends Type {
-  getColumnType(prop, platform) {
-    return platform.getDateTimeTypeDeclarationSQL({ length: prop.length });
-  }
-  compareAsType() {
-    return 'Date';
-  }
-  get runtimeType() {
-    return 'Date';
-  }
-  ensureComparable() {
-    return false;
-  }
-  getDefaultLength(platform) {
-    return platform.getDefaultDateTimeLength();
-  }
+    getColumnType(prop, platform) {
+        return platform.getDateTimeTypeDeclarationSQL({ length: prop.length });
+    }
+    compareAsType() {
+        return 'Date';
+    }
+    get runtimeType() {
+        return 'Date';
+    }
+    ensureComparable() {
+        return false;
+    }
+    getDefaultLength(platform) {
+        return platform.getDefaultDateTimeLength();
+    }
 }

package/types/DateType.d.ts

@@ -3,9 +3,9 @@ import type { Platform } from '../platforms/Platform.js';
 import type { EntityProperty } from '../typings.js';
 /** Maps a database DATE column (date without time) to a JS `string` in YYYY-MM-DD format. */
 export declare class DateType extends Type<string | null | undefined, string | null | undefined> {
-  compareAsType(): string;
-  ensureComparable(): boolean;
-  convertToJSValue(value: any, platform: Platform): string | null | undefined;
-  getColumnType(prop: EntityProperty, platform: Platform): string;
-  getDefaultLength(platform: Platform): number;
+    compareAsType(): string;
+    ensureComparable(): boolean;
+    convertToJSValue(value: any, platform: Platform): string | null | undefined;
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    getDefaultLength(platform: Platform): number;
 }