@mikro-orm/knex 6.0.0-dev.81 → 6.0.0-dev.83

package/AbstractSqlDriver.js

@@ -643,17 +643,18 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
      * @internal
      */
     mapPropToFieldNames(qb, prop, tableAlias) {
-        const aliased = qb.ref(tableAlias ? `${tableAlias}__${prop.fieldNames[0]}` : prop.fieldNames[0]).toString();
+        const knex = this.connection.getKnex();
+        const aliased = knex.ref(tableAlias ? `${tableAlias}__${prop.fieldNames[0]}` : prop.fieldNames[0]).toString();
         if (prop.customType?.convertToJSValueSQL && tableAlias) {
-            const prefixed = qb.ref(prop.fieldNames[0]).withSchema(tableAlias).toString();
+            const prefixed = knex.ref(prop.fieldNames[0]).withSchema(tableAlias).toString();
             return [(0, core_1.raw)(`${prop.customType.convertToJSValueSQL(prefixed, this.platform)} as ${aliased}`)];
         }
         if (prop.formula) {
-            const alias = qb.ref(tableAlias ?? qb.alias).toString();
+            const alias = knex.ref(tableAlias ?? qb.alias).toString();
             return [(0, core_1.raw)(`${prop.formula(alias)} as ${aliased}`)];
         }
         if (tableAlias) {
-            return prop.fieldNames.map(fieldName => qb.ref(fieldName).withSchema(tableAlias).as(`${tableAlias}__${fieldName}`));
+            return prop.fieldNames.map(fieldName => knex.ref(fieldName).withSchema(tableAlias).as(`${tableAlias}__${fieldName}`));
         }
         return prop.fieldNames;
     }
@@ -853,8 +854,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             meta.props
                 .filter(prop => prop.formula && !lazyProps.includes(prop))
                 .forEach(prop => {
-                const alias = qb.ref(qb.alias).toString();
-                const aliased = qb.ref(prop.fieldNames[0]).toString();
+                const alias = this.connection.getKnex().ref(qb.alias).toString();
+                const aliased = this.connection.getKnex().ref(prop.fieldNames[0]).toString();
                 ret.push((0, core_1.raw)(`${prop.formula(alias)} as ${aliased}`));
             });
             meta.props

package/AbstractSqlPlatform.js

@@ -48,9 +48,15 @@ class AbstractSqlPlatform extends core_1.Platform {
         let j = 0;
         let pos = 0;
         let ret = '';
-        if (sql[0] === '?' && sql[1] !== '?') {
-            ret += this.quoteValue(params[j++]);
-            pos = 1;
+        if (sql[0] === '?') {
+            if (sql[1] === '?') {
+                ret += this.quoteIdentifier(params[j++]);
+                pos = 2;
+            }
+            else {
+                ret += this.quoteValue(params[j++]);
+                pos = 1;
+            }
         }
         while (pos < sql.length) {
             const idx = sql.indexOf('?', pos + 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.81",
+  "version": "6.0.0-dev.83",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -66,6 +66,6 @@
     "@mikro-orm/core": "^5.7.10"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "~6.0.0-dev.81"
+    "@mikro-orm/core": "~6.0.0-dev.83"
   }
 }

package/query/QueryBuilder.d.ts

@@ -115,12 +115,6 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
      * @internal
      */
     populate(populate: PopulateOptions<T>[], populateWhere?: ObjectQuery<T> | PopulateHint): this;
-    /**
-     * @internal
-     */
-    ref(field: string): Knex.Ref<string, {
-        [x: string]: string;
-    }>;
     limit(limit?: number, offset?: number): this;
     offset(offset?: number): this;
     withSchema(schema?: string): this;

package/query/QueryBuilder.js

@@ -299,12 +299,6 @@ class QueryBuilder {
         this._populateWhere = populateWhere;
         return this;
     }
-    /**
-     * @internal
-     */
-    ref(field) {
-        return this.knex.ref(field);
-    }
     limit(limit, offset = 0) {
         this.ensureNotFinalized();
         this._limit = limit;
@@ -947,7 +941,7 @@ class QueryBuilder {
                     if (!prop?.persist && !prop?.formula) {
                         addToSelect.push(fieldName);
                     }
-                    orderBy.push({ [(0, core_1.raw)(`min(${this.ref(fieldName)}${type})`)]: direction });
+                    orderBy.push({ [(0, core_1.raw)(`min(${this.knex.ref(fieldName)}${type})`)]: direction });
                 }
             }
             subQuery.orderBy(orderBy);

package/query/QueryBuilderHelper.js

@@ -155,6 +155,7 @@ class QueryBuilderHelper {
         const prop2 = pivotMeta.relations[0] === prop ? pivotMeta.relations[1] : pivotMeta.relations[0];
         return {
             prop, type, cond, ownerAlias, alias,
+            inverseAlias: ownerAlias,
             table: pivotMeta.collection,
             schema: pivotMeta.schema,
             joinColumns: prop.joinColumns,
@@ -179,7 +180,7 @@ class QueryBuilderHelper {
             });
             if (join.prop.targetMeta.discriminatorValue && !join.path?.endsWith('[pivot]')) {
                 const typeProperty = join.prop.targetMeta.root.discriminatorColumn;
-                const alias = !join.prop.owner ? join.inverseAlias ?? join.alias : join.ownerAlias;
+                const alias = join.inverseAlias ?? join.alias;
                 join.cond[`${alias}.${typeProperty}`] = join.prop.targetMeta.discriminatorValue;
             }
             Object.keys(join.cond).forEach(key => {
@@ -344,6 +345,9 @@ class QueryBuilderHelper {
     }
     appendQuerySubCondition(qb, type, method, cond, key, operator) {
         const m = operator === '$or' ? 'orWhere' : method;
+        if (cond[key] instanceof core_1.RawQueryFragment) {
+            cond[key] = this.knex.raw(cond[key].sql, cond[key].params);
+        }
         if (this.isSimpleRegExp(cond[key])) {
             return void qb[m](this.mapper(key, type), 'like', this.getRegExpParam(cond[key]));
         }
@@ -447,9 +451,12 @@ class QueryBuilderHelper {
                 /* istanbul ignore next */
                 const rawColumn = core_1.Utils.isString(column) ? column.split('.').map(e => this.knex.ref(e)).join('.') : column;
                 const customOrder = prop?.customOrder;
-                const colPart = customOrder
+                let colPart = customOrder
                     ? this.platform.generateCustomOrder(rawColumn, customOrder)
                     : rawColumn;
+                if (core_1.Utils.isRawSql(colPart)) {
+                    colPart = this.platform.formatQuery(colPart.sql, colPart.params);
+                }
                 ret.push(`${colPart} ${order.toLowerCase()}`);
             });
         });

package/typings.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import type { CheckCallback, Dictionary, EntityProperty, GroupOperator, QBFilterQuery, QueryOrderMap, Type } from '@mikro-orm/core';
+import type { CheckCallback, Dictionary, EntityProperty, GroupOperator, RawQueryFragment, QBFilterQuery, QueryOrderMap, Type } from '@mikro-orm/core';
 import type { QueryType } from './query/enums';
 import type { DatabaseSchema, DatabaseTable } from './schema';
 export interface Table {
@@ -11,7 +11,7 @@ export type KnexStringRef = Knex.Ref<string, {
     [alias: string]: string;
 }>;
 type AnyString = string & {};
-export type Field<T> = AnyString | keyof T | KnexStringRef | Knex.QueryBuilder;
+export type Field<T> = AnyString | keyof T | RawQueryFragment | KnexStringRef | Knex.QueryBuilder;
 export interface JoinOptions {
     table: string;
     schema?: string;