@mikro-orm/knex 6.0.0-dev.117 → 6.0.0-dev.118

package/AbstractSqlDriver.d.ts

@@ -36,7 +36,10 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
      * 1:1 owner side needs to be marked for population so QB auto-joins the owner id
      */
     protected autoJoinOneToOneOwner<T extends object, P extends string = never>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], fields?: readonly EntityField<T, P>[]): PopulateOptions<T>[];
-    protected joinedProps<T>(meta: EntityMetadata, populate: PopulateOptions<T>[]): PopulateOptions<T>[];
+    /**
+     * @internal
+     */
+    joinedProps<T>(meta: EntityMetadata, populate: PopulateOptions<T>[]): PopulateOptions<T>[];
     /**
      * @internal
      */

package/AbstractSqlDriver.js

@@ -66,9 +66,6 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (isCursorPagination && !first && !!last) {
             result.reverse();
         }
-        if (joinedProps.length > 0) {
-            return this.mergeJoinedResult(result, meta, joinedProps);
-        }
         return result;
     }
     async findOne(entityName, where, options) {
@@ -151,8 +148,6 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (qb) {
             // here we map the aliased results (cartesian product) to an object graph
             this.mapJoinedProps(ret, meta, populate, qb, ret, map);
-            // we need to remove the cycles from the mapped values
-            core_1.Utils.removeCycles(ret, meta);
         }
         return ret;
     }
@@ -167,7 +162,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             const meta2 = this.metadata.find(relation.type);
             const path = parentJoinPath ? `${parentJoinPath}.${relation.name}` : `${meta.name}.${relation.name}`;
             const relationAlias = qb.getAliasForJoinPath(path);
-            let relationPojo = {};
+            const relationPojo = {};
             // If the primary key value for the relation is null, we know we haven't joined to anything
             // and therefore we don't return any record (since all values would be null)
             const hasPK = meta2.primaryKeys.every(pk => meta2.properties[pk].fieldNames.every(name => {
@@ -212,24 +207,6 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                     delete root[alias];
                 }
             });
-            const key = `${meta.name}-${core_1.Utils.getCompositeKeyHash(result, meta)}`;
-            const key2 = `${meta2.name}-${core_1.Utils.getCompositeKeyHash(relationPojo, meta2)}`;
-            if (map[key2]) {
-                const old = map[key2];
-                core_1.Utils.keys(relationPojo)
-                    .filter(k => relationPojo[k] != null)
-                    .forEach(k => old[k] = relationPojo[k]);
-                relationPojo = old;
-            }
-            else {
-                map[key2] = relationPojo;
-            }
-            if (map[key]) {
-                result[relation.name] = map[key][relation.name];
-            }
-            else {
-                map[key] = result;
-            }
             if ([core_1.ReferenceKind.MANY_TO_MANY, core_1.ReferenceKind.ONE_TO_MANY].includes(relation.kind)) {
                 result[relation.name] ??= [];
                 this.appendToCollection(meta2, result[relation.name], relationPojo);
@@ -314,11 +291,23 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             sql += ' ' + data.map(() => `select null as ${this.platform.quoteIdentifier(pks[0])}`).join(' union all ');
         }
         const addParams = (prop, row) => {
+            let value = row[prop.name];
+            if (prop.kind === core_1.ReferenceKind.EMBEDDED && prop.object) {
+                if (prop.array) {
+                    for (let i = 0; i < value.length; i++) {
+                        const item = value[i];
+                        value[i] = this.mapDataToFieldNames(item, false, prop.embeddedProps, options.convertCustomTypes);
+                    }
+                }
+                else {
+                    value = this.mapDataToFieldNames(value, false, prop.embeddedProps, options.convertCustomTypes);
+                }
+            }
             if (options.convertCustomTypes && prop.customType) {
-                params.push(prop.customType.convertToDatabaseValue(row[prop.name], this.platform, { key: prop.name, mode: 'query-data' }));
+                params.push(prop.customType.convertToDatabaseValue(value, this.platform, { key: prop.name, mode: 'query-data' }));
                 return;
             }
-            params.push(row[prop.name]);
+            params.push(value);
         };
         if (fields.length > 0 || this.platform.usesDefaultKeyword()) {
             sql += data.map(row => {
@@ -450,6 +439,20 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const pkCond = core_1.Utils.flatten(meta.primaryKeys.map(pk => meta.properties[pk].fieldNames)).map(pk => `${this.platform.quoteIdentifier(pk)} = ?`).join(' and ');
         const params = [];
         let sql = `update ${this.getTableName(meta, options)} set `;
+        const addParams = (prop, value) => {
+            if (prop.kind === core_1.ReferenceKind.EMBEDDED && prop.object) {
+                if (prop.array) {
+                    for (let i = 0; i < value.length; i++) {
+                        const item = value[i];
+                        value[i] = this.mapDataToFieldNames(item, false, prop.embeddedProps, options.convertCustomTypes);
+                    }
+                }
+                else {
+                    value = this.mapDataToFieldNames(value, false, prop.embeddedProps, options.convertCustomTypes);
+                }
+            }
+            params.push(value);
+        };
         keys.forEach(key => {
             const prop = meta.properties[key];
             prop.fieldNames.forEach((fieldName, fieldNameIdx) => {
@@ -464,7 +467,8 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                         else {
                             sql += '?';
                         }
-                        params.push(...pks, prop.fieldNames.length > 1 ? data[idx][key]?.[fieldNameIdx] : data[idx][key]);
+                        params.push(...pks);
+                        addParams(prop, prop.fieldNames.length > 1 ? data[idx][key]?.[fieldNameIdx] : data[idx][key]);
                     }
                 });
                 sql += ` else ${this.platform.quoteIdentifier(fieldName)} end, `;
@@ -646,12 +650,12 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (owners.length === 1 && (options.offset != null || options.limit != null)) {
             qb.limit(options.limit, options.offset);
         }
-        const res = owners.length ? await this.rethrow(qb.execute('all', false)) : [];
+        const res = owners.length ? await this.rethrow(qb.execute('all', { mergeResults: false, mapResults: false })) : [];
         const items = res.map((row) => super.mapResult(row, prop.targetMeta));
         const map = {};
         const pkProps = ownerMeta.getPrimaryProps();
         owners.forEach(owner => {
-            const key = core_1.Utils.getPrimaryKeyHash(prop.joinColumns.map((col, idx) => {
+            const key = core_1.Utils.getPrimaryKeyHash(prop.joinColumns.map((_col, idx) => {
                 const pkProp = pkProps[idx];
                 return pkProp.customType ? pkProp.customType.convertToJSValue(owner[idx], this.platform) : owner[idx];
             }));
@@ -700,6 +704,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             .map(prop => ({ field: prop.name, strategy: prop.strategy }));
         return [...populate, ...toPopulate];
     }
+    /**
+     * @internal
+     */
     joinedProps(meta, populate) {
         return populate.filter(p => {
             const prop = meta.properties[p.field] || {};
@@ -710,26 +717,33 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
      * @internal
      */
     mergeJoinedResult(rawResults, meta, joinedProps) {
-        // group by the root entity primary key first
-        const map = {};
         const res = [];
-        rawResults.forEach(item => {
+        const map = {};
+        for (const item of rawResults) {
             const pk = core_1.Utils.getCompositeKeyHash(item, meta);
             if (map[pk]) {
-                joinedProps.forEach(hint => {
-                    // Sometimes we might join a M:N relation with additional filter on the target entity, and as a result, we get
-                    // the first result with `null` for all target values, which is mapped as empty array. When we see that happen,
-                    // we need to merge the results of the next item.
-                    if (Array.isArray(map[pk][hint.field]) && Array.isArray(item[hint.field]) && map[pk][hint.field].length === 0) {
-                        item[hint.field].forEach((el) => map[pk][hint.field].push(el));
+                for (const hint of joinedProps) {
+                    const prop = meta.properties[hint.field];
+                    if (!item[hint.field]) {
+                        continue;
                     }
-                });
+                    switch (prop.kind) {
+                        case core_1.ReferenceKind.ONE_TO_MANY:
+                        case core_1.ReferenceKind.MANY_TO_MANY:
+                            map[pk][hint.field] = this.mergeJoinedResult([...map[pk][hint.field], ...item[hint.field]], prop.targetMeta, hint.children ?? []);
+                            break;
+                        case core_1.ReferenceKind.MANY_TO_ONE:
+                        case core_1.ReferenceKind.ONE_TO_ONE:
+                            map[pk][hint.field] = this.mergeJoinedResult([map[pk][hint.field], item[hint.field]], prop.targetMeta, hint.children ?? [])[0];
+                            break;
+                    }
+                }
             }
             else {
                 map[pk] = item;
                 res.push(item);
             }
-        });
+        }
         return res;
     }
     getFieldsForJoinedLoad(qb, meta, explicitFields, populate = [], parentTableAlias, parentJoinPath) {
@@ -901,7 +915,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
     buildFields(meta, populate, joinedProps, qb, alias, fields) {
         const lazyProps = meta.props.filter(prop => prop.lazy && !populate.some(p => p.field === prop.name || p.all));
         const hasLazyFormulas = meta.props.some(p => p.lazy && p.formula);
-        const requiresSQLConversion = meta.props.some(p => p.customType?.convertToJSValueSQL);
+        const requiresSQLConversion = meta.props.some(p => p.customType?.convertToJSValueSQL && p.persist !== false);
         const hasExplicitFields = !!fields;
         const ret = [];
         let addFormulas = false;

package/index.mjs

@@ -47,6 +47,8 @@ export const DatabaseObjectExistsException = mod.DatabaseObjectExistsException;
 export const DatabaseObjectNotFoundException = mod.DatabaseObjectNotFoundException;
 export const DatabaseSchema = mod.DatabaseSchema;
 export const DatabaseTable = mod.DatabaseTable;
+export const Dataloader = mod.Dataloader;
+export const DataloaderUtils = mod.DataloaderUtils;
 export const DateTimeType = mod.DateTimeType;
 export const DateType = mod.DateType;
 export const DeadlockException = mod.DeadlockException;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.117",
+  "version": "6.0.0-dev.118",
   "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",
@@ -59,13 +59,13 @@
   },
   "dependencies": {
     "fs-extra": "11.1.1",
-    "knex": "2.5.1",
+    "knex": "3.0.1",
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^5.8.6"
+    "@mikro-orm/core": "^5.8.10"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.0.0-dev.117"
+    "@mikro-orm/core": "6.0.0-dev.118"
   }
 }

package/query/CriteriaNodeFactory.js

@@ -46,10 +46,17 @@ 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?.kind !== core_1.ReferenceKind.EMBEDDED) {
-            const childEntity = prop && prop.kind !== core_1.ReferenceKind.SCALAR ? prop.type : entityName;
             return this.createNode(metadata, childEntity, payload[key], node, key);
         }
+        if (payload[key] == null) {
+            const map = Object.keys(prop.embeddedProps).reduce((oo, k) => {
+                oo[prop.embeddedProps[k].name] = null;
+                return oo;
+            }, {});
+            return this.createNode(metadata, entityName, map, node, key);
+        }
         const operator = Object.keys(payload[key]).some(f => core_1.Utils.isOperator(f));
         if (operator) {
             throw core_1.ValidationError.cannotUseOperatorsInsideEmbeddables(entityName, prop.name, payload);

package/query/QueryBuilder.d.ts

@@ -8,6 +8,10 @@ import { type Alias, QueryBuilderHelper } from './QueryBuilderHelper';
 import type { SqlEntityManager } from '../SqlEntityManager';
 import type { Field } from '../typings';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
+export interface ExecuteOptions {
+    mapResults?: boolean;
+    mergeResults?: boolean;
+}
 /**
  * SQL query builder with fluent interface.
  *
@@ -179,7 +183,7 @@ export declare class QueryBuilder<T extends object = AnyEntity> {
      * Executes this QB and returns the raw results, mapped to the property names (unless disabled via last parameter).
      * Use `method` to specify what kind of result you want to get (array/single/meta).
      */
-    execute<U = any>(method?: 'all' | 'get' | 'run', mapResults?: boolean): Promise<U>;
+    execute<U = any>(method?: 'all' | 'get' | 'run', options?: ExecuteOptions | boolean): Promise<U>;
     /**
      * Alias for `qb.getResultList()`
      */

package/query/QueryBuilder.js

@@ -508,7 +508,10 @@ class QueryBuilder {
      * Executes this QB and returns the raw results, mapped to the property names (unless disabled via last parameter).
      * Use `method` to specify what kind of result you want to get (array/single/meta).
      */
-    async execute(method = 'all', mapResults = true) {
+    async execute(method = 'all', options) {
+        options = typeof options === 'boolean' ? { mapResults: options } : (options ?? {});
+        options.mergeResults ??= true;
+        options.mapResults ??= true;
         if (!this.connectionType && method !== 'run' && [enums_1.QueryType.INSERT, enums_1.QueryType.UPDATE, enums_1.QueryType.DELETE, enums_1.QueryType.TRUNCATE].includes(this.type ?? enums_1.QueryType.SELECT)) {
             this.connectionType = 'write';
         }
@@ -517,21 +520,33 @@ class QueryBuilder {
         if (cached?.data) {
             return cached.data;
         }
-        const type = this.connectionType || (method === 'run' ? 'write' : 'read');
+        const write = method === 'run' || !this.platform.getConfig().get('preferReadReplicas');
+        const type = this.connectionType || (write ? 'write' : 'read');
         const res = await this.driver.getConnection(type).execute(query.sql, query.bindings, method, this.context, this.logging);
         const meta = this.mainAlias.metadata;
-        if (!mapResults || !meta) {
+        if (!options.mapResults || !meta) {
             await this.em?.storeCache(this._cache, cached, res);
             return res;
         }
-        if (method === 'all' && Array.isArray(res)) {
+        if (method === 'run') {
+            return res;
+        }
+        const joinedProps = this.driver.joinedProps(meta, this._populate);
+        let mapped;
+        if (Array.isArray(res)) {
             const map = {};
-            const mapped = res.map(r => this.driver.mapResult(r, meta, this._populate, this, map));
-            await this.em?.storeCache(this._cache, cached, mapped);
-            return mapped;
+            mapped = res.map(r => this.driver.mapResult(r, meta, this._populate, this, map));
+            if (options.mergeResults && joinedProps.length > 0) {
+                mapped = this.driver.mergeJoinedResult(mapped, this.mainAlias.metadata, joinedProps);
+            }
+        }
+        else {
+            mapped = [this.driver.mapResult(res, meta, joinedProps, this)];
         }
-        const mapped = this.driver.mapResult(res, meta, this._populate, this);
         await this.em?.storeCache(this._cache, cached, mapped);
+        if (method === 'get') {
+            return mapped[0];
+        }
         return mapped;
     }
     /**
@@ -545,10 +560,7 @@ class QueryBuilder {
      */
     async getResultList() {
         await this.em.tryFlush(this.mainAlias.entityName, { flushMode: this.flushMode });
-        let res = await this.execute('all', true);
-        if (this._joinedProps.size > 0) {
-            res = this.driver.mergeJoinedResult(res, this.mainAlias.metadata, [...this._joinedProps.values()]);
-        }
+        const res = await this.execute('all', true);
         const entities = [];
         function propagatePopulateHint(entity, hint) {
             (0, core_1.helper)(entity).__serializationContext.populate ??= hint;
@@ -768,8 +780,9 @@ class QueryBuilder {
                 return;
             }
             if (prop?.embedded) {
-                const name = this._aliases[a] ? `${a}.${prop.fieldNames[0]}` : prop.fieldNames[0];
-                const fieldName = this.helper.mapper(name, this.type);
+                const name = prop.embeddedPath?.join('.') ?? prop.fieldNames[0];
+                const aliased = this._aliases[a] ? `${a}.${name}` : name;
+                const fieldName = this.helper.mapper(aliased, this.type);
                 ret.push(fieldName);
                 return;
             }
@@ -780,7 +793,7 @@ class QueryBuilder {
                 else {
                     const nest = (prop) => {
                         for (const childProp of Object.values(prop.embeddedProps)) {
-                            if (childProp.fieldNames) {
+                            if (childProp.fieldNames && (childProp.kind !== core_1.ReferenceKind.EMBEDDED || childProp.object) && childProp.persist !== false) {
                                 ret.push(this.helper.mapper(childProp.fieldNames[0], this.type));
                             }
                             else {
@@ -800,7 +813,7 @@ class QueryBuilder {
         });
         const meta = this.mainAlias.metadata;
         /* istanbul ignore next */
-        const requiresSQLConversion = meta?.props.filter(p => p.hasConvertToJSValueSQL) ?? [];
+        const requiresSQLConversion = meta?.props.filter(p => p.hasConvertToJSValueSQL && p.persist !== false) ?? [];
         if (this.flags.has(core_1.QueryFlag.CONVERT_CUSTOM_TYPES) && (fields.includes('*') || fields.includes(`${this.mainAlias.aliasName}.*`)) && requiresSQLConversion.length > 0) {
             requiresSQLConversion.forEach(p => ret.push(this.helper.mapper(p.name, this.type)));
         }
@@ -830,7 +843,7 @@ class QueryBuilder {
             if (core_1.Utils.isEntity(data)) {
                 data = this.em?.getComparator().prepareEntity(data) ?? (0, core_1.serialize)(data);
             }
-            this._data = this.helper.processData(data, this.flags.has(core_1.QueryFlag.CONVERT_CUSTOM_TYPES));
+            this._data = this.helper.processData(data, this.flags.has(core_1.QueryFlag.CONVERT_CUSTOM_TYPES), false);
         }
         if (cond) {
             this.where(cond);

package/query/QueryBuilderHelper.d.ts

@@ -55,7 +55,6 @@ export declare class QueryBuilderHelper {
     private fieldName;
     getProperty(field: string, alias?: string): EntityProperty | undefined;
     isTableNameAliasRequired(type?: QueryType): boolean;
-    private mapData;
 }
 export interface Alias<T> {
     aliasName: string;

package/query/QueryBuilderHelper.js

@@ -41,7 +41,11 @@ class QueryBuilderHelper {
             for (const p of fields) {
                 const [a, f] = this.splitField(p);
                 const prop = this.getProperty(f, a);
-                if (prop) {
+                const fkIdx2 = prop?.fieldNames.findIndex(name => name === f) ?? -1;
+                if (fkIdx2 !== -1) {
+                    parts.push(this.mapper(a !== this.alias ? `${a}.${prop.fieldNames[fkIdx2]}` : prop.fieldNames[fkIdx2], type, value, alias));
+                }
+                else if (prop) {
                     parts.push(...prop.fieldNames.map(f => this.mapper(a !== this.alias ? `${a}.${f}` : f, type, value, alias)));
                 }
                 else {
@@ -67,10 +71,12 @@ class QueryBuilderHelper {
         }
         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 this.alias + '.' + prop.fieldNames[0];
+            return this.alias + '.' + prop.fieldNames[fkIdx];
         }
         const noPrefix = prop && prop.persist === false;
         if (prop?.fieldNameRaw) {
@@ -83,16 +89,24 @@ class QueryBuilderHelper {
             return this.knex.raw(`${prop.formula(alias2)}${as}`);
         }
         if (prop?.hasConvertToJSValueSQL) {
-            const prefixed = this.prefix(field, isTableNameAliasRequired, true);
-            const valueSQL = prop.customType.convertToJSValueSQL(prefixed, this.platform);
+            let valueSQL;
+            if (prop.fieldNames.length > 1 && fkIdx !== -1) {
+                const fk = prop.targetMeta.getPrimaryProps()[fkIdx];
+                const prefixed = this.prefix(field, isTableNameAliasRequired, true, fkIdx);
+                valueSQL = fk.customType.convertToJSValueSQL(prefixed, this.platform);
+            }
+            else {
+                const prefixed = this.prefix(field, isTableNameAliasRequired, true);
+                valueSQL = prop.customType.convertToJSValueSQL(prefixed, this.platform);
+            }
             if (alias === null) {
                 return this.knex.raw(valueSQL);
             }
-            return this.knex.raw(`${valueSQL} as ${this.platform.quoteIdentifier(alias ?? prop.fieldNames[0])}`);
+            return this.knex.raw(`${valueSQL} as ${this.platform.quoteIdentifier(alias ?? prop.fieldNames[fkIdx])}`);
         }
         // do not wrap custom expressions
         if (!rawField) {
-            ret = this.prefix(field);
+            ret = this.prefix(field, false, false, fkIdx);
         }
         if (alias) {
             ret += ' as ' + alias;
@@ -107,7 +121,7 @@ class QueryBuilderHelper {
             return data.map(d => this.processData(d, convertCustomTypes, true));
         }
         const meta = this.metadata.find(this.entityName);
-        data = this.mapData(data, meta?.properties, convertCustomTypes);
+        data = this.driver.mapDataToFieldNames(data, true, meta?.properties, convertCustomTypes);
         if (!core_1.Utils.hasObjectKeys(data) && meta && multi) {
             /* istanbul ignore next */
             data[meta.primaryKeys[0]] = this.platform.usesDefaultKeyword() ? this.knex.raw('default') : undefined;
@@ -551,11 +565,11 @@ class QueryBuilderHelper {
         }
         qb.update(versionProperty.fieldNames[0], this.knex.raw(sql));
     }
-    prefix(field, always = false, quote = false) {
+    prefix(field, always = false, quote = false, idx) {
         let ret;
         if (!this.isPrefixed(field)) {
             const alias = always ? (quote ? this.alias : this.platform.quoteIdentifier(this.alias)) + '.' : '';
-            const fieldName = this.fieldName(field, this.alias, always);
+            const fieldName = this.fieldName(field, this.alias, always, idx);
             if (fieldName instanceof core_1.RawQueryFragment) {
                 return fieldName.sql;
             }
@@ -564,7 +578,7 @@ class QueryBuilderHelper {
         else {
             const [a, ...rest] = field.split('.');
             const f = rest.join('.');
-            ret = a + '.' + this.fieldName(f, a);
+            ret = a + '.' + this.fieldName(f, a, always, idx);
         }
         if (quote) {
             return this.platform.quoteIdentifier(ret);
@@ -590,7 +604,7 @@ class QueryBuilderHelper {
     isPrefixed(field) {
         return !!field.match(/[\w`"[\]]+\./);
     }
-    fieldName(field, alias, always) {
+    fieldName(field, alias, always, idx = 0) {
         const prop = this.getProperty(field, alias);
         if (!prop) {
             return field;
@@ -608,7 +622,7 @@ class QueryBuilderHelper {
             return (0, core_1.raw)(prop.fieldNameRaw);
         }
         /* istanbul ignore next */
-        return prop.fieldNames?.[0] ?? field;
+        return prop.fieldNames?.[idx] ?? field;
     }
     getProperty(field, alias) {
         const entityName = this.aliasMap[alias]?.entityName || this.entityName;
@@ -626,49 +640,16 @@ class QueryBuilderHelper {
                 return nest(prop);
             }
         }
-        return meta?.properties[field];
+        if (meta) {
+            if (meta.properties[field]) {
+                return meta.properties[field];
+            }
+            return meta.relations.find(prop => prop.fieldNames?.some(name => field === name));
+        }
+        return undefined;
     }
     isTableNameAliasRequired(type) {
         return [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(type ?? enums_1.QueryType.SELECT);
     }
-    mapData(data, properties, convertCustomTypes) {
-        if (!properties) {
-            return data;
-        }
-        data = Object.assign({}, data); // copy first
-        Object.keys(data).forEach(k => {
-            const prop = properties[k];
-            if (!prop) {
-                return;
-            }
-            if (prop.embeddedProps && !prop.object) {
-                const copy = data[k];
-                delete data[k];
-                Object.assign(data, this.mapData(copy, prop.embeddedProps, convertCustomTypes));
-                return;
-            }
-            if (prop.joinColumns && Array.isArray(data[k])) {
-                const copy = core_1.Utils.flatten(data[k]);
-                delete data[k];
-                prop.joinColumns.forEach((joinColumn, idx) => data[joinColumn] = copy[idx]);
-                return;
-            }
-            if (prop.customType && convertCustomTypes && !this.platform.isRaw(data[k])) {
-                data[k] = prop.customType.convertToDatabaseValue(data[k], this.platform, { fromQuery: true, key: k, mode: 'query-data' });
-            }
-            if (prop.hasConvertToDatabaseValueSQL && !this.platform.isRaw(data[k])) {
-                const quoted = this.platform.quoteValue(data[k]);
-                const sql = prop.customType.convertToDatabaseValueSQL(quoted, this.platform);
-                data[k] = this.knex.raw(sql.replace(/\?/g, '\\?'));
-            }
-            if (!prop.customType && (Array.isArray(data[k]) || core_1.Utils.isPlainObject(data[k]))) {
-                data[k] = JSON.stringify(data[k]);
-            }
-            if (prop.fieldNames) {
-                core_1.Utils.renameKey(data, k, prop.fieldNames[0]);
-            }
-        });
-        return data;
-    }
 }
 exports.QueryBuilderHelper = QueryBuilderHelper;

package/schema/DatabaseSchema.js

@@ -93,10 +93,10 @@ class DatabaseSchema {
         return (meta.schema === '*' ? schema : meta.schema) ?? config.get('schema');
     }
     static shouldHaveColumn(meta, prop) {
-        if (prop.persist === false || !prop.fieldNames) {
+        if (prop.persist === false || (prop.columnTypes?.length ?? 0) === 0) {
             return false;
         }
-        if (meta.pivotTable || (core_1.ReferenceKind.EMBEDDED && prop.object)) {
+        if (meta.pivotTable || (prop.kind === core_1.ReferenceKind.EMBEDDED && prop.object)) {
             return true;
         }
         const getRootProperty = (prop) => prop.embedded ? getRootProperty(meta.properties[prop.embedded[0]]) : prop;

package/schema/DatabaseTable.js

@@ -65,13 +65,19 @@ class DatabaseTable {
                 const match = prop.columnTypes[idx].match(/\w+\((\d+), ?(\d+)\)/);
                 /* istanbul ignore else */
                 if (match) {
-                    prop.precision = +match[1];
-                    prop.scale = +match[2];
+                    prop.precision ??= +match[1];
+                    prop.scale ??= +match[2];
                     prop.length = undefined;
                 }
             }
             if (mappedType instanceof core_1.DateTimeType) {
-                prop.length ??= this.platform.getDefaultDateTimeLength();
+                const match = prop.columnTypes[idx].match(/\w+\((\d+)\)/);
+                if (match) {
+                    prop.length ??= +match[1];
+                }
+                else {
+                    prop.length ??= this.platform.getDefaultDateTimeLength();
+                }
             }
             const primary = !meta.compositePK && !!prop.primary && prop.kind === core_1.ReferenceKind.SCALAR && this.platform.isNumericColumn(mappedType);
             this.columns[field] = {
@@ -303,6 +309,9 @@ class DatabaseTable {
         const properties = core_1.Utils.unique(core_1.Utils.flatten(core_1.Utils.asArray(index.properties).map(prop => {
             const root = prop.replace(/\..+$/, '');
             if (meta.properties[prop]) {
+                if (meta.properties[prop].embeddedPath) {
+                    return [meta.properties[prop].embeddedPath.join('.')];
+                }
                 return meta.properties[prop].fieldNames;
             }
             // json index, we need to rename the column only

package/schema/SchemaComparator.js

@@ -366,7 +366,9 @@ class SchemaComparator {
             log(`'comment' changed for column ${tableName}.${column1.name}`, { column1, column2 });
             changedProperties.add('comment');
         }
-        if (this.diffEnumItems(column1.enumItems, column2.enumItems)) {
+        if (!(column1.mappedType instanceof core_1.ArrayType) &&
+            !(column2.mappedType instanceof core_1.ArrayType) &&
+            this.diffEnumItems(column1.enumItems, column2.enumItems)) {
             log(`'enumItems' changed for column ${tableName}.${column1.name}`, { column1, column2 });
             changedProperties.add('enumItems');
         }