typeorm 0.3.15-dev.115059d → 0.3.15-dev.f6a3ce7

package/browser/driver/mongodb/MongoQueryRunner.d.ts

@@ -1,13 +1,10 @@
 
 import { QueryRunner } from "../../query-runner/QueryRunner";
-import { ObjectLiteral } from "../../common/ObjectLiteral";
 import { TableColumn } from "../../schema-builder/table/TableColumn";
 import { Table } from "../../schema-builder/table/Table";
 import { TableForeignKey } from "../../schema-builder/table/TableForeignKey";
 import { TableIndex } from "../../schema-builder/table/TableIndex";
 import { View } from "../../schema-builder/view/View";
-import { AggregationCursor, BulkWriteOpResultObject, ChangeStream, ChangeStreamOptions, Code, Collection, CollectionAggregationOptions, CollectionBulkWriteOptions, CollectionInsertManyOptions, CollectionInsertOneOptions, CollectionOptions, CollStats, CommandCursor, Cursor, DeleteWriteOpResultObject, FindAndModifyWriteOpResultObject, FindOneAndReplaceOption, GeoHaystackSearchOptions, GeoNearOptions, InsertOneWriteOpResult, InsertWriteOpResult, MapReduceOptions, MongoClient, MongoCountPreferences, MongodbIndexOptions, OrderedBulkOperation, ParallelCollectionScanOptions, ReadPreference, ReplaceOneOptions, UnorderedBulkOperation, UpdateWriteOpResult } from "./typings";
-import { DataSource } from "../../data-source/DataSource";
 import { ReadStream } from "../../platform/PlatformTools";
 import { MongoEntityManager } from "../../entity-manager/MongoEntityManager";
 import { SqlInMemory } from "../SqlInMemory";
@@ -15,6 +12,8 @@ import { TableUnique } from "../../schema-builder/table/TableUnique";
 import { Broadcaster } from "../../subscriber/Broadcaster";
 import { TableCheck } from "../../schema-builder/table/TableCheck";
 import { TableExclusion } from "../../schema-builder/table/TableExclusion";
+import { BulkWriteResult, AggregationCursor, MongoClient, Collection, FindCursor, Document, AggregateOptions, AnyBulkWriteOperation, BulkWriteOptions, Filter, CountOptions, CountDocumentsOptions, IndexSpecification, CreateIndexesOptions, IndexDescription, DeleteResult, DeleteOptions, CommandOperationOptions, FindOneAndDeleteOptions, FindOneAndReplaceOptions, UpdateFilter, FindOneAndUpdateOptions, RenameOptions, ReplaceOptions, UpdateResult, CollStats, CollStatsOptions, ChangeStreamOptions, ChangeStream, UpdateOptions, ListIndexesOptions, ListIndexesCursor, OptionalId, InsertOneOptions, InsertOneResult, InsertManyResult, UnorderedBulkOperation, OrderedBulkOperation, IndexInformationOptions } from "../../driver/mongodb/typings";
+import { DataSource } from "../../data-source/DataSource";
 import { ReplicationMode } from "../types/ReplicationMode";
 /**
  * Runs queries on a single MongoDB connection.
@@ -72,84 +71,68 @@ export declare class MongoQueryRunner implements QueryRunner {
     /**
      * Creates a cursor for a query that can be used to iterate over results from MongoDB.
      */
-    cursor(collectionName: string, query?: ObjectLiteral): Cursor<any>;
+    cursor(collectionName: string, filter: Filter<Document>): FindCursor<any>;
     /**
      * Execute an aggregation framework pipeline against the collection.
      */
-    aggregate(collectionName: string, pipeline: ObjectLiteral[], options?: CollectionAggregationOptions): AggregationCursor<any>;
+    aggregate(collectionName: string, pipeline: Document[], options?: AggregateOptions): AggregationCursor<any>;
     /**
      * Perform a bulkWrite operation without a fluent API.
      */
-    bulkWrite(collectionName: string, operations: ObjectLiteral[], options?: CollectionBulkWriteOptions): Promise<BulkWriteOpResultObject>;
+    bulkWrite(collectionName: string, operations: AnyBulkWriteOperation<Document>[], options?: BulkWriteOptions): Promise<BulkWriteResult>;
+    /**
+     * Count number of matching documents in the db to a query.
+     */
+    count(collectionName: string, filter: Filter<Document>, options?: CountOptions): Promise<number>;
     /**
      * Count number of matching documents in the db to a query.
      */
-    count(collectionName: string, query?: ObjectLiteral, options?: MongoCountPreferences): Promise<any>;
+    countDocuments(collectionName: string, filter: Filter<Document>, options?: CountDocumentsOptions): Promise<any>;
     /**
      * Creates an index on the db and collection.
      */
-    createCollectionIndex(collectionName: string, fieldOrSpec: string | any, options?: MongodbIndexOptions): Promise<string>;
+    createCollectionIndex(collectionName: string, indexSpec: IndexSpecification, options?: CreateIndexesOptions): Promise<string>;
     /**
      * 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/.
      */
-    createCollectionIndexes(collectionName: string, indexSpecs: ObjectLiteral[]): Promise<void>;
+    createCollectionIndexes(collectionName: string, indexSpecs: IndexDescription[]): Promise<string[]>;
     /**
      * Delete multiple documents on MongoDB.
      */
-    deleteMany(collectionName: string, query: ObjectLiteral, options?: CollectionOptions): Promise<DeleteWriteOpResultObject>;
+    deleteMany(collectionName: string, filter: Filter<Document>, options: DeleteOptions): Promise<DeleteResult>;
     /**
      * Delete a document on MongoDB.
      */
-    deleteOne(collectionName: string, query: ObjectLiteral, options?: CollectionOptions): Promise<DeleteWriteOpResultObject>;
+    deleteOne(collectionName: string, filter: Filter<Document>, options?: DeleteOptions): Promise<DeleteResult>;
     /**
      * The distinct command returns returns a list of distinct values for the given key across a collection.
      */
-    distinct(collectionName: string, key: string, query: ObjectLiteral, options?: {
-        readPreference?: ReadPreference | string;
-    }): Promise<any>;
+    distinct(collectionName: string, key: any, filter: Filter<Document>, options?: CommandOperationOptions): Promise<any>;
     /**
      * Drops an index from this collection.
      */
-    dropCollectionIndex(collectionName: string, indexName: string, options?: CollectionOptions): Promise<any>;
+    dropCollectionIndex(collectionName: string, indexName: string, options?: CommandOperationOptions): Promise<Document>;
     /**
      * Drops all indexes from the collection.
      */
-    dropCollectionIndexes(collectionName: string): Promise<any>;
+    dropCollectionIndexes(collectionName: string): Promise<Document>;
     /**
      * Find a document and delete it in one atomic operation, requires a write lock for the duration of the operation.
      */
-    findOneAndDelete(collectionName: string, query: ObjectLiteral, options?: {
-        projection?: Object;
-        sort?: Object;
-        maxTimeMS?: number;
-    }): Promise<FindAndModifyWriteOpResultObject>;
+    findOneAndDelete(collectionName: string, filter: Filter<Document>, options?: FindOneAndDeleteOptions): Promise<Document>;
     /**
      * Find a document and replace it in one atomic operation, requires a write lock for the duration of the operation.
      */
-    findOneAndReplace(collectionName: string, query: ObjectLiteral, replacement: Object, options?: FindOneAndReplaceOption): Promise<FindAndModifyWriteOpResultObject>;
+    findOneAndReplace(collectionName: string, filter: Filter<Document>, replacement: Document, options?: FindOneAndReplaceOptions): Promise<Document>;
     /**
      * Find a document and update it in one atomic operation, requires a write lock for the duration of the operation.
      */
-    findOneAndUpdate(collectionName: string, query: ObjectLiteral, update: Object, options?: FindOneAndReplaceOption): Promise<FindAndModifyWriteOpResultObject>;
-    /**
-     * Execute a geo search using a geo haystack index on a collection.
-     */
-    geoHaystackSearch(collectionName: string, x: number, y: number, options?: GeoHaystackSearchOptions): Promise<any>;
-    /**
-     * Execute the geoNear command to search for items in the collection.
-     */
-    geoNear(collectionName: string, x: number, y: number, options?: GeoNearOptions): Promise<any>;
-    /**
-     * Run a group command across a collection.
-     */
-    group(collectionName: string, keys: Object | Array<any> | Function | Code, condition: Object, initial: Object, reduce: Function | Code, finalize: Function | Code, command: boolean, options?: {
-        readPreference?: ReadPreference | string;
-    }): Promise<any>;
+    findOneAndUpdate(collectionName: string, filter: Filter<Document>, update: UpdateFilter<Document>, options?: FindOneAndUpdateOptions): Promise<Document>;
     /**
      * Retrieve all the indexes on the collection.
      */
-    collectionIndexes(collectionName: string): Promise<any>;
+    collectionIndexes(collectionName: string): Promise<Document>;
     /**
      * Retrieve all the indexes on the collection.
      */
@@ -157,82 +140,55 @@ export declare class MongoQueryRunner implements QueryRunner {
     /**
      * Retrieves this collections index info.
      */
-    collectionIndexInformation(collectionName: string, options?: {
-        full: boolean;
-    }): Promise<any>;
+    collectionIndexInformation(collectionName: string, options?: IndexInformationOptions): Promise<any>;
     /**
      * 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.
      */
-    initializeOrderedBulkOp(collectionName: string, options?: CollectionOptions): OrderedBulkOperation;
+    initializeOrderedBulkOp(collectionName: string, options?: BulkWriteOptions): OrderedBulkOperation;
     /**
      * Initiate a Out of order batch write operation. All operations will be buffered into insert/update/remove commands executed out of order.
      */
-    initializeUnorderedBulkOp(collectionName: string, options?: CollectionOptions): UnorderedBulkOperation;
+    initializeUnorderedBulkOp(collectionName: string, options?: BulkWriteOptions): UnorderedBulkOperation;
     /**
      * Inserts an array of documents into MongoDB.
      */
-    insertMany(collectionName: string, docs: ObjectLiteral[], options?: CollectionInsertManyOptions): Promise<InsertWriteOpResult>;
+    insertMany(collectionName: string, docs: OptionalId<Document>[], options?: BulkWriteOptions): Promise<InsertManyResult>;
     /**
      * Inserts a single document into MongoDB.
      */
-    insertOne(collectionName: string, doc: ObjectLiteral, options?: CollectionInsertOneOptions): Promise<InsertOneWriteOpResult>;
+    insertOne(collectionName: string, doc: OptionalId<Document>, options?: InsertOneOptions): Promise<InsertOneResult>;
     /**
      * Returns if the collection is a capped collection.
      */
-    isCapped(collectionName: string): Promise<any>;
+    isCapped(collectionName: string): Promise<boolean>;
     /**
      * Get the list of all indexes information for the collection.
      */
-    listCollectionIndexes(collectionName: string, options?: {
-        batchSize?: number;
-        readPreference?: ReadPreference | string;
-    }): CommandCursor;
-    /**
-     * Run Map Reduce across a collection. Be aware that the inline option for out will return an array of results not a collection.
-     */
-    mapReduce(collectionName: string, map: Function | string, reduce: Function | string, options?: MapReduceOptions): Promise<any>;
-    /**
-     * Return N number of parallel cursors for a collection allowing parallel reading of entire collection.
-     * There are no ordering guarantees for returned results.
-     */
-    parallelCollectionScan(collectionName: string, options?: ParallelCollectionScanOptions): Promise<Cursor<any>[]>;
-    /**
-     * 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.
-     */
-    reIndex(collectionName: string): Promise<any>;
+    listCollectionIndexes(collectionName: string, options?: ListIndexesOptions): ListIndexesCursor;
     /**
      * 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.
      */
-    rename(collectionName: string, newName: string, options?: {
-        dropTarget?: boolean;
-    }): Promise<Collection<any>>;
+    rename(collectionName: string, newName: string, options?: RenameOptions): Promise<Collection<Document>>;
     /**
      * Replace a document on MongoDB.
      */
-    replaceOne(collectionName: string, query: ObjectLiteral, doc: ObjectLiteral, options?: ReplaceOneOptions): Promise<UpdateWriteOpResult>;
+    replaceOne(collectionName: string, filter: Filter<Document>, replacement: Document, options?: ReplaceOptions): Promise<Document | UpdateResult>;
     /**
      * Get all the collection statistics.
      */
-    stats(collectionName: string, options?: {
-        scale: number;
-    }): Promise<CollStats>;
+    stats(collectionName: string, options?: CollStatsOptions): Promise<CollStats>;
     /**
      * Watching new changes as stream.
      */
-    watch(collectionName: string, pipeline?: Object[], options?: ChangeStreamOptions): ChangeStream;
+    watch(collectionName: string, pipeline?: Document[], options?: ChangeStreamOptions): ChangeStream;
     /**
      * Update multiple documents on MongoDB.
      */
-    updateMany(collectionName: string, query: ObjectLiteral, update: ObjectLiteral, options?: {
-        upsert?: boolean;
-        w?: any;
-        wtimeout?: number;
-        j?: boolean;
-    }): Promise<UpdateWriteOpResult>;
+    updateMany(collectionName: string, filter: Filter<Document>, update: UpdateFilter<Document>, options?: UpdateOptions): Promise<Document | UpdateResult>;
     /**
      * Update a single document on MongoDB.
      */
-    updateOne(collectionName: string, query: ObjectLiteral, update: ObjectLiteral, options?: ReplaceOneOptions): Promise<UpdateWriteOpResult>;
+    updateOne(collectionName: string, filter: Filter<Document>, update: UpdateFilter<Document>, options?: UpdateOptions): Promise<Document | UpdateResult>;
     /**
      * Removes all collections from the currently connected database.
      * Be careful with using this method and avoid using it in production or migrations

package/browser/driver/mongodb/MongoQueryRunner.js

@@ -46,123 +46,111 @@ export class MongoQueryRunner {
     /**
      * Creates a cursor for a query that can be used to iterate over results from MongoDB.
      */
-    cursor(collectionName, query) {
-        return this.getCollection(collectionName).find(query || {});
+    cursor(collectionName, filter) {
+        return this.getCollection(collectionName).find(filter || {});
     }
     /**
      * Execute an aggregation framework pipeline against the collection.
      */
     aggregate(collectionName, pipeline, options) {
-        return this.getCollection(collectionName).aggregate(pipeline, options);
+        return this.getCollection(collectionName).aggregate(pipeline, options || {});
     }
     /**
      * Perform a bulkWrite operation without a fluent API.
      */
     async bulkWrite(collectionName, operations, options) {
-        return await this.getCollection(collectionName).bulkWrite(operations, options);
+        return await this.getCollection(collectionName).bulkWrite(operations, options || {});
     }
     /**
      * Count number of matching documents in the db to a query.
      */
-    async count(collectionName, query, options) {
-        return await this.getCollection(collectionName).countDocuments(query || {}, options);
+    async count(collectionName, filter, options) {
+        return this.getCollection(collectionName).count(filter || {}, options || {});
+    }
+    /**
+     * Count number of matching documents in the db to a query.
+     */
+    async countDocuments(collectionName, filter, options) {
+        return this.getCollection(collectionName).countDocuments(filter || {}, options || {});
     }
     /**
      * Creates an index on the db and collection.
      */
-    async createCollectionIndex(collectionName, fieldOrSpec, options) {
-        return await this.getCollection(collectionName).createIndex(fieldOrSpec, options);
+    async createCollectionIndex(collectionName, indexSpec, options) {
+        return this.getCollection(collectionName).createIndex(indexSpec, 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/.
      */
     async createCollectionIndexes(collectionName, indexSpecs) {
-        return await this.getCollection(collectionName).createIndexes(indexSpecs);
+        return this.getCollection(collectionName).createIndexes(indexSpecs);
     }
     /**
      * Delete multiple documents on MongoDB.
      */
-    async deleteMany(collectionName, query, options) {
-        return await this.getCollection(collectionName).deleteMany(query, options);
+    async deleteMany(collectionName, filter, options) {
+        return this.getCollection(collectionName).deleteMany(filter, options || {});
     }
     /**
      * Delete a document on MongoDB.
      */
-    async deleteOne(collectionName, query, options) {
-        return await this.getCollection(collectionName).deleteOne(query, options);
+    async deleteOne(collectionName, filter, options) {
+        return this.getCollection(collectionName).deleteOne(filter, options || {});
     }
     /**
      * The distinct command returns returns a list of distinct values for the given key across a collection.
      */
-    async distinct(collectionName, key, query, options) {
-        return await this.getCollection(collectionName).distinct(key, query, options);
+    async distinct(collectionName, key, filter, options) {
+        return this.getCollection(collectionName).distinct(key, filter, options || {});
     }
     /**
      * Drops an index from this collection.
      */
     async dropCollectionIndex(collectionName, indexName, options) {
-        return await this.getCollection(collectionName).dropIndex(indexName, options);
+        return this.getCollection(collectionName).dropIndex(indexName, options || {});
     }
     /**
      * Drops all indexes from the collection.
      */
     async dropCollectionIndexes(collectionName) {
-        return await this.getCollection(collectionName).dropIndexes();
+        return this.getCollection(collectionName).dropIndexes();
     }
     /**
      * Find a document and delete it in one atomic operation, requires a write lock for the duration of the operation.
      */
-    async findOneAndDelete(collectionName, query, options) {
-        return await this.getCollection(collectionName).findOneAndDelete(query, options);
+    async findOneAndDelete(collectionName, filter, options) {
+        return this.getCollection(collectionName).findOneAndDelete(filter, options || {});
     }
     /**
      * Find a document and replace it in one atomic operation, requires a write lock for the duration of the operation.
      */
-    async findOneAndReplace(collectionName, query, replacement, options) {
-        return await this.getCollection(collectionName).findOneAndReplace(query, replacement, options);
+    async findOneAndReplace(collectionName, filter, replacement, options) {
+        return this.getCollection(collectionName).findOneAndReplace(filter, replacement, options || {});
     }
     /**
      * Find a document and update it in one atomic operation, requires a write lock for the duration of the operation.
      */
-    async findOneAndUpdate(collectionName, query, update, options) {
-        return await this.getCollection(collectionName).findOneAndUpdate(query, update, options);
-    }
-    /**
-     * Execute a geo search using a geo haystack index on a collection.
-     */
-    async geoHaystackSearch(collectionName, x, y, options) {
-        return await this.getCollection(collectionName).geoHaystackSearch(x, y, options);
-    }
-    /**
-     * Execute the geoNear command to search for items in the collection.
-     */
-    async geoNear(collectionName, x, y, options) {
-        return await this.getCollection(collectionName).geoNear(x, y, options);
-    }
-    /**
-     * Run a group command across a collection.
-     */
-    async group(collectionName, keys, condition, initial, reduce, finalize, command, options) {
-        return await this.getCollection(collectionName).group(keys, condition, initial, reduce, finalize, command, options);
+    async findOneAndUpdate(collectionName, filter, update, options) {
+        return this.getCollection(collectionName).findOneAndUpdate(filter, update, options || {});
     }
     /**
      * Retrieve all the indexes on the collection.
      */
     async collectionIndexes(collectionName) {
-        return await this.getCollection(collectionName).indexes();
+        return this.getCollection(collectionName).indexes();
     }
     /**
      * Retrieve all the indexes on the collection.
      */
     async collectionIndexExists(collectionName, indexes) {
-        return await this.getCollection(collectionName).indexExists(indexes);
+        return this.getCollection(collectionName).indexExists(indexes);
     }
     /**
      * Retrieves this collections index info.
      */
     async collectionIndexInformation(collectionName, options) {
-        return await this.getCollection(collectionName).indexInformation(options);
+        return this.getCollection(collectionName).indexInformation(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.
@@ -180,19 +168,19 @@ export class MongoQueryRunner {
      * Inserts an array of documents into MongoDB.
      */
     async insertMany(collectionName, docs, options) {
-        return await this.getCollection(collectionName).insertMany(docs, options);
+        return this.getCollection(collectionName).insertMany(docs, options || {});
     }
     /**
      * Inserts a single document into MongoDB.
      */
     async insertOne(collectionName, doc, options) {
-        return await this.getCollection(collectionName).insertOne(doc, options);
+        return this.getCollection(collectionName).insertOne(doc, options || {});
     }
     /**
      * Returns if the collection is a capped collection.
      */
     async isCapped(collectionName) {
-        return await this.getCollection(collectionName).isCapped();
+        return this.getCollection(collectionName).isCapped();
     }
     /**
      * Get the list of all indexes information for the collection.
@@ -200,42 +188,23 @@ export class MongoQueryRunner {
     listCollectionIndexes(collectionName, options) {
         return this.getCollection(collectionName).listIndexes(options);
     }
-    /**
-     * Run Map Reduce across a collection. Be aware that the inline option for out will return an array of results not a collection.
-     */
-    async mapReduce(collectionName, map, reduce, options) {
-        return await this.getCollection(collectionName).mapReduce(map, reduce, options);
-    }
-    /**
-     * Return N number of parallel cursors for a collection allowing parallel reading of entire collection.
-     * There are no ordering guarantees for returned results.
-     */
-    async parallelCollectionScan(collectionName, options) {
-        return await this.getCollection(collectionName).parallelCollectionScan(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.
-     */
-    async reIndex(collectionName) {
-        return await this.getCollection(collectionName).reIndex();
-    }
     /**
      * 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.
      */
     async rename(collectionName, newName, options) {
-        return await this.getCollection(collectionName).rename(newName, options);
+        return this.getCollection(collectionName).rename(newName, options || {});
     }
     /**
      * Replace a document on MongoDB.
      */
-    async replaceOne(collectionName, query, doc, options) {
-        return await this.getCollection(collectionName).replaceOne(query, doc, options);
+    async replaceOne(collectionName, filter, replacement, options) {
+        return this.getCollection(collectionName).replaceOne(filter, replacement, options || {});
     }
     /**
      * Get all the collection statistics.
      */
     async stats(collectionName, options) {
-        return await this.getCollection(collectionName).stats(options);
+        return this.getCollection(collectionName).stats(options || {});
     }
     /**
      * Watching new changes as stream.
@@ -246,14 +215,14 @@ export class MongoQueryRunner {
     /**
      * Update multiple documents on MongoDB.
      */
-    async updateMany(collectionName, query, update, options) {
-        return await this.getCollection(collectionName).updateMany(query, update, options);
+    async updateMany(collectionName, filter, update, options) {
+        return this.getCollection(collectionName).updateMany(filter, update, options || {});
     }
     /**
      * Update a single document on MongoDB.
      */
-    async updateOne(collectionName, query, update, options) {
-        return await this.getCollection(collectionName).updateOne(query, update, options);
+    async updateOne(collectionName, filter, update, options) {
+        return await this.getCollection(collectionName).updateOne(filter, update, options || {});
     }
     // -------------------------------------------------------------------------
     // Public Implemented Methods (from QueryRunner)