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

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>;
@@ -54,9 +54,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;
@@ -525,55 +526,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);
@@ -818,48 +828,11 @@ 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));
-            }
-        }
-    }
-    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);
+                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());
             }
-            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) {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.0.0-dev.116",
+  "version": "6.0.0-dev.117",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -66,6 +66,6 @@
     "@mikro-orm/core": "^5.8.6"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.0.0-dev.116"
+    "@mikro-orm/core": "6.0.0-dev.117"
   }
 }