typeorm 0.3.29-dev.cc07c90 → 1.0.0-beta.1

package/browser/entity-manager/MongoEntityManager.js

@@ -1,27 +1,30 @@
-import { EntityManager } from "./EntityManager";
-import { DocumentToEntityTransformer } from "../query-builder/transformer/DocumentToEntityTransformer";
-import { FindOptionsUtils } from "../find-options/FindOptionsUtils";
-import { PlatformTools } from "../platform/PlatformTools";
-import { InsertResult } from "../query-builder/result/InsertResult";
-import { UpdateResult } from "../query-builder/result/UpdateResult";
-import { DeleteResult } from "../query-builder/result/DeleteResult";
-import { ObjectUtils } from "../util/ObjectUtils";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoEntityManager = void 0;
+const EntityManager_1 = require("./EntityManager");
+const DocumentToEntityTransformer_1 = require("../query-builder/transformer/DocumentToEntityTransformer");
+const FindOptionsUtils_1 = require("../find-options/FindOptionsUtils");
+const PlatformTools_1 = require("../platform/PlatformTools");
+const InsertResult_1 = require("../query-builder/result/InsertResult");
+const UpdateResult_1 = require("../query-builder/result/UpdateResult");
+const DeleteResult_1 = require("../query-builder/result/DeleteResult");
+const ObjectUtils_1 = require("../util/ObjectUtils");
 /**
  * Entity manager supposed to work with any entity, automatically find its repository and call its methods,
  * whatever entity type are you passing.
  *
  * This implementation is used for MongoDB driver which has some specifics in its EntityManager.
  */
-export class MongoEntityManager extends EntityManager {
+class MongoEntityManager extends EntityManager_1.EntityManager {
     get mongoQueryRunner() {
-        return this.connection.driver
+        return this.dataSource.driver
             .queryRunner;
     }
     // -------------------------------------------------------------------------
     // Constructor
     // -------------------------------------------------------------------------
-    constructor(connection) {
-        super(connection);
+    constructor(dataSource) {
+        super(dataSource);
         this["@instanceof"] = Symbol.for("MongoEntityManager");
     }
     // -------------------------------------------------------------------------
@@ -32,12 +35,15 @@ export class MongoEntityManager extends EntityManager {
      */
     /**
      * Finds entities that match given find options or conditions.
+     * @param entityClassOrName
+     * @param optionsOrConditions
      */
     async find(entityClassOrName, optionsOrConditions) {
-        const query = this.convertFindManyOptionsOrConditionsToMongodbQuery(optionsOrConditions);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
+        const query = this.replaceObjectIdProperty(metadata, this.convertFindManyOptionsOrConditionsToMongodbQuery(optionsOrConditions));
         const cursor = this.createEntityCursor(entityClassOrName, query);
-        const deleteDateColumn = this.connection.getMetadata(entityClassOrName).deleteDateColumn;
-        if (FindOptionsUtils.isFindManyOptions(optionsOrConditions)) {
+        const deleteDateColumn = metadata.deleteDateColumn;
+        if (FindOptionsUtils_1.FindOptionsUtils.isFindManyOptions(optionsOrConditions)) {
             if (optionsOrConditions.select)
                 cursor.project(this.convertFindOptionsSelectToProjectCriteria(optionsOrConditions.select));
             if (optionsOrConditions.skip)
@@ -59,18 +65,24 @@ export class MongoEntityManager extends EntityManager {
      * Finds entities that match given find options or conditions.
      * Also counts all entities that match given conditions,
      * but ignores pagination settings (from and take options).
+     * @param entityClassOrName
+     * @param options
      */
     async findAndCount(entityClassOrName, options) {
         return this.executeFindAndCount(entityClassOrName, options);
     }
     /**
      * Finds entities that match given where conditions.
+     * @param entityClassOrName
+     * @param where
      */
     async findAndCountBy(entityClassOrName, where) {
         return this.executeFindAndCount(entityClassOrName, where);
     }
     /**
      * Finds entities that match given WHERE conditions.
+     * @param entityClassOrName
+     * @param where
      */
     async findBy(entityClassOrName, where) {
         return this.executeFind(entityClassOrName, where);
@@ -78,31 +90,32 @@ export class MongoEntityManager extends EntityManager {
     /**
      * Finds entities by ids.
      * Optionally find options can be applied.
-     *
-     * @deprecated use `findBy` method instead.
+     * @param entityClassOrName
+     * @param ids
+     * @param optionsOrConditions
      */
     async findByIds(entityClassOrName, ids, optionsOrConditions) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         const query = this.convertFindManyOptionsOrConditionsToMongodbQuery(optionsOrConditions) || {};
-        const objectIdInstance = PlatformTools.load("mongodb").ObjectId;
+        const objectIdClass = PlatformTools_1.PlatformTools.load("mongodb").ObjectId;
         query["_id"] = {
             $in: ids.map((id) => {
                 if (typeof id === "string") {
-                    return new objectIdInstance(id);
+                    return new objectIdClass(id);
                 }
                 if (typeof id === "object") {
-                    if (id instanceof objectIdInstance) {
+                    if (id instanceof objectIdClass) {
                         return id;
                     }
                     const propertyName = metadata.objectIdColumn.propertyName;
-                    if (id[propertyName] instanceof objectIdInstance) {
+                    if (id[propertyName] instanceof objectIdClass) {
                         return id[propertyName];
                     }
                 }
             }),
         };
         const cursor = this.createEntityCursor(entityClassOrName, query);
-        if (FindOptionsUtils.isFindManyOptions(optionsOrConditions)) {
+        if (FindOptionsUtils_1.FindOptionsUtils.isFindManyOptions(optionsOrConditions)) {
             if (optionsOrConditions.select)
                 cursor.project(this.convertFindOptionsSelectToProjectCriteria(optionsOrConditions.select));
             if (optionsOrConditions.skip)
@@ -116,50 +129,44 @@ export class MongoEntityManager extends EntityManager {
     }
     /**
      * Finds first entity that matches given conditions and/or find options.
+     * @param entityClassOrName
+     * @param options
      */
     async findOne(entityClassOrName, options) {
         return this.executeFindOne(entityClassOrName, options);
     }
     /**
      * Finds first entity that matches given WHERE conditions.
+     * @param entityClassOrName
+     * @param where
      */
     async findOneBy(entityClassOrName, where) {
         return this.executeFindOne(entityClassOrName, where);
     }
-    /**
-     * Finds entity that matches given id.
-     *
-     * @deprecated use `findOneBy` method instead in conjunction with `In` operator, for example:
-     *
-     * .findOneBy({
-     *     id: 1 // where "id" is your primary column name
-     * })
-     */
-    async findOneById(entityClassOrName, id) {
-        return this.executeFindOne(entityClassOrName, id);
-    }
     /**
      * Inserts a given entity into the database.
      * Unlike save method executes a primitive operation without cascades, relations and other operations included.
      * Executes fast and efficient INSERT query.
      * Does not check if entity exist in the database, so query will fail if duplicate entity is being inserted.
      * You can execute bulk inserts using this method.
+     * @param target
+     * @param entity
      */
     async insert(target, entity) {
         // todo: convert entity to its database name
-        const result = new InsertResult();
+        const result = new InsertResult_1.InsertResult();
         if (Array.isArray(entity)) {
             result.raw = await this.insertMany(target, entity);
             Object.keys(result.raw.insertedIds).forEach((key) => {
                 const insertedId = result.raw.insertedIds[key];
-                result.generatedMaps.push(this.connection.driver.createGeneratedMap(this.connection.getMetadata(target), insertedId));
-                result.identifiers.push(this.connection.driver.createGeneratedMap(this.connection.getMetadata(target), insertedId));
+                result.generatedMaps.push(this.dataSource.driver.createGeneratedMap(this.dataSource.getMetadata(target), insertedId));
+                result.identifiers.push(this.dataSource.driver.createGeneratedMap(this.dataSource.getMetadata(target), insertedId));
             });
         }
         else {
             result.raw = await this.insertOne(target, entity);
-            result.generatedMaps.push(this.connection.driver.createGeneratedMap(this.connection.getMetadata(target), result.raw.insertedId));
-            result.identifiers.push(this.connection.driver.createGeneratedMap(this.connection.getMetadata(target), result.raw.insertedId));
+            result.generatedMaps.push(this.dataSource.driver.createGeneratedMap(this.dataSource.getMetadata(target), result.raw.insertedId));
+            result.identifiers.push(this.dataSource.driver.createGeneratedMap(this.dataSource.getMetadata(target), result.raw.insertedId));
         }
         return result;
     }
@@ -168,9 +175,12 @@ export class MongoEntityManager extends EntityManager {
      * Unlike save method executes a primitive operation without cascades, relations and other operations included.
      * Executes fast and efficient UPDATE query.
      * Does not check if entity exist in the database.
+     * @param target
+     * @param criteria
+     * @param partialEntity
      */
     async update(target, criteria, partialEntity) {
-        const result = new UpdateResult();
+        const result = new UpdateResult_1.UpdateResult();
         if (Array.isArray(criteria)) {
             const updateResults = await Promise.all(criteria.map((criteriaItem) => {
                 return this.update(target, criteriaItem, partialEntity);
@@ -182,7 +192,7 @@ export class MongoEntityManager extends EntityManager {
             result.generatedMaps = updateResults.reduce((c, r) => c.concat(r.generatedMaps), []);
         }
         else {
-            const metadata = this.connection.getMetadata(target);
+            const metadata = this.dataSource.getMetadata(target);
             const mongoResult = await this.updateMany(target, this.convertMixedCriteria(metadata, criteria), { $set: partialEntity });
             result.raw = mongoResult;
             result.affected = mongoResult.modifiedCount;
@@ -194,9 +204,11 @@ export class MongoEntityManager extends EntityManager {
      * Unlike save method executes a primitive operation without cascades, relations and other operations included.
      * Executes fast and efficient DELETE query.
      * Does not check if entity exist in the database.
+     * @param target
+     * @param criteria
      */
     async delete(target, criteria) {
-        const result = new DeleteResult();
+        const result = new DeleteResult_1.DeleteResult();
         if (Array.isArray(criteria)) {
             const deleteResults = await Promise.all(criteria.map((criteriaItem) => {
                 return this.delete(target, criteriaItem);
@@ -207,7 +219,7 @@ export class MongoEntityManager extends EntityManager {
                 .reduce((c, r) => c + r, 0);
         }
         else {
-            const mongoResult = await this.deleteMany(target, this.convertMixedCriteria(this.connection.getMetadata(target), criteria));
+            const mongoResult = await this.deleteMany(target, this.convertMixedCriteria(this.dataSource.getMetadata(target), criteria));
             result.raw = mongoResult;
             result.affected = mongoResult.deletedCount;
         }
@@ -218,249 +230,404 @@ export class MongoEntityManager extends EntityManager {
     // -------------------------------------------------------------------------
     /**
      * Creates a cursor for a query that can be used to iterate over results from MongoDB.
+     * @param entityClassOrName
+     * @param query
      */
     createCursor(entityClassOrName, query = {}) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.cursor(metadata.tableName, query);
     }
     /**
      * Creates a cursor for a query that can be used to iterate over results from MongoDB.
      * This returns modified version of cursor that transforms each result into Entity model.
+     * @param entityClassOrName
+     * @param query
      */
     createEntityCursor(entityClassOrName, query = {}) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         const cursor = this.createCursor(entityClassOrName, query);
         this.applyEntityTransformationToCursor(metadata, cursor);
         return cursor;
     }
     /**
      * Execute an aggregation framework pipeline against the collection.
+     * @param entityClassOrName
+     * @param pipeline
+     * @param options
      */
     aggregate(entityClassOrName, pipeline, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.aggregate(metadata.tableName, pipeline, options);
     }
     /**
      * Execute an aggregation framework pipeline against the collection.
      * This returns modified version of cursor that transforms each result into Entity model.
+     * @param entityClassOrName
+     * @param pipeline
+     * @param options
      */
     aggregateEntity(entityClassOrName, pipeline, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         const cursor = this.mongoQueryRunner.aggregate(metadata.tableName, pipeline, options);
         this.applyEntityTransformationToCursor(metadata, cursor);
         return cursor;
     }
     /**
      * Perform a bulkWrite operation without a fluent API.
+     * @param entityClassOrName
+     * @param operations
+     * @param options
      */
     bulkWrite(entityClassOrName, operations, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.bulkWrite(metadata.tableName, operations, options);
     }
     /**
      * Count number of matching documents in the db to a query.
+     * @param entityClassOrName
+     * @param query
+     * @param options
      */
     count(entityClassOrName, query = {}, options = {}) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.count(metadata.tableName, query, options);
     }
     /**
      * Count number of matching documents in the db to a query.
+     * @param entityClassOrName
+     * @param query
+     * @param options
      */
     countDocuments(entityClassOrName, query = {}, options = {}) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.countDocuments(metadata.tableName, query, options);
     }
     /**
      * Count number of matching documents in the db to a query.
+     * @param entityClassOrName
+     * @param query
+     * @param options
      */
     countBy(entityClassOrName, query, options) {
         return this.count(entityClassOrName, query, options);
     }
     /**
      * Creates an index on the db and collection.
+     * @param entityClassOrName
+     * @param fieldOrSpec
+     * @param options
      */
     createCollectionIndex(entityClassOrName, fieldOrSpec, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.createCollectionIndex(metadata.tableName, fieldOrSpec, options);
     }
     /**
      * Creates multiple indexes in the collection, this method is only supported for MongoDB 2.6 or higher.
      * Earlier version of MongoDB will throw a command not supported error.
      * Index specifications are defined at http://docs.mongodb.org/manual/reference/command/createIndexes/.
+     * @param entityClassOrName
+     * @param indexSpecs
      */
     createCollectionIndexes(entityClassOrName, indexSpecs) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.createCollectionIndexes(metadata.tableName, indexSpecs);
     }
     /**
      * Delete multiple documents on MongoDB.
+     * @param entityClassOrName
+     * @param query
+     * @param options
      */
     deleteMany(entityClassOrName, query, options = {}) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.deleteMany(metadata.tableName, query, options);
     }
     /**
      * Delete a document on MongoDB.
+     * @param entityClassOrName
+     * @param query
+     * @param options
      */
     deleteOne(entityClassOrName, query, options = {}) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.deleteOne(metadata.tableName, query, options);
     }
     /**
      * The distinct command returns returns a list of distinct values for the given key across a collection.
+     * @param entityClassOrName
+     * @param key
+     * @param query
+     * @param options
      */
     distinct(entityClassOrName, key, query, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.distinct(metadata.tableName, key, query, options);
     }
     /**
      * Drops an index from this collection.
+     * @param entityClassOrName
+     * @param indexName
+     * @param options
      */
     dropCollectionIndex(entityClassOrName, indexName, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.dropCollectionIndex(metadata.tableName, indexName, options);
     }
     /**
      * Drops all indexes from the collection.
+     * @param entityClassOrName
      */
     dropCollectionIndexes(entityClassOrName) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.dropCollectionIndexes(metadata.tableName);
     }
     /**
      * Find a document and delete it in one atomic operation, requires a write lock for the duration of the operation.
+     * @param entityClassOrName
+     * @param query
+     * @param options
      */
     findOneAndDelete(entityClassOrName, query, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.findOneAndDelete(metadata.tableName, query, options);
     }
     /**
      * Find a document and replace it in one atomic operation, requires a write lock for the duration of the operation.
+     * @param entityClassOrName
+     * @param query
+     * @param replacement
+     * @param options
      */
     findOneAndReplace(entityClassOrName, query, replacement, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.findOneAndReplace(metadata.tableName, query, replacement, options);
     }
     /**
      * Find a document and update it in one atomic operation, requires a write lock for the duration of the operation.
+     * @param entityClassOrName
+     * @param query
+     * @param update
+     * @param options
      */
     findOneAndUpdate(entityClassOrName, query, update, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.findOneAndUpdate(metadata.tableName, query, update, options);
     }
     /**
      * Retrieve all the indexes on the collection.
+     * @param entityClassOrName
      */
     collectionIndexes(entityClassOrName) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.collectionIndexes(metadata.tableName);
     }
     /**
      * Retrieve all the indexes on the collection.
+     * @param entityClassOrName
+     * @param indexes
      */
     collectionIndexExists(entityClassOrName, indexes) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.collectionIndexExists(metadata.tableName, indexes);
     }
     /**
      * Retrieves this collections index info.
+     * @param entityClassOrName
+     * @param options
      */
     collectionIndexInformation(entityClassOrName, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.collectionIndexInformation(metadata.tableName, options);
     }
     /**
      * Initiate an In order bulk write operation, operations will be serially executed in the order they are added, creating a new operation for each switch in types.
+     * @param entityClassOrName
+     * @param options
      */
     initializeOrderedBulkOp(entityClassOrName, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.initializeOrderedBulkOp(metadata.tableName, options);
     }
     /**
      * Initiate a Out of order batch write operation. All operations will be buffered into insert/update/remove commands executed out of order.
+     * @param entityClassOrName
+     * @param options
      */
     initializeUnorderedBulkOp(entityClassOrName, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.initializeUnorderedBulkOp(metadata.tableName, options);
     }
     /**
      * Inserts an array of documents into MongoDB.
+     * @param entityClassOrName
+     * @param docs
+     * @param options
      */
     insertMany(entityClassOrName, docs, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.insertMany(metadata.tableName, docs, options);
     }
     /**
      * Inserts a single document into MongoDB.
+     * @param entityClassOrName
+     * @param doc
+     * @param options
      */
     insertOne(entityClassOrName, doc, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.insertOne(metadata.tableName, doc, options);
     }
     /**
      * Returns if the collection is a capped collection.
+     * @param entityClassOrName
      */
     isCapped(entityClassOrName) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.isCapped(metadata.tableName);
     }
     /**
      * Get the list of all indexes information for the collection.
+     * @param entityClassOrName
+     * @param options
      */
     listCollectionIndexes(entityClassOrName, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.listCollectionIndexes(metadata.tableName, options);
     }
     /**
      * Reindex all indexes on the collection Warning: reIndex is a blocking operation (indexes are rebuilt in the foreground) and will be slow for large collections.
+     * @param entityClassOrName
+     * @param newName
+     * @param options
      */
     rename(entityClassOrName, newName, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.rename(metadata.tableName, newName, options);
     }
     /**
      * Replace a document on MongoDB.
+     * @param entityClassOrName
+     * @param query
+     * @param doc
+     * @param options
      */
     replaceOne(entityClassOrName, query, doc, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.replaceOne(metadata.tableName, query, doc, options);
     }
-    /**
-     * Get all the collection statistics.
-     */
-    stats(entityClassOrName, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
-        return this.mongoQueryRunner.stats(metadata.tableName, options);
-    }
     watch(entityClassOrName, pipeline, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.watch(metadata.tableName, pipeline, options);
     }
     /**
      * Update multiple documents on MongoDB.
+     * @param entityClassOrName
+     * @param query
+     * @param update
+     * @param options
      */
     updateMany(entityClassOrName, query, update, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.updateMany(metadata.tableName, query, update, options);
     }
     /**
      * Update a single document on MongoDB.
+     * @param entityClassOrName
+     * @param query
+     * @param update
+     * @param options
      */
     updateOne(entityClassOrName, query, update, options) {
-        const metadata = this.connection.getMetadata(entityClassOrName);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
         return this.mongoQueryRunner.updateOne(metadata.tableName, query, update, options);
     }
     // -------------------------------------------------------------------------
     // Protected Methods
     // -------------------------------------------------------------------------
+    /**
+     * Replaces the entity's ObjectId property name (e.g. "id") with "_id" in a
+     * query object so that `findOneBy({ id: value })` works as expected.
+     * @param metadata
+     * @param query
+     */
+    replaceObjectIdProperty(metadata, query) {
+        if (!query)
+            return query;
+        const objectIdColumn = metadata.objectIdColumn;
+        if (!objectIdColumn)
+            return query;
+        const propertyName = objectIdColumn.propertyName;
+        if (propertyName === "_id")
+            return query;
+        if (!(propertyName in query)) {
+            const hasNested = ("$or" in query && Array.isArray(query.$or)) ||
+                ("$and" in query && Array.isArray(query.$and));
+            if (!hasNested)
+                return query;
+        }
+        const objectIdClass = PlatformTools_1.PlatformTools.load("mongodb").ObjectId;
+        return this.rewriteObjectIdQuery(query, propertyName, objectIdClass);
+    }
+    /**
+     * Recursively rewrites a query object, renaming the given property to
+     * "_id" and converting values to ObjectId instances. Walks into $or/$and.
+     * @param obj
+     * @param propertyName
+     * @param objectIdClass
+     */
+    rewriteObjectIdQuery(obj, propertyName, objectIdClass) {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (key === propertyName) {
+                result["_id"] = this.convertToObjectId(value, objectIdClass);
+            }
+            else if ((key === "$or" || key === "$and") &&
+                Array.isArray(value)) {
+                result[key] = value.map((item) => typeof item === "object" && item !== null
+                    ? this.rewriteObjectIdQuery(item, propertyName, objectIdClass)
+                    : item);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    /**
+     * Converts a query value to ObjectId, handling scalars, arrays, and
+     * MongoDB operator objects (e.g. { $in: [...] }, { $ne: ... }).
+     * @param value
+     * @param objectIdClass
+     */
+    convertToObjectId(value, objectIdClass) {
+        if (value instanceof objectIdClass)
+            return value;
+        if (typeof value === "string" || typeof value === "number")
+            return new objectIdClass(value);
+        if (Array.isArray(value))
+            return value.map((v) => this.convertToObjectId(v, objectIdClass));
+        if (value !== null &&
+            typeof value === "object" &&
+            Object.keys(value).some((k) => k.startsWith("$"))) {
+            const result = {};
+            for (const [k, v] of Object.entries(value)) {
+                result[k] = this.convertToObjectId(v, objectIdClass);
+            }
+            return result;
+        }
+        return value;
+    }
     /**
      * Converts FindManyOptions to mongodb query.
+     * @param optionsOrConditions
      */
     convertFindManyOptionsOrConditionsToMongodbQuery(optionsOrConditions) {
         if (!optionsOrConditions)
             return undefined;
-        if (FindOptionsUtils.isFindManyOptions(optionsOrConditions))
+        FindOptionsUtils_1.FindOptionsUtils.rejectJoinOption(optionsOrConditions);
+        FindOptionsUtils_1.FindOptionsUtils.rejectStringArraySelect(optionsOrConditions);
+        FindOptionsUtils_1.FindOptionsUtils.rejectStringArrayRelations(optionsOrConditions);
+        if (FindOptionsUtils_1.FindOptionsUtils.isFindManyOptions(optionsOrConditions))
             // If where condition is passed as a string which contains sql we have to ignore
             // as mongo is not a sql database
             return typeof optionsOrConditions.where === "string"
@@ -470,11 +637,15 @@ export class MongoEntityManager extends EntityManager {
     }
     /**
      * Converts FindOneOptions to mongodb query.
+     * @param optionsOrConditions
      */
     convertFindOneOptionsOrConditionsToMongodbQuery(optionsOrConditions) {
         if (!optionsOrConditions)
             return undefined;
-        if (FindOptionsUtils.isFindOneOptions(optionsOrConditions))
+        FindOptionsUtils_1.FindOptionsUtils.rejectJoinOption(optionsOrConditions);
+        FindOptionsUtils_1.FindOptionsUtils.rejectStringArraySelect(optionsOrConditions);
+        FindOptionsUtils_1.FindOptionsUtils.rejectStringArrayRelations(optionsOrConditions);
+        if (FindOptionsUtils_1.FindOptionsUtils.isFindOneOptions(optionsOrConditions))
             // If where condition is passed as a string which contains sql we have to ignore
             // as mongo is not a sql database
             return typeof optionsOrConditions.where === "string"
@@ -484,6 +655,7 @@ export class MongoEntityManager extends EntityManager {
     }
     /**
      * Converts FindOptions into mongodb order by criteria.
+     * @param order
      */
     convertFindOptionsOrderToOrderCriteria(order) {
         return Object.keys(order).reduce((orderCriteria, key) => {
@@ -502,24 +674,19 @@ export class MongoEntityManager extends EntityManager {
     }
     /**
      * Converts FindOptions into mongodb select by criteria.
+     * @param selects
      */
     convertFindOptionsSelectToProjectCriteria(selects) {
-        if (Array.isArray(selects)) {
-            return selects.reduce((projectCriteria, key) => {
-                projectCriteria[key] = 1;
-                return projectCriteria;
-            }, {});
-        }
-        else {
-            // todo: implement
-            return {};
-        }
+        // todo: implement
+        return {};
     }
     /**
      * Ensures given id is an id for query.
+     * @param metadata
+     * @param idMap
      */
     convertMixedCriteria(metadata, idMap) {
-        const objectIdInstance = PlatformTools.load("mongodb").ObjectId;
+        const objectIdInstance = PlatformTools_1.PlatformTools.load("mongodb").ObjectId;
         // check first if it's ObjectId compatible:
         // string, number, Buffer, ObjectId or ObjectId-like
         if (objectIdInstance.isValid(idMap)) {
@@ -529,7 +696,7 @@ export class MongoEntityManager extends EntityManager {
         }
         // if it's some other type of object build a query from the columns
         // this check needs to be after the ObjectId check, because a valid ObjectId is also an Object instance
-        if (ObjectUtils.isObject(idMap)) {
+        if (ObjectUtils_1.ObjectUtils.isObject(idMap)) {
             return metadata.columns.reduce((query, column) => {
                 const columnValue = column.getEntityValue(idMap);
                 if (columnValue !== undefined)
@@ -546,12 +713,14 @@ export class MongoEntityManager extends EntityManager {
     }
     /**
      * Overrides cursor's toArray and next methods to convert results to entity automatically.
+     * @param metadata
+     * @param cursor
      */
     applyEntityTransformationToCursor(metadata, cursor) {
         const queryRunner = this.mongoQueryRunner;
         cursor["__to_array_func"] = cursor.toArray;
         cursor.toArray = () => cursor["__to_array_func"]().then(async (results) => {
-            const transformer = new DocumentToEntityTransformer();
+            const transformer = new DocumentToEntityTransformer_1.DocumentToEntityTransformer();
             const entities = transformer.transformAll(results, metadata);
             // broadcast "load" events
             await queryRunner.broadcaster.broadcast("Load", metadata, entities);
@@ -562,7 +731,7 @@ export class MongoEntityManager extends EntityManager {
             if (!result) {
                 return result;
             }
-            const transformer = new DocumentToEntityTransformer();
+            const transformer = new DocumentToEntityTransformer_1.DocumentToEntityTransformer();
             const entity = transformer.transform(result, metadata);
             // broadcast "load" events
             await queryRunner.broadcaster.broadcast("Load", metadata, [
@@ -583,22 +752,26 @@ export class MongoEntityManager extends EntityManager {
     }
     /**
      * Finds first entity that matches given conditions and/or find options.
+     * @param entityClassOrName
+     * @param optionsOrConditions
+     * @param maybeOptions
      */
     async executeFindOne(entityClassOrName, optionsOrConditions, maybeOptions) {
-        const objectIdInstance = PlatformTools.load("mongodb").ObjectId;
-        const id = optionsOrConditions instanceof objectIdInstance ||
+        const objectIdClass = PlatformTools_1.PlatformTools.load("mongodb").ObjectId;
+        const id = optionsOrConditions instanceof objectIdClass ||
             typeof optionsOrConditions === "string"
             ? optionsOrConditions
             : undefined;
         const findOneOptionsOrConditions = (id ? maybeOptions : optionsOrConditions);
-        const query = this.convertFindOneOptionsOrConditionsToMongodbQuery(findOneOptionsOrConditions) || {};
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
+        const query = this.replaceObjectIdProperty(metadata, this.convertFindOneOptionsOrConditionsToMongodbQuery(findOneOptionsOrConditions)) || {};
         if (id) {
             query["_id"] =
-                id instanceof objectIdInstance ? id : new objectIdInstance(id);
+                id instanceof objectIdClass ? id : new objectIdClass(id);
         }
         const cursor = this.createEntityCursor(entityClassOrName, query);
-        const deleteDateColumn = this.connection.getMetadata(entityClassOrName).deleteDateColumn;
-        if (FindOptionsUtils.isFindOneOptions(findOneOptionsOrConditions)) {
+        const deleteDateColumn = this.dataSource.getMetadata(entityClassOrName).deleteDateColumn;
+        if (FindOptionsUtils_1.FindOptionsUtils.isFindOneOptions(findOneOptionsOrConditions)) {
             if (findOneOptionsOrConditions.select)
                 cursor.project(this.convertFindOptionsSelectToProjectCriteria(findOneOptionsOrConditions.select));
             if (findOneOptionsOrConditions.order)
@@ -615,10 +788,11 @@ export class MongoEntityManager extends EntityManager {
         return result.length > 0 ? result[0] : null;
     }
     async executeFind(entityClassOrName, optionsOrConditions) {
-        const query = this.convertFindManyOptionsOrConditionsToMongodbQuery(optionsOrConditions);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
+        const query = this.replaceObjectIdProperty(metadata, this.convertFindManyOptionsOrConditionsToMongodbQuery(optionsOrConditions));
         const cursor = this.createEntityCursor(entityClassOrName, query);
-        const deleteDateColumn = this.connection.getMetadata(entityClassOrName).deleteDateColumn;
-        if (FindOptionsUtils.isFindManyOptions(optionsOrConditions)) {
+        const deleteDateColumn = metadata.deleteDateColumn;
+        if (FindOptionsUtils_1.FindOptionsUtils.isFindManyOptions(optionsOrConditions)) {
             if (optionsOrConditions.select)
                 cursor.project(this.convertFindOptionsSelectToProjectCriteria(optionsOrConditions.select));
             if (optionsOrConditions.skip)
@@ -638,12 +812,15 @@ export class MongoEntityManager extends EntityManager {
     }
     /**
      * Finds entities that match given find options or conditions.
+     * @param entityClassOrName
+     * @param optionsOrConditions
      */
     async executeFindAndCount(entityClassOrName, optionsOrConditions) {
-        const query = this.convertFindManyOptionsOrConditionsToMongodbQuery(optionsOrConditions);
+        const metadata = this.dataSource.getMetadata(entityClassOrName);
+        const query = this.replaceObjectIdProperty(metadata, this.convertFindManyOptionsOrConditionsToMongodbQuery(optionsOrConditions));
         const cursor = this.createEntityCursor(entityClassOrName, query);
-        const deleteDateColumn = this.connection.getMetadata(entityClassOrName).deleteDateColumn;
-        if (FindOptionsUtils.isFindManyOptions(optionsOrConditions)) {
+        const deleteDateColumn = metadata.deleteDateColumn;
+        if (FindOptionsUtils_1.FindOptionsUtils.isFindManyOptions(optionsOrConditions)) {
             if (optionsOrConditions.select)
                 cursor.project(this.convertFindOptionsSelectToProjectCriteria(optionsOrConditions.select));
             if (optionsOrConditions.skip)
@@ -666,5 +843,5 @@ export class MongoEntityManager extends EntityManager {
         return [results, parseInt(count)];
     }
 }
-
-//# sourceMappingURL=MongoEntityManager.js.map
+exports.MongoEntityManager = MongoEntityManager;
+//# sourceMappingURL=MongoEntityManager.js.map