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

package/types/TimeType.d.ts

@@ -1,10 +1,11 @@
 import { Type } from './Type.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { EntityProperty } from '../typings.js';
+/** Maps a database TIME column to a JS `string` in HH:MM:SS format. */
 export declare class TimeType extends Type {
-    convertToDatabaseValue(value: any, platform: Platform): string;
-    compareAsType(): string;
-    ensureComparable(): boolean;
-    getColumnType(prop: EntityProperty, platform: Platform): string;
-    getDefaultLength(platform: Platform): number;
+  convertToDatabaseValue(value: any, platform: Platform): string;
+  compareAsType(): string;
+  ensureComparable(): boolean;
+  getColumnType(prop: EntityProperty, platform: Platform): string;
+  getDefaultLength(platform: Platform): number;
 }

package/types/TimeType.js

@@ -1,22 +1,23 @@
 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');
-        }
-        return super.convertToDatabaseValue(value, platform);
-    }
-    compareAsType() {
-        return 'string';
-    }
-    ensureComparable() {
-        return false;
-    }
-    getColumnType(prop, platform) {
-        return platform.getTimeTypeDeclarationSQL(prop.length);
-    }
-    getDefaultLength(platform) {
-        return platform.getDefaultDateTimeLength();
+  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();
+  }
 }

package/types/TinyIntType.d.ts

@@ -1,8 +1,9 @@
 import { Type } from './Type.js';
 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,13 +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

@@ -1,81 +1,96 @@
 import type { Platform } from '../platforms/Platform.js';
 import type { Constructor, EntityMetadata, EntityProperty } from '../typings.js';
+/** @internal */
+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>;
+  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

@@ -1,80 +1,91 @@
 import { inspect } from '../logging/inspect.js';
+/** @internal */
+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());
-        }
-        return Type.types.get(key);
-    }
-    /**
-     * Checks whether the argument is instance of `Type`.
-     */
-    static isMappedType(data) {
-        return !!data?.__mappedType;
-    }
-    /** @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;
+  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;
+  }
 }
 Object.defineProperties(Type.prototype, {
-    __mappedType: { value: true, enumerable: false, writable: false },
+  __mappedType: { value: true, enumerable: false, writable: false },
 });

package/types/Uint8ArrayType.d.ts

@@ -1,9 +1,10 @@
 import { Type } from './Type.js';
 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,28 +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;
-        }
-        return Buffer.from(value);
+  convertToDatabaseValue(value) {
+    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));
+    return Buffer.from(value);
+  }
+  convertToJSValue(value) {
+    /* v8 ignore next */
+    if (!value) {
+      return value;
     }
-    compareAsType() {
-        return 'Buffer';
+    if (value instanceof Buffer) {
+      return new Uint8Array(value);
     }
-    getColumnType(prop, platform) {
-        return platform.getBlobDeclarationSQL();
+    if (value.buffer instanceof Buffer) {
+      return new Uint8Array(value.buffer);
     }
+    return new Uint8Array(Buffer.from(value));
+  }
+  compareAsType() {
+    return 'Buffer';
+  }
+  getColumnType(prop, platform) {
+    return platform.getBlobDeclarationSQL();
+  }
 }

package/types/UnknownType.d.ts

@@ -1,9 +1,10 @@
 import type { EntityProperty } from '../typings.js';
 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,15 +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

@@ -1,10 +1,11 @@
 import { Type } from './Type.js';
 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,24 +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);
+  getColumnType(prop, platform) {
+    return platform.getUuidTypeDeclarationSQL(prop);
+  }
+  compareAsType() {
+    return this.platform?.compareUuids() ?? 'string';
+  }
+  convertToDatabaseValue(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.convertUuidToDatabaseValue(value);
+  }
+  convertToJSValue(value, platform) {
+    if (value == null) {
+      return value;
     }
+    return platform.convertUuidToJSValue(value);
+  }
+  ensureComparable() {
+    return this.platform?.compareUuids() !== 'string';
+  }
 }