@mikro-orm/knex 6.2.9-dev.8 → 6.2.9

package/AbstractSqlDriver.d.ts

@@ -28,6 +28,12 @@ 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>>;
+    /**
+     * Fast comparison for collection snapshots that are represented by PK arrays.
+     * Compares scalars via `===` and fallbacks to Utils.equals()` for more complex types like Buffer.
+     * Always expects the same length of the arrays, since we only compare PKs of the same entity type.
+     */
+    private comparePrimaryKeyArrays;
     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, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
     private getPivotOrderBy;

package/AbstractSqlDriver.js

@@ -389,12 +389,21 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 const usedDups = [];
                 props.forEach(prop => {
                     if (prop.fieldNames.length > 1) {
-                        const param = core_1.Utils.flatten([...row[prop.name] ?? prop.fieldNames.map(() => null)]);
-                        const key = param.map(() => '?');
+                        const newFields = [];
+                        const allParam = [...row[prop.name] ?? prop.fieldNames.map(() => null)];
+                        const newParam = [];
                         prop.fieldNames.forEach((field, idx) => {
+                            if (usedDups.includes(field)) {
+                                return;
+                            }
+                            newFields.push(field);
+                            newParam.push(allParam[idx]);
+                        });
+                        const param = core_1.Utils.flatten(newParam);
+                        newFields.forEach((field, idx) => {
                             if (!duplicates.includes(field) || !usedDups.includes(field)) {
                                 params.push(param[idx]);
-                                keys.push(key[idx]);
+                                keys.push('?');
                                 usedDups.push(field);
                             }
                         });
@@ -622,6 +631,26 @@ 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));
     }
+    /**
+     * Fast comparison for collection snapshots that are represented by PK arrays.
+     * Compares scalars via `===` and fallbacks to Utils.equals()` for more complex types like Buffer.
+     * Always expects the same length of the arrays, since we only compare PKs of the same entity type.
+     */
+    comparePrimaryKeyArrays(a, b) {
+        for (let i = a.length; i-- !== 0;) {
+            if (['number', 'string', 'bigint', 'boolean'].includes(typeof a[i])) {
+                if (a[i] !== b[i]) {
+                    return false;
+                }
+            }
+            else {
+                if (!core_1.Utils.equals(a[i], b[i])) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
     async syncCollections(collections, options) {
         const groups = {};
         for (const coll of collections) {
@@ -629,7 +658,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             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 includes = (arr, item) => !!arr.find(i => this.comparePrimaryKeyArrays(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;
@@ -639,8 +668,12 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             // 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);
+                for (const item of snapshot) {
+                    deleteDiff.push(item);
+                }
+                for (const item of current) {
+                    insertDiff.push(item);
+                }
             }
             if (coll.property.kind === core_1.ReferenceKind.ONE_TO_MANY) {
                 const cols = coll.property.referencedColumnNames;

package/PivotCollectionPersister.d.ts

@@ -8,6 +8,7 @@ export declare class PivotCollectionPersister<Entity extends object> {
     private readonly platform;
     private readonly inserts;
     private readonly deletes;
+    private readonly batchSize;
     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;

package/PivotCollectionPersister.js

@@ -44,6 +44,7 @@ class PivotCollectionPersister {
     platform;
     inserts = new Map();
     deletes = new Map();
+    batchSize;
     order = 0;
     constructor(meta, driver, ctx, schema) {
         this.meta = meta;
@@ -51,6 +52,7 @@ class PivotCollectionPersister {
         this.ctx = ctx;
         this.schema = schema;
         this.platform = this.driver.getPlatform();
+        this.batchSize = this.driver.config.get('batchSize');
     }
     enqueueUpdate(prop, insertDiff, deleteDiff, pks) {
         if (insertDiff.length) {
@@ -90,13 +92,18 @@ class PivotCollectionPersister {
     }
     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());
+            const deletes = [...this.deletes.values()];
+            for (let i = 0; i < deletes.length; i += this.batchSize) {
+                const chunk = deletes.slice(i, i + this.batchSize);
+                const cond = { $or: [] };
+                for (const item of chunk) {
+                    cond.$or.push(item.getCondition());
+                }
+                await this.driver.nativeDelete(this.meta.className, cond, {
+                    ctx: this.ctx,
+                    schema: this.schema,
+                });
             }
-            await this.driver.execute(knex.delete());
         }
         if (this.inserts.size === 0) {
             return;
@@ -108,12 +115,15 @@ class PivotCollectionPersister {
         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,
-            });
+            for (let i = 0; i < items.length; i += this.batchSize) {
+                const chunk = items.slice(i, i + this.batchSize);
+                await this.driver.nativeInsertMany(this.meta.className, chunk, {
+                    ctx: this.ctx,
+                    schema: this.schema,
+                    convertCustomTypes: false,
+                    processCollections: false,
+                });
+            }
         }
         else {
             await core_1.Utils.runSerial(items, item => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.2.9-dev.8",
+  "version": "6.2.9",
   "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",
@@ -63,9 +63,23 @@
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.2.8"
+    "@mikro-orm/core": "^6.2.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.2.9-dev.8"
+    "@mikro-orm/core": "^6.0.0",
+    "better-sqlite3": "*",
+    "libsql": "*",
+    "mariadb": "*"
+  },
+  "peerDependenciesMeta": {
+    "better-sqlite3": {
+      "optional": true
+    },
+    "libsql": {
+      "optional": true
+    },
+    "mariadb": {
+      "optional": true
+    }
   }
 }

package/schema/DatabaseTable.js

@@ -158,6 +158,7 @@ class DatabaseTable {
                 constraint: !prop.fieldNames.some((d) => d.includes('.')),
                 primary: false,
                 unique: true,
+                deferMode: prop.deferMode,
             });
         }
     }

package/schema/SchemaComparator.js

@@ -484,7 +484,7 @@ class SchemaComparator {
             // index that has no constraints.
             return true;
         }
-        return index1.primary === index2.primary && index1.unique === index2.unique;
+        return index1.primary === index2.primary && index1.unique === index2.unique && index1.deferMode === index2.deferMode;
     }
     diffExpression(expr1, expr2) {
         // expressions like check constraints might be normalized by the driver,

package/schema/SqlSchemaGenerator.js

@@ -90,11 +90,11 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
         await this.execute(sql);
     }
     async createNamespace(name) {
-        const sql = await this.helper.getCreateNamespaceSQL(name);
+        const sql = this.helper.getCreateNamespaceSQL(name);
         await this.execute(sql);
     }
     async dropNamespace(name) {
-        const sql = await this.helper.getDropNamespaceSQL(name);
+        const sql = this.helper.getDropNamespaceSQL(name);
         await this.execute(sql);
     }
     async clearDatabase(options) {
@@ -359,14 +359,17 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 const foreignKey = Object.values(diff.addedForeignKeys).find(fk => fk.columnNames.length === 1 && fk.columnNames[0] === column.name);
                 if (foreignKey && this.options.createForeignKeyConstraints) {
                     delete diff.addedForeignKeys[foreignKey.constraintName];
-                    col.references(foreignKey.referencedColumnNames[0])
+                    const builder = col.references(foreignKey.referencedColumnNames[0])
                         .inTable(this.getReferencedTableName(foreignKey.referencedTableName))
                         .withKeyName(foreignKey.constraintName)
                         .onUpdate(foreignKey.updateRule)
                         .onDelete(foreignKey.deleteRule);
+                    if (foreignKey.deferMode) {
+                        builder.deferrable(foreignKey.deferMode);
+                    }
                 }
             }
-            for (const { column, changedProperties, fromColumn } of Object.values(diff.changedColumns)) {
+            for (const { column, changedProperties } of Object.values(diff.changedColumns)) {
                 if (changedProperties.size === 1 && changedProperties.has('comment')) {
                     continue;
                 }
@@ -527,7 +530,7 @@ class SqlSchemaGenerator extends core_1.AbstractSchemaGenerator {
                 table.index(columns.map(column => this.knex.raw(column)), index.keyName, { indexType: 'unique' });
             }
             else {
-                table.unique(index.columnNames, { indexName: index.keyName });
+                table.unique(index.columnNames, { indexName: index.keyName, deferrable: index.deferMode });
             }
         }
         else if (index.expression) {

package/typings.d.ts

@@ -73,6 +73,7 @@ export interface IndexDef {
         storageEngineIndexType?: 'hash' | 'btree';
         predicate?: Knex.QueryBuilder;
     }>;
+    deferMode?: DeferMode;
 }
 export interface CheckDef<T = unknown> {
     name: string;