@mikro-orm/mongodb 7.0.4-dev.9 → 7.0.4

package/MongoSchemaGenerator.js

@@ -1,224 +1,228 @@
-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));
+  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 });
     }
-    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 });
-        }
-        await Promise.all(promises);
+    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 });
     }
-    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;
+        /* 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.dropCollection(meta.class));
-        await Promise.all(promises);
+      }
     }
-    async update(options = {}) {
-        await this.create(options);
+    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 ensureDatabase() {
-        return 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'));
+      }
     }
-    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));
-                }
-            }
+    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 Promise.all(promises);
+      }
+      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,
+      });
     }
-    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,
-            });
+  }
+  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('.'))];
         }
-    }
-    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 [];
+        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 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 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,
+        }),
+      ],
+    ];
+  }
 }

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,4 +8,8 @@ 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-dev.9",
+  "version": "7.0.4",
   "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",
@@ -50,10 +50,10 @@
     "mongodb": "7.1.0"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.3"
+    "@mikro-orm/core": "^7.0.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.4-dev.9"
+    "@mikro-orm/core": "7.0.4"
   },
   "engines": {
     "node": ">= 22.17.0"