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

package/index.d.ts

@@ -2,8 +2,122 @@
  * @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,7 +2,16 @@
  * @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,36 +1,38 @@
 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;
+  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;
     }
-    /**
-     * @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);
+    // 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
-     */
-    error(namespace, message, context) {
-        this.log(namespace, message, { ...context, level: 'error' });
+    // use yellow for warning levels
+    if (context?.level === 'warning') {
+      message = colors.yellow(message);
     }
-    /**
-     * @inheritDoc
-     */
-    warn(namespace, message, context) {
-        this.log(namespace, message, { ...context, level: 'warning' });
+    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
-     */
-    setDebugMode(debugMode) {
-        this.debugMode = debugMode;
+    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;
     }
-    /** 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));
+    return !!debugMode && (!Array.isArray(debugMode) || debugMode.includes(namespace));
+  }
+  /**
+   * @inheritDoc
+   */
+  logQuery(context) {
+    const namespace = context.namespace ?? 'query';
+    if (!this.isEnabled(namespace, context)) {
+      return;
     }
-    /**
-     * @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);
+    /* 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(', ')}]`);
     }
-    /** Factory method for creating a new DefaultLogger instance. */
-    static create(options) {
-        return new DefaultLogger(options);
+    if (this.usesReplicas && context.connection) {
+      msg += colors.cyan(` (via ${context.connection.type} connection '${context.connection.name}')`);
     }
+    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,15 +4,17 @@ 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;
-        }
-        // clean up the whitespace
-        message = message.replace(/\n/g, '').replace(/ +/g, ' ').trim();
-        const label = context?.label ? `(${context.label}) ` : '';
-        this.writer(`[${namespace}] ${label}${message}`);
+  /**
+   * @inheritDoc
+   */
+  log(namespace, message, context) {
+    if (!this.isEnabled(namespace, 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);
+    // 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;
     }
+    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,14 +1,15 @@
 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);
 }