@mikro-orm/knex 6.4.17-dev.5 → 6.4.17-dev.51

package/AbstractSqlDriver.js

@@ -333,6 +333,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (meta && !core_1.Utils.isEmpty(populate)) {
             this.buildFields(meta, populate, joinedProps, qb, qb.alias, options, true);
         }
+        if (options.em) {
+            await qb.applyJoinedFilters(options.em, options.filters);
+        }
         return this.rethrow(qb.getCount());
     }
     async nativeInsert(entityName, data, options = {}) {
@@ -401,14 +404,14 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                     value = this.mapDataToFieldNames(value, false, prop.embeddedProps, options.convertCustomTypes);
                 }
             }
-            if (options.convertCustomTypes && prop.customType) {
-                params.push(prop.customType.convertToDatabaseValue(value, this.platform, { key: prop.name, mode: 'query-data' }));
-                return;
-            }
             if (typeof value === 'undefined' && this.platform.usesDefaultKeyword()) {
                 params.push((0, core_1.raw)('default'));
                 return;
             }
+            if (options.convertCustomTypes && prop.customType) {
+                params.push(prop.customType.convertToDatabaseValue(value, this.platform, { key: prop.name, mode: 'query-data' }));
+                return;
+            }
             params.push(value);
         };
         if (fields.length > 0 || this.platform.usesDefaultKeyword()) {
@@ -1156,7 +1159,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 if (!join && parentAlias === qb.alias) {
                     continue;
                 }
-                if (![core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.EMBEDDED].includes(prop.kind) && typeof childOrder === 'object') {
+                if (join && ![core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.EMBEDDED].includes(prop.kind) && typeof childOrder === 'object') {
                     const children = this.buildPopulateOrderBy(qb, meta2, core_1.Utils.asArray(childOrder), path, explicit, propAlias);
                     orderBy.push(...children);
                     continue;
@@ -1311,16 +1314,19 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             ret.push('*');
         }
         if (ret.length > 0 && !hasExplicitFields && addFormulas) {
-            meta.props
-                .filter(prop => prop.formula && !lazyProps.includes(prop))
-                .forEach(prop => {
-                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
-                .filter(prop => !prop.object && (prop.hasConvertToDatabaseValueSQL || prop.hasConvertToJSValueSQL))
-                .forEach(prop => ret.push(prop.name));
+            for (const prop of meta.props) {
+                if (lazyProps.includes(prop)) {
+                    continue;
+                }
+                if (prop.formula) {
+                    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}`));
+                }
+                if (!prop.object && (prop.hasConvertToDatabaseValueSQL || prop.hasConvertToJSValueSQL)) {
+                    ret.push(prop.name);
+                }
+            }
         }
         // add joined relations after the root entity fields
         if (joinedProps.length > 0) {

package/dialects/mysql/MySqlSchemaHelper.js

@@ -204,7 +204,14 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
                 col.defaultTo(null);
             }
             else {
-                col.defaultTo(knex.raw(column.default + (column.extra ? ' ' + column.extra : '')));
+                const columnType = column.type.toLowerCase();
+                // https://dev.mysql.com/doc/refman/9.0/en/data-type-defaults.html
+                const needsExpression = ['blob', 'text', 'json', 'point', 'linestring', 'polygon', 'multipoint', 'multilinestring', 'multipolygon', 'geometrycollection'].some(type => columnType.startsWith(type));
+                let defaultSql = needsExpression && !column.default.startsWith('(') ? `(${column.default})` : column.default;
+                if (column.extra) {
+                    defaultSql += ' ' + column.extra;
+                }
+                col.defaultTo(knex.raw(defaultSql));
             }
         }
         return col;

package/index.mjs

@@ -219,12 +219,14 @@ export const compareBuffers = mod.compareBuffers;
 export const compareObjects = mod.compareObjects;
 export const createSqlFunction = mod.createSqlFunction;
 export const defineConfig = mod.defineConfig;
+export const defineEntity = mod.defineEntity;
 export const equals = mod.equals;
 export const getOnConflictFields = mod.getOnConflictFields;
 export const getOnConflictReturningFields = mod.getOnConflictReturningFields;
 export const helper = mod.helper;
 export const knex = mod.knex;
 export const parseJsonSafe = mod.parseJsonSafe;
+export const quote = mod.quote;
 export const raw = mod.raw;
 export const ref = mod.ref;
 export const rel = mod.rel;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.4.17-dev.5",
+  "version": "6.4.17-dev.51",
   "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,7 +66,7 @@
     "@mikro-orm/core": "^6.4.16"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.4.17-dev.5",
+    "@mikro-orm/core": "6.4.17-dev.51",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/query/CriteriaNodeFactory.js

@@ -49,13 +49,14 @@ class CriteriaNodeFactory {
     static createObjectItemNode(metadata, entityName, node, payload, key, meta) {
         const prop = meta?.properties[key];
         const childEntity = prop && prop.kind !== core_1.ReferenceKind.SCALAR ? prop.type : entityName;
-        if (prop?.customType instanceof core_1.JsonType) {
+        const isNotEmbedded = prop?.kind !== core_1.ReferenceKind.EMBEDDED;
+        if (isNotEmbedded && prop?.customType instanceof core_1.JsonType) {
             return this.createScalarNode(metadata, childEntity, payload[key], node, key);
         }
         if (prop?.kind === core_1.ReferenceKind.SCALAR && payload[key] != null && Object.keys(payload[key]).some(f => core_1.Utils.isGroupOperator(f))) {
             throw core_1.ValidationError.cannotUseGroupOperatorsInsideScalars(entityName, prop.name, payload);
         }
-        if (prop?.kind !== core_1.ReferenceKind.EMBEDDED) {
+        if (isNotEmbedded) {
             return this.createNode(metadata, childEntity, payload[key], node, key);
         }
         if (payload[key] == null) {
@@ -72,11 +73,12 @@ class CriteriaNodeFactory {
             throw core_1.ValidationError.cannotUseOperatorsInsideEmbeddables(entityName, prop.name, payload);
         }
         const map = Object.keys(payload[key]).reduce((oo, k) => {
-            if (!prop.embeddedProps[k] && !allowedOperators.includes(k)) {
+            const embeddedProp = prop.embeddedProps[k] ?? Object.values(prop.embeddedProps).find(p => p.name === k);
+            if (!embeddedProp && !allowedOperators.includes(k)) {
                 throw core_1.ValidationError.invalidEmbeddableQuery(entityName, k, prop.type);
             }
-            if (prop.embeddedProps[k]) {
-                oo[prop.embeddedProps[k].name] = payload[key][k];
+            if (embeddedProp) {
+                oo[embeddedProp.name] = payload[key][k];
             }
             else if (typeof payload[key][k] === 'object') {
                 oo[k] = JSON.stringify(payload[key][k]);

package/schema/DatabaseTable.d.ts

@@ -1,4 +1,4 @@
-import { type Configuration, type DeferMode, type Dictionary, type EntityMetadata, type EntityProperty, type NamingStrategy } from '@mikro-orm/core';
+import { type Configuration, type DeferMode, type Dictionary, type EntityMetadata, type EntityProperty, type NamingStrategy, type IndexCallback } from '@mikro-orm/core';
 import type { SchemaHelper } from './SchemaHelper';
 import type { CheckDef, Column, ForeignKey, IndexDef } from '../typings';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
@@ -53,12 +53,13 @@ export declare class DatabaseTable {
     private getPropertyTypeForForeignKey;
     private getPropertyTypeForColumn;
     private getPropertyDefaultValue;
+    private processIndexExpression;
     addIndex(meta: EntityMetadata, index: {
-        properties: string | string[];
+        properties?: string | string[];
         name?: string;
         type?: string;
-        expression?: string;
-        deferMode?: DeferMode;
+        expression?: string | IndexCallback<any>;
+        deferMode?: DeferMode | `${DeferMode}`;
         options?: Dictionary;
     }, type: 'index' | 'unique' | 'primary'): void;
     addCheck(check: CheckDef): void;

package/schema/DatabaseTable.js

@@ -115,6 +115,7 @@ class DatabaseTable {
                 localTableName: this.getShortestName(),
                 referencedColumnNames: prop.referencedColumnNames,
                 referencedTableName: schema ? `${schema}.${prop.referencedTableName}` : prop.referencedTableName,
+                createForeignKeyConstraint: prop.createForeignKeyConstraint,
             };
             const cascade = prop.cascade.includes(core_1.Cascade.REMOVE) || prop.cascade.includes(core_1.Cascade.ALL);
             if (prop.deleteRule || cascade || prop.nullable) {
@@ -699,6 +700,18 @@ class DatabaseTable {
         }
         return '' + val;
     }
+    processIndexExpression(expression, meta) {
+        if (expression instanceof Function) {
+            const exp = expression({ name: this.name, schema: this.schema, toString() {
+                    if (this.schema) {
+                        return `${this.schema}.${this.name}`;
+                    }
+                    return this.name;
+                } }, meta.createColumnMappingObject());
+            return exp instanceof core_1.RawQueryFragment ? this.platform.formatQuery(exp.sql, exp.params) : exp;
+        }
+        return expression;
+    }
     addIndex(meta, index, type) {
         const properties = core_1.Utils.unique(core_1.Utils.flatten(core_1.Utils.asArray(index.properties).map(prop => {
             const parts = prop.split('.');
@@ -740,7 +753,7 @@ class DatabaseTable {
             primary: type === 'primary',
             unique: type !== 'index',
             type: index.type,
-            expression: index.expression,
+            expression: this.processIndexExpression(index.expression, meta),
             options: index.options,
             deferMode: index.deferMode,
         });

package/schema/SchemaHelper.js

@@ -321,7 +321,7 @@ class SchemaHelper {
         });
     }
     createForeignKey(table, foreignKey, schema) {
-        if (!this.options.createForeignKeyConstraints) {
+        if (!this.options.createForeignKeyConstraints || !foreignKey.createForeignKeyConstraint) {
             return;
         }
         const builder = table

package/typings.d.ts

@@ -59,6 +59,7 @@ export interface ForeignKey {
     updateRule?: string;
     deleteRule?: string;
     deferMode?: DeferMode;
+    createForeignKeyConstraint: boolean;
 }
 export interface IndexDef {
     columnNames: string[];
@@ -74,7 +75,7 @@ export interface IndexDef {
         storageEngineIndexType?: 'hash' | 'btree';
         predicate?: Knex.QueryBuilder;
     }>;
-    deferMode?: DeferMode;
+    deferMode?: DeferMode | `${DeferMode}`;
 }
 export interface CheckDef<T = unknown> {
     name: string;