@mikro-orm/knex 7.0.0-dev.14 → 7.0.0-dev.16

package/dialects/mssql/MsSqlNativeQueryBuilder.js

@@ -82,7 +82,7 @@ export class MsSqlNativeQueryBuilder extends NativeQueryBuilder {
             }
             this.parts.push('then update set');
             if (!clause.merge || Array.isArray(clause.merge)) {
-                const parts = keys
+                const parts = (clause.merge || keys)
                     .filter(field => !Array.isArray(clause.fields) || !clause.fields.includes(field))
                     .map((column) => `${this.quote(column)} = tsource.${this.quote(column)}`);
                 this.parts.push(parts.join(', '));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "7.0.0-dev.14",
+  "version": "7.0.0-dev.16",
   "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": {
@@ -54,9 +54,9 @@
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.4.13"
+    "@mikro-orm/core": "^6.4.14"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.14"
+    "@mikro-orm/core": "7.0.0-dev.16"
   }
 }

package/query/QueryBuilder.js

@@ -684,7 +684,7 @@ export class QueryBuilder {
         }
         const query = this.toQuery();
         const cached = await this.em?.tryCache(this.mainAlias.entityName, this._cache, ['qb.execute', query.sql, query.params, method]);
-        if (cached?.data) {
+        if (cached?.data !== undefined) {
             return cached.data;
         }
         const write = method === 'run' || !this.platform.getConfig().get('preferReadReplicas');
@@ -1175,6 +1175,7 @@ export class QueryBuilder {
                 this._joins[aliasedName] = this.helper.joinOneToReference(prop, this.mainAlias.aliasName, alias, JoinType.leftJoin);
                 this._joins[aliasedName].path = `${(Object.values(this._joins).find(j => j.alias === fromAlias)?.path ?? meta.className)}.${prop.name}`;
                 this._populateMap[aliasedName] = this._joins[aliasedName].alias;
+                this.createAlias(prop.type, alias);
             }
         });
         this.processPopulateWhere(false);

package/query/QueryBuilderHelper.js

@@ -251,6 +251,105 @@ export class QueryBuilderHelper {
         }
         return { sql, params };
     }
+    // <<<<<<< HEAD
+    //   private processJoinClause(key: string, value: unknown, alias: string, params: Knex.Value[], operator = '$eq'): string {
+    //     if (Utils.isGroupOperator(key) && Array.isArray(value)) {
+    //       const parts = value.map(sub => {
+    //         return this.wrapQueryGroup(Object.keys(sub).map(k => this.processJoinClause(k, sub[k], alias, params)));
+    //       });
+    //       return this.wrapQueryGroup(parts, key);
+    //     }
+    //
+    //     const rawField = RawQueryFragment.getKnownFragment(key);
+    //
+    //     if (!rawField && !Utils.isOperator(key, false) && !this.isPrefixed(key)) {
+    //       key = `${alias}.${key}`;
+    //     }
+    //
+    //     if (this.isSimpleRegExp(value)) {
+    //       params.push(this.getRegExpParam(value));
+    //       return `${this.knex.ref(this.mapper(key))} like ?`;
+    //     }
+    //
+    //     if (value instanceof RegExp) {
+    //       value = this.platform.getRegExpValue(value);
+    //     }
+    //
+    //     if (Utils.isOperator(key, false) && Utils.isPlainObject(value)) {
+    //       const parts = Object.keys(value).map(k => this.processJoinClause(k, (value as Dictionary)[k], alias, params, key));
+    //
+    //       return key === '$not' ? `not ${this.wrapQueryGroup(parts)}` : this.wrapQueryGroup(parts);
+    //     }
+    //
+    //     if (Utils.isPlainObject(value) && Object.keys(value).every(k => Utils.isOperator(k, false))) {
+    //       const parts = Object.keys(value).map(op => this.processJoinClause(key, (value as Dictionary)[op], alias, params, op));
+    //
+    //       return this.wrapQueryGroup(parts);
+    //     }
+    //
+    //     const [fromAlias, fromField] = this.splitField(key as EntityKey);
+    //     const prop = this.getProperty(fromField, fromAlias);
+    //     operator = operator === '$not' ? '$eq' : operator;
+    //     const column = this.mapper(key, undefined, undefined, null);
+    //
+    //     if (value === null) {
+    //       return `${this.knex.ref(column)} is ${operator === '$ne' ? 'not ' : ''}null`;
+    //     }
+    //
+    //     if (operator === '$fulltext' && prop) {
+    //       const query = this.knex.raw(this.platform.getFullTextWhereClause(prop), {
+    //         column,
+    //         query: this.knex.raw('?'),
+    //       }).toSQL().toNative();
+    //       params.push(value as Knex.Value);
+    //
+    //       return query.sql;
+    //     }
+    //
+    //     const replacement = this.getOperatorReplacement(operator, { [operator]: value });
+    //
+    //     if (['$in', '$nin'].includes(operator) && Array.isArray(value)) {
+    //       params.push(...value as Knex.Value[]);
+    //       return `${this.knex.ref(column)} ${replacement} (${value.map(() => '?').join(', ')})`;
+    //     }
+    //
+    //     if (operator === '$exists') {
+    //       value = null;
+    //     }
+    //
+    //     if (rawField) {
+    //       let sql = rawField.sql.replaceAll(ALIAS_REPLACEMENT, alias);
+    //       params.push(...rawField.params as Knex.Value[]);
+    //       params.push(...Utils.asArray(value) as Knex.Value[]);
+    //
+    //       if ((Utils.asArray(value) as Knex.Value[]).length > 0) {
+    //         sql += ' = ?';
+    //       }
+    //
+    //       return sql;
+    //     }
+    //
+    //     if (value !== null) {
+    //       if (prop?.customType) {
+    //         value = prop.customType.convertToDatabaseValue(value, this.platform, { fromQuery: true, key, mode: 'query' });
+    //       }
+    //
+    //       params.push(value as Knex.Value);
+    //     }
+    //
+    //     return `${this.knex.ref(column)} ${replacement} ${value === null ? 'null' : '?'}`;
+    //   }
+    //
+    //   private wrapQueryGroup(parts: string[], operator = '$and') {
+    //     if (parts.length === 1) {
+    //       return parts[0];
+    //     }
+    //
+    //     return `(${parts.join(` ${GroupOperator[operator as keyof typeof GroupOperator]} `)})`;
+    //   }
+    //
+    //   mapJoinColumns(type: QueryType, join: JoinOptions): (string | Knex.Raw)[] {
+    // =======
     mapJoinColumns(type, join) {
         if (join.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(join.prop.kind)) {
             return join.prop.fieldNames.map((_fieldName, idx) => {

package/schema/DatabaseTable.js

@@ -104,7 +104,7 @@ export class DatabaseTable {
             this.columns[field].default = defaultValue;
         });
         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
-            const constraintName = this.getIndexName(true, prop.fieldNames, 'foreign');
+            const constraintName = this.getIndexName(prop.foreignKeyName ?? true, prop.fieldNames, 'foreign');
             let schema = prop.targetMeta.root.schema === '*' ? this.schema : (prop.targetMeta.root.schema ?? config.get('schema', this.platform.getDefaultSchemaName()));
             if (prop.referencedTableName.includes('.')) {
                 schema = undefined;

package/schema/SchemaHelper.js

@@ -119,9 +119,8 @@ export class SchemaHelper {
                 }
             }
             Utils.removeDuplicates(changedNativeEnums).forEach(([enumName, itemsNew, itemsOld]) => {
-                // postgres allows only adding new items, the values are case insensitive
-                itemsOld = itemsOld.map(v => v.toLowerCase());
-                const newItems = itemsNew.filter(val => !itemsOld.includes(val.toLowerCase()));
+                // postgres allows only adding new items
+                const newItems = itemsNew.filter(val => !itemsOld.includes(val));
                 if (enumName.includes('.')) {
                     const [enumSchemaName, rawEnumName] = enumName.split('.');
                     ret.push(...newItems.map(val => this.getAlterNativeEnumSQL(rawEnumName, enumSchemaName, val, itemsNew, itemsOld)));