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

package/index.d.ts

@@ -2,122 +2,8 @@
  * @packageDocumentation
  * @module core
  */
-export {
-  EntityMetadata,
-  PrimaryKeyProp,
-  EntityRepositoryType,
-  OptionalProps,
-  EagerProps,
-  HiddenProps,
-  Config,
-  EntityName,
-} from './typings.js';
-export type {
-  CompiledFunctions,
-  Constructor,
-  ConnectionType,
-  Dictionary,
-  Primary,
-  IPrimaryKey,
-  ObjectQuery,
-  FilterQuery,
-  IWrappedEntity,
-  InferEntityName,
-  EntityData,
-  Highlighter,
-  MaybePromise,
-  AnyEntity,
-  EntityClass,
-  EntityProperty,
-  PopulateOptions,
-  Populate,
-  Loaded,
-  New,
-  LoadedReference,
-  LoadedCollection,
-  IMigrator,
-  IMigrationGenerator,
-  MigratorEvent,
-  GetRepository,
-  MigrationObject,
-  DeepPartial,
-  PrimaryProperty,
-  Cast,
-  IsUnknown,
-  EntityDictionary,
-  EntityDTO,
-  EntityDTOFlat,
-  EntityDTOProp,
-  SerializeDTO,
-  MigrationDiff,
-  GenerateOptions,
-  FilterObject,
-  IMigrationRunner,
-  IEntityGenerator,
-  ISeedManager,
-  SeederObject,
-  IMigratorStorage,
-  RequiredEntityData,
-  CheckCallback,
-  IndexCallback,
-  FormulaCallback,
-  FormulaTable,
-  SchemaTable,
-  SchemaColumns,
-  SimpleColumnMeta,
-  Rel,
-  Ref,
-  ScalarRef,
-  EntityRef,
-  ISchemaGenerator,
-  MigrationInfo,
-  MigrateOptions,
-  MigrationResult,
-  MigrationRow,
-  EntityKey,
-  EntityValue,
-  EntityDataValue,
-  FilterKey,
-  EntityType,
-  FromEntityType,
-  Selected,
-  IsSubset,
-  EntityProps,
-  ExpandProperty,
-  ExpandScalar,
-  FilterItemValue,
-  ExpandQuery,
-  Scalar,
-  ExpandHint,
-  FilterValue,
-  MergeLoaded,
-  MergeSelected,
-  TypeConfig,
-  AnyString,
-  ClearDatabaseOptions,
-  CreateSchemaOptions,
-  EnsureDatabaseOptions,
-  UpdateSchemaOptions,
-  DropSchemaOptions,
-  RefreshDatabaseOptions,
-  AutoPath,
-  UnboxArray,
-  MetadataProcessor,
-  ImportsResolver,
-  RequiredNullable,
-  DefineConfig,
-  Opt,
-  Hidden,
-  EntitySchemaWithMeta,
-  InferEntity,
-  CheckConstraint,
-  GeneratedColumnCallback,
-  FilterDef,
-  EntityCtor,
-  Subquery,
-  PopulateHintOptions,
-  Prefixes,
-} from './typings.js';
+export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, EntityName, } from './typings.js';
+export type { CompiledFunctions, Constructor, ConnectionType, Dictionary, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, InferEntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, EntityDTOFlat, EntityDTOProp, SerializeDTO, MigrationDiff, GenerateOptions, FilterObject, IMigrationRunner, IEntityGenerator, ISeedManager, SeederObject, IMigratorStorage, RequiredEntityData, CheckCallback, IndexCallback, FormulaCallback, FormulaTable, SchemaTable, SchemaColumns, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, MigrationInfo, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, EntityType, FromEntityType, Selected, IsSubset, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, FilterValue, MergeLoaded, MergeSelected, TypeConfig, AnyString, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, RequiredNullable, DefineConfig, Opt, Hidden, EntitySchemaWithMeta, InferEntity, CheckConstraint, GeneratedColumnCallback, FilterDef, EntityCtor, Subquery, PopulateHintOptions, Prefixes, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';

package/index.js

@@ -2,16 +2,7 @@
  * @packageDocumentation
  * @module core
  */
-export {
-  EntityMetadata,
-  PrimaryKeyProp,
-  EntityRepositoryType,
-  OptionalProps,
-  EagerProps,
-  HiddenProps,
-  Config,
-  EntityName,
-} from './typings.js';
+export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, EntityName, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';

package/logging/DefaultLogger.d.ts

@@ -1,38 +1,36 @@
 import type { Logger, LoggerNamespace, LogContext, LoggerOptions } from './Logger.js';
 /** Default logger implementation with colored output, query formatting, and namespace-based filtering. */
 export declare class DefaultLogger implements Logger {
-  private readonly options;
-  debugMode: boolean | LoggerNamespace[];
-  readonly writer: (message: string) => void;
-  private readonly usesReplicas?;
-  private readonly highlighter?;
-  constructor(options: LoggerOptions);
-  /**
-   * @inheritDoc
-   */
-  log(namespace: LoggerNamespace, message: string, context?: LogContext): void;
-  /**
-   * @inheritDoc
-   */
-  error(namespace: LoggerNamespace, message: string, context?: LogContext): void;
-  /**
-   * @inheritDoc
-   */
-  warn(namespace: LoggerNamespace, message: string, context?: LogContext): void;
-  /**
-   * @inheritDoc
-   */
-  setDebugMode(debugMode: boolean | LoggerNamespace[]): void;
-  /** Checks whether logging is enabled for the given namespace, considering context overrides. */
-  isEnabled(namespace: LoggerNamespace, context?: LogContext): boolean;
-  /**
-   * @inheritDoc
-   */
-  logQuery(
-    context: {
-      query: string;
-    } & LogContext,
-  ): void;
-  /** Factory method for creating a new DefaultLogger instance. */
-  static create(this: void, options: LoggerOptions): DefaultLogger;
+    private readonly options;
+    debugMode: boolean | LoggerNamespace[];
+    readonly writer: (message: string) => void;
+    private readonly usesReplicas?;
+    private readonly highlighter?;
+    constructor(options: LoggerOptions);
+    /**
+     * @inheritDoc
+     */
+    log(namespace: LoggerNamespace, message: string, context?: LogContext): void;
+    /**
+     * @inheritDoc
+     */
+    error(namespace: LoggerNamespace, message: string, context?: LogContext): void;
+    /**
+     * @inheritDoc
+     */
+    warn(namespace: LoggerNamespace, message: string, context?: LogContext): void;
+    /**
+     * @inheritDoc
+     */
+    setDebugMode(debugMode: boolean | LoggerNamespace[]): void;
+    /** Checks whether logging is enabled for the given namespace, considering context overrides. */
+    isEnabled(namespace: LoggerNamespace, context?: LogContext): boolean;
+    /**
+     * @inheritDoc
+     */
+    logQuery(context: {
+        query: string;
+    } & LogContext): void;
+    /** Factory method for creating a new DefaultLogger instance. */
+    static create(this: void, options: LoggerOptions): DefaultLogger;
 }

package/logging/DefaultLogger.js

@@ -1,98 +1,98 @@
 import { colors } from './colors.js';
 /** Default logger implementation with colored output, query formatting, and namespace-based filtering. */
 export class DefaultLogger {
-  options;
-  debugMode;
-  writer;
-  usesReplicas;
-  highlighter;
-  constructor(options) {
-    this.options = options;
-    this.debugMode = this.options.debugMode ?? false;
-    this.writer = this.options.writer;
-    this.usesReplicas = this.options.usesReplicas;
-    this.highlighter = this.options.highlighter;
-  }
-  /**
-   * @inheritDoc
-   */
-  log(namespace, message, context) {
-    if (!this.isEnabled(namespace, context)) {
-      return;
+    options;
+    debugMode;
+    writer;
+    usesReplicas;
+    highlighter;
+    constructor(options) {
+        this.options = options;
+        this.debugMode = this.options.debugMode ?? false;
+        this.writer = this.options.writer;
+        this.usesReplicas = this.options.usesReplicas;
+        this.highlighter = this.options.highlighter;
     }
-    // clean up the whitespace
-    message = message.replace(/\n/g, '').replace(/ +/g, ' ').trim();
-    // use red for error levels
-    if (context?.level === 'error') {
-      message = colors.red(message);
+    /**
+     * @inheritDoc
+     */
+    log(namespace, message, context) {
+        if (!this.isEnabled(namespace, context)) {
+            return;
+        }
+        // clean up the whitespace
+        message = message.replace(/\n/g, '').replace(/ +/g, ' ').trim();
+        // use red for error levels
+        if (context?.level === 'error') {
+            message = colors.red(message);
+        }
+        // use yellow for warning levels
+        if (context?.level === 'warning') {
+            message = colors.yellow(message);
+        }
+        const label = context?.label ? colors.cyan(`(${context.label}) `) : '';
+        this.writer(colors.grey(`[${namespace}] `) + label + message);
     }
-    // use yellow for warning levels
-    if (context?.level === 'warning') {
-      message = colors.yellow(message);
+    /**
+     * @inheritDoc
+     */
+    error(namespace, message, context) {
+        this.log(namespace, message, { ...context, level: 'error' });
     }
-    const label = context?.label ? colors.cyan(`(${context.label}) `) : '';
-    this.writer(colors.grey(`[${namespace}] `) + label + message);
-  }
-  /**
-   * @inheritDoc
-   */
-  error(namespace, message, context) {
-    this.log(namespace, message, { ...context, level: 'error' });
-  }
-  /**
-   * @inheritDoc
-   */
-  warn(namespace, message, context) {
-    this.log(namespace, message, { ...context, level: 'warning' });
-  }
-  /**
-   * @inheritDoc
-   */
-  setDebugMode(debugMode) {
-    this.debugMode = debugMode;
-  }
-  /** Checks whether logging is enabled for the given namespace, considering context overrides. */
-  isEnabled(namespace, context) {
-    if (context?.enabled !== undefined) {
-      return context.enabled;
+    /**
+     * @inheritDoc
+     */
+    warn(namespace, message, context) {
+        this.log(namespace, message, { ...context, level: 'warning' });
     }
-    const debugMode = context?.debugMode ?? this.debugMode;
-    if (namespace === 'deprecated') {
-      const { ignoreDeprecations = false } = this.options;
-      return Array.isArray(ignoreDeprecations)
-        ? /* v8 ignore next */
-          !ignoreDeprecations.includes(context?.label ?? '')
-        : !ignoreDeprecations;
+    /**
+     * @inheritDoc
+     */
+    setDebugMode(debugMode) {
+        this.debugMode = debugMode;
     }
-    return !!debugMode && (!Array.isArray(debugMode) || debugMode.includes(namespace));
-  }
-  /**
-   * @inheritDoc
-   */
-  logQuery(context) {
-    const namespace = context.namespace ?? 'query';
-    if (!this.isEnabled(namespace, context)) {
-      return;
+    /** Checks whether logging is enabled for the given namespace, considering context overrides. */
+    isEnabled(namespace, context) {
+        if (context?.enabled !== undefined) {
+            return context.enabled;
+        }
+        const debugMode = context?.debugMode ?? this.debugMode;
+        if (namespace === 'deprecated') {
+            const { ignoreDeprecations = false } = this.options;
+            return Array.isArray(ignoreDeprecations)
+                ? /* v8 ignore next */
+                    !ignoreDeprecations.includes(context?.label ?? '')
+                : !ignoreDeprecations;
+        }
+        return !!debugMode && (!Array.isArray(debugMode) || debugMode.includes(namespace));
     }
-    /* v8 ignore next */
-    let msg = this.highlighter?.highlight(context.query) ?? context.query;
-    if (context.took != null) {
-      const meta = [`took ${context.took} ms`];
-      if (context.results != null) {
-        meta.push(`${context.results} result${context.results === 0 || context.results > 1 ? 's' : ''}`);
-      }
-      if (context.affected != null) {
-        meta.push(`${context.affected} row${context.affected === 0 || context.affected > 1 ? 's' : ''} affected`);
-      }
-      msg += colors.grey(` [${meta.join(', ')}]`);
+    /**
+     * @inheritDoc
+     */
+    logQuery(context) {
+        const namespace = context.namespace ?? 'query';
+        if (!this.isEnabled(namespace, context)) {
+            return;
+        }
+        /* v8 ignore next */
+        let msg = this.highlighter?.highlight(context.query) ?? context.query;
+        if (context.took != null) {
+            const meta = [`took ${context.took} ms`];
+            if (context.results != null) {
+                meta.push(`${context.results} result${context.results === 0 || context.results > 1 ? 's' : ''}`);
+            }
+            if (context.affected != null) {
+                meta.push(`${context.affected} row${context.affected === 0 || context.affected > 1 ? 's' : ''} affected`);
+            }
+            msg += colors.grey(` [${meta.join(', ')}]`);
+        }
+        if (this.usesReplicas && context.connection) {
+            msg += colors.cyan(` (via ${context.connection.type} connection '${context.connection.name}')`);
+        }
+        return this.log(namespace, msg, context);
     }
-    if (this.usesReplicas && context.connection) {
-      msg += colors.cyan(` (via ${context.connection.type} connection '${context.connection.name}')`);
+    /** Factory method for creating a new DefaultLogger instance. */
+    static create(options) {
+        return new DefaultLogger(options);
     }
-    return this.log(namespace, msg, context);
-  }
-  /** Factory method for creating a new DefaultLogger instance. */
-  static create(options) {
-    return new DefaultLogger(options);
-  }
 }

package/logging/Logger.d.ts

@@ -1,55 +1,55 @@
 import type { AnyString, Dictionary, Highlighter } from '../typings.js';
 /** Interface for ORM logging, supporting namespaced log levels and query logging. */
 export interface Logger {
-  /**
-   * Logs a message inside given namespace.
-   */
-  log(namespace: LoggerNamespace | AnyString, message: string, context?: LogContext): void;
-  /**
-   * Logs error message inside given namespace.
-   */
-  error(namespace: LoggerNamespace | AnyString, message: string, context?: LogContext): void;
-  /**
-   * Logs warning message inside given namespace.
-   */
-  warn(namespace: LoggerNamespace | AnyString, message: string, context?: LogContext): void;
-  /**
-   * Logs a message inside given namespace.
-   */
-  logQuery(context: LogContext): void;
-  /**
-   * Sets active namespaces. Pass `true` to enable all logging.
-   */
-  setDebugMode(debugMode: boolean | LoggerNamespace[]): void;
-  /** Checks whether logging is enabled for the given namespace. */
-  isEnabled(namespace: LoggerNamespace, context?: LogContext): boolean;
+    /**
+     * Logs a message inside given namespace.
+     */
+    log(namespace: LoggerNamespace | AnyString, message: string, context?: LogContext): void;
+    /**
+     * Logs error message inside given namespace.
+     */
+    error(namespace: LoggerNamespace | AnyString, message: string, context?: LogContext): void;
+    /**
+     * Logs warning message inside given namespace.
+     */
+    warn(namespace: LoggerNamespace | AnyString, message: string, context?: LogContext): void;
+    /**
+     * Logs a message inside given namespace.
+     */
+    logQuery(context: LogContext): void;
+    /**
+     * Sets active namespaces. Pass `true` to enable all logging.
+     */
+    setDebugMode(debugMode: boolean | LoggerNamespace[]): void;
+    /** Checks whether logging is enabled for the given namespace. */
+    isEnabled(namespace: LoggerNamespace, context?: LogContext): boolean;
 }
 /** Available logging namespaces that can be individually enabled or disabled. */
 export type LoggerNamespace = 'query' | 'query-params' | 'schema' | 'discovery' | 'info' | 'deprecated' | 'slow-query';
 /** Contextual metadata passed alongside log messages, including query details and timing. */
 export interface LogContext extends Dictionary {
-  query?: string;
-  label?: string;
-  namespace?: LoggerNamespace;
-  params?: readonly unknown[];
-  took?: number;
-  results?: number;
-  affected?: number;
-  level?: 'info' | 'warning' | 'error';
-  enabled?: boolean;
-  debugMode?: LoggerNamespace[];
-  connection?: {
-    type?: string;
-    name?: string;
-  };
+    query?: string;
+    label?: string;
+    namespace?: LoggerNamespace;
+    params?: readonly unknown[];
+    took?: number;
+    results?: number;
+    affected?: number;
+    level?: 'info' | 'warning' | 'error';
+    enabled?: boolean;
+    debugMode?: LoggerNamespace[];
+    connection?: {
+        type?: string;
+        name?: string;
+    };
 }
 /** Options for constructing a Logger instance. */
 export interface LoggerOptions {
-  writer: (message: string) => void;
-  debugMode?: boolean | LoggerNamespace[];
-  ignoreDeprecations?: boolean | string[];
-  highlighter?: Highlighter;
-  usesReplicas?: boolean;
+    writer: (message: string) => void;
+    debugMode?: boolean | LoggerNamespace[];
+    ignoreDeprecations?: boolean | string[];
+    highlighter?: Highlighter;
+    usesReplicas?: boolean;
 }
 /**
  * Logger options to modify format output and overrides, including a label and additional properties that can be accessed by custom loggers.

package/logging/SimpleLogger.d.ts

@@ -4,17 +4,15 @@ import { DefaultLogger } from './DefaultLogger.js';
  * A basic logger that provides fully formatted output without color
  */
 export declare class SimpleLogger extends DefaultLogger {
-  /**
-   * @inheritDoc
-   */
-  log(namespace: LoggerNamespace, message: string, context?: LogContext): void;
-  /**
-   * @inheritDoc
-   */
-  logQuery(
-    context: {
-      query: string;
-    } & LogContext,
-  ): void;
-  static create(this: void, options: LoggerOptions): SimpleLogger;
+    /**
+     * @inheritDoc
+     */
+    log(namespace: LoggerNamespace, message: string, context?: LogContext): void;
+    /**
+     * @inheritDoc
+     */
+    logQuery(context: {
+        query: string;
+    } & LogContext): void;
+    static create(this: void, options: LoggerOptions): SimpleLogger;
 }

package/logging/SimpleLogger.js

@@ -3,28 +3,28 @@ import { DefaultLogger } from './DefaultLogger.js';
  * A basic logger that provides fully formatted output without color
  */
 export class SimpleLogger extends DefaultLogger {
-  /**
-   * @inheritDoc
-   */
-  log(namespace, message, context) {
-    if (!this.isEnabled(namespace, context)) {
-      return;
+    /**
+     * @inheritDoc
+     */
+    log(namespace, message, context) {
+        if (!this.isEnabled(namespace, context)) {
+            return;
+        }
+        // clean up the whitespace
+        message = message.replace(/\n/g, '').replace(/ +/g, ' ').trim();
+        const label = context?.label ? `(${context.label}) ` : '';
+        this.writer(`[${namespace}] ${label}${message}`);
     }
-    // clean up the whitespace
-    message = message.replace(/\n/g, '').replace(/ +/g, ' ').trim();
-    const label = context?.label ? `(${context.label}) ` : '';
-    this.writer(`[${namespace}] ${label}${message}`);
-  }
-  /**
-   * @inheritDoc
-   */
-  logQuery(context) {
-    if (!this.isEnabled('query', context)) {
-      return;
+    /**
+     * @inheritDoc
+     */
+    logQuery(context) {
+        if (!this.isEnabled('query', context)) {
+            return;
+        }
+        return this.log('query', context.query, context);
+    }
+    static create(options) {
+        return new SimpleLogger(options);
     }
-    return this.log('query', context.query, context);
-  }
-  static create(options) {
-    return new SimpleLogger(options);
-  }
 }

package/logging/colors.d.ts

@@ -1,9 +1,9 @@
 /** @internal */
 export declare const colors: {
-  red: (text: string) => string;
-  green: (text: string) => string;
-  yellow: (text: string) => string;
-  grey: (text: string) => string;
-  cyan: (text: string) => string;
-  enabled: () => boolean;
+    red: (text: string) => string;
+    green: (text: string) => string;
+    yellow: (text: string) => string;
+    grey: (text: string) => string;
+    cyan: (text: string) => string;
+    enabled: () => boolean;
 };

package/logging/colors.js

@@ -1,15 +1,14 @@
 import { getEnv } from '../utils/env-vars.js';
-const bool = k => ['true', 't', '1'].includes(getEnv(k)?.toLowerCase() ?? '');
-const boolIfDefined = k => (getEnv(k) != null ? bool(k) : true);
-const enabled = () =>
-  !bool('NO_COLOR') && !bool('MIKRO_ORM_NO_COLOR') && boolIfDefined('FORCE_COLOR') && boolIfDefined('MIKRO_ORM_COLORS');
-const wrap = fn => text => (enabled() ? fn(text) : text);
+const bool = (k) => ['true', 't', '1'].includes(getEnv(k)?.toLowerCase() ?? '');
+const boolIfDefined = (k) => (getEnv(k) != null ? bool(k) : true);
+const enabled = () => !bool('NO_COLOR') && !bool('MIKRO_ORM_NO_COLOR') && boolIfDefined('FORCE_COLOR') && boolIfDefined('MIKRO_ORM_COLORS');
+const wrap = (fn) => (text) => enabled() ? fn(text) : text;
 /** @internal */
 export const colors = {
-  red: wrap(text => `\x1B[31m${text}\x1B[39m`),
-  green: wrap(text => `\x1B[32m${text}\x1B[39m`),
-  yellow: wrap(text => `\x1B[33m${text}\x1B[39m`),
-  grey: wrap(text => `\x1B[90m${text}\x1B[39m`),
-  cyan: wrap(text => `\x1B[36m${text}\x1B[39m`),
-  enabled,
+    red: wrap((text) => `\x1B[31m${text}\x1B[39m`),
+    green: wrap((text) => `\x1B[32m${text}\x1B[39m`),
+    yellow: wrap((text) => `\x1B[33m${text}\x1B[39m`),
+    grey: wrap((text) => `\x1B[90m${text}\x1B[39m`),
+    cyan: wrap((text) => `\x1B[36m${text}\x1B[39m`),
+    enabled,
 };

package/logging/inspect.js

@@ -1,11 +1,11 @@
 let nodeInspect;
 /** @internal */
 export function inspect(value, options) {
-  nodeInspect ??= globalThis.process?.getBuiltinModule?.('node:util').inspect;
-  /* v8 ignore else */
-  if (nodeInspect) {
-    return nodeInspect(value, options);
-  }
-  /* v8 ignore next */
-  return JSON.stringify(value, null, 2);
+    nodeInspect ??= globalThis.process?.getBuiltinModule?.('node:util').inspect;
+    /* v8 ignore else */
+    if (nodeInspect) {
+        return nodeInspect(value, options);
+    }
+    /* v8 ignore next */
+    return JSON.stringify(value, null, 2);
 }