@mikro-orm/sql 7.0.0-dev.113 → 7.0.0-dev.115

package/query/QueryBuilderHelper.js

@@ -1,4 +1,4 @@
-import { ALIAS_REPLACEMENT, ALIAS_REPLACEMENT_RE, ArrayType, isRaw, LockMode, OptimisticLockError, QueryOperator, QueryOrderNumeric, raw, RawQueryFragment, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
+import { ALIAS_REPLACEMENT, ALIAS_REPLACEMENT_RE, ArrayType, inspect, isRaw, LockMode, OptimisticLockError, QueryOperator, QueryOrderNumeric, raw, Raw, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
 import { JoinType, QueryType } from './enums.js';
 import { NativeQueryBuilder } from './NativeQueryBuilder.js';
 /**
@@ -25,6 +25,9 @@ export class QueryBuilderHelper {
         if (isRaw(field)) {
             return raw(field.sql, field.params);
         }
+        if (Raw.isKnownFragmentSymbol(field)) {
+            return Raw.getKnownFragment(field);
+        }
         /* v8 ignore next */
         if (typeof field !== 'string') {
             return field;
@@ -60,16 +63,11 @@ export class QueryBuilderHelper {
             }
             return raw('(' + parts.map(part => this.platform.quoteIdentifier(part)).join(', ') + ')');
         }
-        const rawField = RawQueryFragment.getKnownFragment(field);
-        if (rawField) {
-            return rawField;
-        }
         const aliasPrefix = isTableNameAliasRequired ? this.alias + '.' : '';
         const [a, f] = this.splitField(field);
         const prop = this.getProperty(f, a);
         const fkIdx2 = prop?.fieldNames.findIndex(name => name === f) ?? -1;
         const fkIdx = fkIdx2 === -1 ? 0 : fkIdx2;
-        let ret = field;
         // embeddable nested path instead of a regular property with table alias, reset alias
         if (prop?.name === a && prop.embeddedProps[f]) {
             return aliasPrefix + prop.fieldNames[fkIdx];
@@ -107,10 +105,7 @@ export class QueryBuilderHelper {
             }
             return raw(`${valueSQL} as ${this.platform.quoteIdentifier(alias ?? prop.fieldNames[fkIdx])}`);
         }
-        // do not wrap custom expressions
-        if (!rawField) {
-            ret = this.prefix(field, false, false, fkIdx);
-        }
+        let ret = this.prefix(field, false, false, fkIdx);
         if (alias) {
             ret += ' as ' + alias;
         }
@@ -133,7 +128,7 @@ export class QueryBuilderHelper {
     }
     joinOneToReference(prop, ownerAlias, alias, type, cond = {}, schema) {
         const prop2 = prop.targetMeta.properties[prop.mappedBy || prop.inversedBy];
-        const table = this.getTableName(prop.type);
+        const table = this.getTableName(prop.targetMeta.class);
         const joinColumns = prop.owner ? prop.referencedColumnNames : prop2.joinColumns;
         const inverseJoinColumns = prop.referencedColumnNames;
         const primaryKeys = prop.owner ? prop.joinColumns : prop2.referencedColumnNames;
@@ -147,7 +142,7 @@ export class QueryBuilderHelper {
     joinManyToOneReference(prop, ownerAlias, alias, type, cond = {}, schema) {
         return {
             prop, type, cond, ownerAlias, alias,
-            table: this.getTableName(prop.type),
+            table: this.getTableName(prop.targetMeta.class),
             schema: prop.targetMeta?.schema === '*' ? '*' : this.driver.getSchemaName(prop.targetMeta, { schema }),
             joinColumns: prop.referencedColumnNames,
             primaryKeys: prop.fieldNames,
@@ -172,7 +167,7 @@ export class QueryBuilderHelper {
         if (type === JoinType.pivotJoin) {
             return ret;
         }
-        const prop2 = prop.owner ? pivotMeta.relations[1] : pivotMeta.relations[0];
+        const prop2 = pivotMeta.relations[prop.owner ? 1 : 0];
         ret[`${pivotAlias}.${prop2.name}#${alias}`] = this.joinManyToOneReference(prop2, pivotAlias, alias, type, cond, schema);
         ret[`${pivotAlias}.${prop2.name}#${alias}`].path = path;
         const tmp = prop2.referencedTableName.split('.');
@@ -243,7 +238,7 @@ export class QueryBuilderHelper {
         this.alias = oldAlias;
         if (subquery.sql) {
             conditions.push(subquery.sql);
-            params.push(...subquery.params);
+            subquery.params.forEach(p => params.push(p));
         }
         if (conditions.length > 0) {
             sql += ` on ${conditions.join(' and ')}`;
@@ -269,7 +264,7 @@ export class QueryBuilderHelper {
     }
     getTableName(entityName) {
         const meta = this.metadata.find(entityName);
-        return meta ? meta.collection : entityName;
+        return meta?.tableName ?? Utils.className(entityName);
     }
     /**
      * Checks whether the RE can be rewritten to simple LIKE query
@@ -332,7 +327,7 @@ export class QueryBuilderHelper {
     _appendQueryCondition(type, cond, operator) {
         const parts = [];
         const params = [];
-        for (const k of Object.keys(cond)) {
+        for (const k of Utils.getObjectQueryKeys(cond)) {
             if (k === '$and' || k === '$or') {
                 if (operator) {
                     this.append(() => this.appendGroupCondition(type, k, cond[k]), parts, params, operator);
@@ -344,7 +339,7 @@ export class QueryBuilderHelper {
             if (k === '$not') {
                 const res = this._appendQueryCondition(type, cond[k]);
                 parts.push(`not (${res.sql})`);
-                params.push(...res.params);
+                res.params.forEach(p => params.push(p));
                 continue;
             }
             this.append(() => this.appendQuerySubCondition(type, cond, k), parts, params);
@@ -362,7 +357,6 @@ export class QueryBuilderHelper {
     appendQuerySubCondition(type, cond, key) {
         const parts = [];
         const params = [];
-        const fields = Utils.splitPrimaryKeys(key);
         if (this.isSimpleRegExp(cond[key])) {
             parts.push(`${this.platform.quoteIdentifier(this.mapper(key, type))} like ?`);
             params.push(this.getRegExpParam(cond[key]));
@@ -372,19 +366,21 @@ export class QueryBuilderHelper {
             return this.processObjectSubCondition(cond, key, type);
         }
         const op = cond[key] === null ? 'is' : '=';
-        const raw = RawQueryFragment.getKnownFragment(key);
-        if (raw) {
+        if (Raw.isKnownFragmentSymbol(key)) {
+            const raw = Raw.getKnownFragment(key);
             const sql = raw.sql.replaceAll(ALIAS_REPLACEMENT, this.alias);
             const value = Utils.asArray(cond[key]);
             params.push(...raw.params);
             if (value.length > 0) {
-                const val = this.getValueReplacement(fields, value[0], params, key);
+                const k = key;
+                const val = this.getValueReplacement([k], value[0], params, k);
                 parts.push(`${sql} ${op} ${val}`);
                 return { sql: parts.join(' and '), params };
             }
             parts.push(sql);
             return { sql: parts.join(' and '), params };
         }
+        const fields = Utils.splitPrimaryKeys(key);
         if (this.subQueries[key]) {
             const val = this.getValueReplacement(fields, cond[key], params, key);
             parts.push(`(${this.subQueries[key]}) ${op} ${val}`);
@@ -404,9 +400,7 @@ export class QueryBuilderHelper {
         }
         // grouped condition for one field, e.g. `{ age: { $gte: 10, $lt: 50 } }`
         if (size > 1) {
-            const rawField = RawQueryFragment.getKnownFragment(key);
             const subCondition = Object.entries(value).map(([subKey, subValue]) => {
-                key = rawField?.clone().toString() ?? key;
                 return ({ [key]: { [subKey]: subValue } });
             });
             for (const sub of subCondition) {
@@ -424,7 +418,8 @@ export class QueryBuilderHelper {
             throw ValidationError.invalidQueryCondition(cond);
         }
         const replacement = this.getOperatorReplacement(op, value);
-        const fields = Utils.splitPrimaryKeys(key);
+        const rawField = Raw.isKnownFragmentSymbol(key);
+        const fields = rawField ? [key] : Utils.splitPrimaryKeys(key);
         if (fields.length > 1 && Array.isArray(value[op])) {
             const singleTuple = !value[op].every((v) => Array.isArray(v));
             if (!this.platform.allowsComparingTuples()) {
@@ -452,12 +447,12 @@ export class QueryBuilderHelper {
             parts.push(`(${this.subQueries[key]}) ${replacement} ${val}`);
             return { sql: parts.join(' and '), params };
         }
-        const [a, f] = this.splitField(key);
-        const prop = this.getProperty(f, a);
+        const [a, f] = rawField ? [] : this.splitField(key);
+        const prop = f && this.getProperty(f, a);
         if (op === '$fulltext') {
             /* v8 ignore next */
             if (!prop) {
-                throw new Error(`Cannot use $fulltext operator on ${key}, property not found`);
+                throw new Error(`Cannot use $fulltext operator on ${String(key)}, property not found`);
             }
             const { sql, params: params2 } = raw(this.platform.getFullTextWhereClause(prop), {
                 column: this.mapper(key, type, undefined, null),
@@ -469,7 +464,7 @@ export class QueryBuilderHelper {
         else if (['$in', '$nin'].includes(op) && Array.isArray(value[op]) && value[op].length === 0) {
             parts.push(`1 = ${op === '$in' ? 0 : 1}`);
         }
-        else if (value[op] instanceof RawQueryFragment || value[op] instanceof NativeQueryBuilder) {
+        else if (value[op] instanceof Raw || value[op] instanceof NativeQueryBuilder) {
             const query = value[op] instanceof NativeQueryBuilder ? value[op].toRaw() : value[op];
             const mappedKey = this.mapper(key, type, query, null);
             let sql = query.sql;
@@ -501,7 +496,7 @@ export class QueryBuilderHelper {
                 params.push(item);
             }
             else {
-                value.forEach(v => params.push(v));
+                value.forEach(p => params.push(p));
             }
             return `(${value.map(() => '?').join(', ')})`;
         }
@@ -528,6 +523,31 @@ export class QueryBuilderHelper {
         }
         return replacement;
     }
+    validateQueryOrder(orderBy) {
+        const strKeys = [];
+        const rawKeys = [];
+        for (const key of Utils.getObjectQueryKeys(orderBy)) {
+            const raw = Raw.getKnownFragment(key);
+            if (raw) {
+                rawKeys.push(raw);
+            }
+            else {
+                strKeys.push(key);
+            }
+        }
+        if (strKeys.length > 0 && rawKeys.length > 0) {
+            const example = [
+                ...strKeys.map(key => ({ [key]: orderBy[key] })),
+                ...rawKeys.map(rawKey => ({ [`raw('${rawKey.sql}')`]: orderBy[rawKey] })),
+            ];
+            throw new Error([
+                `Invalid "orderBy": You are mixing field-based keys and raw SQL fragments inside a single object.`,
+                `This is not allowed because object key order cannot reliably preserve evaluation order.`,
+                `To fix this, split them into separate objects inside an array:\n`,
+                `orderBy: ${inspect(example, { depth: 5 }).replace(/"raw\('(.*)'\)"/g, `[raw('$1')]`)}`,
+            ].join('\n'));
+        }
+    }
     getQueryOrder(type, orderBy, populate) {
         if (Array.isArray(orderBy)) {
             return orderBy.flatMap(o => this.getQueryOrder(type, o, populate));
@@ -536,11 +556,11 @@ export class QueryBuilderHelper {
     }
     getQueryOrderFromObject(type, orderBy, populate) {
         const ret = [];
-        for (const key of Object.keys(orderBy)) {
+        for (const key of Utils.getObjectQueryKeys(orderBy)) {
             const direction = orderBy[key];
             const order = typeof direction === 'number' ? QueryOrderNumeric[direction] : direction;
-            const raw = RawQueryFragment.getKnownFragment(key);
-            if (raw) {
+            if (Raw.isKnownFragmentSymbol(key)) {
+                const raw = Raw.getKnownFragment(key);
                 ret.push(...this.platform.getOrderByExpression(this.platform.formatQuery(raw.sql, raw.params), order));
                 continue;
             }
@@ -549,7 +569,7 @@ export class QueryBuilderHelper {
                 let [alias, field] = this.splitField(f, true);
                 alias = populate[alias] || alias;
                 const prop = this.getProperty(field, alias);
-                const noPrefix = (prop?.persist === false && !prop.formula && !prop.embedded) || RawQueryFragment.isKnownFragment(f);
+                const noPrefix = (prop?.persist === false && !prop.formula && !prop.embedded) || Raw.isKnownFragment(f);
                 const column = this.mapper(noPrefix ? field : `${alias}.${field}`, type, undefined, null);
                 /* v8 ignore next */
                 const rawColumn = typeof column === 'string' ? column.split('.').map(e => this.platform.quoteIdentifier(e)).join('.') : column;
@@ -624,7 +644,7 @@ export class QueryBuilderHelper {
     getLockSQL(qb, lockMode, lockTables = [], joinsMap) {
         const meta = this.metadata.find(this.entityName);
         if (lockMode === LockMode.OPTIMISTIC && meta && !meta.versionProperty) {
-            throw OptimisticLockError.lockFailed(this.entityName);
+            throw OptimisticLockError.lockFailed(Utils.className(this.entityName));
         }
         if (lockMode !== LockMode.OPTIMISTIC && lockTables.length === 0 && joinsMap) {
             const joins = Object.values(joinsMap);
@@ -652,7 +672,7 @@ export class QueryBuilderHelper {
         if (!this.isPrefixed(field)) {
             const alias = always ? (quote ? this.alias : this.platform.quoteIdentifier(this.alias)) + '.' : '';
             const fieldName = this.fieldName(field, this.alias, always, idx);
-            if (fieldName instanceof RawQueryFragment) {
+            if (fieldName instanceof Raw) {
                 return fieldName.sql;
             }
             ret = alias + fieldName;
@@ -661,7 +681,7 @@ export class QueryBuilderHelper {
             const [a, ...rest] = field.split('.');
             const f = rest.join('.');
             const fieldName = this.fieldName(f, a, always, idx);
-            if (fieldName instanceof RawQueryFragment) {
+            if (fieldName instanceof Raw) {
                 return fieldName.sql;
             }
             ret = a + '.' + fieldName;
@@ -683,7 +703,7 @@ export class QueryBuilderHelper {
         }
         for (const sub of subCondition) {
             // skip nesting parens if the value is simple = scalar or object without operators or with only single key, being the operator
-            const keys = Object.keys(sub);
+            const keys = Utils.getObjectQueryKeys(sub);
             const val = sub[keys[0]];
             const simple = !Utils.isPlainObject(val) || Utils.getObjectKeysSize(val) === 1 || Object.keys(val).every(k => !Utils.isOperator(k));
             if (keys.length === 1 && simple) {
@@ -719,9 +739,9 @@ export class QueryBuilderHelper {
     }
     getProperty(field, alias) {
         const entityName = this.aliasMap[alias]?.entityName || this.entityName;
-        const meta = this.metadata.find(entityName);
+        const meta = this.metadata.get(entityName);
         // check if `alias` is not matching an embedded property name instead of alias, e.g. `address.city`
-        if (alias && meta) {
+        if (alias) {
             const prop = meta.properties[alias];
             if (prop?.kind === ReferenceKind.EMBEDDED) {
                 // we want to select the full object property so hydration works as expected
@@ -733,13 +753,10 @@ export class QueryBuilderHelper {
                 return nest(prop);
             }
         }
-        if (meta) {
-            if (meta.properties[field]) {
-                return meta.properties[field];
-            }
-            return meta.relations.find(prop => prop.fieldNames?.some(name => field === name));
+        if (meta.properties[field]) {
+            return meta.properties[field];
         }
-        return undefined;
+        return meta.relations.find(prop => prop.fieldNames?.some(name => field === name));
     }
     isTableNameAliasRequired(type) {
         return [QueryType.SELECT, QueryType.COUNT].includes(type);

package/query/ScalarCriteriaNode.js

@@ -12,7 +12,7 @@ export class ScalarCriteriaNode extends CriteriaNode {
         if (this.shouldJoin(qb, nestedAlias)) {
             const path = this.getPath();
             const parentPath = this.parent.getPath(); // the parent is always there, otherwise `shouldJoin` would return `false`
-            const nestedAlias = qb.getAliasForJoinPath(path) || qb.getNextAlias(this.prop?.pivotTable ?? this.entityName);
+            const nestedAlias = qb.getAliasForJoinPath(path) || qb.getNextAlias(this.prop?.pivotEntity ?? this.entityName);
             const field = this.aliased(this.prop.name, options?.alias);
             const type = this.prop.kind === ReferenceKind.MANY_TO_MANY ? JoinType.pivotJoin : JoinType.leftJoin;
             qb.join(field, nestedAlias, undefined, type, path);

package/schema/DatabaseSchema.js

@@ -1,4 +1,4 @@
-import { ReferenceKind, RawQueryFragment, } from '@mikro-orm/core';
+import { ReferenceKind, isRaw, } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable.js';
 /**
  * @internal
@@ -108,15 +108,11 @@ export class DatabaseSchema {
             table.addIndex(meta, { properties: meta.props.filter(prop => prop.primary).map(prop => prop.name) }, 'primary');
             for (const check of meta.checks) {
                 const columnName = check.property ? meta.properties[check.property].fieldNames[0] : undefined;
-                let expression = check.expression;
-                const raw = RawQueryFragment.getKnownFragment(expression);
-                if (raw) {
-                    expression = platform.formatQuery(raw.sql, raw.params);
-                }
+                const expression = isRaw(check.expression) ? platform.formatQuery(check.expression.sql, check.expression.params) : check.expression;
                 table.addCheck({
                     name: check.name,
                     expression,
-                    definition: `check (${check.expression})`,
+                    definition: `check (${expression})`,
                     columnName,
                 });
             }

package/schema/SchemaHelper.d.ts

@@ -1,4 +1,4 @@
-import { type Connection, type Dictionary } from '@mikro-orm/core';
+import { type Connection, type Dictionary, RawQueryFragment } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } from '../typings.js';
@@ -39,7 +39,7 @@ export declare abstract class SchemaHelper {
     getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
     protected mapIndexes(indexes: IndexDef[]): Promise<IndexDef[]>;
     mapForeignKeys(fks: any[], tableName: string, schemaName?: string): Dictionary;
-    normalizeDefaultValue(defaultValue: string, length?: number, defaultValues?: Dictionary<string[]>): string | number;
+    normalizeDefaultValue(defaultValue: string | RawQueryFragment, length?: number, defaultValues?: Dictionary<string[]>): string | number;
     getCreateDatabaseSQL(name: string): string;
     getDropDatabaseSQL(name: string): string;
     getCreateNamespaceSQL(name: string): string;

package/schema/SchemaHelper.js

@@ -323,9 +323,8 @@ export class SchemaHelper {
         if (defaultValue == null) {
             return defaultValue;
         }
-        const raw = RawQueryFragment.getKnownFragment(defaultValue);
-        if (raw) {
-            return this.platform.formatQuery(raw.sql, raw.params);
+        if (defaultValue instanceof RawQueryFragment) {
+            return this.platform.formatQuery(defaultValue.sql, defaultValue.params);
         }
         const genericValue = defaultValue.replace(/\(\d+\)/, '(?)').toLowerCase();
         const norm = defaultValues[genericValue];

package/schema/SqlSchemaGenerator.js

@@ -114,7 +114,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         await this.execute(this.helper.disableForeignKeysSQL());
         const schema = options?.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());
         for (const meta of this.getOrderedMetadata(schema).reverse()) {
-            await this.driver.createQueryBuilder(meta.className, this.em?.getTransactionContext(), 'write', false)
+            await this.driver.createQueryBuilder(meta.class, this.em?.getTransactionContext(), 'write', false)
                 .withSchema(schema)
                 .truncate()
                 .execute();
@@ -197,7 +197,7 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         const toSchema = this.getTargetSchema(options.schema);
         const schemas = toSchema.getNamespaces();
         const fromSchema = options.fromSchema ?? (await DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas, undefined, this.options.skipTables));
-        const wildcardSchemaTables = Object.values(this.metadata.getAll()).filter(meta => meta.schema === '*').map(meta => meta.tableName);
+        const wildcardSchemaTables = [...this.metadata.getAll().values()].filter(meta => meta.schema === '*').map(meta => meta.tableName);
         fromSchema.prune(options.schema, wildcardSchemaTables);
         toSchema.prune(options.schema, wildcardSchemaTables);
         return { fromSchema, toSchema };