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

package/AbstractSqlDriver.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import { type AnyEntity, type Collection, type Configuration, type ConnectionType, type Constructor, type CountOptions, DatabaseDriver, type DeleteOptions, type Dictionary, type DriverMethodOptions, type EntityData, type EntityDictionary, type EntityField, EntityManagerType, type EntityMetadata, type EntityName, type EntityProperty, type FilterQuery, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type LoggingOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type PopulateOptions, type Primary, type QueryOrderMap, type QueryResult, type Transaction, type UpsertManyOptions, type UpsertOptions, type OrderDefinition } from '@mikro-orm/core';
+import { type AnyEntity, type Collection, type Configuration, type ConnectionType, type Constructor, type CountOptions, DatabaseDriver, type DeleteOptions, type Dictionary, type DriverMethodOptions, type EntityData, type EntityDictionary, type EntityField, EntityManagerType, type EntityMetadata, type EntityName, type EntityProperty, type FilterQuery, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type LoggingOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type OrderDefinition, type PopulateOptions, type Primary, type QueryOrderMap, type QueryResult, type Transaction, type UpsertManyOptions, type UpsertOptions } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from './AbstractSqlConnection';
 import type { AbstractSqlPlatform } from './AbstractSqlPlatform';
 import { QueryBuilder, QueryType } from './query';
@@ -28,7 +28,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>): Promise<QueryResult<T>>;
     nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>): Promise<QueryResult<T>>;
     nativeDelete<T extends object>(entityName: string, where: FilterQuery<T> | string | any, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
-    syncCollection<T extends object, O extends object>(coll: Collection<T, O>, options?: DriverMethodOptions): Promise<void>;
+    syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
     loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
     private getPivotOrderBy;
     execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(queryOrKnex: string | Knex.QueryBuilder | Knex.Raw, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction): Promise<T>;
@@ -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
      */
@@ -54,9 +57,6 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     }): ConnectionType;
     protected extractManyToMany<T>(entityName: string, data: EntityDictionary<T>): EntityData<T>;
     protected processManyToMany<T extends object>(meta: EntityMetadata<T> | undefined, pks: Primary<T>[], collections: EntityData<T>, clear: boolean, options?: DriverMethodOptions): Promise<void>;
-    protected updateCollectionDiff<T extends object, O extends object>(meta: EntityMetadata<O>, prop: EntityProperty<O>, pks: Primary<O>[], deleteDiff: Primary<T>[][] | boolean, insertDiff: Primary<T>[][], options?: DriverMethodOptions & {
-        ownerSchema?: string;
-    }): Promise<void>;
     lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
     protected buildJoinedPropsOrderBy<T extends object>(entityName: string, qb: QueryBuilder<T>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], parentPath?: string): QueryOrderMap<T>[];
     protected normalizeFields<T extends object>(fields: Field<T>[], prefix?: string): string[];

package/AbstractSqlDriver.js

@@ -4,6 +4,7 @@ exports.AbstractSqlDriver = void 0;
 const core_1 = require("@mikro-orm/core");
 const query_1 = require("./query");
 const SqlEntityManager_1 = require("./SqlEntityManager");
+const PivotCollectionPersister_1 = require("./PivotCollectionPersister");
 class AbstractSqlDriver extends core_1.DatabaseDriver {
     [core_1.EntityManagerType];
     connection;
@@ -65,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) {
@@ -150,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;
     }
@@ -166,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 => {
@@ -211,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);
@@ -313,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 => {
@@ -449,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) => {
@@ -463,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, `;
@@ -525,55 +530,64 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         const qb = this.createQueryBuilder(entityName, options.ctx, 'write', false).delete(where).withSchema(this.getSchemaName(meta, options));
         return this.rethrow(qb.execute('run', false));
     }
-    async syncCollection(coll, options) {
-        const wrapped = (0, core_1.helper)(coll.owner);
-        const meta = wrapped.__meta;
-        const pks = wrapped.getPrimaryKeys(true);
-        const snap = coll.getSnapshot();
-        const includes = (arr, item) => !!arr.find(i => core_1.Utils.equals(i, item));
-        const snapshot = snap ? snap.map(item => (0, core_1.helper)(item).getPrimaryKeys(true)) : [];
-        const current = coll.getItems(false).map(item => (0, core_1.helper)(item).getPrimaryKeys(true));
-        const deleteDiff = snap ? snapshot.filter(item => !includes(current, item)) : true;
-        const insertDiff = current.filter(item => !includes(snapshot, item));
-        const target = snapshot.filter(item => includes(current, item)).concat(...insertDiff);
-        const equals = core_1.Utils.equals(current, target);
-        const ctx = options?.ctx;
-        // wrong order if we just delete and insert to the end (only owning sides can have fixed order)
-        if (coll.property.owner && coll.property.fixedOrder && !equals && Array.isArray(deleteDiff)) {
-            deleteDiff.length = insertDiff.length = 0;
-            deleteDiff.push(...snapshot);
-            insertDiff.push(...current);
-        }
-        if (coll.property.kind === core_1.ReferenceKind.ONE_TO_MANY) {
-            const cols = coll.property.referencedColumnNames;
-            const qb = this.createQueryBuilder(coll.property.type, ctx, 'write')
-                .withSchema(this.getSchemaName(meta, options));
-            if (coll.getSnapshot() === undefined) {
-                if (coll.property.orphanRemoval) {
-                    const kqb = qb.delete({ [coll.property.mappedBy]: pks })
+    async syncCollections(collections, options) {
+        const groups = {};
+        for (const coll of collections) {
+            const wrapped = (0, core_1.helper)(coll.owner);
+            const meta = wrapped.__meta;
+            const pks = wrapped.getPrimaryKeys(true);
+            const snap = coll.getSnapshot();
+            const includes = (arr, item) => !!arr.find(i => core_1.Utils.equals(i, item));
+            const snapshot = snap ? snap.map(item => (0, core_1.helper)(item).getPrimaryKeys(true)) : [];
+            const current = coll.getItems(false).map(item => (0, core_1.helper)(item).getPrimaryKeys(true));
+            const deleteDiff = snap ? snapshot.filter(item => !includes(current, item)) : true;
+            const insertDiff = current.filter(item => !includes(snapshot, item));
+            const target = snapshot.filter(item => includes(current, item)).concat(...insertDiff);
+            const equals = core_1.Utils.equals(current, target);
+            // wrong order if we just delete and insert to the end (only owning sides can have fixed order)
+            if (coll.property.owner && coll.property.fixedOrder && !equals && Array.isArray(deleteDiff)) {
+                deleteDiff.length = insertDiff.length = 0;
+                deleteDiff.push(...snapshot);
+                insertDiff.push(...current);
+            }
+            if (coll.property.kind === core_1.ReferenceKind.ONE_TO_MANY) {
+                const cols = coll.property.referencedColumnNames;
+                const qb = this.createQueryBuilder(coll.property.type, options?.ctx, 'write')
+                    .withSchema(this.getSchemaName(meta, options));
+                if (coll.getSnapshot() === undefined) {
+                    if (coll.property.orphanRemoval) {
+                        const kqb = qb.delete({ [coll.property.mappedBy]: pks })
+                            .getKnexQuery()
+                            .whereNotIn(cols, insertDiff);
+                        return this.rethrow(this.execute(kqb));
+                    }
+                    const kqb = qb.update({ [coll.property.mappedBy]: null })
                         .getKnexQuery()
                         .whereNotIn(cols, insertDiff);
                     return this.rethrow(this.execute(kqb));
                 }
-                const kqb = qb.update({ [coll.property.mappedBy]: null })
+                const kqb = qb.update({ [coll.property.mappedBy]: pks })
                     .getKnexQuery()
-                    .whereNotIn(cols, insertDiff);
+                    .whereIn(cols, insertDiff);
                 return this.rethrow(this.execute(kqb));
             }
-            const kqb = qb.update({ [coll.property.mappedBy]: pks })
-                .getKnexQuery()
-                .whereIn(cols, insertDiff);
-            return this.rethrow(this.execute(kqb));
-        }
-        /* istanbul ignore next */
-        const ownerSchema = wrapped.getSchema() === '*' ? this.config.get('schema') : wrapped.getSchema();
-        const pivotMeta = this.metadata.find(coll.property.pivotEntity);
-        if (pivotMeta.schema === '*') {
             /* istanbul ignore next */
-            options ??= {};
-            options.schema = ownerSchema;
+            const pivotMeta = this.metadata.find(coll.property.pivotEntity);
+            let schema = pivotMeta.schema;
+            if (schema === '*') {
+                const ownerSchema = wrapped.getSchema() === '*' ? this.config.get('schema') : wrapped.getSchema();
+                schema = coll.property.owner ? ownerSchema : this.config.get('schema');
+            }
+            else if (schema == null) {
+                schema = this.config.get('schema');
+            }
+            const tableName = `${schema ?? '_'}.${pivotMeta.tableName}`;
+            const persister = groups[tableName] ??= new PivotCollectionPersister_1.PivotCollectionPersister(pivotMeta, this, options?.ctx, schema);
+            persister.enqueueUpdate(coll.property, insertDiff, deleteDiff, pks);
+        }
+        for (const persister of core_1.Utils.values(groups)) {
+            await this.rethrow(persister.execute());
         }
-        return this.rethrow(this.updateCollectionDiff(meta, coll.property, pks, deleteDiff, insertDiff, options));
     }
     async loadFromPivotTable(prop, owners, where = {}, orderBy, ctx, options, pivotJoin) {
         const pivotMeta = this.metadata.find(prop.pivotEntity);
@@ -636,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];
             }));
@@ -690,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] || {};
@@ -700,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) {
@@ -818,50 +842,13 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         }
         for (const prop of meta.relations) {
             if (collections[prop.name]) {
-                await this.rethrow(this.updateCollectionDiff(meta, prop, pks, clear, collections[prop.name], options));
+                const pivotMeta = this.metadata.find(prop.pivotEntity);
+                const persister = new PivotCollectionPersister_1.PivotCollectionPersister(pivotMeta, this, options?.ctx, options?.schema);
+                persister.enqueueUpdate(prop, collections[prop.name], clear, pks);
+                await this.rethrow(persister.execute());
             }
         }
     }
-    async updateCollectionDiff(meta, prop, pks, deleteDiff, insertDiff, options) {
-        if (!deleteDiff) {
-            deleteDiff = [];
-        }
-        const pivotMeta = this.metadata.find(prop.pivotEntity);
-        if (deleteDiff === true || deleteDiff.length > 0) {
-            const qb1 = this.createQueryBuilder(prop.pivotEntity, options?.ctx, 'write').withSchema(this.getSchemaName(pivotMeta, options));
-            const knex = qb1.getKnex();
-            if (Array.isArray(deleteDiff)) {
-                knex.whereIn(prop.inverseJoinColumns, deleteDiff);
-            }
-            prop.joinColumns.forEach((joinColumn, idx) => knex.andWhere(joinColumn, pks[idx]));
-            await this.execute(knex.delete());
-        }
-        if (insertDiff.length === 0) {
-            return;
-        }
-        const items = insertDiff.map(item => {
-            const cond = {};
-            prop.joinColumns.forEach((joinColumn, idx) => cond[joinColumn] = pks[idx]);
-            prop.inverseJoinColumns.forEach((inverseJoinColumn, idx) => cond[inverseJoinColumn] = item[idx]);
-            return cond;
-        });
-        /* istanbul ignore else */
-        if (this.platform.allowsMultiInsert()) {
-            await this.nativeInsertMany(prop.pivotEntity, items, {
-                ...options,
-                convertCustomTypes: false,
-                processCollections: false,
-            });
-        }
-        else {
-            await core_1.Utils.runSerial(items, item => {
-                return this.createQueryBuilder(prop.pivotEntity, options?.ctx, 'write')
-                    .withSchema(this.getSchemaName(pivotMeta, options))
-                    .insert(item)
-                    .execute('run', false);
-            });
-        }
-    }
     async lockPessimistic(entity, options) {
         const meta = (0, core_1.helper)(entity).__meta;
         const qb = this.createQueryBuilder(entity.constructor.name, options.ctx).withSchema(options.schema ?? meta.schema);
@@ -928,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/PivotCollectionPersister.d.ts

@@ -0,0 +1,17 @@
+import { type EntityMetadata, type EntityProperty, type Primary } from '@mikro-orm/core';
+import { type AbstractSqlDriver } from './AbstractSqlDriver';
+export declare class PivotCollectionPersister<Entity extends object> {
+    private readonly meta;
+    private readonly driver;
+    private readonly ctx?;
+    private readonly schema?;
+    private readonly platform;
+    private readonly inserts;
+    private readonly deletes;
+    private order;
+    constructor(meta: EntityMetadata<Entity>, driver: AbstractSqlDriver, ctx?: any, schema?: string | undefined);
+    enqueueUpdate(prop: EntityProperty<Entity>, insertDiff: Primary<Entity>[][], deleteDiff: Primary<Entity>[][] | boolean, pks: Primary<Entity>[]): void;
+    private enqueueInsert;
+    private enqueueDelete;
+    execute(): Promise<void>;
+}

package/PivotCollectionPersister.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PivotCollectionPersister = void 0;
+const core_1 = require("@mikro-orm/core");
+class InsertStatement {
+    keys;
+    data;
+    order;
+    constructor(keys, data, order) {
+        this.keys = keys;
+        this.data = data;
+        this.order = order;
+    }
+    getHash() {
+        return JSON.stringify(this.data);
+    }
+    getData() {
+        const data = {};
+        this.keys.forEach((key, idx) => data[key] = this.data[idx]);
+        return data;
+    }
+}
+class DeleteStatement {
+    keys;
+    cond;
+    constructor(keys, cond) {
+        this.keys = keys;
+        this.cond = cond;
+    }
+    getHash() {
+        return JSON.stringify(this.cond);
+    }
+    getCondition() {
+        const cond = {};
+        this.keys.forEach((key, idx) => cond[key] = this.cond[idx]);
+        return cond;
+    }
+}
+class PivotCollectionPersister {
+    meta;
+    driver;
+    ctx;
+    schema;
+    platform;
+    inserts = new Map();
+    deletes = new Map();
+    order = 0;
+    constructor(meta, driver, ctx, schema) {
+        this.meta = meta;
+        this.driver = driver;
+        this.ctx = ctx;
+        this.schema = schema;
+        this.platform = this.driver.getPlatform();
+    }
+    enqueueUpdate(prop, insertDiff, deleteDiff, pks) {
+        if (insertDiff.length) {
+            this.enqueueInsert(prop, insertDiff, pks);
+        }
+        if (deleteDiff === true || (Array.isArray(deleteDiff) && deleteDiff.length)) {
+            this.enqueueDelete(prop, deleteDiff, pks);
+        }
+    }
+    enqueueInsert(prop, insertDiff, pks) {
+        for (const fks of insertDiff) {
+            const data = prop.owner ? [...fks, ...pks] : [...pks, ...fks];
+            const keys = prop.owner
+                ? [...prop.inverseJoinColumns, ...prop.joinColumns]
+                : [...prop.joinColumns, ...prop.inverseJoinColumns];
+            const statement = new InsertStatement(keys, data, this.order++);
+            const hash = statement.getHash();
+            if (prop.owner || !this.inserts.has(hash)) {
+                this.inserts.set(hash, statement);
+            }
+        }
+    }
+    enqueueDelete(prop, deleteDiff, pks) {
+        if (deleteDiff === true) {
+            const statement = new DeleteStatement(prop.joinColumns, pks);
+            this.deletes.set(statement.getHash(), statement);
+            return;
+        }
+        for (const fks of deleteDiff) {
+            const data = prop.owner ? [...fks, ...pks] : [...pks, ...fks];
+            const keys = prop.owner
+                ? [...prop.inverseJoinColumns, ...prop.joinColumns]
+                : [...prop.joinColumns, ...prop.inverseJoinColumns];
+            const statement = new DeleteStatement(keys, data);
+            this.deletes.set(statement.getHash(), statement);
+        }
+    }
+    async execute() {
+        if (this.deletes.size > 0) {
+            const knex = this.driver.createQueryBuilder(this.meta.className, this.ctx, 'write')
+                .withSchema(this.schema)
+                .getKnex();
+            for (const item of this.deletes.values()) {
+                knex.orWhere(item.getCondition());
+            }
+            await this.driver.execute(knex.delete());
+        }
+        if (this.inserts.size === 0) {
+            return;
+        }
+        let items = [];
+        for (const insert of this.inserts.values()) {
+            items[insert.order] = insert.getData();
+        }
+        items = items.filter(i => i);
+        /* istanbul ignore else */
+        if (this.platform.allowsMultiInsert()) {
+            await this.driver.nativeInsertMany(this.meta.className, items, {
+                ctx: this.ctx,
+                schema: this.schema,
+                convertCustomTypes: false,
+                processCollections: false,
+            });
+        }
+        else {
+            await core_1.Utils.runSerial(items, item => {
+                return this.driver.createQueryBuilder(this.meta.className, this.ctx, 'write')
+                    .withSchema(this.schema)
+                    .insert(item)
+                    .execute('run', false);
+            });
+        }
+    }
+}
+exports.PivotCollectionPersister = PivotCollectionPersister;

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.116",
+  "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.116"
+    "@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');
         }