@mikro-orm/knex 6.1.10-dev.8 → 6.1.10

package/AbstractSqlDriver.js

@@ -826,7 +826,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                     if (!item[propName]) {
                         continue;
                     }
-                    if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && ref) {
+                    if ([core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind) && ref) {
                         map[pk][propName] = [...map[pk][propName], ...item[propName]];
                         continue;
                     }
@@ -922,28 +922,31 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
      * @internal
      */
     mapPropToFieldNames(qb, prop, tableAlias) {
-        const knex = this.connection.getKnex();
-        const aliased = knex.ref(tableAlias ? `${tableAlias}__${prop.fieldNames[0]}` : prop.fieldNames[0]).toString();
+        const aliased = this.platform.quoteIdentifier(tableAlias ? `${tableAlias}__${prop.fieldNames[0]}` : prop.fieldNames[0]);
         if (tableAlias && prop.customTypes?.some(type => type?.convertToJSValueSQL)) {
             return prop.fieldNames.map((col, idx) => {
                 if (!prop.customTypes[idx]?.convertToJSValueSQL) {
                     return col;
                 }
-                const prefixed = knex.ref(col).withSchema(tableAlias).toString();
-                const aliased = knex.ref(`${tableAlias}__${col}`).toString();
+                const prefixed = this.platform.quoteIdentifier(`${tableAlias}.${col}`);
+                const aliased = this.platform.quoteIdentifier(`${tableAlias}__${col}`);
                 return (0, core_1.raw)(`${prop.customTypes[idx].convertToJSValueSQL(prefixed, this.platform)} as ${aliased}`);
             });
         }
         if (tableAlias && prop.customType?.convertToJSValueSQL) {
-            const prefixed = knex.ref(prop.fieldNames[0]).withSchema(tableAlias).toString();
+            const prefixed = this.platform.quoteIdentifier(`${tableAlias}.${prop.fieldNames[0]}`);
             return [(0, core_1.raw)(`${prop.customType.convertToJSValueSQL(prefixed, this.platform)} as ${aliased}`)];
         }
         if (prop.formula) {
-            const alias = knex.ref(tableAlias ?? qb.alias).toString();
+            const alias = this.platform.quoteIdentifier(tableAlias ?? qb.alias);
             return [(0, core_1.raw)(`${prop.formula(alias)} as ${aliased}`)];
         }
         if (tableAlias) {
-            return prop.fieldNames.map(fieldName => knex.ref(fieldName).withSchema(tableAlias).as(`${tableAlias}__${fieldName}`));
+            return prop.fieldNames.map(fieldName => {
+                const name = this.platform.quoteIdentifier(`${tableAlias}.${fieldName}`);
+                const alias = this.platform.quoteIdentifier(`${tableAlias}__${fieldName}`);
+                return (0, core_1.raw)(`${name} as ${alias}`);
+            });
         }
         return prop.fieldNames;
     }
@@ -1207,8 +1210,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             meta.props
                 .filter(prop => prop.formula && !lazyProps.includes(prop))
                 .forEach(prop => {
-                const a = this.connection.getKnex().ref(alias).toString();
-                const aliased = this.connection.getKnex().ref(prop.fieldNames[0]).toString();
+                const a = this.platform.quoteIdentifier(alias);
+                const aliased = this.platform.quoteIdentifier(prop.fieldNames[0]);
                 ret.push((0, core_1.raw)(`${prop.formula(a)} as ${aliased}`));
             });
             meta.props

package/AbstractSqlPlatform.js

@@ -55,8 +55,11 @@ class AbstractSqlPlatform extends core_1.Platform {
     getJsonIndexDefinition(index) {
         return index.columnNames
             .map(column => {
+            if (!column.includes('.')) {
+                return column;
+            }
             const [root, ...path] = column.split('.');
-            return `json_extract(${root}, '$.${path.join('.')}')`;
+            return `(json_extract(${root}, '$.${path.join('.')}'))`;
         });
     }
     isRaw(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.1.10-dev.8",
+  "version": "6.1.10",
   "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",
@@ -63,9 +63,9 @@
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.1.9"
+    "@mikro-orm/core": "^6.1.10"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.1.10-dev.8"
+    "@mikro-orm/core": "^6.0.0"
   }
 }

package/query/QueryBuilderHelper.js

@@ -86,7 +86,11 @@ class QueryBuilderHelper {
             const alias2 = this.knex.ref(a).toString();
             const aliased = this.knex.ref(prop.fieldNames[0]).toString();
             const as = alias === null ? '' : ` as ${aliased}`;
-            return this.knex.raw(`${prop.formula(alias2)}${as}`);
+            let value = prop.formula(alias2);
+            if (!this.isTableNameAliasRequired(type)) {
+                value = value.replaceAll(alias2 + '.', '');
+            }
+            return this.knex.raw(`${value}${as}`);
         }
         if (prop?.hasConvertToJSValueSQL) {
             let valueSQL;

package/schema/SqlSchemaGenerator.js

@@ -498,7 +498,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
             // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
             if (index.columnNames.some(column => column.includes('.'))) {
                 const columns = this.platform.getJsonIndexDefinition(index);
-                table.index(columns.map(column => this.knex.raw(`(${column})`)), index.keyName, { indexType: 'unique' });
+                table.index(columns.map(column => this.knex.raw(column)), index.keyName, { indexType: 'unique' });
             }
             else {
                 table.unique(index.columnNames, { indexName: index.keyName });
@@ -517,7 +517,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
             // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
             if (index.columnNames.some(column => column.includes('.'))) {
                 const columns = this.platform.getJsonIndexDefinition(index);
-                table.index(columns.map(column => this.knex.raw(`(${column})`)), index.keyName, index.type);
+                table.index(columns.map(column => this.knex.raw(column)), index.keyName, index.type);
             }
             else {
                 table.index(index.columnNames, index.keyName, index.type);