@mikro-orm/sql 7.0.2-dev.9 → 7.0.2

package/PivotCollectionPersister.js

@@ -1,177 +1,175 @@
 class InsertStatement {
-    order;
-    #keys;
-    #data;
-    constructor(keys, data, order) {
-        this.order = order;
-        this.#keys = keys;
-        this.#data = data;
-    }
-    getHash() {
-        return JSON.stringify(this.#data);
-    }
-    getData() {
-        const data = {};
-        this.#keys.forEach((key, idx) => (data[key] = this.#data[idx]));
-        return data;
-    }
+  order;
+  #keys;
+  #data;
+  constructor(keys, data, order) {
+    this.order = order;
+    this.#keys = keys;
+    this.#data = data;
+  }
+  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;
+  #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;
+  }
+}
+export class PivotCollectionPersister {
+  #inserts = new Map();
+  #upserts = new Map();
+  #deletes = new Map();
+  #batchSize;
+  #order = 0;
+  #meta;
+  #driver;
+  #ctx;
+  #schema;
+  #loggerContext;
+  constructor(meta, driver, ctx, schema, loggerContext) {
+    this.#meta = meta;
+    this.#driver = driver;
+    this.#ctx = ctx;
+    this.#schema = schema;
+    this.#loggerContext = loggerContext;
+    this.#batchSize = this.#driver.config.get('batchSize');
+  }
+  enqueueUpdate(prop, insertDiff, deleteDiff, pks, isInitialized = true) {
+    if (insertDiff.length) {
+      if (isInitialized) {
+        this.enqueueInsert(prop, insertDiff, pks);
+      } else {
+        this.enqueueUpsert(prop, insertDiff, pks);
+      }
     }
-    getHash() {
-        return JSON.stringify(this.#cond);
+    if (deleteDiff === true || (Array.isArray(deleteDiff) && deleteDiff.length)) {
+      this.enqueueDelete(prop, deleteDiff, pks);
     }
-    getCondition() {
-        const cond = {};
-        this.#keys.forEach((key, idx) => (cond[key] = this.#cond[idx]));
-        return cond;
+  }
+  enqueueInsert(prop, insertDiff, pks) {
+    for (const fks of insertDiff) {
+      const statement = this.createInsertStatement(prop, fks, pks);
+      const hash = statement.getHash();
+      if (prop.owner || !this.#inserts.has(hash)) {
+        this.#inserts.set(hash, statement);
+      }
     }
-}
-export class PivotCollectionPersister {
-    #inserts = new Map();
-    #upserts = new Map();
-    #deletes = new Map();
-    #batchSize;
-    #order = 0;
-    #meta;
-    #driver;
-    #ctx;
-    #schema;
-    #loggerContext;
-    constructor(meta, driver, ctx, schema, loggerContext) {
-        this.#meta = meta;
-        this.#driver = driver;
-        this.#ctx = ctx;
-        this.#schema = schema;
-        this.#loggerContext = loggerContext;
-        this.#batchSize = this.#driver.config.get('batchSize');
+  }
+  enqueueUpsert(prop, insertDiff, pks) {
+    for (const fks of insertDiff) {
+      const statement = this.createInsertStatement(prop, fks, pks);
+      const hash = statement.getHash();
+      if (prop.owner || !this.#upserts.has(hash)) {
+        this.#upserts.set(hash, statement);
+      }
     }
-    enqueueUpdate(prop, insertDiff, deleteDiff, pks, isInitialized = true) {
-        if (insertDiff.length) {
-            if (isInitialized) {
-                this.enqueueInsert(prop, insertDiff, pks);
-            }
-            else {
-                this.enqueueUpsert(prop, insertDiff, pks);
-            }
-        }
-        if (deleteDiff === true || (Array.isArray(deleteDiff) && deleteDiff.length)) {
-            this.enqueueDelete(prop, deleteDiff, pks);
-        }
+  }
+  createInsertStatement(prop, fks, pks) {
+    const { data, keys } = this.buildPivotKeysAndData(prop, fks, pks);
+    return new InsertStatement(keys, data, this.#order++);
+  }
+  enqueueDelete(prop, deleteDiff, pks) {
+    if (deleteDiff === true) {
+      const { data, keys } = this.buildPivotKeysAndData(prop, [], pks, true);
+      const statement = new DeleteStatement(keys, data);
+      this.#deletes.set(statement.getHash(), statement);
+      return;
     }
-    enqueueInsert(prop, insertDiff, pks) {
-        for (const fks of insertDiff) {
-            const statement = this.createInsertStatement(prop, fks, pks);
-            const hash = statement.getHash();
-            if (prop.owner || !this.#inserts.has(hash)) {
-                this.#inserts.set(hash, statement);
-            }
-        }
+    for (const fks of deleteDiff) {
+      const { data, keys } = this.buildPivotKeysAndData(prop, fks, pks);
+      const statement = new DeleteStatement(keys, data);
+      this.#deletes.set(statement.getHash(), statement);
     }
-    enqueueUpsert(prop, insertDiff, pks) {
-        for (const fks of insertDiff) {
-            const statement = this.createInsertStatement(prop, fks, pks);
-            const hash = statement.getHash();
-            if (prop.owner || !this.#upserts.has(hash)) {
-                this.#upserts.set(hash, statement);
-            }
-        }
+  }
+  /**
+   * Build the keys and data arrays for pivot table operations.
+   * Handles polymorphic M:N by prepending the discriminator column/value.
+   */
+  buildPivotKeysAndData(prop, fks, pks, deleteAll = false) {
+    let data;
+    let keys;
+    if (deleteAll) {
+      data = pks;
+      keys = prop.joinColumns;
+    } else {
+      data = prop.owner ? [...fks, ...pks] : [...pks, ...fks];
+      keys = prop.owner
+        ? [...prop.inverseJoinColumns, ...prop.joinColumns]
+        : [...prop.joinColumns, ...prop.inverseJoinColumns];
     }
-    createInsertStatement(prop, fks, pks) {
-        const { data, keys } = this.buildPivotKeysAndData(prop, fks, pks);
-        return new InsertStatement(keys, data, this.#order++);
+    if (prop.polymorphic && prop.discriminatorColumn && prop.discriminatorValue) {
+      data = [prop.discriminatorValue, ...data];
+      keys = [prop.discriminatorColumn, ...keys];
     }
-    enqueueDelete(prop, deleteDiff, pks) {
-        if (deleteDiff === true) {
-            const { data, keys } = this.buildPivotKeysAndData(prop, [], pks, true);
-            const statement = new DeleteStatement(keys, data);
-            this.#deletes.set(statement.getHash(), statement);
-            return;
-        }
-        for (const fks of deleteDiff) {
-            const { data, keys } = this.buildPivotKeysAndData(prop, fks, pks);
-            const statement = new DeleteStatement(keys, data);
-            this.#deletes.set(statement.getHash(), statement);
-        }
+    return { data, keys };
+  }
+  collectStatements(statements) {
+    const items = [];
+    for (const statement of statements.values()) {
+      items[statement.order] = statement.getData();
     }
-    /**
-     * Build the keys and data arrays for pivot table operations.
-     * Handles polymorphic M:N by prepending the discriminator column/value.
-     */
-    buildPivotKeysAndData(prop, fks, pks, deleteAll = false) {
-        let data;
-        let keys;
-        if (deleteAll) {
-            data = pks;
-            keys = prop.joinColumns;
-        }
-        else {
-            data = prop.owner ? [...fks, ...pks] : [...pks, ...fks];
-            keys = prop.owner
-                ? [...prop.inverseJoinColumns, ...prop.joinColumns]
-                : [...prop.joinColumns, ...prop.inverseJoinColumns];
-        }
-        if (prop.polymorphic && prop.discriminatorColumn && prop.discriminatorValue) {
-            data = [prop.discriminatorValue, ...data];
-            keys = [prop.discriminatorColumn, ...keys];
+    return items.filter(Boolean);
+  }
+  async execute() {
+    if (this.#deletes.size > 0) {
+      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());
         }
-        return { data, keys };
+        await this.#driver.nativeDelete(this.#meta.class, cond, {
+          ctx: this.#ctx,
+          schema: this.#schema,
+          loggerContext: this.#loggerContext,
+        });
+      }
     }
-    collectStatements(statements) {
-        const items = [];
-        for (const statement of statements.values()) {
-            items[statement.order] = statement.getData();
-        }
-        return items.filter(Boolean);
+    if (this.#inserts.size > 0) {
+      const filtered = this.collectStatements(this.#inserts);
+      for (let i = 0; i < filtered.length; i += this.#batchSize) {
+        const chunk = filtered.slice(i, i + this.#batchSize);
+        await this.#driver.nativeInsertMany(this.#meta.class, chunk, {
+          ctx: this.#ctx,
+          schema: this.#schema,
+          convertCustomTypes: false,
+          processCollections: false,
+          loggerContext: this.#loggerContext,
+        });
+      }
     }
-    async execute() {
-        if (this.#deletes.size > 0) {
-            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.class, cond, {
-                    ctx: this.#ctx,
-                    schema: this.#schema,
-                    loggerContext: this.#loggerContext,
-                });
-            }
-        }
-        if (this.#inserts.size > 0) {
-            const filtered = this.collectStatements(this.#inserts);
-            for (let i = 0; i < filtered.length; i += this.#batchSize) {
-                const chunk = filtered.slice(i, i + this.#batchSize);
-                await this.#driver.nativeInsertMany(this.#meta.class, chunk, {
-                    ctx: this.#ctx,
-                    schema: this.#schema,
-                    convertCustomTypes: false,
-                    processCollections: false,
-                    loggerContext: this.#loggerContext,
-                });
-            }
-        }
-        if (this.#upserts.size > 0) {
-            const filtered = this.collectStatements(this.#upserts);
-            for (let i = 0; i < filtered.length; i += this.#batchSize) {
-                const chunk = filtered.slice(i, i + this.#batchSize);
-                await this.#driver.nativeUpdateMany(this.#meta.class, [], chunk, {
-                    ctx: this.#ctx,
-                    schema: this.#schema,
-                    convertCustomTypes: false,
-                    processCollections: false,
-                    upsert: true,
-                    onConflictAction: 'ignore',
-                    loggerContext: this.#loggerContext,
-                });
-            }
-        }
+    if (this.#upserts.size > 0) {
+      const filtered = this.collectStatements(this.#upserts);
+      for (let i = 0; i < filtered.length; i += this.#batchSize) {
+        const chunk = filtered.slice(i, i + this.#batchSize);
+        await this.#driver.nativeUpdateMany(this.#meta.class, [], chunk, {
+          ctx: this.#ctx,
+          schema: this.#schema,
+          convertCustomTypes: false,
+          processCollections: false,
+          upsert: true,
+          onConflictAction: 'ignore',
+          loggerContext: this.#loggerContext,
+        });
+      }
     }
+  }
 }