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

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;
+  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;
     }
-    /**
-     * 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;
+    // check if the path is explicitly populated
+    if (!this.isMarkedAsPopulated(entityName, prop)) {
+      return true;
     }
-    /** 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('.')}`);
-        }
+    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('.')}`);
     }
-    /** 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;
-        }
+  }
+  /** 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;
     }
-    /**
-     * 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);
-                    }
-                }
-            }
+  }
+  /**
+   * 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);
         }
-    }
-    /** 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;
-            }
+        continue;
+      }
+      if (Utils.isCollection(target)) {
+        for (const item of target.getItems(false)) {
+          if (!item.__helper.__serializationContext.root) {
+            this.propagate(root, item, isVisible);
+          }
         }
-        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 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);
+          }
         }
-        const fullPath = this.path.map(segment => segment[1] + '.').join('') + prop;
-        return this.#exclude.includes(fullPath);
+        populate = childHints;
+      }
     }
-    /** 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 === '*');
+    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;
+    }
+    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;
     }
-    register(entity) {
-        helper(entity).__serializationContext.root = this;
-        this.#entities.add(entity);
+    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 === '*');
+  }
+  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;
+  toJsValue;
+  toDbValue;
+  constructor(toJsValue = i => i, toDbValue = i => i) {
+    super();
+    this.toJsValue = toJsValue;
+    this.toDbValue = toDbValue;
+  }
+  convertToDatabaseValue(value, platform, context) {
+    if (!value) {
+      return value;
     }
-    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');
+    if (Array.isArray(value)) {
+      return platform.marshallArray(value.map(i => this.toDbValue(i)));
     }
-    convertToJSValue(value, platform) {
-        if (value == null) {
-            return value;
-        }
-        if (typeof value === 'string') {
-            value = platform.unmarshallArray(value);
-        }
-        return value.map(i => this.toJsValue(i));
+    /* v8 ignore next */
+    if (context?.fromQuery) {
+      return value;
     }
-    compareAsType() {
-        return 'string[]';
+    throw ValidationError.invalidType(ArrayType, value, 'JS');
+  }
+  convertToJSValue(value, platform) {
+    if (value == null) {
+      return value;
     }
-    toJSON(value) {
-        return value;
-    }
-    getColumnType(prop, platform) {
-        return platform.getArrayDeclarationSQL();
+    if (typeof value === 'string') {
+      value = platform.unmarshallArray(value);
     }
+    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,15 +5,22 @@ 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;
+  mode;
+  constructor(mode) {
+    super();
+    this.mode = mode;
+  }
+  convertToDatabaseValue(value) {
+    if (value == null) {
+      return value;
     }
-    convertToDatabaseValue(value) {
-        if (value == null) {
-            return value;
-        }
-        return '' + value;
+    return '' + value;
+  }
+  convertToJSValue(value) {
+    /* v8 ignore next */
+    if (value == null) {
+      return 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));
-        }
+    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;
-        }
-        return this.convertToDatabaseValue(value);
-    }
-    getColumnType(prop, platform) {
-        return platform.getBigIntTypeDeclarationSQL(prop);
-    }
-    compareAsType() {
-        return this.mode ?? 'bigint';
-    }
-    compareValues(a, b) {
-        return String(a) === String(b);
+  }
+  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);
+  }
 }

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;
-        }
-        if (value.buffer instanceof Buffer) {
-            return value.buffer;
-        }
-        return Buffer.from(value);
+  convertToJSValue(value) {
+    if (value instanceof Buffer || !value) {
+      return value;
     }
-    compareAsType() {
-        return 'Buffer';
-    }
-    getColumnType(prop, platform) {
-        return platform.getBlobDeclarationSQL();
+    if (value.buffer instanceof Buffer) {
+      return value.buffer;
     }
+    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;
 }