@mikro-orm/sql 7.0.0-dev.98 → 7.0.0-rc.0

package/dialects/postgresql/index.d.ts

@@ -1 +1,4 @@
 export * from './PostgreSqlNativeQueryBuilder.js';
+export * from './BasePostgreSqlPlatform.js';
+export * from './FullTextType.js';
+export * from './PostgreSqlSchemaHelper.js';

package/dialects/postgresql/index.js

@@ -1 +1,4 @@
 export * from './PostgreSqlNativeQueryBuilder.js';
+export * from './BasePostgreSqlPlatform.js';
+export * from './FullTextType.js';
+export * from './PostgreSqlSchemaHelper.js';

package/dialects/sqlite/BaseSqliteConnection.d.ts

@@ -3,4 +3,5 @@ export declare abstract class BaseSqliteConnection extends AbstractSqlConnection
     connect(options?: {
         skipOnConnect?: boolean;
     }): Promise<void>;
+    protected attachDatabases(): Promise<void>;
 }

package/dialects/sqlite/BaseSqliteConnection.js

@@ -3,6 +3,19 @@ import { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 export class BaseSqliteConnection extends AbstractSqlConnection {
     async connect(options) {
         await super.connect(options);
-        await this.client.executeQuery(CompiledQuery.raw('pragma foreign_keys = on'));
+        await this.getClient().executeQuery(CompiledQuery.raw('pragma foreign_keys = on'));
+        await this.attachDatabases();
+    }
+    async attachDatabases() {
+        const attachDatabases = this.config.get('attachDatabases');
+        if (!attachDatabases?.length) {
+            return;
+        }
+        const { fs } = await import('@mikro-orm/core/fs-utils');
+        const baseDir = this.config.get('baseDir');
+        for (const db of attachDatabases) {
+            const path = fs.absolutePath(db.path, baseDir);
+            await this.execute(`attach database '${path}' as ${this.platform.quoteIdentifier(db.name)}`);
+        }
     }
 }

package/dialects/sqlite/BaseSqlitePlatform.d.ts

@@ -64,6 +64,12 @@ export declare abstract class BaseSqlitePlatform extends AbstractSqlPlatform {
     processDateProperty(value: unknown): string | number | Date;
     getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
     supportsDeferredUniqueConstraints(): boolean;
+    /**
+     * SQLite supports schemas via ATTACH DATABASE. Returns true when there are
+     * attached databases configured.
+     */
+    supportsSchemas(): boolean;
+    getDefaultSchemaName(): string | undefined;
     getFullTextWhereClause(): string;
     quoteVersionValue(value: Date | number, prop: EntityProperty): Date | string | number;
     quoteValue(value: any): string;

package/dialects/sqlite/BaseSqlitePlatform.js

@@ -86,6 +86,18 @@ export class BaseSqlitePlatform extends AbstractSqlPlatform {
     supportsDeferredUniqueConstraints() {
         return false;
     }
+    /**
+     * SQLite supports schemas via ATTACH DATABASE. Returns true when there are
+     * attached databases configured.
+     */
+    supportsSchemas() {
+        const attachDatabases = this.config.get('attachDatabases');
+        return !!attachDatabases?.length;
+    }
+    getDefaultSchemaName() {
+        // Return 'main' only when schema support is active (i.e., databases are attached)
+        return this.supportsSchemas() ? 'main' : undefined;
+    }
     getFullTextWhereClause() {
         return `:column: match :query`;
     }

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -8,7 +8,14 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
     disableForeignKeysSQL(): string;
     enableForeignKeysSQL(): string;
     supportsSchemaConstraints(): boolean;
+    getCreateNamespaceSQL(name: string): string;
+    getDropNamespaceSQL(name: string): string;
     getListTablesSQL(): string;
+    getAllTables(connection: AbstractSqlConnection, schemas?: string[]): Promise<Table[]>;
+    getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
+    private getIgnoredViewsCondition;
+    getListViewsSQL(): string;
+    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
     getDropDatabaseSQL(name: string): string;
     loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
     createTable(table: DatabaseTable, alter?: boolean): string[];
@@ -18,6 +25,19 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
     getDropColumnsSQL(tableName: string, columns: Column[], schemaName?: string): string;
     getCreateIndexSQL(tableName: string, index: IndexDef): string;
     private parseTableDefinition;
+    /**
+     * Returns schema prefix for pragma and sqlite_master queries.
+     * Returns empty string for main database (no prefix needed).
+     */
+    private getSchemaPrefix;
+    /**
+     * Returns all database names excluding 'temp'.
+     */
+    private getDatabaseList;
+    /**
+     * Extracts the SELECT part from a CREATE VIEW statement.
+     */
+    private extractViewDefinition;
     private getColumns;
     private getEnumDefinitions;
     getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[], tableName: string, schemaName?: string): Promise<string[]>;
@@ -33,6 +53,11 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
      */
     isImplicitIndex(name: string): boolean;
     dropIndex(table: string, index: IndexDef, oldIndexName?: string): string;
+    /**
+     * SQLite does not support schema-qualified table names in REFERENCES clauses.
+     * Foreign key references can only point to tables in the same database.
+     */
+    getReferencedTableName(referencedTableName: string, schema?: string): string;
     alterTable(diff: TableDifference, safe?: boolean): string[];
     private getAlterTempTableSQL;
 }

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -1,5 +1,19 @@
 import { Utils } from '@mikro-orm/core';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
+/** SpatiaLite system views that should be automatically ignored */
+const SPATIALITE_VIEWS = [
+    'geometry_columns',
+    'spatial_ref_sys',
+    'views_geometry_columns',
+    'virts_geometry_columns',
+    'geom_cols_ref_sys',
+    'spatial_ref_sys_aux',
+    'vector_layers',
+    'vector_layers_auth',
+    'vector_layers_field_infos',
+    'vector_layers_statistics',
+    'ElementaryGeometries',
+];
 export class SqliteSchemaHelper extends SchemaHelper {
     disableForeignKeysSQL() {
         return 'pragma foreign_keys = off;';
@@ -10,10 +24,67 @@ export class SqliteSchemaHelper extends SchemaHelper {
     supportsSchemaConstraints() {
         return false;
     }
+    getCreateNamespaceSQL(name) {
+        return '';
+    }
+    getDropNamespaceSQL(name) {
+        return '';
+    }
     getListTablesSQL() {
         return `select name as table_name from sqlite_master where type = 'table' and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys' `
             + `union all select name as table_name from sqlite_temp_master where type = 'table' order by name`;
     }
+    async getAllTables(connection, schemas) {
+        const databases = await this.getDatabaseList(connection);
+        const hasAttachedDbs = databases.length > 1; // More than just 'main'
+        // If no attached databases, use original behavior
+        if (!hasAttachedDbs && !schemas?.length) {
+            return connection.execute(this.getListTablesSQL());
+        }
+        // With attached databases, query each one
+        const targetSchemas = schemas?.length ? schemas : databases;
+        const allTables = [];
+        for (const dbName of targetSchemas) {
+            const prefix = this.getSchemaPrefix(dbName);
+            const tables = await connection.execute(`select name from ${prefix}sqlite_master where type = 'table' ` +
+                `and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys'`);
+            for (const t of tables) {
+                allTables.push({ table_name: t.name, schema_name: dbName });
+            }
+        }
+        return allTables;
+    }
+    async getNamespaces(connection) {
+        return this.getDatabaseList(connection);
+    }
+    getIgnoredViewsCondition() {
+        return SPATIALITE_VIEWS.map(v => `name != '${v}'`).join(' and ');
+    }
+    getListViewsSQL() {
+        return `select name as view_name, sql as view_definition from sqlite_master where type = 'view' and ${this.getIgnoredViewsCondition()} order by name`;
+    }
+    async loadViews(schema, connection, schemaName) {
+        const databases = await this.getDatabaseList(connection);
+        const hasAttachedDbs = databases.length > 1; // More than just 'main'
+        // If no attached databases and no specific schema, use original behavior
+        if (!hasAttachedDbs && !schemaName) {
+            const views = await connection.execute(this.getListViewsSQL());
+            for (const view of views) {
+                schema.addView(view.view_name, schemaName, this.extractViewDefinition(view.view_definition));
+            }
+            return;
+        }
+        // With attached databases, query each one
+        /* v8 ignore next - schemaName branch not commonly used */
+        const targetDbs = schemaName ? [schemaName] : databases;
+        for (const dbName of targetDbs) {
+            const prefix = this.getSchemaPrefix(dbName);
+            const views = await connection.execute(`select name as view_name, sql as view_definition from ${prefix}sqlite_master where type = 'view' and ${this.getIgnoredViewsCondition()} order by name`);
+            for (const view of views) {
+                schema.addView(view.view_name, dbName, this.extractViewDefinition(view.view_definition));
+            }
+        }
+    }
     getDropDatabaseSQL(name) {
         if (name === ':memory:') {
             return '';
@@ -29,7 +100,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
             const checks = await this.getChecks(connection, table.name, table.schema);
             const pks = await this.getPrimaryKeys(connection, indexes, table.name, table.schema);
             const fks = await this.getForeignKeys(connection, table.name, table.schema);
-            const enums = await this.getEnumDefinitions(connection, table.name);
+            const enums = await this.getEnumDefinitions(connection, table.name, table.schema);
             table.init(cols, indexes, checks, pks, fks, enums);
         }
     }
@@ -61,6 +132,9 @@ export class SqliteSchemaHelper extends SchemaHelper {
             sql += ', ' + parts.join(', ');
         }
         sql += ')';
+        if (table.comment) {
+            sql += ` /* ${table.comment} */`;
+        }
         const ret = [];
         this.append(ret, sql);
         for (const index of table.getIndexes()) {
@@ -118,16 +192,27 @@ export class SqliteSchemaHelper extends SchemaHelper {
         if (index.expression) {
             return index.expression;
         }
-        tableName = this.quote(tableName);
-        const keyName = this.quote(index.keyName);
-        const sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName} `;
+        // SQLite requires: CREATE INDEX schema.index_name ON table_name (columns)
+        // NOT: CREATE INDEX index_name ON schema.table_name (columns)
+        const [schemaName, rawTableName] = this.splitTableName(tableName);
+        const quotedTableName = this.quote(rawTableName);
+        // If there's a schema, prefix the index name with it
+        let keyName;
+        if (schemaName && schemaName !== 'main') {
+            keyName = `${this.quote(schemaName)}.${this.quote(index.keyName)}`;
+        }
+        else {
+            keyName = this.quote(index.keyName);
+        }
+        const sqlPrefix = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${quotedTableName}`;
+        /* v8 ignore next 4 */
         if (index.columnNames.some(column => column.includes('.'))) {
             // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
-            const sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName} `;
             const columns = this.platform.getJsonIndexDefinition(index);
-            return `${sql}(${columns.join(', ')})`;
+            return `${sqlPrefix} (${columns.join(', ')})`;
         }
-        return `${sql}(${index.columnNames.map(c => this.quote(c)).join(', ')})`;
+        // Use getIndexColumns to support advanced options like sort order and collation
+        return `${sqlPrefix} (${this.getIndexColumns(index)})`;
     }
     parseTableDefinition(sql, cols) {
         const columns = {};
@@ -152,9 +237,35 @@ export class SqliteSchemaHelper extends SchemaHelper {
         }
         return { columns, constraints };
     }
+    /**
+     * Returns schema prefix for pragma and sqlite_master queries.
+     * Returns empty string for main database (no prefix needed).
+     */
+    getSchemaPrefix(schemaName) {
+        if (!schemaName || schemaName === 'main') {
+            return '';
+        }
+        return `${this.platform.quoteIdentifier(schemaName)}.`;
+    }
+    /**
+     * Returns all database names excluding 'temp'.
+     */
+    async getDatabaseList(connection) {
+        const databases = await connection.execute('pragma database_list');
+        return databases.filter(d => d.name !== 'temp').map(d => d.name);
+    }
+    /**
+     * Extracts the SELECT part from a CREATE VIEW statement.
+     */
+    extractViewDefinition(viewDefinition) {
+        const match = viewDefinition?.match(/create\s+view\s+[`"']?\w+[`"']?\s+as\s+(.*)/i);
+        /* v8 ignore next - fallback for non-standard view definitions */
+        return match ? match[1] : viewDefinition;
+    }
     async getColumns(connection, tableName, schemaName) {
-        const columns = await connection.execute(`pragma table_xinfo('${tableName}')`);
-        const sql = `select sql from sqlite_master where type = ? and name = ?`;
+        const prefix = this.getSchemaPrefix(schemaName);
+        const columns = await connection.execute(`pragma ${prefix}table_xinfo('${tableName}')`);
+        const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
         const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
         const composite = columns.reduce((count, col) => count + (col.pk ? 1 : 0), 0) > 1;
         // there can be only one, so naive check like this should be enough
@@ -185,8 +296,9 @@ export class SqliteSchemaHelper extends SchemaHelper {
             };
         });
     }
-    async getEnumDefinitions(connection, tableName) {
-        const sql = `select sql from sqlite_master where type = ? and name = ?`;
+    async getEnumDefinitions(connection, tableName, schemaName) {
+        const prefix = this.getSchemaPrefix(schemaName);
+        const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
         const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
         const checkConstraints = [...(tableDefinition.sql.match(/[`["'][^`\]"']+[`\]"'] text check \(.*?\)/gi) ?? [])];
         return checkConstraints.reduce((o, item) => {
@@ -201,14 +313,16 @@ export class SqliteSchemaHelper extends SchemaHelper {
         }, {});
     }
     async getPrimaryKeys(connection, indexes, tableName, schemaName) {
-        const sql = `pragma table_info(\`${tableName}\`)`;
+        const prefix = this.getSchemaPrefix(schemaName);
+        const sql = `pragma ${prefix}table_info(\`${tableName}\`)`;
         const cols = await connection.execute(sql);
         return cols.filter(col => !!col.pk).map(col => col.name);
     }
     async getIndexes(connection, tableName, schemaName) {
-        const sql = `pragma table_info(\`${tableName}\`)`;
+        const prefix = this.getSchemaPrefix(schemaName);
+        const sql = `pragma ${prefix}table_info(\`${tableName}\`)`;
         const cols = await connection.execute(sql);
-        const indexes = await connection.execute(`pragma index_list(\`${tableName}\`)`);
+        const indexes = await connection.execute(`pragma ${prefix}index_list(\`${tableName}\`)`);
         const ret = [];
         for (const col of cols.filter(c => c.pk)) {
             ret.push({
@@ -220,7 +334,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
             });
         }
         for (const index of indexes.filter(index => !this.isImplicitIndex(index.name))) {
-            const res = await connection.execute(`pragma index_info(\`${index.name}\`)`);
+            const res = await connection.execute(`pragma ${prefix}index_info(\`${index.name}\`)`);
             ret.push(...res.map(row => ({
                 columnNames: [row.name],
                 keyName: index.name,
@@ -259,14 +373,17 @@ export class SqliteSchemaHelper extends SchemaHelper {
         return checks;
     }
     async getColumnDefinitions(connection, tableName, schemaName) {
-        const columns = await connection.execute(`pragma table_xinfo('${tableName}')`);
-        const sql = `select sql from sqlite_master where type = ? and name = ?`;
+        const prefix = this.getSchemaPrefix(schemaName);
+        const columns = await connection.execute(`pragma ${prefix}table_xinfo('${tableName}')`);
+        const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
         const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
         return this.parseTableDefinition(tableDefinition.sql, columns);
     }
     async getForeignKeys(connection, tableName, schemaName) {
         const { constraints } = await this.getColumnDefinitions(connection, tableName, schemaName);
-        const fks = await connection.execute(`pragma foreign_key_list(\`${tableName}\`)`);
+        const prefix = this.getSchemaPrefix(schemaName);
+        const fks = await connection.execute(`pragma ${prefix}foreign_key_list(\`${tableName}\`)`);
+        const qualifiedTableName = schemaName ? `${schemaName}.${tableName}` : tableName;
         return fks.reduce((ret, fk) => {
             const constraintName = this.platform.getIndexName(tableName, [fk.from], 'foreign');
             const constraint = constraints?.find(c => c.includes(constraintName));
@@ -274,7 +391,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
                 constraintName,
                 columnName: fk.from,
                 columnNames: [fk.from],
-                localTableName: tableName,
+                localTableName: qualifiedTableName,
                 referencedTableName: fk.table,
                 referencedColumnName: fk.to,
                 referencedColumnNames: [fk.to],
@@ -305,6 +422,15 @@ export class SqliteSchemaHelper extends SchemaHelper {
     dropIndex(table, index, oldIndexName = index.keyName) {
         return `drop index ${this.quote(oldIndexName)}`;
     }
+    /**
+     * SQLite does not support schema-qualified table names in REFERENCES clauses.
+     * Foreign key references can only point to tables in the same database.
+     */
+    getReferencedTableName(referencedTableName, schema) {
+        const [schemaName, tableName] = this.splitTableName(referencedTableName);
+        // Strip any schema prefix - SQLite REFERENCES clause doesn't support it
+        return tableName;
+    }
     alterTable(diff, safe) {
         const ret = [];
         const [schemaName, tableName] = this.splitTableName(diff.name);

package/dialects/sqlite/index.d.ts

@@ -2,4 +2,3 @@ export * from './BaseSqliteConnection.js';
 export * from './BaseSqlitePlatform.js';
 export * from './SqliteSchemaHelper.js';
 export * from './SqliteNativeQueryBuilder.js';
-export * from './SqliteExceptionConverter.js';

package/dialects/sqlite/index.js

@@ -2,4 +2,3 @@ export * from './BaseSqliteConnection.js';
 export * from './BaseSqlitePlatform.js';
 export * from './SqliteSchemaHelper.js';
 export * from './SqliteNativeQueryBuilder.js';
-export * from './SqliteExceptionConverter.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-dev.98",
+  "version": "7.0.0-rc.0",
   "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.",
   "type": "module",
   "exports": {
@@ -41,7 +41,7 @@
     "node": ">= 22.17.0"
   },
   "scripts": {
-    "build": "yarn clean && yarn compile && yarn copy",
+    "build": "yarn compile && yarn copy",
     "clean": "yarn run -T rimraf ./dist",
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
@@ -50,13 +50,12 @@
     "access": "public"
   },
   "dependencies": {
-    "kysely": "0.28.8",
-    "sqlstring": "2.3.3"
+    "kysely": "0.28.11"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.6.2"
+    "@mikro-orm/core": "^6.6.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.98"
+    "@mikro-orm/core": "7.0.0-rc.0"
   }
 }

package/plugin/transformer.d.ts

@@ -23,7 +23,7 @@ export declare class MikroTransformer extends OperationNodeTransformer {
      * Global map of all entities involved in the query.
      * Populated during AST transformation and used for result transformation.
      */
-    protected readonly entityMap: Map<string, EntityMetadata<any>>;
+    protected readonly entityMap: Map<string, EntityMetadata<any, import("@mikro-orm/core").EntityCtor<any>>>;
     constructor(em: SqlEntityManager, options?: MikroKyselyPluginOptions);
     reset(): void;
     getOutputEntityMap(): Map<string, EntityMetadata>;

package/plugin/transformer.js

@@ -706,7 +706,7 @@ export class MikroTransformer extends OperationNodeTransformer {
      * Find entity metadata by table name or entity name
      */
     findEntityMetadata(name) {
-        const byEntity = this.metadata.find(name);
+        const byEntity = this.metadata.getByClassName(name, false);
         if (byEntity) {
             return byEntity;
         }

package/query/CriteriaNode.d.ts

@@ -1,4 +1,4 @@
-import { type EntityKey, type EntityProperty, type MetadataStorage } from '@mikro-orm/core';
+import { type EntityKey, type EntityProperty, type MetadataStorage, type RawQueryFragmentSymbol, type EntityName } from '@mikro-orm/core';
 import type { ICriteriaNode, ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings.js';
 /**
  * Helper for working with deeply nested where/orderBy/having criteria. Uses composite pattern to build tree from the payload.
@@ -7,21 +7,25 @@ import type { ICriteriaNode, ICriteriaNodeProcessOptions, IQueryBuilder } from '
  */
 export declare class CriteriaNode<T extends object> implements ICriteriaNode<T> {
     protected readonly metadata: MetadataStorage;
-    readonly entityName: string;
+    readonly entityName: EntityName<T>;
     readonly parent?: ICriteriaNode<T> | undefined;
-    readonly key?: EntityKey<T> | undefined;
+    readonly key?: (EntityKey<T> | RawQueryFragmentSymbol) | undefined;
+    readonly validate: boolean;
     readonly strict: boolean;
     payload: any;
     prop?: EntityProperty<T>;
     index?: number;
-    constructor(metadata: MetadataStorage, entityName: string, parent?: ICriteriaNode<T> | undefined, key?: EntityKey<T> | undefined, validate?: boolean, strict?: boolean);
+    constructor(metadata: MetadataStorage, entityName: EntityName<T>, parent?: ICriteriaNode<T> | undefined, key?: (EntityKey<T> | RawQueryFragmentSymbol) | undefined, validate?: boolean, strict?: boolean);
     process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
     unwrap(): any;
     shouldInline(payload: any): boolean;
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
     shouldRename(payload: any): boolean;
     renameFieldToPK<T>(qb: IQueryBuilder<T>, ownerAlias?: string): string;
-    getPath(addIndex?: boolean): string;
+    getPath(opts?: {
+        addIndex?: boolean;
+        parentPath?: string;
+    }): string;
     private isPivotJoin;
     getPivotPath(path: string): string;
     aliased(field: string, alias?: string): string;

package/query/CriteriaNode.js

@@ -9,6 +9,7 @@ export class CriteriaNode {
     entityName;
     parent;
     key;
+    validate;
     strict;
     payload;
     prop;
@@ -18,9 +19,10 @@ export class CriteriaNode {
         this.entityName = entityName;
         this.parent = parent;
         this.key = key;
+        this.validate = validate;
         this.strict = strict;
         const meta = parent && metadata.find(parent.entityName);
-        if (meta && key) {
+        if (meta && key && !RawQueryFragment.isKnownFragmentSymbol(key)) {
             const pks = Utils.splitPrimaryKeys(key);
             if (pks.length > 1) {
                 return;
@@ -29,8 +31,8 @@ export class CriteriaNode {
                 this.prop = meta.props.find(prop => prop.name === k || (prop.fieldNames?.length === 1 && prop.fieldNames[0] === k && prop.persist !== false));
                 const isProp = this.prop || meta.props.find(prop => (prop.fieldNames || []).includes(k));
                 // do not validate if the key is prefixed or type casted (e.g. `k::text`)
-                if (validate && !isProp && !k.includes('.') && !k.includes('::') && !Utils.isOperator(k) && !RawQueryFragment.isKnownFragment(k)) {
-                    throw new Error(`Trying to query by not existing property ${entityName}.${k}`);
+                if (validate && !isProp && !k.includes('.') && !k.includes('::') && !Utils.isOperator(k)) {
+                    throw new Error(`Trying to query by not existing property ${Utils.className(entityName)}.${k}`);
                 }
             }
         }
@@ -50,11 +52,9 @@ export class CriteriaNode {
     shouldRename(payload) {
         const type = this.prop ? this.prop.kind : null;
         const composite = this.prop?.joinColumns ? this.prop.joinColumns.length > 1 : false;
-        const customExpression = RawQueryFragment.isKnownFragment(this.key);
-        const scalar = payload === null || Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
-        const plainObject = Utils.isPlainObject(payload);
-        const keys = plainObject ? Object.keys(payload) : [];
-        const operator = plainObject && keys.every(k => Utils.isOperator(k, false));
+        const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
+        const scalar = payload === null || Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || rawField;
+        const operator = Utils.isPlainObject(payload) && Utils.getObjectQueryKeys(payload).every(k => Utils.isOperator(k, false));
         if (composite) {
             return true;
         }
@@ -78,13 +78,13 @@ export class CriteriaNode {
         }
         return Utils.getPrimaryKeyHash(this.prop.referencedColumnNames.map(col => `${alias}.${col}`));
     }
-    getPath(addIndex = false) {
+    getPath(opts) {
         // use index on parent only if we are processing to-many relation
         const addParentIndex = this.prop && [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(this.prop.kind);
-        const parentPath = this.parent?.getPath(addParentIndex) ?? this.entityName;
-        const index = addIndex && this.index != null ? `[${this.index}]` : '';
+        const parentPath = opts?.parentPath ?? this.parent?.getPath({ addIndex: addParentIndex }) ?? Utils.className(this.entityName);
+        const index = opts?.addIndex && this.index != null ? `[${this.index}]` : '';
         // ignore group operators to allow easier mapping (e.g. for orderBy)
-        const key = this.key && !['$and', '$or', '$not'].includes(this.key) ? '.' + this.key : '';
+        const key = this.key && !RawQueryFragment.isKnownFragmentSymbol(this.key) && !['$and', '$or', '$not'].includes(this.key) ? '.' + this.key : '';
         const ret = parentPath + index + key;
         if (this.isPivotJoin()) {
             // distinguish pivot table join from target entity join
@@ -96,9 +96,9 @@ export class CriteriaNode {
         if (!this.key || !this.prop) {
             return false;
         }
-        const customExpression = RawQueryFragment.isKnownFragment(this.key);
-        const scalar = this.payload === null || Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || customExpression;
-        const operator = Utils.isObject(this.payload) && Object.keys(this.payload).every(k => Utils.isOperator(k, false));
+        const rawField = RawQueryFragment.isKnownFragmentSymbol(this.key);
+        const scalar = this.payload === null || Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || rawField;
+        const operator = Utils.isObject(this.payload) && Utils.getObjectQueryKeys(this.payload).every(k => Utils.isOperator(k, false));
         return this.prop.kind === ReferenceKind.MANY_TO_MANY && (scalar || operator);
     }
     getPivotPath(path) {
@@ -111,6 +111,7 @@ export class CriteriaNode {
         return this.strict;
     }
     /** @ignore */
+    /* v8 ignore next */
     [Symbol.for('nodejs.util.inspect.custom')]() {
         const o = {};
         ['entityName', 'key', 'index', 'payload']

package/query/CriteriaNodeFactory.d.ts

@@ -1,12 +1,12 @@
-import { type Dictionary, type EntityKey, type EntityMetadata, type MetadataStorage } from '@mikro-orm/core';
+import { type Dictionary, type EntityKey, type EntityMetadata, type EntityName, type MetadataStorage, type RawQueryFragmentSymbol } from '@mikro-orm/core';
 import type { ICriteriaNode } from '../typings.js';
 /**
  * @internal
  */
 export declare class CriteriaNodeFactory {
-    static createNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
-    static createScalarNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
-    static createArrayNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any[], parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
-    static createObjectNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: Dictionary, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
-    static createObjectItemNode<T extends object>(metadata: MetadataStorage, entityName: string, node: ICriteriaNode<T>, payload: Dictionary, key: EntityKey<T>, meta?: EntityMetadata<T>): ICriteriaNode<T>;
+    static createNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T> | RawQueryFragmentSymbol, validate?: boolean): ICriteriaNode<T>;
+    static createScalarNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T> | RawQueryFragmentSymbol, validate?: boolean): ICriteriaNode<T>;
+    static createArrayNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: any[], parent?: ICriteriaNode<T>, key?: EntityKey<T>, validate?: boolean): ICriteriaNode<T>;
+    static createObjectNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, payload: Dictionary, parent?: ICriteriaNode<T>, key?: EntityKey<T>, validate?: boolean): ICriteriaNode<T>;
+    static createObjectItemNode<T extends object>(metadata: MetadataStorage, entityName: EntityName<T>, node: ICriteriaNode<T>, payload: Dictionary, key: EntityKey<T> | RawQueryFragmentSymbol, meta?: EntityMetadata<T>, validate?: boolean): ICriteriaNode<T>;
 }