@mikro-orm/core 7.0.0-dev.215 → 7.0.0-dev.217

package/EntityManager.d.ts

@@ -7,7 +7,7 @@ import { EntityLoader, type EntityLoaderOptions } from './entity/EntityLoader.js
 import { Reference } from './entity/Reference.js';
 import { UnitOfWork } from './unit-of-work/UnitOfWork.js';
 import type { CountOptions, DeleteOptions, FilterOptions, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetReferenceOptions, IDatabaseDriver, LockOptions, NativeInsertUpdateOptions, StreamOptions, UpdateOptions, UpsertManyOptions, UpsertOptions } from './drivers/IDatabaseDriver.js';
-import type { AnyString, ArrayElement, AutoPath, ConnectionType, Dictionary, EntityClass, EntityData, EntityDictionary, EntityDTO, EntityMetadata, EntityName, FilterDef, FilterQuery, FromEntityType, GetRepository, IHydrator, IsSubset, Loaded, MergeLoaded, MergeSelected, NoInfer, ObjectQuery, PopulateOptions, Primary, Ref, RequiredEntityData, UnboxArray } from './typings.js';
+import type { AnyString, ArrayElement, AutoPath, ConnectionType, Dictionary, EntityClass, EntityData, EntityDictionary, EntityDTO, EntityMetadata, EntityName, FilterDef, FilterQuery, FromEntityType, GetRepository, IHydrator, IsSubset, Loaded, MergeLoaded, MergeSelected, ObjectQuery, PopulateOptions, Primary, Ref, RequiredEntityData, UnboxArray } from './typings.js';
 import { FlushMode, LockMode, PopulatePath, type TransactionOptions } from './enums.js';
 import type { MetadataStorage } from './metadata/MetadataStorage.js';
 import type { Transaction } from './connections/Connection.js';

package/MikroORM.d.ts

@@ -5,7 +5,7 @@ import { Configuration, type Options } from './utils/Configuration.js';
 import type { EntityManager } from './EntityManager.js';
 import type { AnyEntity, Constructor, EntityClass, EntityMetadata, EntityName, IEntityGenerator, IMigrator, ISeedManager } from './typings.js';
 /** @internal */
-export declare function lookupExtensions(options: Options): Promise<void>;
+export declare function loadOptionalDependencies(options: Options): Promise<void>;
 /**
  * The main class used to configure and bootstrap the ORM.
  *

package/MikroORM.js

@@ -4,31 +4,35 @@ import { Configuration } from './utils/Configuration.js';
 import { loadEnvironmentVars } from './utils/env-vars.js';
 import { Utils } from './utils/Utils.js';
 import { colors } from './logging/colors.js';
-async function registerExtension(name, mod, extensions) {
-    /* v8 ignore next */
-    const resolved = await mod.catch(() => null);
-    const module = resolved?.[name];
-    /* v8 ignore else */
-    if (module) {
-        extensions.push(module);
+async function tryRegisterExtension(name, pkg, extensions) {
+    try {
+        const url = import.meta.resolve(pkg);
+        const mod = await import(url);
+        if (mod[name]) {
+            extensions.push(mod[name]);
+        }
+    }
+    catch {
+        // not installed
     }
 }
 /** @internal */
-export async function lookupExtensions(options) {
+export async function loadOptionalDependencies(options) {
+    await import('@mikro-orm/core/fs-utils').then(m => m.fs.init()).catch(() => null);
     const extensions = options.extensions ?? [];
     const exists = (name) => extensions.some(ext => ext.name === name);
     if (!exists('SeedManager')) {
-        await registerExtension('SeedManager', import((() => '@mikro-orm/seeder')()), extensions);
+        await tryRegisterExtension('SeedManager', '@mikro-orm/seeder', extensions);
     }
     if (!exists('Migrator')) {
-        await registerExtension('Migrator', import((() => '@mikro-orm/migrations')()), extensions);
+        await tryRegisterExtension('Migrator', '@mikro-orm/migrations', extensions);
     }
     /* v8 ignore if */
     if (!exists('Migrator')) {
-        await registerExtension('Migrator', import((() => '@mikro-orm/migrations-mongodb')()), extensions);
+        await tryRegisterExtension('Migrator', '@mikro-orm/migrations-mongodb', extensions);
     }
     if (!exists('EntityGenerator')) {
-        await registerExtension('EntityGenerator', import((() => '@mikro-orm/entity-generator')()), extensions);
+        await tryRegisterExtension('EntityGenerator', '@mikro-orm/entity-generator', extensions);
     }
     options.extensions = extensions;
     const metadataCacheEnabled = options.metadataCache?.enabled || options.metadataProvider?.useCache?.();
@@ -85,7 +89,7 @@ export class MikroORM {
         options = { ...options };
         options.discovery ??= {};
         options.discovery.skipSyncDiscovery ??= true;
-        await lookupExtensions(options);
+        await loadOptionalDependencies(options);
         const orm = new this(options);
         const preferTs = orm.config.get('preferTs', Utils.detectTypeScriptSupport());
         orm.metadata = await orm.discovery.discover(preferTs);

package/drivers/IDatabaseDriver.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectionType, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, QBFilterQuery, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate, EntityName } from '../typings.js';
+import type { ConnectionType, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate, EntityName } from '../typings.js';
 import type { Connection, QueryResult, Transaction } from '../connections/Connection.js';
 import type { FlushMode, LockMode, QueryOrderMap, QueryFlag, LoadStrategy, PopulateHint, PopulatePath } from '../enums.js';
 import type { Platform } from '../platforms/Platform.js';
@@ -144,7 +144,7 @@ export interface FindOptions<Entity, Hint extends string = never, Fields extends
     flags?: QueryFlag[];
     /** sql only */
     groupBy?: string | string[];
-    having?: QBFilterQuery<Entity>;
+    having?: FilterQuery<Entity>;
     /** sql only */
     strategy?: LoadStrategy | `${LoadStrategy}`;
     flushMode?: FlushMode | `${FlushMode}`;
@@ -203,7 +203,7 @@ export interface CountOptions<T extends object, P extends string = never> {
     filters?: FilterOptions;
     schema?: string;
     groupBy?: string | readonly string[];
-    having?: QBFilterQuery<T>;
+    having?: FilterQuery<T>;
     cache?: boolean | number | [string, number];
     populate?: Populate<T, P>;
     populateWhere?: ObjectQuery<T> | PopulateHint | `${PopulateHint}`;

package/entity/BaseEntity.d.ts

@@ -10,8 +10,67 @@ export declare abstract class BaseEntity {
     populated(populated?: boolean): void;
     populate<Entity extends this = this, Hint extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity>): Promise<Loaded<Entity, Hint>>;
     toReference<Entity extends this = this>(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
+    /**
+     * Converts the entity to a plain object representation.
+     *
+     * **Note on typing with `Loaded` entities:** When called on a `Loaded<Entity, 'relation'>` type,
+     * the return type will be `EntityDTO<Entity>` (with relations as primary keys), not
+     * `EntityDTO<Loaded<Entity, 'relation'>>` (with loaded relations as nested objects).
+     * This is a TypeScript limitation - the `this` type resolves to the class, not the `Loaded` wrapper.
+     *
+     * For correct typing that reflects loaded relations, use `wrap()`:
+     * ```ts
+     * const result = await em.find(User, {}, { populate: ['profile'] });
+     * // Type: EntityDTO<User> (profile is number)
+     * const obj1 = result[0].toObject();
+     * // Type: EntityDTO<Loaded<User, 'profile'>> (profile is nested object)
+     * const obj2 = wrap(result[0]).toObject();
+     * ```
+     *
+     * Runtime values are correct in both cases - only the static types differ.
+     */
     toObject<Entity extends this = this>(): EntityDTO<Entity>;
+    /**
+     * Converts the entity to a plain object representation.
+     *
+     * **Note on typing with `Loaded` entities:** When called on a `Loaded<Entity, 'relation'>` type,
+     * the return type will be `EntityDTO<Entity>` (with relations as primary keys), not
+     * `EntityDTO<Loaded<Entity, 'relation'>>` (with loaded relations as nested objects).
+     * This is a TypeScript limitation - the `this` type resolves to the class, not the `Loaded` wrapper.
+     *
+     * For correct typing that reflects loaded relations, use `wrap()`:
+     * ```ts
+     * const result = await em.find(User, {}, { populate: ['profile'] });
+     * // Type: EntityDTO<User> (profile is number)
+     * const obj1 = result[0].toObject();
+     * // Type: EntityDTO<Loaded<User, 'profile'>> (profile is nested object)
+     * const obj2 = wrap(result[0]).toObject();
+     * ```
+     *
+     * Runtime values are correct in both cases - only the static types differ.
+     */
     toObject<Entity extends this = this>(ignoreFields: never[]): EntityDTO<Entity>;
+    /**
+     * Converts the entity to a plain object representation.
+     *
+     * **Note on typing with `Loaded` entities:** When called on a `Loaded<Entity, 'relation'>` type,
+     * the return type will be `EntityDTO<Entity>` (with relations as primary keys), not
+     * `EntityDTO<Loaded<Entity, 'relation'>>` (with loaded relations as nested objects).
+     * This is a TypeScript limitation - the `this` type resolves to the class, not the `Loaded` wrapper.
+     *
+     * For correct typing that reflects loaded relations, use `wrap()`:
+     * ```ts
+     * const result = await em.find(User, {}, { populate: ['profile'] });
+     * // Type: EntityDTO<User> (profile is number)
+     * const obj1 = result[0].toObject();
+     * // Type: EntityDTO<Loaded<User, 'profile'>> (profile is nested object)
+     * const obj2 = wrap(result[0]).toObject();
+     * ```
+     *
+     * Runtime values are correct in both cases - only the static types differ.
+     *
+     * @param ignoreFields - Array of field names to omit from the result.
+     */
     toObject<Entity extends this = this, Ignored extends EntityKey<Entity> = never>(ignoreFields: Ignored[]): Omit<EntityDTO<Entity>, Ignored>;
     toPOJO<Entity extends this = this>(): EntityDTO<Entity>;
     serialize<Entity extends this = this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): EntityDTO<Loaded<Naked, Hint>>;

package/entity/WrappedEntity.d.ts

@@ -58,7 +58,7 @@ export declare class WrappedEntity<Entity extends object> {
     setPrimaryKey(id: Primary<Entity> | null): void;
     getSerializedPrimaryKey(): string;
     get __meta(): EntityMetadata<Entity>;
-    get __platform(): import("@mikro-orm/sql").Platform;
-    get __config(): import("@mikro-orm/sql").Configuration<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("@mikro-orm/sql").Connection>, EntityManager<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("@mikro-orm/sql").Connection>>>;
+    get __platform(): import("../index.js").Platform;
+    get __config(): import("../index.js").Configuration<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("../index.js").Connection>, EntityManager<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("../index.js").Connection>>>;
     get __primaryKeys(): Primary<Entity>[];
 }

package/entity/defineEntity.d.ts

@@ -1,6 +1,7 @@
 import type { EntityManager } from '../EntityManager.js';
 import type { ColumnType, PropertyOptions, ReferenceOptions, EnumOptions, EmbeddedOptions, ManyToOneOptions, OneToManyOptions, OneToOneOptions, ManyToManyOptions } from '../metadata/types.js';
 import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, EntityRepositoryType, Hidden, Opt, Primary, EntityClass, EntitySchemaWithMeta, InferEntity, MaybeReturnType, Ref, IndexCallback, FormulaCallback, EntityCtor, IsNever } from '../typings.js';
+import type { Raw } from '../utils/RawQueryFragment.js';
 import type { ScalarReference } from './Reference.js';
 import type { SerializeOptions } from '../serialization/EntitySerializer.js';
 import type { Cascade, DeferMode, EmbeddedPrefixMode, LoadStrategy, QueryOrderMap } from '../enums.js';
@@ -120,7 +121,7 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
      * Specify default column value for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}.
      * This is a runtime value, assignable to the entity property. (SQL only)
      */
-    default<T extends string | string[] | number | number[] | boolean | null>(defaultValue: T): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'default'> & {
+    default<T extends string | string[] | number | number[] | boolean | null | Date | Raw>(defaultValue: T): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'default'> & {
         default: T;
     }, IncludeKeys>, IncludeKeys>;
     /**
@@ -577,7 +578,7 @@ type MaybeOpt<Value, Options> = Options extends {
 } ? Opt<Value> : Options extends {
     onCreate: Function;
 } ? Opt<Value> : Options extends {
-    default: string | string[] | number | number[] | boolean | null;
+    default: string | string[] | number | number[] | boolean | null | Date | Raw;
 } ? Opt<Value> : Options extends {
     defaultRaw: string;
 } ? Opt<Value> : Options extends {

package/enums.d.ts

@@ -1,4 +1,4 @@
-import type { Dictionary, EntityKey, ExpandProperty } from './typings.js';
+import type { EntityKey, ExpandProperty } from './typings.js';
 import type { Transaction } from './connections/Connection.js';
 import type { LogContext } from './logging/Logger.js';
 export declare enum FlushMode {
@@ -72,7 +72,6 @@ export type QueryOrderKeys<T> = QueryOrderKeysFlat | QueryOrderMap<T>;
 export type QueryOrderMap<T> = {
     [K in EntityKey<T>]?: QueryOrderKeys<ExpandProperty<T[K]>>;
 };
-export type QBQueryOrderMap<T> = QueryOrderMap<T> | Dictionary;
 export interface FlatQueryOrderMap {
     [x: string]: QueryOrderKeysFlat;
 }

package/index.d.ts

@@ -3,7 +3,7 @@
  * @module core
  */
 export { EntityMetadata, PrimaryKeyProp, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config } from './typings.js';
-export type { Constructor, ConnectionType, Dictionary, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, EntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, QBFilterQuery, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, RequiredEntityData, CheckCallback, IndexCallback, FormulaCallback, FormulaTable, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, EntityType, FromEntityType, Selected, IsSubset, NoInfer, 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, } from './typings.js';
+export type { Constructor, ConnectionType, Dictionary, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, EntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, RequiredEntityData, CheckCallback, IndexCallback, FormulaCallback, FormulaTable, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, 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, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';

package/metadata/types.d.ts

@@ -4,6 +4,7 @@ import type { Type, types } from '../types/index.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { FilterOptions, FindOptions } from '../drivers/IDatabaseDriver.js';
 import type { SerializeOptions } from '../serialization/EntitySerializer.js';
+import type { Raw } from '../utils/RawQueryFragment.js';
 export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
     /** Override default collection/table name. Alias for `collection`. */
     tableName?: string;
@@ -126,12 +127,12 @@ export interface PropertyOptions<Owner> {
      * Specify default column value for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}.
      * This is a runtime value, assignable to the entity property. (SQL only)
      */
-    default?: string | string[] | number | number[] | boolean | null;
+    default?: string | string[] | number | number[] | boolean | null | Date | Raw;
     /**
      * Specify SQL functions for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
      * Since v4 you should use defaultRaw for SQL functions. e.g. now()
      */
-    defaultRaw?: string;
+    defaultRaw?: string | Raw;
     /**
      * Set to map some SQL snippet for the entity.
      *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.215",
+  "version": "7.0.0-dev.217",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "exports": {
     "./package.json": "./package.json",

package/platforms/Platform.d.ts

@@ -8,6 +8,7 @@ import type { IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
 import { Type } from '../types/index.js';
 import type { MikroORM } from '../MikroORM.js';
 import type { TransformContext } from '../types/Type.js';
+import { Raw } from '../utils/RawQueryFragment.js';
 export declare const JsonProperty: unique symbol;
 export declare abstract class Platform {
     protected readonly exceptionConverter: ExceptionConverter;
@@ -142,8 +143,8 @@ export declare abstract class Platform {
     unmarshallArray(value: string): string[];
     getBlobDeclarationSQL(): string;
     getJsonDeclarationSQL(): string;
-    getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string;
-    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string;
+    getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string | Raw;
+    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string | Raw;
     getJsonIndexDefinition(index: {
         columnNames: string[];
     }): string[];

package/typings.d.ts

@@ -40,7 +40,6 @@ export type IsUnknown<T> = T extends unknown ? unknown extends T ? true : never
 export type IsAny<T> = 0 extends (1 & T) ? true : false;
 export type IsNever<T, True = true, False = false> = [T] extends [never] ? True : False;
 export type MaybePromise<T> = T | Promise<T>;
-export type NoInfer<T> = [T][T extends any ? 0 : never];
 /**
  * Structural type for matching Collection without triggering full interface evaluation.
  * Using `T extends CollectionShape` instead of `T extends Collection<any, any>` avoids
@@ -80,8 +79,11 @@ type ReferenceShape<T = any> = {
 };
 /**
  * Structural type for matching LoadedReference (Reference with `$` property).
+ * Note: We don't parameterize ReferenceShape here because for loaded relations,
+ * the Reference unwrap() returns the base type while $ returns the Loaded type.
+ * We infer T from $ to get the full Loaded type for EntityDTO.
  */
-type LoadedReferenceShape<T = any> = ReferenceShape<T> & {
+type LoadedReferenceShape<T = any> = ReferenceShape & {
     $: T;
 };
 /**
@@ -91,10 +93,11 @@ type LoadedReferenceShape<T = any> = ReferenceShape<T> & {
  */
 type LoadableShape = CollectionShape | ReferenceShape | readonly any[];
 export type UnionKeys<T> = T extends any ? keyof T : never;
-export type UnionPropertyType<T, K extends PropertyKey> = T extends any ? K extends keyof T ? T[K] : never : never;
-export type MergeUnion<T> = [T] extends [object] ? T extends Scalar ? T : {
+export type UnionPropertyType<T, K extends PropertyKey> = T extends any ? (K extends keyof T ? T[K] : never) : never;
+type IsUnion<T, U = T> = T extends any ? ([U] extends [T] ? false : true) : false;
+export type MergeUnion<T> = [T] extends [object] ? (T extends Scalar ? T : IsUnion<T> extends true ? {
     [K in UnionKeys<T>]: UnionPropertyType<T, K>;
-} : T;
+} : T) : T;
 export type DeepPartial<T> = T & {
     [P in keyof T]?: T[P] extends (infer U)[] ? DeepPartial<U>[] : T[P] extends Readonly<infer U>[] ? Readonly<DeepPartial<U>>[] : DeepPartial<T[P]>;
 };
@@ -181,13 +184,17 @@ export type Scalar = boolean | number | string | bigint | symbol | Date | RegExp
 };
 type Primitive = boolean | number | string | bigint | symbol;
 export type ExpandScalar<T> = null | (T extends string ? T | RegExp : T extends Date ? Date | string : T extends bigint ? bigint | string | number : T);
+/** Marker interface for query builders that can be used as subqueries */
+export interface Subquery {
+    readonly __subquery: true;
+}
 export type OperatorMap<T> = {
     $and?: ExpandQuery<T>[];
     $or?: ExpandQuery<T>[];
-    $eq?: ExpandScalar<T> | readonly ExpandScalar<T>[];
-    $ne?: ExpandScalar<T>;
-    $in?: readonly ExpandScalar<T>[];
-    $nin?: readonly ExpandScalar<T>[];
+    $eq?: ExpandScalar<T> | readonly ExpandScalar<T>[] | Subquery;
+    $ne?: ExpandScalar<T> | readonly ExpandScalar<T>[] | Subquery;
+    $in?: readonly ExpandScalar<T>[] | readonly Primary<T>[] | Raw | Subquery;
+    $nin?: readonly ExpandScalar<T>[] | readonly Primary<T>[] | Raw | Subquery;
     $not?: ExpandQuery<T>;
     $none?: ExpandQuery<T>;
     $some?: ExpandQuery<T>;
@@ -200,10 +207,10 @@ export type OperatorMap<T> = {
         $lt?: number;
         $lte?: number;
     };
-    $gt?: ExpandScalar<T>;
-    $gte?: ExpandScalar<T>;
-    $lt?: ExpandScalar<T>;
-    $lte?: ExpandScalar<T>;
+    $gt?: ExpandScalar<T> | readonly ExpandScalar<T>[] | Subquery;
+    $gte?: ExpandScalar<T> | readonly ExpandScalar<T>[] | Subquery;
+    $lt?: ExpandScalar<T> | readonly ExpandScalar<T>[] | Subquery;
+    $lte?: ExpandScalar<T> | readonly ExpandScalar<T>[] | Subquery;
     $like?: string;
     $re?: string;
     $ilike?: string;
@@ -216,7 +223,7 @@ export type OperatorMap<T> = {
     $hasKeys?: readonly string[];
     $hasSomeKeys?: readonly string[];
 };
-export type FilterItemValue<T> = T | ExpandScalar<T> | Primary<T>;
+export type FilterItemValue<T> = T | ExpandScalar<T> | Primary<T> | Raw;
 export type FilterValue<T> = OperatorMap<FilterItemValue<T>> | FilterItemValue<T> | FilterItemValue<T>[] | null;
 type FilterObjectProp<T, K extends PropertyKey> = K extends keyof MergeUnion<T> ? MergeUnion<T>[K] : K extends keyof T ? T[K] : never;
 type ExpandQueryMerged<T> = [T] extends [object] ? [T] extends [Scalar] ? never : FilterQuery<MergeUnion<T>> : FilterValue<T>;
@@ -229,7 +236,6 @@ export type EntityProps<T> = {
 };
 export type ObjectQuery<T> = OperatorMap<T> & FilterObject<T>;
 export type FilterQuery<T> = ObjectQuery<T> | NonNullable<ExpandScalar<Primary<T>>> | NonNullable<EntityProps<T> & OperatorMap<T>> | FilterQuery<T>[];
-export type QBFilterQuery<T = any> = ObjectQuery<T> | Dictionary;
 export interface IWrappedEntity<Entity extends object> {
     isInitialized(): boolean;
     isManaged(): boolean;
@@ -310,7 +316,7 @@ export type RequiredEntityDataProp<T, O, C extends boolean> = T extends Date ? s
     __raw?: infer Raw;
 } ? (C extends true ? Raw : Runtime) : T extends ReferenceShape<infer U> ? RequiredEntityDataNested<U, O, C> : T extends ScalarReference<infer U> ? RequiredEntityDataProp<U, O, C> : T extends CollectionShape<infer U> ? U | U[] | RequiredEntityDataNested<U & object, O, C> | RequiredEntityDataNested<U & object, O, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | RequiredEntityDataNested<U, O, C> | RequiredEntityDataNested<U, O, C>[] : U[] | RequiredEntityDataNested<U, O, C>[] : RequiredEntityDataNested<T, O, C>;
 export type EntityDataNested<T, C extends boolean = false> = T extends undefined ? never : T extends any[] ? Readonly<T> : EntityData<T, C> | ExpandEntityProp<T, C>;
-type EntityDataItem<T, C extends boolean> = C extends false ? T | EntityDataProp<T, C> | null : EntityDataProp<T, C> | null;
+type EntityDataItem<T, C extends boolean> = C extends false ? T | EntityDataProp<T, C> | Raw | null : EntityDataProp<T, C> | Raw | null;
 export type RequiredEntityDataNested<T, O, C extends boolean> = T extends any[] ? Readonly<T> : RequiredEntityData<T, O> | ExpandRequiredEntityProp<T, O, C>;
 type ExplicitlyOptionalProps<T> = (T extends {
     [OptionalProps]?: infer K;
@@ -331,9 +337,9 @@ export type EntityData<T, C extends boolean = false> = {
     [K in EntityKey<T>]?: EntityDataItem<T[K] & {}, C>;
 };
 export type RequiredEntityData<T, I = never, C extends boolean = false> = {
-    [K in keyof T as RequiredKeys<T, K, I>]: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]>;
+    [K in keyof T as RequiredKeys<T, K, I>]: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]> | Raw;
 } & {
-    [K in keyof T as OptionalKeys<T, K, I>]?: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]> | null;
+    [K in keyof T as OptionalKeys<T, K, I>]?: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]> | Raw | null;
 };
 export type EntityDictionary<T> = EntityData<T> & Record<any, any>;
 type ExtractEagerProps<T> = T extends {
@@ -399,12 +405,12 @@ export type FormulaTable = {
 };
 export type IndexCallback<T> = (table: TableName, columns: Record<PropertyName<T>, string>, indexName: string) => string | Raw;
 export type FormulaCallback<T> = (table: FormulaTable, columns: Record<PropertyName<T>, string>) => string;
-export type CheckCallback<T> = (columns: Record<PropertyName<T>, string>) => string;
+export type CheckCallback<T> = (columns: Record<PropertyName<T>, string>) => string | Raw;
 export type GeneratedColumnCallback<T> = (columns: Record<keyof T, string>) => string;
 export interface CheckConstraint<T = any> {
     name?: string;
     property?: string;
-    expression: string | CheckCallback<T>;
+    expression: string | Raw | CheckCallback<T>;
 }
 export type AnyString = string & {};
 export interface EntityProperty<Owner = any, Target = any> {
@@ -897,9 +903,7 @@ type LoadedEntityType<T> = {
 };
 export type EntityType<T> = T | LoadedEntityType<T>;
 export type FromEntityType<T> = T extends LoadedEntityType<infer U> ? U : T;
-type LoadedInternal<T, L extends string = never, F extends string = '*', E extends string = never> = [
-    F
-] extends ['*'] ? IsNever<E> extends true ? T & {
+type LoadedInternal<T, L extends string = never, F extends string = '*', E extends string = never> = [F] extends ['*'] ? IsNever<E> extends true ? T & {
     [K in keyof T as IsPrefixed<T, K, ExpandHint<T, L>>]: LoadedProp<NonNullable<T[K]>, Suffix<K, L>, Suffix<K, F>, Suffix<K, E>> | AddOptional<T[K]>;
 } : {
     [K in keyof T as IsPrefixed<T, K, ExpandHint<T, L>, E>]: LoadedProp<NonNullable<T[K]>, Suffix<K, L>, Suffix<K, F>, Suffix<K, E>> | AddOptional<T[K]>;

package/utils/Configuration.d.ts

@@ -35,7 +35,7 @@ declare const DEFAULTS: {
         readonly inferDefaultValues: true;
     };
     readonly validateRequired: true;
-    readonly context: (name: string) => EntityManager<IDatabaseDriver<import("@mikro-orm/sql").Connection>> | undefined;
+    readonly context: (name: string) => EntityManager<IDatabaseDriver<import("../index.js").Connection>> | undefined;
     readonly contextName: "default";
     readonly allowGlobalContext: false;
     readonly logger: (message?: any, ...optionalParams: any[]) => void;

package/utils/RawQueryFragment.d.ts

@@ -3,13 +3,15 @@ declare const rawFragmentSymbolBrand: unique symbol;
 export type RawQueryFragmentSymbol = symbol & {
     readonly [rawFragmentSymbolBrand]: true;
 };
-export declare class RawQueryFragment {
+export declare class RawQueryFragment<Alias extends string = string> {
     #private;
     readonly sql: string;
     readonly params: unknown[];
+    /** @internal Type-level only - used to track the alias for type inference */
+    private readonly __alias?;
     constructor(sql: string, params?: unknown[]);
     get key(): RawQueryFragmentSymbol;
-    as(alias: string): RawQueryFragment;
+    as<A extends string>(alias: A): RawQueryFragment<A>;
     [Symbol.toPrimitive](hint: 'string'): RawQueryFragmentSymbol;
     get [Symbol.toStringTag](): string;
     toJSON(): string;
@@ -17,7 +19,7 @@ export declare class RawQueryFragment {
     static isKnownFragmentSymbol(key: unknown): key is RawQueryFragmentSymbol;
     static hasObjectFragments(object: unknown): boolean;
     static isKnownFragment(key: unknown): key is RawQueryFragment | symbol;
-    static getKnownFragment(key: unknown): RawQueryFragment | undefined;
+    static getKnownFragment(key: unknown): RawQueryFragment<any> | undefined;
 }
 export { RawQueryFragment as Raw };
 export declare function isRaw(value: unknown): value is RawQueryFragment;
@@ -80,7 +82,7 @@ export declare const ALIAS_REPLACEMENT_RE = "\\[::alias::\\]";
  * export class Author { ... }
  * ```
  */
-export declare function raw<T extends object = any, R = any>(sql: EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): NoInfer<R>;
+export declare function raw<R = RawQueryFragment & symbol, T extends object = any>(sql: EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): R;
 /**
  * Alternative to the `raw()` helper allowing to use it as a tagged template function for the simple cases.
  *
@@ -93,16 +95,19 @@ export declare function raw<T extends object = any, R = any>(sql: EntityKey<T> |
  *
  * // value can be empty array
  * await em.find(User, { [sql`(select 1 = 1)`]: [] });
+ *
+ * // with type parameter for assignment without casting
+ * entity.date = sql<Date>`now()`;
  * ```
  */
-export declare function sql(sql: readonly string[], ...values: unknown[]): any;
+export declare function sql<R = RawQueryFragment & symbol>(sql: readonly string[], ...values: unknown[]): R;
 export declare namespace sql {
-    var ref: <T extends object>(...keys: string[]) => NoInfer<RawQueryFragment>;
-    var now: (length?: number) => string;
-    var lower: <T extends object>(key: string | ((alias: string) => string)) => string;
-    var upper: <T extends object>(key: string | ((alias: string) => string)) => string;
+    var ref: <T extends object = any>(...keys: string[]) => RawQueryFragment<string> & symbol;
+    var now: (length?: number) => RawQueryFragment<string> & symbol;
+    var lower: <R = RawQueryFragment<string> & symbol, T extends object = any>(key: string | ((alias: string) => string)) => R;
+    var upper: <R = RawQueryFragment<string> & symbol, T extends object = any>(key: string | ((alias: string) => string)) => R;
 }
-export declare function createSqlFunction<T extends object, R = string>(func: string, key: string | ((alias: string) => string)): R;
+export declare function createSqlFunction<R = RawQueryFragment & symbol, T extends object = any>(func: string, key: string | ((alias: string) => string)): R;
 /**
  * Tag function providing quoting of db identifiers (table name, columns names, index names, ...).
  *
@@ -111,11 +116,11 @@ export declare function createSqlFunction<T extends object, R = string>(func: st
  * ```ts
  * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("name")
  * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`name`)
- * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns, indexName) => quote`create index ${indexName} on ${table} (${columns.name})` })
  * @Entity({ schema: 'library' })
  * export class Author { ... }
  * ```
  */
 export declare function quote(expParts: readonly string[], ...values: (string | {
     toString(): string;
-})[]): any;
+})[]): RawQueryFragment<string> & symbol;

package/utils/RawQueryFragment.js

@@ -2,7 +2,6 @@ import { Utils } from './Utils.js';
 export class RawQueryFragment {
     sql;
     params;
-    // holds a weak reference to fragments used as object keys
     static #rawQueryReferences = new WeakMap();
     #key;
     constructor(sql, params = []) {
@@ -170,6 +169,9 @@ export function raw(sql, params) {
  *
  * // value can be empty array
  * await em.find(User, { [sql`(select 1 = 1)`]: [] });
+ *
+ * // with type parameter for assignment without casting
+ * entity.date = sql<Date>`now()`;
  * ```
  */
 export function sql(sql, ...values) {
@@ -193,7 +195,7 @@ sql.upper = (key) => createSqlFunction('upper', key);
  * ```ts
  * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("name")
  * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`name`)
- * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns, indexName) => quote`create index ${indexName} on ${table} (${columns.name})` })
  * @Entity({ schema: 'library' })
  * export class Author { ... }
  * ```

package/utils/Utils.js

@@ -123,7 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-dev.215';
+    static #ORM_VERSION = '7.0.0-dev.217';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */

package/utils/fs-utils.d.ts

@@ -1,5 +1,6 @@
 import { type Dictionary } from '../typings.js';
 export declare const fs: {
+    init(): Promise<void>;
     pathExists(path: string): boolean;
     ensureDir(path: string): void;
     readJSONSync<T = Dictionary>(path: string): T;

package/utils/fs-utils.js

@@ -1,9 +1,25 @@
-import { existsSync, globSync, mkdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { existsSync, globSync as nodeGlobSync, mkdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { isAbsolute, join, normalize, relative } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { Utils } from './Utils.js';
 import { colors } from '../logging/colors.js';
+let globSync = (patterns, options) => {
+    const files = nodeGlobSync(patterns, { ...options, withFileTypes: true });
+    return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
+};
 export const fs = {
+    async init() {
+        const tinyGlobby = await import('tinyglobby').catch(() => null);
+        if (tinyGlobby) {
+            globSync = (patterns, options) => {
+                patterns = Utils.asArray(patterns).map(p => p.replace(/\\/g, '/'));
+                if (options?.cwd) {
+                    options = { ...options, cwd: options.cwd.replace(/\\/g, '/') };
+                }
+                return tinyGlobby.globSync(patterns, { ...options, expandDirectories: false });
+            };
+        }
+    },
     pathExists(path) {
         if (/[*?[\]]/.test(path)) {
             return globSync(path).length > 0;
@@ -49,16 +65,14 @@ export const fs = {
             try {
                 const s = statSync(cwd ? this.normalizePath(cwd, input) : input);
                 if (s.isDirectory()) {
-                    const files = globSync(join(input, '**'), { cwd, withFileTypes: true });
-                    return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
+                    return globSync(join(input, '**'), { cwd });
                 }
             }
             catch {
                 // ignore
             }
         }
-        const files = globSync(input, { cwd, withFileTypes: true });
-        return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
+        return globSync(input, { cwd });
     },
     getPackageConfig(basePath = process.cwd()) {
         if (this.pathExists(`${basePath}/package.json`)) {