@mikro-orm/core 7.0.4 → 7.0.5-dev.1

package/types/TimeType.js

@@ -2,22 +2,22 @@ import { Type } from './Type.js';
 import { ValidationError } from '../errors.js';
 /** Maps a database TIME column to a JS `string` in HH:MM:SS format. */
 export class TimeType extends Type {
-  convertToDatabaseValue(value, platform) {
-    if (value && !value.toString().match(/^\d{2,}:(?:[0-5]\d):(?:[0-5]\d)$/)) {
-      throw ValidationError.invalidType(TimeType, value, 'JS');
+    convertToDatabaseValue(value, platform) {
+        if (value && !value.toString().match(/^\d{2,}:(?:[0-5]\d):(?:[0-5]\d)$/)) {
+            throw ValidationError.invalidType(TimeType, value, 'JS');
+        }
+        return super.convertToDatabaseValue(value, platform);
+    }
+    compareAsType() {
+        return 'string';
+    }
+    ensureComparable() {
+        return false;
+    }
+    getColumnType(prop, platform) {
+        return platform.getTimeTypeDeclarationSQL(prop.length);
+    }
+    getDefaultLength(platform) {
+        return platform.getDefaultDateTimeLength();
     }
-    return super.convertToDatabaseValue(value, platform);
-  }
-  compareAsType() {
-    return 'string';
-  }
-  ensureComparable() {
-    return false;
-  }
-  getColumnType(prop, platform) {
-    return platform.getTimeTypeDeclarationSQL(prop.length);
-  }
-  getDefaultLength(platform) {
-    return platform.getDefaultDateTimeLength();
-  }
 }

package/types/TinyIntType.d.ts

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

package/types/TinyIntType.js

@@ -1,14 +1,14 @@
 import { Type } from './Type.js';
 /** Maps a database TINYINT column to a JS `number`. */
 export class TinyIntType extends Type {
-  getColumnType(prop, platform) {
-    return platform.getTinyIntTypeDeclarationSQL(prop);
-  }
-  compareAsType() {
-    return 'number';
-  }
-  /* v8 ignore next */
-  ensureComparable() {
-    return false;
-  }
+    getColumnType(prop, platform) {
+        return platform.getTinyIntTypeDeclarationSQL(prop);
+    }
+    compareAsType() {
+        return 'number';
+    }
+    /* v8 ignore next */
+    ensureComparable() {
+        return false;
+    }
 }

package/types/Type.d.ts

@@ -4,93 +4,89 @@ import type { Constructor, EntityMetadata, EntityProperty } from '../typings.js'
 export declare const ORM_TYPE: unique symbol;
 /** Context passed to type conversion methods, indicating the conversion mode and source. */
 export interface TransformContext {
-  fromQuery?: boolean;
-  force?: boolean;
-  key?: string;
-  mode?: 'hydration' | 'query' | 'query-data' | 'discovery' | 'serialization';
+    fromQuery?: boolean;
+    force?: boolean;
+    key?: string;
+    mode?: 'hydration' | 'query' | 'query-data' | 'discovery' | 'serialization';
 }
 /** Branded type helper for mapping between JS runtime, database raw, and JSON serialized representations. */
 export type IType<Runtime, Raw, Serialized = Raw> = Runtime & {
-  __raw?: Raw;
-  __runtime?: Runtime;
-  __serialized?: Serialized;
+    __raw?: Raw;
+    __runtime?: Runtime;
+    __serialized?: Serialized;
 };
 /** Abstract base class for custom property types that handle conversion between JS and database representations. */
 export declare abstract class Type<JSType = string, DBType = JSType> {
-  private static readonly types;
-  platform?: Platform;
-  meta?: EntityMetadata;
-  prop?: EntityProperty;
-  /**
-   * Converts a value from its JS representation to its database representation of this type.
-   */
-  convertToDatabaseValue(value: JSType, platform: Platform, context?: TransformContext): DBType;
-  /**
-   * Converts a value from its database representation to its JS representation of this type.
-   */
-  convertToJSValue(value: DBType, platform: Platform, context?: TransformContext): JSType;
-  /**
-   * Converts a value from its JS representation to its database representation of this type.
-   */
-  convertToDatabaseValueSQL?(key: string, platform: Platform): string;
-  /**
-   * Modifies the SQL expression (identifier, parameter) to convert to a JS value.
-   */
-  convertToJSValueSQL?(key: string, platform: Platform): string;
-  /**
-   * How should the raw database values be compared? Used in `EntityComparator`.
-   * Possible values: string | number | bigint | boolean | date | any | buffer | array
-   */
-  compareAsType(): string;
-  /**
-   * Allows to override the internal comparison logic.
-   */
-  compareValues?(a: DBType, b: DBType): boolean;
-  get runtimeType(): string;
-  get name(): string;
-  /**
-   * When a value is hydrated, we convert it back to the database value to ensure comparability,
-   * as often the raw database response is not the same as the `convertToDatabaseValue` result.
-   * This allows to disable the additional conversion in case you know it is not needed.
-   */
-  ensureComparable<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T>): boolean;
-  /**
-   * Converts a value from its JS representation to its serialized JSON form of this type.
-   * By default uses the runtime value.
-   */
-  toJSON(value: JSType, platform: Platform): JSType | DBType;
-  /**
-   * Gets the SQL declaration snippet for a field of this type.
-   */
-  getColumnType(prop: EntityProperty, platform: Platform): string;
-  /**
-   * Get the default length for values of this type
-   *
-   * When doing schema generation, if neither "length" nor "columnType" option is provided,
-   * the length will be defaulted to this value.
-   *
-   * When doing entity generation, if the type is recognized to this type, and the inferred length is this value,
-   * the length option will be omitted in the output. If this method is not defined, length is always outputted
-   * based on what is in the database metadata.
-   *
-   * @param platform The platform the default will be used for.
-   *
-   * @return The default value for the given platform.
-   */
-  getDefaultLength?(platform: Platform): number;
-  static getType<
-    JSType,
-    DBType = JSType,
-    TypeClass extends Constructor<Type<JSType, DBType>> = Constructor<Type<JSType, DBType>>,
-  >(cls: TypeClass): InstanceType<TypeClass>;
-  /**
-   * Checks whether the argument is instance of `Type`.
-   */
-  static isMappedType(data: any): data is Type<any>;
-  /**
-   * @internal
-   * Returns the built-in type registry key if the given constructor is a branded ORM type
-   * (not a user subclass). Uses `Symbol.for()` so it works across CJS/ESM module graphs.
-   */
-  static getOrmType(cls: object): string | undefined;
+    private static readonly types;
+    platform?: Platform;
+    meta?: EntityMetadata;
+    prop?: EntityProperty;
+    /**
+     * Converts a value from its JS representation to its database representation of this type.
+     */
+    convertToDatabaseValue(value: JSType, platform: Platform, context?: TransformContext): DBType;
+    /**
+     * Converts a value from its database representation to its JS representation of this type.
+     */
+    convertToJSValue(value: DBType, platform: Platform, context?: TransformContext): JSType;
+    /**
+     * Converts a value from its JS representation to its database representation of this type.
+     */
+    convertToDatabaseValueSQL?(key: string, platform: Platform): string;
+    /**
+     * Modifies the SQL expression (identifier, parameter) to convert to a JS value.
+     */
+    convertToJSValueSQL?(key: string, platform: Platform): string;
+    /**
+     * How should the raw database values be compared? Used in `EntityComparator`.
+     * Possible values: string | number | bigint | boolean | date | any | buffer | array
+     */
+    compareAsType(): string;
+    /**
+     * Allows to override the internal comparison logic.
+     */
+    compareValues?(a: DBType, b: DBType): boolean;
+    get runtimeType(): string;
+    get name(): string;
+    /**
+     * When a value is hydrated, we convert it back to the database value to ensure comparability,
+     * as often the raw database response is not the same as the `convertToDatabaseValue` result.
+     * This allows to disable the additional conversion in case you know it is not needed.
+     */
+    ensureComparable<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T>): boolean;
+    /**
+     * Converts a value from its JS representation to its serialized JSON form of this type.
+     * By default uses the runtime value.
+     */
+    toJSON(value: JSType, platform: Platform): JSType | DBType;
+    /**
+     * Gets the SQL declaration snippet for a field of this type.
+     */
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    /**
+     * Get the default length for values of this type
+     *
+     * When doing schema generation, if neither "length" nor "columnType" option is provided,
+     * the length will be defaulted to this value.
+     *
+     * When doing entity generation, if the type is recognized to this type, and the inferred length is this value,
+     * the length option will be omitted in the output. If this method is not defined, length is always outputted
+     * based on what is in the database metadata.
+     *
+     * @param platform The platform the default will be used for.
+     *
+     * @return The default value for the given platform.
+     */
+    getDefaultLength?(platform: Platform): number;
+    static getType<JSType, DBType = JSType, TypeClass extends Constructor<Type<JSType, DBType>> = Constructor<Type<JSType, DBType>>>(cls: TypeClass): InstanceType<TypeClass>;
+    /**
+     * Checks whether the argument is instance of `Type`.
+     */
+    static isMappedType(data: any): data is Type<any>;
+    /**
+     * @internal
+     * Returns the built-in type registry key if the given constructor is a branded ORM type
+     * (not a user subclass). Uses `Symbol.for()` so it works across CJS/ESM module graphs.
+     */
+    static getOrmType(cls: object): string | undefined;
 }

package/types/Type.js

@@ -3,89 +3,89 @@ import { inspect } from '../logging/inspect.js';
 export const ORM_TYPE = Symbol.for('@mikro-orm/type');
 /** Abstract base class for custom property types that handle conversion between JS and database representations. */
 export class Type {
-  static types = new Map();
-  platform;
-  meta;
-  prop;
-  /**
-   * Converts a value from its JS representation to its database representation of this type.
-   */
-  convertToDatabaseValue(value, platform, context) {
-    return value;
-  }
-  /**
-   * Converts a value from its database representation to its JS representation of this type.
-   */
-  convertToJSValue(value, platform, context) {
-    return value;
-  }
-  /**
-   * How should the raw database values be compared? Used in `EntityComparator`.
-   * Possible values: string | number | bigint | boolean | date | any | buffer | array
-   */
-  compareAsType() {
-    return 'any';
-  }
-  get runtimeType() {
-    const compareType = this.compareAsType();
-    return compareType === 'any' ? 'string' : compareType;
-  }
-  get name() {
-    return this.constructor.name;
-  }
-  /**
-   * When a value is hydrated, we convert it back to the database value to ensure comparability,
-   * as often the raw database response is not the same as the `convertToDatabaseValue` result.
-   * This allows to disable the additional conversion in case you know it is not needed.
-   */
-  ensureComparable(meta, prop) {
-    return true;
-  }
-  /**
-   * Converts a value from its JS representation to its serialized JSON form of this type.
-   * By default uses the runtime value.
-   */
-  toJSON(value, platform) {
-    return value;
-  }
-  /**
-   * Gets the SQL declaration snippet for a field of this type.
-   */
-  getColumnType(prop, platform) {
-    return prop.columnTypes?.[0] ?? platform.getTextTypeDeclarationSQL(prop);
-  }
-  static getType(cls) {
-    const key = cls.name;
-    if (!Type.types.has(key)) {
-      Type.types.set(key, new cls());
+    static types = new Map();
+    platform;
+    meta;
+    prop;
+    /**
+     * Converts a value from its JS representation to its database representation of this type.
+     */
+    convertToDatabaseValue(value, platform, context) {
+        return value;
+    }
+    /**
+     * Converts a value from its database representation to its JS representation of this type.
+     */
+    convertToJSValue(value, platform, context) {
+        return value;
+    }
+    /**
+     * How should the raw database values be compared? Used in `EntityComparator`.
+     * Possible values: string | number | bigint | boolean | date | any | buffer | array
+     */
+    compareAsType() {
+        return 'any';
+    }
+    get runtimeType() {
+        const compareType = this.compareAsType();
+        return compareType === 'any' ? 'string' : compareType;
+    }
+    get name() {
+        return this.constructor.name;
+    }
+    /**
+     * When a value is hydrated, we convert it back to the database value to ensure comparability,
+     * as often the raw database response is not the same as the `convertToDatabaseValue` result.
+     * This allows to disable the additional conversion in case you know it is not needed.
+     */
+    ensureComparable(meta, prop) {
+        return true;
+    }
+    /**
+     * Converts a value from its JS representation to its serialized JSON form of this type.
+     * By default uses the runtime value.
+     */
+    toJSON(value, platform) {
+        return value;
+    }
+    /**
+     * Gets the SQL declaration snippet for a field of this type.
+     */
+    getColumnType(prop, platform) {
+        return prop.columnTypes?.[0] ?? platform.getTextTypeDeclarationSQL(prop);
+    }
+    static getType(cls) {
+        const key = cls.name;
+        if (!Type.types.has(key)) {
+            Type.types.set(key, new cls());
+        }
+        return Type.types.get(key);
+    }
+    /**
+     * Checks whether the argument is instance of `Type`.
+     */
+    static isMappedType(data) {
+        return !!data?.__mappedType;
+    }
+    /**
+     * @internal
+     * Returns the built-in type registry key if the given constructor is a branded ORM type
+     * (not a user subclass). Uses `Symbol.for()` so it works across CJS/ESM module graphs.
+     */
+    static getOrmType(cls) {
+        return Object.hasOwn(cls, ORM_TYPE) ? cls[ORM_TYPE] : undefined;
+    }
+    /** @ignore */
+    [Symbol.for('nodejs.util.inspect.custom')](depth = 2) {
+        const object = { ...this };
+        const hidden = ['prop', 'platform', 'meta'];
+        hidden.forEach(k => delete object[k]);
+        const ret = inspect(object, { depth });
+        const name = this.constructor.name;
+        /* v8 ignore next */
+        return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
     }
-    return Type.types.get(key);
-  }
-  /**
-   * Checks whether the argument is instance of `Type`.
-   */
-  static isMappedType(data) {
-    return !!data?.__mappedType;
-  }
-  /**
-   * @internal
-   * Returns the built-in type registry key if the given constructor is a branded ORM type
-   * (not a user subclass). Uses `Symbol.for()` so it works across CJS/ESM module graphs.
-   */
-  static getOrmType(cls) {
-    return Object.hasOwn(cls, ORM_TYPE) ? cls[ORM_TYPE] : undefined;
-  }
-  /** @ignore */
-  [Symbol.for('nodejs.util.inspect.custom')](depth = 2) {
-    const object = { ...this };
-    const hidden = ['prop', 'platform', 'meta'];
-    hidden.forEach(k => delete object[k]);
-    const ret = inspect(object, { depth });
-    const name = this.constructor.name;
-    /* v8 ignore next */
-    return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
-  }
 }
 Object.defineProperties(Type.prototype, {
-  __mappedType: { value: true, enumerable: false, writable: false },
+    __mappedType: { value: true, enumerable: false, writable: false },
 });

package/types/Uint8ArrayType.d.ts

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

package/types/Uint8ArrayType.js

@@ -1,29 +1,29 @@
 import { Type } from './Type.js';
 /** Maps a database BLOB/BYTEA column to a JS `Uint8Array`. */
 export class Uint8ArrayType extends Type {
-  convertToDatabaseValue(value) {
-    if (!value) {
-      return value;
+    convertToDatabaseValue(value) {
+        if (!value) {
+            return value;
+        }
+        return Buffer.from(value);
     }
-    return Buffer.from(value);
-  }
-  convertToJSValue(value) {
-    /* v8 ignore next */
-    if (!value) {
-      return value;
+    convertToJSValue(value) {
+        /* v8 ignore next */
+        if (!value) {
+            return value;
+        }
+        if (value instanceof Buffer) {
+            return new Uint8Array(value);
+        }
+        if (value.buffer instanceof Buffer) {
+            return new Uint8Array(value.buffer);
+        }
+        return new Uint8Array(Buffer.from(value));
     }
-    if (value instanceof Buffer) {
-      return new Uint8Array(value);
+    compareAsType() {
+        return 'Buffer';
     }
-    if (value.buffer instanceof Buffer) {
-      return new Uint8Array(value.buffer);
+    getColumnType(prop, platform) {
+        return platform.getBlobDeclarationSQL();
     }
-    return new Uint8Array(Buffer.from(value));
-  }
-  compareAsType() {
-    return 'Buffer';
-  }
-  getColumnType(prop, platform) {
-    return platform.getBlobDeclarationSQL();
-  }
 }

package/types/UnknownType.d.ts

@@ -3,8 +3,8 @@ import type { Platform } from '../platforms/Platform.js';
 import { Type } from './Type.js';
 /** Passthrough type that performs no conversion, used when the column type is unknown or unrecognized. */
 export declare class UnknownType extends Type<unknown | null | undefined, unknown | null | undefined> {
-  getColumnType(prop: EntityProperty, platform: Platform): string;
-  get runtimeType(): string;
-  compareAsType(): string;
-  ensureComparable(): boolean;
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    get runtimeType(): string;
+    compareAsType(): string;
+    ensureComparable(): boolean;
 }

package/types/UnknownType.js

@@ -1,16 +1,16 @@
 import { Type } from './Type.js';
 /** Passthrough type that performs no conversion, used when the column type is unknown or unrecognized. */
 export class UnknownType extends Type {
-  getColumnType(prop, platform) {
-    return prop.columnTypes?.[0] ?? platform.getVarcharTypeDeclarationSQL(prop);
-  }
-  get runtimeType() {
-    return 'unknown';
-  }
-  compareAsType() {
-    return 'unknown';
-  }
-  ensureComparable() {
-    return false;
-  }
+    getColumnType(prop, platform) {
+        return prop.columnTypes?.[0] ?? platform.getVarcharTypeDeclarationSQL(prop);
+    }
+    get runtimeType() {
+        return 'unknown';
+    }
+    compareAsType() {
+        return 'unknown';
+    }
+    ensureComparable() {
+        return false;
+    }
 }

package/types/UuidType.d.ts

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

package/types/UuidType.js

@@ -1,25 +1,25 @@
 import { Type } from './Type.js';
 /** Maps a database UUID column to a JS `string`, with platform-specific normalization. */
 export class UuidType extends Type {
-  getColumnType(prop, platform) {
-    return platform.getUuidTypeDeclarationSQL(prop);
-  }
-  compareAsType() {
-    return this.platform?.compareUuids() ?? 'string';
-  }
-  convertToDatabaseValue(value, platform) {
-    if (value == null) {
-      return value;
+    getColumnType(prop, platform) {
+        return platform.getUuidTypeDeclarationSQL(prop);
     }
-    return platform.convertUuidToDatabaseValue(value);
-  }
-  convertToJSValue(value, platform) {
-    if (value == null) {
-      return value;
+    compareAsType() {
+        return this.platform?.compareUuids() ?? 'string';
+    }
+    convertToDatabaseValue(value, platform) {
+        if (value == null) {
+            return value;
+        }
+        return platform.convertUuidToDatabaseValue(value);
+    }
+    convertToJSValue(value, platform) {
+        if (value == null) {
+            return value;
+        }
+        return platform.convertUuidToJSValue(value);
+    }
+    ensureComparable() {
+        return this.platform?.compareUuids() !== 'string';
     }
-    return platform.convertUuidToJSValue(value);
-  }
-  ensureComparable() {
-    return this.platform?.compareUuids() !== 'string';
-  }
 }