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

package/entity-manager/EntityManager.d.ts

@@ -1,27 +1,27 @@
-import { DataSource } from "../data-source/DataSource";
-import { FindManyOptions } from "../find-options/FindManyOptions";
-import { EntityTarget } from "../common/EntityTarget";
-import { ObjectType } from "../common/ObjectType";
-import { FindOneOptions } from "../find-options/FindOneOptions";
-import { DeepPartial } from "../common/DeepPartial";
-import { RemoveOptions } from "../repository/RemoveOptions";
-import { SaveOptions } from "../repository/SaveOptions";
+import type { DataSource } from "../data-source/DataSource";
+import type { FindManyOptions } from "../find-options/FindManyOptions";
+import type { EntityTarget } from "../common/EntityTarget";
+import type { FindOneOptions } from "../find-options/FindOneOptions";
+import type { DeepPartial } from "../common/DeepPartial";
+import type { RemoveOptions } from "../repository/RemoveOptions";
+import type { SaveOptions } from "../repository/SaveOptions";
 import { MongoRepository } from "../repository/MongoRepository";
 import { TreeRepository } from "../repository/TreeRepository";
 import { Repository } from "../repository/Repository";
 import { PlainObjectToNewEntityTransformer } from "../query-builder/transformer/PlainObjectToNewEntityTransformer";
-import { QueryRunner } from "../query-runner/QueryRunner";
-import { SelectQueryBuilder } from "../query-builder/SelectQueryBuilder";
-import { QueryDeepPartialEntity } from "../query-builder/QueryPartialEntity";
-import { ObjectId } from "../driver/mongodb/typings";
-import { InsertResult } from "../query-builder/result/InsertResult";
-import { UpdateResult } from "../query-builder/result/UpdateResult";
-import { DeleteResult } from "../query-builder/result/DeleteResult";
-import { FindOptionsWhere } from "../find-options/FindOptionsWhere";
-import { IsolationLevel } from "../driver/types/IsolationLevel";
-import { UpsertOptions } from "../repository/UpsertOptions";
-import { ObjectLiteral } from "../common/ObjectLiteral";
-import { PickKeysByType } from "../common/PickKeysByType";
+import type { QueryRunner } from "../query-runner/QueryRunner";
+import type { SelectQueryBuilder } from "../query-builder/SelectQueryBuilder";
+import type { QueryDeepPartialEntity } from "../query-builder/QueryPartialEntity";
+import type { ObjectId } from "../driver/mongodb/typings";
+import type { InsertResult } from "../query-builder/result/InsertResult";
+import type { UpdateResult } from "../query-builder/result/UpdateResult";
+import type { DeleteResult } from "../query-builder/result/DeleteResult";
+import type { FindOptionsWhere } from "../find-options/FindOptionsWhere";
+import type { IsolationLevel } from "../driver/types/IsolationLevel";
+import type { UpsertOptions } from "../repository/UpsertOptions";
+import type { UpdateOptions } from "../repository/UpdateOptions";
+import type { ObjectLiteral } from "../common/ObjectLiteral";
+import type { PickKeysByType } from "../common/PickKeysByType";
 /**
  * Entity manager supposed to work with any entity, automatically find its repository and call its methods,
  * whatever entity type are you passing.
@@ -29,9 +29,14 @@ import { PickKeysByType } from "../common/PickKeysByType";
 export declare class EntityManager {
     readonly "@instanceof": symbol;
     /**
-     * Connection used by this entity manager.
+     * DataSource used by this entity manager.
      */
-    readonly connection: DataSource;
+    readonly dataSource: DataSource;
+    /**
+     * DataSource used by this entity manager.
+     * @deprecated since 1.0.0. Use {@link dataSource} instance instead.
+     */
+    get connection(): DataSource;
     /**
      * Custom query runner to be used for operations in this entity manager.
      * Used only in non-global entity manager.
@@ -50,7 +55,7 @@ export declare class EntityManager {
      * Plain to object transformer used in create and merge operations.
      */
     protected plainObjectToEntityTransformer: PlainObjectToNewEntityTransformer;
-    constructor(connection: DataSource, queryRunner?: QueryRunner);
+    constructor(dataSource: DataSource, queryRunner?: QueryRunner);
     /**
      * Wraps given function execution (and all operations made there) in a transaction.
      * All database operations must be executed using provided entity manager.
@@ -63,7 +68,8 @@ export declare class EntityManager {
     transaction<T>(isolationLevel: IsolationLevel, runInTransaction: (entityManager: EntityManager) => Promise<T>): Promise<T>;
     /**
      * Executes raw SQL query and returns raw database results.
-     *
+     * @param query
+     * @param parameters
      * @see [Official docs](https://typeorm.io/docs/Working%20with%20Entity%20Manager/entity-manager-api/) for examples.
      */
     query<T = any>(query: string, parameters?: any[]): Promise<T>;
@@ -73,6 +79,8 @@ export declare class EntityManager {
      * Raw query execution is supported only by relational databases (MongoDB is not supported).
      * Note: Don't call this as a regular function, it is meant to be used with backticks to tag a template literal.
      * Example: entityManager.sql`SELECT * FROM table_name WHERE id = ${id}`
+     * @param strings
+     * @param values
      */
     sql<T = any>(strings: TemplateStringsArray, ...values: unknown[]): Promise<T>;
     /**
@@ -111,6 +119,9 @@ export declare class EntityManager {
     create<Entity, EntityLike extends DeepPartial<Entity>>(entityClass: EntityTarget<Entity>, plainObjects?: EntityLike[]): Entity[];
     /**
      * Merges two entities into one new entity.
+     * @param entityClass
+     * @param mergeIntoEntity
+     * @param entityLikes
      */
     merge<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, mergeIntoEntity: Entity, ...entityLikes: DeepPartial<Entity>[]): Entity;
     /**
@@ -118,6 +129,8 @@ export declare class EntityManager {
      * it loads it (and everything related to it), replaces all values with the new ones from the given object
      * and returns this new entity. This new entity is actually a loaded from the db entity with all properties
      * replaced from the new object.
+     * @param entityClass
+     * @param entityLike
      */
     preload<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, entityLike: DeepPartial<Entity>): Promise<Entity | undefined>;
     /**
@@ -208,6 +221,8 @@ export declare class EntityManager {
      * 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
      */
     insert<Entity extends ObjectLiteral>(target: EntityTarget<Entity>, entity: QueryDeepPartialEntity<Entity> | QueryDeepPartialEntity<Entity>[]): Promise<InsertResult>;
     upsert<Entity extends ObjectLiteral>(target: EntityTarget<Entity>, entityOrEntities: QueryDeepPartialEntity<Entity> | QueryDeepPartialEntity<Entity>[], conflictPathsOrOptions: string[] | UpsertOptions<Entity>): Promise<InsertResult>;
@@ -217,22 +232,31 @@ export declare class EntityManager {
      * Executes fast and efficient UPDATE query.
      * Does not check if entity exist in the database.
      * Condition(s) cannot be empty.
+     * @param target
+     * @param criteria
+     * @param partialEntity
+     * @param options
      */
-    update<Entity extends ObjectLiteral>(target: EntityTarget<Entity>, criteria: string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | any, partialEntity: QueryDeepPartialEntity<Entity>): Promise<UpdateResult>;
+    update<Entity extends ObjectLiteral>(target: EntityTarget<Entity>, criteria: string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | any, partialEntity: QueryDeepPartialEntity<Entity>, options?: UpdateOptions): Promise<UpdateResult>;
     /**
      * Updates all entities of target type, setting fields from supplied partial entity.
      * This is a primitive operation without cascades, relations or other operations included.
      * Executes fast and efficient UPDATE query without WHERE clause.
      *
      * WARNING! This method updates ALL rows in the target table.
+     * @param target
+     * @param partialEntity
+     * @param options
      */
-    updateAll<Entity extends ObjectLiteral>(target: EntityTarget<Entity>, partialEntity: QueryDeepPartialEntity<Entity>): Promise<UpdateResult>;
+    updateAll<Entity extends ObjectLiteral>(target: EntityTarget<Entity>, partialEntity: QueryDeepPartialEntity<Entity>, options?: UpdateOptions): Promise<UpdateResult>;
     /**
      * Deletes entities by a given condition(s).
      * 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.
      * Condition(s) cannot be empty.
+     * @param targetOrEntity
+     * @param criteria
      */
     delete<Entity extends ObjectLiteral>(targetOrEntity: EntityTarget<Entity>, criteria: string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | any): Promise<DeleteResult>;
     /**
@@ -241,6 +265,7 @@ export declare class EntityManager {
      * Executes fast and efficient DELETE query without WHERE clause.
      *
      * WARNING! This method deletes ALL rows in the target table.
+     * @param targetOrEntity
      */
     deleteAll<Entity extends ObjectLiteral>(targetOrEntity: EntityTarget<Entity>): Promise<DeleteResult>;
     /**
@@ -249,6 +274,8 @@ export declare class EntityManager {
      * Executes fast and efficient UPDATE query.
      * Does not check if entity exist in the database.
      * Condition(s) cannot be empty.
+     * @param targetOrEntity
+     * @param criteria
      */
     softDelete<Entity extends ObjectLiteral>(targetOrEntity: EntityTarget<Entity>, criteria: string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | any): Promise<UpdateResult>;
     /**
@@ -257,125 +284,155 @@ export declare class EntityManager {
      * Executes fast and efficient UPDATE query.
      * Does not check if entity exist in the database.
      * Condition(s) cannot be empty.
+     * @param targetOrEntity
+     * @param criteria
      */
     restore<Entity extends ObjectLiteral>(targetOrEntity: EntityTarget<Entity>, criteria: string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | any): Promise<UpdateResult>;
     /**
      * Checks whether any entity exists with the given options.
+     * @param entityClass
+     * @param options
      */
     exists<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, options?: FindManyOptions<Entity>): Promise<boolean>;
     /**
      * Checks whether any entity exists with the given conditions.
+     * @param entityClass
+     * @param where
      */
     existsBy<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<boolean>;
     /**
      * Counts entities that match given options.
      * Useful for pagination.
+     * @param entityClass
+     * @param options
      */
     count<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, options?: FindManyOptions<Entity>): Promise<number>;
     /**
      * Counts entities that match given conditions.
      * Useful for pagination.
+     * @param entityClass
+     * @param where
      */
     countBy<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<number>;
     /**
      * Return the SUM of a column
+     * @param entityClass
+     * @param columnName
+     * @param where
      */
     sum<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, columnName: PickKeysByType<Entity, number>, where?: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<number | null>;
     /**
      * Return the AVG of a column
+     * @param entityClass
+     * @param columnName
+     * @param where
      */
     average<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, columnName: PickKeysByType<Entity, number>, where?: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<number | null>;
     /**
      * Return the MIN of a column
+     * @param entityClass
+     * @param columnName
+     * @param where
      */
     minimum<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, columnName: PickKeysByType<Entity, number>, where?: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<number | null>;
     /**
      * Return the MAX of a column
+     * @param entityClass
+     * @param columnName
+     * @param where
      */
     maximum<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, columnName: PickKeysByType<Entity, number>, where?: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<number | null>;
     private callAggregateFun;
     /**
      * Finds entities that match given find options.
+     * @param entityClass
+     * @param options
      */
     find<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, options?: FindManyOptions<Entity>): Promise<Entity[]>;
     /**
      * Finds entities that match given find options.
+     * @param entityClass
+     * @param where
      */
     findBy<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<Entity[]>;
     /**
      * Finds entities that match given find options.
      * Also counts all entities that match given conditions,
      * but ignores pagination settings (from and take options).
+     * @param entityClass
+     * @param options
      */
     findAndCount<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, options?: FindManyOptions<Entity>): Promise<[Entity[], number]>;
     /**
      * Finds entities that match given WHERE conditions.
      * Also counts all entities that match given conditions,
      * but ignores pagination settings (from and take options).
+     * @param entityClass
+     * @param where
      */
     findAndCountBy<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<[Entity[], number]>;
-    /**
-     * Finds entities with ids.
-     * Optionally find options or conditions can be applied.
-     *
-     * @deprecated use `findBy` method instead in conjunction with `In` operator, for example:
-     *
-     * .findBy({
-     *     id: In([1, 2, 3])
-     * })
-     */
-    findByIds<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, ids: any[]): Promise<Entity[]>;
     /**
      * Finds first entity by a given find options.
      * If entity was not found in the database - returns null.
+     * @param entityClass
+     * @param options
      */
     findOne<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, options: FindOneOptions<Entity>): Promise<Entity | null>;
     /**
      * Finds first entity that matches given where condition.
      * If entity was not found in the database - returns null.
+     * @param entityClass
+     * @param where
      */
     findOneBy<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<Entity | null>;
-    /**
-     * Finds first entity that matches given id.
-     * If entity was not found in the database - returns null.
-     *
-     * @deprecated use `findOneBy` method instead in conjunction with `In` operator, for example:
-     *
-     * .findOneBy({
-     *     id: 1 // where "id" is your primary column name
-     * })
-     */
-    findOneById<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, id: number | string | Date | ObjectId): Promise<Entity | null>;
     /**
      * Finds first entity by a given find options.
      * If entity was not found in the database - rejects with error.
+     * @param entityClass
+     * @param options
      */
     findOneOrFail<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, options: FindOneOptions<Entity>): Promise<Entity>;
     /**
      * Finds first entity that matches given where condition.
      * If entity was not found in the database - rejects with error.
+     * @param entityClass
+     * @param where
      */
     findOneByOrFail<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<Entity>;
     /**
      * Clears all the data from the given table (truncates/drops it).
      *
      * Note: this method uses TRUNCATE and may not work as you expect in transactions on some platforms.
+     * @param entityClass
+     * @param options
+     * @param options.cascade
      * @see https://stackoverflow.com/a/5972738/925151
      */
-    clear<Entity>(entityClass: EntityTarget<Entity>): Promise<void>;
+    clear<Entity>(entityClass: EntityTarget<Entity>, options?: {
+        cascade?: boolean;
+    }): Promise<void>;
     /**
      * Increments some column by provided value of the entities matched given conditions.
+     * @param entityClass
+     * @param conditions
+     * @param propertyPath
+     * @param value
      */
-    increment<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, conditions: any, propertyPath: string, value: number | string): Promise<UpdateResult>;
+    increment<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, conditions: FindOptionsWhere<Entity>, propertyPath: string, value: number | string): Promise<UpdateResult>;
     /**
      * Decrements some column by provided value of the entities matched given conditions.
+     * @param entityClass
+     * @param conditions
+     * @param propertyPath
+     * @param value
      */
-    decrement<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, conditions: any, propertyPath: string, value: number | string): Promise<UpdateResult>;
+    decrement<Entity extends ObjectLiteral>(entityClass: EntityTarget<Entity>, conditions: FindOptionsWhere<Entity>, propertyPath: string, value: number | string): Promise<UpdateResult>;
     /**
      * Gets repository for the given entity class or name.
      * If single database connection mode is used, then repository is obtained from the
      * repository aggregator, where each repository is individually created for this entity manager.
      * When single database connection is not used, repository is being obtained from the connection.
+     * @param target
      */
     getRepository<Entity extends ObjectLiteral>(target: EntityTarget<Entity>): Repository<Entity>;
     /**
@@ -383,24 +440,21 @@ export declare class EntityManager {
      * If single database connection mode is used, then repository is obtained from the
      * repository aggregator, where each repository is individually created for this entity manager.
      * When single database connection is not used, repository is being obtained from the connection.
+     * @param target
      */
     getTreeRepository<Entity extends ObjectLiteral>(target: EntityTarget<Entity>): TreeRepository<Entity>;
     /**
      * Gets mongodb repository for the given entity class.
+     * @param target
      */
     getMongoRepository<Entity extends ObjectLiteral>(target: EntityTarget<Entity>): MongoRepository<Entity>;
     /**
      * Creates a new repository instance out of a given Repository and
      * sets current EntityManager instance to it. Used to work with custom repositories
      * in transactions.
+     * @param repository
      */
     withRepository<Entity extends ObjectLiteral, R extends Repository<any>>(repository: R & Repository<Entity>): R;
-    /**
-     * Gets custom entity repository marked with @EntityRepository decorator.
-     *
-     * @deprecated use Repository.extend to create custom repositories
-     */
-    getCustomRepository<T>(customRepository: ObjectType<T>): T;
     /**
      * Releases all resources used by entity manager.
      * This is used when entity manager is created with a single query runner,