@mikro-orm/mongodb 7.0.4 → 7.0.5-dev.1

package/MongoSchemaGenerator.js

@@ -1,228 +1,224 @@
-import { Utils, inspect } from '@mikro-orm/core';
+import { Utils, inspect, } from '@mikro-orm/core';
 import { AbstractSchemaGenerator } from '@mikro-orm/core/schema';
 /** Schema generator for MongoDB that manages collections and indexes. */
 export class MongoSchemaGenerator extends AbstractSchemaGenerator {
-  static register(orm) {
-    orm.config.registerExtension('@mikro-orm/schema-generator', () => new MongoSchemaGenerator(orm.em));
-  }
-  async create(options = {}) {
-    await this.connection.ensureConnection();
-    options.ensureIndexes ??= true;
-    const existing = await this.connection.listCollections();
-    const metadata = this.getOrderedMetadata();
-    /* v8 ignore next */
-    const promises = metadata
-      .filter(meta => !existing.includes(meta.collection))
-      .map(meta =>
-        this.connection.createCollection(meta.class).catch(err => {
-          const existsErrorMessage = `Collection ${this.config.get('dbName')}.${meta.collection} already exists.`;
-          // ignore errors about the collection already existing
-          if (!(err.name === 'MongoServerError' && err.message.includes(existsErrorMessage))) {
-            throw err;
-          }
-        }),
-      );
-    if (options.ensureIndexes) {
-      await this.ensureIndexes({ ensureCollections: false });
+    static register(orm) {
+        orm.config.registerExtension('@mikro-orm/schema-generator', () => new MongoSchemaGenerator(orm.em));
     }
-    await Promise.all(promises);
-  }
-  async drop(options = {}) {
-    await this.connection.ensureConnection();
-    const existing = await this.connection.listCollections();
-    const metadata = this.getOrderedMetadata();
-    if (options.dropMigrationsTable) {
-      metadata.push({ collection: this.config.get('migrations').tableName });
-    }
-    const promises = metadata
-      .filter(meta => existing.includes(meta.collection))
-      .map(meta => this.connection.dropCollection(meta.class));
-    await Promise.all(promises);
-  }
-  async update(options = {}) {
-    await this.create(options);
-  }
-  async ensureDatabase() {
-    return false;
-  }
-  async refresh(options = {}) {
-    await this.ensureDatabase();
-    await this.drop();
-    await this.create(options);
-  }
-  async dropIndexes(options) {
-    await this.connection.ensureConnection();
-    const db = this.connection.getDb();
-    const collections = await db.listCollections().toArray();
-    const promises = [];
-    for (const collection of collections) {
-      if (options?.collectionsWithFailedIndexes && !options.collectionsWithFailedIndexes.includes(collection.name)) {
-        continue;
-      }
-      const indexes = await db.collection(collection.name).listIndexes().toArray();
-      for (const index of indexes) {
-        const isIdIndex = index.key._id === 1 && Utils.getObjectKeysSize(index.key) === 1;
+    async create(options = {}) {
+        await this.connection.ensureConnection();
+        options.ensureIndexes ??= true;
+        const existing = await this.connection.listCollections();
+        const metadata = this.getOrderedMetadata();
         /* v8 ignore next */
-        if (
-          !isIdIndex &&
-          !options?.skipIndexes?.find(idx => idx.collection === collection.name && idx.indexName === index.name)
-        ) {
-          promises.push(this.executeQuery(db.collection(collection.name), 'dropIndex', index.name));
+        const promises = metadata
+            .filter(meta => !existing.includes(meta.collection))
+            .map(meta => this.connection.createCollection(meta.class).catch(err => {
+            const existsErrorMessage = `Collection ${this.config.get('dbName')}.${meta.collection} already exists.`;
+            // ignore errors about the collection already existing
+            if (!(err.name === 'MongoServerError' && err.message.includes(existsErrorMessage))) {
+                throw err;
+            }
+        }));
+        if (options.ensureIndexes) {
+            await this.ensureIndexes({ ensureCollections: false });
+        }
+        await Promise.all(promises);
+    }
+    async drop(options = {}) {
+        await this.connection.ensureConnection();
+        const existing = await this.connection.listCollections();
+        const metadata = this.getOrderedMetadata();
+        if (options.dropMigrationsTable) {
+            metadata.push({ collection: this.config.get('migrations').tableName });
         }
-      }
+        const promises = metadata
+            .filter(meta => existing.includes(meta.collection))
+            .map(meta => this.connection.dropCollection(meta.class));
+        await Promise.all(promises);
     }
-    await Promise.all(promises);
-  }
-  async ensureIndexes(options = {}) {
-    await this.connection.ensureConnection();
-    options.ensureCollections ??= true;
-    options.retryLimit ??= 3;
-    if (options.ensureCollections) {
-      await this.create({ ensureIndexes: false });
+    async update(options = {}) {
+        await this.create(options);
     }
-    const promises = [];
-    for (const meta of this.getOrderedMetadata()) {
-      if (Array.isArray(options?.retry) && !options.retry.includes(meta.collection)) {
-        continue;
-      }
-      promises.push(...this.createIndexes(meta));
-      promises.push(...this.createUniqueIndexes(meta));
-      for (const prop of meta.props) {
-        promises.push(...this.createPropertyIndexes(meta, prop, 'index'));
-        promises.push(...this.createPropertyIndexes(meta, prop, 'unique'));
-      }
+    async ensureDatabase() {
+        return false;
     }
-    const res = await Promise.allSettled(promises.map(p => p[1]));
-    if (res.some(r => r.status === 'rejected') && options.retry !== false) {
-      const skipIndexes = [];
-      const collectionsWithFailedIndexes = [];
-      const errors = [];
-      for (let i = 0; i < res.length; i++) {
-        const r = res[i];
-        if (r.status === 'rejected') {
-          collectionsWithFailedIndexes.push(promises[i][0]);
-          errors.push(r.reason);
-        } else {
-          skipIndexes.push({ collection: promises[i][0], indexName: r.value });
+    async refresh(options = {}) {
+        await this.ensureDatabase();
+        await this.drop();
+        await this.create(options);
+    }
+    async dropIndexes(options) {
+        await this.connection.ensureConnection();
+        const db = this.connection.getDb();
+        const collections = await db.listCollections().toArray();
+        const promises = [];
+        for (const collection of collections) {
+            if (options?.collectionsWithFailedIndexes && !options.collectionsWithFailedIndexes.includes(collection.name)) {
+                continue;
+            }
+            const indexes = await db.collection(collection.name).listIndexes().toArray();
+            for (const index of indexes) {
+                const isIdIndex = index.key._id === 1 && Utils.getObjectKeysSize(index.key) === 1;
+                /* v8 ignore next */
+                if (!isIdIndex &&
+                    !options?.skipIndexes?.find(idx => idx.collection === collection.name && idx.indexName === index.name)) {
+                    promises.push(this.executeQuery(db.collection(collection.name), 'dropIndex', index.name));
+                }
+            }
         }
-      }
-      await this.dropIndexes({ skipIndexes, collectionsWithFailedIndexes });
-      if (options.retryLimit === 0) {
-        const details = errors.map(e => e.message).join('\n');
-        const message = `Failed to create indexes on the following collections: ${collectionsWithFailedIndexes.join(', ')}\n${details}`;
-        throw new Error(message, { cause: errors });
-      }
-      await this.ensureIndexes({
-        retry: collectionsWithFailedIndexes,
-        retryLimit: options.retryLimit - 1,
-      });
+        await Promise.all(promises);
     }
-  }
-  mapIndexProperties(index, meta) {
-    return Utils.flatten(
-      Utils.asArray(index.properties).map(propName => {
-        const rootPropName = propName.split('.')[0];
-        const prop = meta.properties[rootPropName];
-        if (propName.includes('.')) {
-          return [prop.fieldNames[0] + propName.substring(propName.indexOf('.'))];
+    async ensureIndexes(options = {}) {
+        await this.connection.ensureConnection();
+        options.ensureCollections ??= true;
+        options.retryLimit ??= 3;
+        if (options.ensureCollections) {
+            await this.create({ ensureIndexes: false });
+        }
+        const promises = [];
+        for (const meta of this.getOrderedMetadata()) {
+            if (Array.isArray(options?.retry) && !options.retry.includes(meta.collection)) {
+                continue;
+            }
+            promises.push(...this.createIndexes(meta));
+            promises.push(...this.createUniqueIndexes(meta));
+            for (const prop of meta.props) {
+                promises.push(...this.createPropertyIndexes(meta, prop, 'index'));
+                promises.push(...this.createPropertyIndexes(meta, prop, 'unique'));
+            }
+        }
+        const res = await Promise.allSettled(promises.map(p => p[1]));
+        if (res.some(r => r.status === 'rejected') && options.retry !== false) {
+            const skipIndexes = [];
+            const collectionsWithFailedIndexes = [];
+            const errors = [];
+            for (let i = 0; i < res.length; i++) {
+                const r = res[i];
+                if (r.status === 'rejected') {
+                    collectionsWithFailedIndexes.push(promises[i][0]);
+                    errors.push(r.reason);
+                }
+                else {
+                    skipIndexes.push({ collection: promises[i][0], indexName: r.value });
+                }
+            }
+            await this.dropIndexes({ skipIndexes, collectionsWithFailedIndexes });
+            if (options.retryLimit === 0) {
+                const details = errors.map(e => e.message).join('\n');
+                const message = `Failed to create indexes on the following collections: ${collectionsWithFailedIndexes.join(', ')}\n${details}`;
+                throw new Error(message, { cause: errors });
+            }
+            await this.ensureIndexes({
+                retry: collectionsWithFailedIndexes,
+                retryLimit: options.retryLimit - 1,
+            });
         }
-        return prop?.fieldNames ?? propName;
-      }),
-    );
-  }
-  createIndexes(meta) {
-    const res = [];
-    meta.indexes.forEach(index => {
-      let fieldOrSpec;
-      const properties = this.mapIndexProperties(index, meta);
-      const collection = this.connection.getCollection(meta.class);
-      if (Array.isArray(index.options) && index.options.length === 2 && properties.length === 0) {
-        res.push([collection.collectionName, collection.createIndex(index.options[0], index.options[1])]);
-        return;
-      }
-      if (index.options && properties.length === 0) {
-        res.push([collection.collectionName, collection.createIndex(index.options)]);
-        return;
-      }
-      if (index.type) {
-        if (index.type === 'fulltext') {
-          index.type = 'text';
+    }
+    mapIndexProperties(index, meta) {
+        return Utils.flatten(Utils.asArray(index.properties).map(propName => {
+            const rootPropName = propName.split('.')[0];
+            const prop = meta.properties[rootPropName];
+            if (propName.includes('.')) {
+                return [prop.fieldNames[0] + propName.substring(propName.indexOf('.'))];
+            }
+            return prop?.fieldNames ?? propName;
+        }));
+    }
+    createIndexes(meta) {
+        const res = [];
+        meta.indexes.forEach(index => {
+            let fieldOrSpec;
+            const properties = this.mapIndexProperties(index, meta);
+            const collection = this.connection.getCollection(meta.class);
+            if (Array.isArray(index.options) && index.options.length === 2 && properties.length === 0) {
+                res.push([collection.collectionName, collection.createIndex(index.options[0], index.options[1])]);
+                return;
+            }
+            if (index.options && properties.length === 0) {
+                res.push([collection.collectionName, collection.createIndex(index.options)]);
+                return;
+            }
+            if (index.type) {
+                if (index.type === 'fulltext') {
+                    index.type = 'text';
+                }
+                const spec = {};
+                properties.forEach(prop => (spec[prop] = index.type));
+                fieldOrSpec = spec;
+            }
+            else {
+                fieldOrSpec = properties.reduce((o, i) => {
+                    o[i] = 1;
+                    return o;
+                }, {});
+            }
+            // MongoDB uses 'hidden' for invisible indexes
+            const indexOptions = {
+                name: index.name,
+                unique: false,
+                ...index.options,
+            };
+            if (index.invisible) {
+                indexOptions.hidden = true;
+            }
+            res.push([collection.collectionName, this.executeQuery(collection, 'createIndex', fieldOrSpec, indexOptions)]);
+        });
+        return res;
+    }
+    async executeQuery(collection, method, ...args) {
+        const now = Date.now();
+        return collection[method](...args).then((res) => {
+            Utils.dropUndefinedProperties(args);
+            const query = `db.getCollection('${collection.collectionName}').${method}(${args.map(arg => inspect(arg)).join(', ')});`;
+            this.config.getLogger().logQuery({
+                level: 'info',
+                query,
+                took: Date.now() - now,
+            });
+            return res;
+        });
+    }
+    createUniqueIndexes(meta) {
+        const res = [];
+        meta.uniques.forEach(index => {
+            const properties = this.mapIndexProperties(index, meta);
+            const fieldOrSpec = properties.reduce((o, i) => {
+                o[i] = 1;
+                return o;
+            }, {});
+            const collection = this.connection.getCollection(meta.class);
+            res.push([
+                collection.collectionName,
+                this.executeQuery(collection, 'createIndex', fieldOrSpec, {
+                    name: index.name,
+                    unique: true,
+                    ...index.options,
+                }),
+            ]);
+        });
+        return res;
+    }
+    createPropertyIndexes(meta, prop, type) {
+        if (!prop[type] || !meta.collection) {
+            return [];
         }
-        const spec = {};
-        properties.forEach(prop => (spec[prop] = index.type));
-        fieldOrSpec = spec;
-      } else {
-        fieldOrSpec = properties.reduce((o, i) => {
-          o[i] = 1;
-          return o;
-        }, {});
-      }
-      // MongoDB uses 'hidden' for invisible indexes
-      const indexOptions = {
-        name: index.name,
-        unique: false,
-        ...index.options,
-      };
-      if (index.invisible) {
-        indexOptions.hidden = true;
-      }
-      res.push([collection.collectionName, this.executeQuery(collection, 'createIndex', fieldOrSpec, indexOptions)]);
-    });
-    return res;
-  }
-  async executeQuery(collection, method, ...args) {
-    const now = Date.now();
-    return collection[method](...args).then(res => {
-      Utils.dropUndefinedProperties(args);
-      const query = `db.getCollection('${collection.collectionName}').${method}(${args.map(arg => inspect(arg)).join(', ')});`;
-      this.config.getLogger().logQuery({
-        level: 'info',
-        query,
-        took: Date.now() - now,
-      });
-      return res;
-    });
-  }
-  createUniqueIndexes(meta) {
-    const res = [];
-    meta.uniques.forEach(index => {
-      const properties = this.mapIndexProperties(index, meta);
-      const fieldOrSpec = properties.reduce((o, i) => {
-        o[i] = 1;
-        return o;
-      }, {});
-      const collection = this.connection.getCollection(meta.class);
-      res.push([
-        collection.collectionName,
-        this.executeQuery(collection, 'createIndex', fieldOrSpec, {
-          name: index.name,
-          unique: true,
-          ...index.options,
-        }),
-      ]);
-    });
-    return res;
-  }
-  createPropertyIndexes(meta, prop, type) {
-    if (!prop[type] || !meta.collection) {
-      return [];
+        const collection = this.connection.getCollection(meta.class);
+        const fieldOrSpec = prop.embeddedPath
+            ? prop.embeddedPath.join('.')
+            : prop.fieldNames.reduce((o, i) => {
+                o[i] = 1;
+                return o;
+            }, {});
+        return [
+            [
+                collection.collectionName,
+                this.executeQuery(collection, 'createIndex', fieldOrSpec, {
+                    name: typeof prop[type] === 'string' ? prop[type] : undefined,
+                    unique: type === 'unique',
+                    sparse: prop.nullable === true,
+                }),
+            ],
+        ];
     }
-    const collection = this.connection.getCollection(meta.class);
-    const fieldOrSpec = prop.embeddedPath
-      ? prop.embeddedPath.join('.')
-      : prop.fieldNames.reduce((o, i) => {
-          o[i] = 1;
-          return o;
-        }, {});
-    return [
-      [
-        collection.collectionName,
-        this.executeQuery(collection, 'createIndex', fieldOrSpec, {
-          name: typeof prop[type] === 'string' ? prop[type] : undefined,
-          unique: type === 'unique',
-          sparse: prop.nullable === true,
-        }),
-      ],
-    ];
-  }
 }

package/README.md

@@ -133,7 +133,7 @@ const author = await em.findOneOrFail(Author, 1, {
   populate: ['books'],
 });
 author.name = 'Jon Snow II';
-author.books.getItems().forEach(book => (book.title += ' (2nd ed.)'));
+author.books.getItems().forEach(book => book.title += ' (2nd ed.)');
 author.books.add(orm.em.create(Book, { title: 'New Book', author }));
 
 // Flush computes change sets and executes them in a single transaction

package/index.d.ts

@@ -8,8 +8,4 @@ export * from './MongoEntityRepository.js';
 export * from './MongoSchemaGenerator.js';
 export { MongoEntityManager as EntityManager } from './MongoEntityManager.js';
 export { MongoEntityRepository as EntityRepository } from './MongoEntityRepository.js';
-export {
-  MongoMikroORM as MikroORM,
-  type MongoOptions as Options,
-  defineMongoConfig as defineConfig,
-} from './MongoMikroORM.js';
+export { MongoMikroORM as MikroORM, type MongoOptions as Options, defineMongoConfig as defineConfig, } from './MongoMikroORM.js';

package/index.js

@@ -8,4 +8,4 @@ export * from './MongoEntityRepository.js';
 export * from './MongoSchemaGenerator.js';
 export { MongoEntityManager as EntityManager } from './MongoEntityManager.js';
 export { MongoEntityRepository as EntityRepository } from './MongoEntityRepository.js';
-export { MongoMikroORM as MikroORM, defineMongoConfig as defineConfig } from './MongoMikroORM.js';
+export { MongoMikroORM as MikroORM, defineMongoConfig as defineConfig, } from './MongoMikroORM.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/mongodb",
-  "version": "7.0.4",
+  "version": "7.0.5-dev.1",
   "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.",
   "keywords": [
     "data-mapper",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.0.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.4"
+    "@mikro-orm/core": "7.0.5-dev.1"
   },
   "engines": {
     "node": ">= 22.17.0"