@mikro-orm/knex 6.0.0-dev.2 → 6.0.0-dev.20

package/{dist/query → query}/QueryBuilderHelper.d.ts

@@ -1,8 +1,9 @@
 import type { Knex } from 'knex';
-import type { Dictionary, EntityData, EntityMetadata, EntityProperty, FlatQueryOrderMap, MetadataStorage, Platform, QBFilterQuery } from '@mikro-orm/core';
+import type { Dictionary, EntityData, EntityMetadata, EntityProperty, FlatQueryOrderMap, QBFilterQuery } from '@mikro-orm/core';
 import { LockMode } from '@mikro-orm/core';
 import { QueryType } from './enums';
 import type { Field, JoinOptions } from '../typings';
+import type { AbstractSqlDriver } from '../AbstractSqlDriver';
 /**
  * @internal
  */
@@ -11,25 +12,28 @@ export declare class QueryBuilderHelper {
     private readonly alias;
     private readonly aliasMap;
     private readonly subQueries;
-    private readonly metadata;
     private readonly knex;
+    private readonly driver;
     private readonly platform;
-    constructor(entityName: string, alias: string, aliasMap: Dictionary<string>, subQueries: Dictionary<string>, metadata: MetadataStorage, knex: Knex, platform: Platform);
-    mapper(field: string, type?: QueryType): string;
-    mapper(field: string, type?: QueryType, value?: any, alias?: string | null): string;
+    private readonly metadata;
+    constructor(entityName: string, alias: string, aliasMap: Dictionary<Alias>, subQueries: Dictionary<string>, knex: Knex, driver: AbstractSqlDriver);
+    mapper(field: string | Knex.Raw, type?: QueryType): string;
+    mapper(field: string | Knex.Raw, type?: QueryType, value?: any, alias?: string | null): string;
     processData(data: Dictionary, convertCustomTypes: boolean, multi?: boolean): any;
     joinOneToReference(prop: EntityProperty, ownerAlias: string, alias: string, type: 'leftJoin' | 'innerJoin' | 'pivotJoin', cond?: Dictionary): JoinOptions;
     joinManyToOneReference(prop: EntityProperty, ownerAlias: string, alias: string, type: 'leftJoin' | 'innerJoin' | 'pivotJoin', cond?: Dictionary): JoinOptions;
     joinManyToManyReference(prop: EntityProperty, ownerAlias: string, alias: string, pivotAlias: string, type: 'leftJoin' | 'innerJoin' | 'pivotJoin', cond: Dictionary, path: string): Dictionary<JoinOptions>;
     joinPivotTable(field: string, prop: EntityProperty, ownerAlias: string, alias: string, type: 'leftJoin' | 'innerJoin' | 'pivotJoin', cond?: Dictionary): JoinOptions;
     processJoins(qb: Knex.QueryBuilder, joins: Dictionary<JoinOptions>, schema?: string): void;
+    private processJoinClause;
+    private wrapQueryGroup;
     mapJoinColumns(type: QueryType, join: JoinOptions): (string | Knex.Raw)[];
     isOneToOneInverse(field: string): boolean;
     getTableName(entityName: string): string;
     /**
      * Checks whether the RE can be rewritten to simple LIKE query
      */
-    isSimpleRegExp(re: any): boolean;
+    isSimpleRegExp(re: any): re is RegExp;
     getRegExpParam(re: RegExp): string;
     appendOnConflictClause<T>(type: QueryType, onConflict: {
         fields: string[];
@@ -42,13 +46,10 @@ export declare class QueryBuilderHelper {
     private processCustomExpression;
     private processObjectSubCondition;
     private getOperatorReplacement;
-    private appendJoinClause;
-    private appendJoinSubClause;
-    private processObjectSubClause;
     getQueryOrder(type: QueryType, orderBy: FlatQueryOrderMap | FlatQueryOrderMap[], populate: Dictionary<string>): string;
     getQueryOrderFromObject(type: QueryType, orderBy: FlatQueryOrderMap, populate: Dictionary<string>): string;
     finalize(type: QueryType, qb: Knex.QueryBuilder, meta?: EntityMetadata): void;
-    splitField(field: string): [string, string];
+    splitField(field: string, greedyAlias?: boolean): [string, string];
     getLockSQL(qb: Knex.QueryBuilder, lockMode: LockMode, lockTables?: string[]): void;
     updateVersionProperty(qb: Knex.QueryBuilder, data: Dictionary): void;
     static isCustomExpression(field: string, hasAlias?: boolean): boolean;
@@ -57,5 +58,12 @@ export declare class QueryBuilderHelper {
     private isPrefixed;
     private fieldName;
     getProperty(field: string, alias?: string): EntityProperty | undefined;
-    isTableNameAliasRequired(type: QueryType): boolean;
+    isTableNameAliasRequired(type?: QueryType): boolean;
+    private mapData;
+}
+export interface Alias {
+    aliasName: string;
+    entityName: string;
+    metadata?: EntityMetadata;
+    subQuery?: Knex.QueryBuilder;
 }

package/{dist/query → query}/QueryBuilderHelper.js

@@ -8,16 +8,20 @@ const enums_1 = require("./enums");
  * @internal
  */
 class QueryBuilderHelper {
-    constructor(entityName, alias, aliasMap, subQueries, metadata, knex, platform) {
+    constructor(entityName, alias, aliasMap, subQueries, knex, driver) {
         this.entityName = entityName;
         this.alias = alias;
         this.aliasMap = aliasMap;
         this.subQueries = subQueries;
-        this.metadata = metadata;
         this.knex = knex;
-        this.platform = platform;
+        this.driver = driver;
+        this.platform = this.driver.getPlatform();
+        this.metadata = this.driver.getMetadata();
     }
     mapper(field, type = enums_1.QueryType.SELECT, value, alias) {
+        if (typeof field !== 'string') {
+            return field;
+        }
         const isTableNameAliasRequired = this.isTableNameAliasRequired(type);
         const fields = core_1.Utils.splitPrimaryKeys(field);
         if (fields.length > 1) {
@@ -26,18 +30,33 @@ class QueryBuilderHelper {
                 const [a, f] = this.splitField(p);
                 const prop = this.getProperty(f, a);
                 if (prop) {
-                    parts.push(...prop.fieldNames.map(f => this.mapper(f, type, value, alias)));
+                    parts.push(...prop.fieldNames.map(f => this.mapper(a !== this.alias ? `${a}.${f}` : f, type, value, alias)));
                 }
                 else {
-                    parts.push(this.mapper(`${a}.${f}`, type, value, alias));
+                    parts.push(this.mapper(a !== this.alias ? `${a}.${f}` : f, type, value, alias));
                 }
             }
+            // flatten the value if we see we are expanding nested composite key
+            // hackish, but cleaner solution would require quite a lot of refactoring
+            if (fields.length !== parts.length && Array.isArray(value)) {
+                value.forEach(row => {
+                    if (Array.isArray(row)) {
+                        const tmp = core_1.Utils.flatten(row);
+                        row.length = 0;
+                        row.push(...tmp);
+                    }
+                });
+            }
             return this.knex.raw('(' + parts.map(part => this.knex.ref(part)).join(', ') + ')');
         }
         let ret = field;
         const customExpression = QueryBuilderHelper.isCustomExpression(field, !!alias);
         const [a, f] = this.splitField(field);
         const prop = this.getProperty(f, a);
+        // 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];
+        }
         const noPrefix = prop && prop.persist === false;
         if (prop?.fieldNameRaw) {
             return this.knex.raw(this.prefix(field, isTableNameAliasRequired));
@@ -64,7 +83,8 @@ class QueryBuilderHelper {
             ret += ' as ' + alias;
         }
         if (customExpression) {
-            return this.knex.raw(ret, value);
+            const bindings = core_1.Utils.asArray(value).slice(0, ret.match(/\?/g)?.length ?? 0);
+            return this.knex.raw(ret, bindings);
         }
         if (!isTableNameAliasRequired || this.isPrefixed(ret) || noPrefix) {
             return ret;
@@ -75,47 +95,23 @@ class QueryBuilderHelper {
         if (Array.isArray(data)) {
             return data.map(d => this.processData(d, convertCustomTypes, true));
         }
-        data = Object.assign({}, data); // copy first
         const meta = this.metadata.find(this.entityName);
-        Object.keys(data).forEach(k => {
-            if (!meta?.properties[k]) {
-                return;
-            }
-            const prop = meta.properties[k];
-            if (prop.joinColumns && Array.isArray(data[k])) {
-                const copy = 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, true);
-            }
-            if (prop.customType && 'convertToDatabaseValueSQL' in prop.customType && !this.platform.isRaw(data[k])) {
-                const quoted = this.platform.quoteValue(data[k]);
-                data[k] = this.knex.raw(prop.customType.convertToDatabaseValueSQL(quoted, this.platform));
-            }
-            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]);
-            }
-        });
+        data = this.mapData(data, 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;
         }
         return data;
     }
     joinOneToReference(prop, ownerAlias, alias, type, cond = {}) {
-        const meta = this.metadata.find(prop.type);
-        const prop2 = meta.properties[prop.mappedBy || prop.inversedBy];
+        const prop2 = prop.targetMeta.properties[prop.mappedBy || prop.inversedBy];
         const table = this.getTableName(prop.type);
+        const schema = this.driver.getSchemaName(prop.targetMeta);
         const joinColumns = prop.owner ? prop.referencedColumnNames : prop2.joinColumns;
         const inverseJoinColumns = prop.referencedColumnNames;
         const primaryKeys = prop.owner ? prop.joinColumns : prop2.referencedColumnNames;
         return {
-            prop, type, cond, ownerAlias, alias, table,
+            prop, type, cond, ownerAlias, alias, table, schema,
             joinColumns, inverseJoinColumns, primaryKeys,
         };
     }
@@ -123,11 +119,13 @@ class QueryBuilderHelper {
         return {
             prop, type, cond, ownerAlias, alias,
             table: this.getTableName(prop.type),
+            schema: this.driver.getSchemaName(prop.targetMeta),
             joinColumns: prop.referencedColumnNames,
             primaryKeys: prop.fieldNames,
         };
     }
     joinManyToManyReference(prop, ownerAlias, alias, pivotAlias, type, cond, path) {
+        const pivotMeta = this.metadata.find(prop.pivotEntity);
         const ret = {
             [`${ownerAlias}.${prop.name}#${pivotAlias}`]: {
                 prop, type, cond, ownerAlias,
@@ -136,21 +134,22 @@ class QueryBuilderHelper {
                 joinColumns: prop.joinColumns,
                 inverseJoinColumns: prop.inverseJoinColumns,
                 primaryKeys: prop.referencedColumnNames,
-                table: prop.pivotTable,
+                table: pivotMeta.tableName,
+                schema: this.driver.getSchemaName(pivotMeta),
                 path: path.endsWith('[pivot]') ? path : `${path}[pivot]`,
             },
         };
         if (type === 'pivotJoin') {
             return ret;
         }
-        const prop2 = this.metadata.find(prop.pivotTable).properties[prop.type + (prop.owner ? '_inverse' : '_owner')];
+        const prop2 = prop.owner ? pivotMeta.relations[1] : pivotMeta.relations[0];
         ret[`${pivotAlias}.${prop2.name}#${alias}`] = this.joinManyToOneReference(prop2, pivotAlias, alias, type);
         ret[`${pivotAlias}.${prop2.name}#${alias}`].path = path;
         return ret;
     }
     joinPivotTable(field, prop, ownerAlias, alias, type, cond = {}) {
         const pivotMeta = this.metadata.find(field);
-        const prop2 = pivotMeta.properties[prop.mappedBy || prop.inversedBy];
+        const prop2 = pivotMeta.relations[0] === prop ? pivotMeta.relations[1] : pivotMeta.relations[0];
         return {
             prop, type, cond, ownerAlias, alias,
             table: pivotMeta.collection,
@@ -163,21 +162,96 @@ class QueryBuilderHelper {
     processJoins(qb, joins, schema) {
         Object.values(joins).forEach(join => {
             let table = `${join.table} as ${join.alias}`;
-            const method = join.type === 'pivotJoin' ? 'leftJoin' : join.type;
+            const method = join.type === 'innerJoin' ? 'inner join' : 'left join';
             schema = join.schema && join.schema !== '*' ? join.schema : schema;
             if (schema) {
                 table = `${schema}.${table}`;
             }
-            return qb[method](this.knex.ref(table), inner => {
-                join.primaryKeys.forEach((primaryKey, idx) => {
-                    const left = `${join.ownerAlias}.${primaryKey}`;
-                    const right = `${join.alias}.${join.joinColumns[idx]}`;
-                    inner.on(left, right);
-                });
-                this.appendJoinClause(inner, join.cond);
+            const conditions = [];
+            const params = [];
+            join.primaryKeys.forEach((primaryKey, idx) => {
+                const left = `${join.ownerAlias}.${primaryKey}`;
+                const right = `${join.alias}.${join.joinColumns[idx]}`;
+                conditions.push(`${this.knex.ref(left)} = ${this.knex.ref(right)}`);
             });
+            Object.keys(join.cond).forEach(key => {
+                conditions.push(this.processJoinClause(key, join.cond[key], params));
+            });
+            return qb.joinRaw(`${method} ${this.knex.ref(table)} on ${conditions.join(' and ')}`, params);
         });
     }
+    processJoinClause(key, value, params, operator = '$eq') {
+        if (core_1.Utils.isGroupOperator(key) && Array.isArray(value)) {
+            const parts = value.map(sub => {
+                return this.wrapQueryGroup(Object.keys(sub).map(k => this.processJoinClause(k, sub[k], params)));
+            });
+            return this.wrapQueryGroup(parts, 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 (core_1.Utils.isOperator(key, false) && core_1.Utils.isPlainObject(value)) {
+            const parts = Object.keys(value).map(k => this.processJoinClause(k, value[k], params, key));
+            return key === '$not' ? `not ${this.wrapQueryGroup(parts)}` : this.wrapQueryGroup(parts);
+        }
+        if (core_1.Utils.isPlainObject(value) && Object.keys(value).every(k => core_1.Utils.isOperator(k, false))) {
+            const parts = Object.keys(value).map(op => this.processJoinClause(key, value[op], params, op));
+            return this.wrapQueryGroup(parts);
+        }
+        operator = operator === '$not' ? '$eq' : operator;
+        if (value === null) {
+            return `${this.knex.ref(this.mapper(key))} is ${operator === '$ne' ? 'not ' : ''}null`;
+        }
+        if (operator === '$fulltext') {
+            const [fromAlias, fromField] = this.splitField(key);
+            const property = this.getProperty(fromField, fromAlias);
+            const query = this.knex.raw(this.platform.getFullTextWhereClause(property), {
+                column: this.mapper(key),
+                query: this.knex.raw('?'),
+            }).toSQL().toNative();
+            params.push(value);
+            return query.sql;
+        }
+        const replacement = this.getOperatorReplacement(operator, { [operator]: value });
+        if (['$in', '$nin'].includes(operator) && Array.isArray(value)) {
+            params.push(...value);
+            return `${this.knex.ref(this.mapper(key))} ${replacement} (${value.map(() => '?').join(', ')})`;
+        }
+        if (operator === '$exists') {
+            value = null;
+        }
+        if (QueryBuilderHelper.isCustomExpression(key)) {
+            // unwind parameters when ? found in field name
+            const count = key.concat('?').match(/\?/g).length - 1;
+            const values = core_1.Utils.asArray(value);
+            const params1 = values.slice(0, count).map((c) => core_1.Utils.isObject(c) ? JSON.stringify(c) : c);
+            const params2 = values.slice(count);
+            const k = this.mapper(key, enums_1.QueryType.SELECT, params1);
+            const { sql, bindings } = k.toSQL().toNative();
+            if (params2.length > 0) {
+                params.push(...bindings);
+                params.push(...params2);
+                return sql + ' = ?';
+            }
+            params.push(...bindings);
+            return sql;
+        }
+        const sql = this.mapper(key);
+        if (value !== null) {
+            params.push(value);
+        }
+        return `${this.knex.ref(sql)} ${replacement} ${value === null ? 'null' : '?'}`;
+    }
+    wrapQueryGroup(parts, operator = '$and') {
+        if (parts.length === 1) {
+            return parts[0];
+        }
+        return `(${parts.join(` ${core_1.GroupOperator[operator]} `)})`;
+    }
     mapJoinColumns(type, join) {
         if (join.prop && join.prop.reference === core_1.ReferenceType.ONE_TO_ONE && !join.prop.owner) {
             return join.prop.fieldNames.map((fieldName, idx) => {
@@ -205,6 +279,9 @@ class QueryBuilderHelper {
         if (!(re instanceof RegExp)) {
             return false;
         }
+        if (re.flags.includes('i')) {
+            return false;
+        }
         // when including the opening bracket/paren we consider it complex
         return !re.source.match(/[{[(]/);
     }
@@ -280,7 +357,7 @@ class QueryBuilderHelper {
         }
         qb[m](this.mapper(key, type, cond[key], null), op, cond[key]);
     }
-    processCustomExpression(clause, m, key, cond, type = enums_1.QueryType.SELECT) {
+    processCustomExpression(clause, m, key, cond, type) {
         // unwind parameters when ? found in field name
         const count = key.concat('?').match(/\?/g).length - 1;
         const value = core_1.Utils.asArray(cond[key]);
@@ -301,7 +378,7 @@ class QueryBuilderHelper {
             return subCondition.forEach(sub => this.appendQueryCondition(type, sub, qb, '$and', method));
         }
         if (value instanceof RegExp) {
-            value = { $re: value.source };
+            value = this.platform.getRegExpValue(value);
         }
         // operators
         const op = Object.keys(core_1.QueryOperator).find(op => op in value);
@@ -311,68 +388,42 @@ class QueryBuilderHelper {
         const replacement = this.getOperatorReplacement(op, value);
         const fields = core_1.Utils.splitPrimaryKeys(key);
         if (fields.length > 1 && Array.isArray(value[op]) && !value[op].every((v) => Array.isArray(v))) {
-            const values = this.platform.requiresValuesKeyword() ? 'values ' : '';
-            value[op] = this.knex.raw(`${values}(${fields.map(() => '?').join(', ')})`, value[op]);
+            value[op] = this.knex.raw(`(${fields.map(() => '?').join(', ')})`, value[op]);
         }
         if (this.subQueries[key]) {
             return void qb[m](this.knex.raw(`(${this.subQueries[key]})`), replacement, value[op]);
         }
-        qb[m](this.mapper(key, type, undefined, null), replacement, value[op]);
+        if (op === '$fulltext') {
+            const [a, f] = this.splitField(key);
+            const prop = this.getProperty(f, a);
+            /* istanbul ignore next */
+            if (!prop) {
+                throw new Error(`Cannot use $fulltext operator on ${key}, property not found`);
+            }
+            qb[m](this.knex.raw(this.platform.getFullTextWhereClause(prop), {
+                column: this.mapper(key, type, undefined, null),
+                query: value[op],
+            }));
+        }
+        else {
+            const mappedKey = this.mapper(key, type, value[op], null);
+            qb[m](mappedKey, replacement, value[op]);
+        }
     }
     getOperatorReplacement(op, value) {
         let replacement = core_1.QueryOperator[op];
+        if (op === '$exists') {
+            replacement = value[op] ? 'is not' : 'is';
+            value[op] = null;
+        }
         if (value[op] === null && ['$eq', '$ne'].includes(op)) {
             replacement = op === '$eq' ? 'is' : 'is not';
         }
         if (op === '$re') {
-            replacement = this.platform.getRegExpOperator();
+            replacement = this.platform.getRegExpOperator(value[op], value.$flags);
         }
         return replacement;
     }
-    appendJoinClause(clause, cond, operator) {
-        Object.keys(cond).forEach(k => {
-            if (k === '$and' || k === '$or') {
-                const method = operator === '$or' ? 'orOn' : 'andOn';
-                const m = k === '$or' ? 'orOn' : 'andOn';
-                return clause[method](outer => cond[k].forEach((sub) => {
-                    if (core_1.Utils.getObjectKeysSize(sub) === 1) {
-                        return this.appendJoinClause(outer, sub, k);
-                    }
-                    outer[m](inner => this.appendJoinClause(inner, sub, '$and'));
-                }));
-            }
-            this.appendJoinSubClause(clause, cond, k, operator);
-        });
-    }
-    appendJoinSubClause(clause, cond, key, operator) {
-        const m = operator === '$or' ? 'orOn' : 'andOn';
-        if (cond[key] instanceof RegExp) {
-            return void clause[m](this.mapper(key), 'like', this.knex.raw('?', this.getRegExpParam(cond[key])));
-        }
-        if (core_1.Utils.isPlainObject(cond[key])) {
-            return this.processObjectSubClause(cond, key, clause, m);
-        }
-        if (QueryBuilderHelper.isCustomExpression(key)) {
-            return this.processCustomExpression(clause, m, key, cond);
-        }
-        const op = cond[key] === null ? 'is' : '=';
-        clause[m](this.knex.raw(`${this.knex.ref(this.mapper(key, enums_1.QueryType.SELECT, cond[key]))} ${op} ?`, cond[key]));
-    }
-    processObjectSubClause(cond, key, clause, m) {
-        // grouped condition for one field
-        if (core_1.Utils.getObjectKeysSize(cond[key]) > 1) {
-            const subCondition = Object.entries(cond[key]).map(([subKey, subValue]) => ({ [key]: { [subKey]: subValue } }));
-            return void clause[m](inner => subCondition.map(sub => this.appendJoinClause(inner, sub, '$and')));
-        }
-        // operators
-        for (const [op, replacement] of Object.entries(core_1.QueryOperator)) {
-            if (!(op in cond[key])) {
-                continue;
-            }
-            clause[m](this.mapper(key), replacement, this.knex.raw('?', cond[key][op]));
-            break;
-        }
-    }
     getQueryOrder(type, orderBy, populate) {
         if (Array.isArray(orderBy)) {
             return orderBy
@@ -391,13 +442,13 @@ class QueryBuilderHelper {
                 ret.push(`${k} ${order.toLowerCase()}`);
                 return;
             }
-            // eslint-disable-next-line prefer-const
-            let [alias, field] = this.splitField(k);
-            alias = populate[alias] || alias;
-            core_1.Utils.splitPrimaryKeys(field).forEach(f => {
-                const prop = this.getProperty(f, alias);
-                const noPrefix = (prop && prop.persist === false) || QueryBuilderHelper.isCustomExpression(f);
-                const column = this.mapper(noPrefix ? f : `${alias}.${f}`, type);
+            core_1.Utils.splitPrimaryKeys(k).forEach(f => {
+                // eslint-disable-next-line prefer-const
+                let [alias, field] = this.splitField(f, true);
+                alias = populate[alias] || alias;
+                const prop = this.getProperty(field, alias);
+                const noPrefix = (prop && prop.persist === false && !prop.formula) || QueryBuilderHelper.isCustomExpression(f);
+                const column = this.mapper(noPrefix ? field : `${alias}.${field}`, type, undefined, null);
                 /* istanbul ignore next */
                 const rawColumn = core_1.Utils.isString(column) ? column.split('.').map(e => this.knex.ref(e)).join('.') : column;
                 const customOrder = prop?.customOrder;
@@ -412,14 +463,22 @@ class QueryBuilderHelper {
     finalize(type, qb, meta) {
         const useReturningStatement = type === enums_1.QueryType.INSERT && this.platform.usesReturningStatement() && meta && !meta.compositePK;
         if (useReturningStatement) {
-            const returningProps = meta.props.filter(prop => prop.primary || prop.defaultRaw);
+            const returningProps = meta.hydrateProps.filter(prop => prop.persist !== false && (prop.primary || prop.defaultRaw));
             qb.returning(core_1.Utils.flatten(returningProps.map(prop => prop.fieldNames)));
         }
     }
-    splitField(field) {
+    splitField(field, greedyAlias = false) {
         const parts = field.split('.');
-        const fromField = parts.pop();
-        const fromAlias = parts.length > 0 ? parts.join('.') : this.alias;
+        if (parts.length === 1) {
+            return [this.alias, parts[0]];
+        }
+        if (greedyAlias) {
+            const fromField = parts.pop();
+            const fromAlias = parts.join('.');
+            return [fromAlias, fromField];
+        }
+        const fromAlias = parts.shift();
+        const fromField = parts.join('.');
         return [fromAlias, fromField];
     }
     getLockSQL(qb, lockMode, lockTables = []) {
@@ -438,7 +497,7 @@ class QueryBuilderHelper {
     }
     updateVersionProperty(qb, data) {
         const meta = this.metadata.find(this.entityName);
-        if (!meta || !meta.versionProperty || meta.versionProperty in data) {
+        if (!meta?.versionProperty || meta.versionProperty in data) {
             return;
         }
         const versionProperty = meta.properties[meta.versionProperty];
@@ -464,7 +523,8 @@ class QueryBuilderHelper {
             ret = alias + fieldName;
         }
         else {
-            const [a, f] = field.split('.');
+            const [a, ...rest] = field.split('.');
+            const f = rest.join('.');
             ret = a + '.' + this.fieldName(f, a);
         }
         if (quote) {
@@ -509,15 +569,66 @@ class QueryBuilderHelper {
             return prop.fieldNameRaw;
         }
         /* istanbul ignore next */
-        return prop.fieldNames[0] ?? field;
+        return prop.fieldNames?.[0] ?? field;
     }
     getProperty(field, alias) {
-        const entityName = this.aliasMap[alias] || this.entityName;
+        const entityName = this.aliasMap[alias]?.entityName || this.entityName;
         const meta = this.metadata.find(entityName);
-        return meta ? meta.properties[field] : undefined;
+        // check if `alias` is not matching an embedded property name instead of alias, e.g. `address.city`
+        if (alias && meta) {
+            const prop = meta.properties[alias];
+            if (prop?.reference === core_1.ReferenceType.EMBEDDED) {
+                // we want to select the full object property so hydration works as expected
+                if (prop.object) {
+                    return prop;
+                }
+                const parts = field.split('.');
+                const nest = (p) => parts.length > 0 ? nest(p.embeddedProps[parts.shift()]) : p;
+                return nest(prop);
+            }
+        }
+        return meta?.properties[field];
     }
     isTableNameAliasRequired(type) {
-        return [enums_1.QueryType.SELECT, enums_1.QueryType.COUNT].includes(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 = 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' });
+            }
+            if (prop.customType && 'convertToDatabaseValueSQL' in prop.customType && !this.platform.isRaw(data[k])) {
+                const quoted = this.platform.quoteValue(data[k]);
+                data[k] = this.knex.raw(prop.customType.convertToDatabaseValueSQL(quoted, this.platform).replace(/\?/, '\\?'));
+            }
+            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/{dist/query → query}/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/{dist/schema → schema}/DatabaseSchema.d.ts

@@ -11,7 +11,7 @@ export declare class DatabaseSchema {
     private tables;
     private namespaces;
     constructor(platform: AbstractSqlPlatform, name: string);
-    addTable(name: string, schema: string | undefined | null): DatabaseTable;
+    addTable(name: string, schema: string | undefined | null, comment?: string): DatabaseTable;
     getTables(): DatabaseTable[];
     getTable(name: string): DatabaseTable | undefined;
     hasTable(name: string): boolean;