typeorm 0.3.0-rc.8 → 0.3.1-dev.941b584

package/browser/repository/Repository.d.ts

@@ -1,42 +1,45 @@
-import { DeepPartial } from "../common/DeepPartial";
+import { FindManyOptions } from "../find-options/FindManyOptions";
 import { ObjectLiteral } from "../common/ObjectLiteral";
-import { ObjectID } from "../driver/mongodb/typings";
+import { FindOneOptions } from "../find-options/FindOneOptions";
+import { DeepPartial } from "../common/DeepPartial";
+import { SaveOptions } from "./SaveOptions";
+import { RemoveOptions } from "./RemoveOptions";
 import { EntityManager } from "../entity-manager/EntityManager";
-import { FindOptions, FindOptionsWhere } from "../find-options/FindOptions";
-import { EntityMetadata } from "../metadata/EntityMetadata";
+import { QueryRunner } from "../query-runner/QueryRunner";
+import { SelectQueryBuilder } from "../query-builder/SelectQueryBuilder";
 import { DeleteResult } from "../query-builder/result/DeleteResult";
 import { UpdateResult } from "../query-builder/result/UpdateResult";
 import { InsertResult } from "../query-builder/result/InsertResult";
 import { QueryDeepPartialEntity } from "../query-builder/QueryPartialEntity";
-import { SelectQueryBuilder } from "../query-builder/SelectQueryBuilder";
-import { QueryRunner } from "../query-runner/QueryRunner";
-import { RemoveOptions } from "./RemoveOptions";
-import { SaveOptions } from "./SaveOptions";
-import * as Observable from "zen-observable";
+import { ObjectID } from "../driver/mongodb/typings";
+import { FindOptionsWhere } from "../find-options/FindOptionsWhere";
+import { UpsertOptions } from "./UpsertOptions";
+import { EntityTarget } from "../common/EntityTarget";
 /**
  * Repository is supposed to work with your entity objects. Find entities, insert, update, delete, etc.
  */
-export declare type Repository<Entity extends ObjectLiteral> = {
+export declare class Repository<Entity extends ObjectLiteral> {
     /**
-     * Entity Manager used by this repository.
+     * Entity target that is managed by this repository.
+     * If this repository manages entity from schema,
+     * then it returns a name of that schema instead.
      */
-    readonly manager: EntityManager;
+    readonly target: EntityTarget<Entity>;
     /**
-     * Entity metadata of the entity current repository manages.
+     * Entity Manager used by this repository.
      */
-    readonly metadata: EntityMetadata;
+    readonly manager: EntityManager;
     /**
      * Query runner provider used for this repository.
      */
     readonly queryRunner?: QueryRunner;
     /**
-     * Returns object that is managed by this repository.
-     * If this repository manages entity from schema,
-     * then it returns a name of that schema instead.
+     * Entity metadata of the entity current repository manages.
      */
-    readonly target: Function | string;
+    get metadata(): import("..").EntityMetadata;
+    constructor(target: EntityTarget<Entity>, manager: EntityManager, queryRunner?: QueryRunner);
     /**
-     * Creates a new query builder that can be used to build a sql query.
+     * Creates a new query builder that can be used to build a SQL query.
      */
     createQueryBuilder(alias?: string, queryRunner?: QueryRunner): SelectQueryBuilder<Entity>;
     /**
@@ -53,13 +56,13 @@ export declare type Repository<Entity extends ObjectLiteral> = {
      */
     create(): Entity;
     /**
-     * Creates a new entities and copies all entity properties from given objects into their new entities.
-     * Note that it copies only properties that present in entity schema.
+     * Creates new entities and copies all entity properties from given objects into their new entities.
+     * Note that it copies only properties that are present in entity schema.
      */
     create(entityLikeArray: DeepPartial<Entity>[]): Entity[];
     /**
      * Creates a new entity instance and copies all entity properties from this object into a new entity.
-     * Note that it copies only properties that present in entity schema.
+     * Note that it copies only properties that are present in entity schema.
      */
     create(entityLike: DeepPartial<Entity>): Entity;
     /**
@@ -67,7 +70,7 @@ export declare type Repository<Entity extends ObjectLiteral> = {
      */
     merge(mergeIntoEntity: Entity, ...entityLikes: DeepPartial<Entity>[]): Entity;
     /**
-     * Creates a new entity from the given plan javascript object. If entity already exist in the database, then
+     * Creates a new entity from the given plain javascript object. If entity already exist in the database, then
      * 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.
@@ -108,13 +111,53 @@ export declare type Repository<Entity extends ObjectLiteral> = {
      * Removes a given entity from the database.
      */
     remove(entity: Entity, options?: RemoveOptions): Promise<Entity>;
+    /**
+     * Records the delete date of all given entities.
+     */
+    softRemove<T extends DeepPartial<Entity>>(entities: T[], options: SaveOptions & {
+        reload: false;
+    }): Promise<T[]>;
+    /**
+     * Records the delete date of all given entities.
+     */
+    softRemove<T extends DeepPartial<Entity>>(entities: T[], options?: SaveOptions): Promise<(T & Entity)[]>;
+    /**
+     * Records the delete date of a given entity.
+     */
+    softRemove<T extends DeepPartial<Entity>>(entity: T, options: SaveOptions & {
+        reload: false;
+    }): Promise<T>;
+    /**
+     * Records the delete date of a given entity.
+     */
+    softRemove<T extends DeepPartial<Entity>>(entity: T, options?: SaveOptions): Promise<T & Entity>;
+    /**
+     * Recovers all given entities in the database.
+     */
+    recover<T extends DeepPartial<Entity>>(entities: T[], options: SaveOptions & {
+        reload: false;
+    }): Promise<T[]>;
+    /**
+     * Recovers all given entities in the database.
+     */
+    recover<T extends DeepPartial<Entity>>(entities: T[], options?: SaveOptions): Promise<(T & Entity)[]>;
+    /**
+     * Recovers a given entity in the database.
+     */
+    recover<T extends DeepPartial<Entity>>(entity: T, options: SaveOptions & {
+        reload: false;
+    }): Promise<T>;
+    /**
+     * Recovers a given entity in the database.
+     */
+    recover<T extends DeepPartial<Entity>>(entity: T, options?: SaveOptions): Promise<T & Entity>;
     /**
      * 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.
      */
-    insert(entity: QueryDeepPartialEntity<Entity> | (QueryDeepPartialEntity<Entity>[])): Promise<InsertResult>;
+    insert(entity: QueryDeepPartialEntity<Entity> | QueryDeepPartialEntity<Entity>[]): Promise<InsertResult>;
     /**
      * Updates entity partially. Entity can be found by a given conditions.
      * Unlike save method executes a primitive operation without cascades, relations and other operations included.
@@ -122,6 +165,12 @@ export declare type Repository<Entity extends ObjectLiteral> = {
      * Does not check if entity exist in the database.
      */
     update(criteria: string | string[] | number | number[] | Date | Date[] | ObjectID | ObjectID[] | FindOptionsWhere<Entity>, partialEntity: QueryDeepPartialEntity<Entity>): Promise<UpdateResult>;
+    /**
+     * Inserts a given entity into the database, unless a unique constraint conflicts then updates the entity
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient INSERT ... ON CONFLICT DO UPDATE/ON DUPLICATE KEY UPDATE query.
+     */
+    upsert(entityOrEntities: QueryDeepPartialEntity<Entity> | QueryDeepPartialEntity<Entity>[], conflictPathsOrOptions: string[] | UpsertOptions<Entity>): Promise<InsertResult>;
     /**
      * Deletes entities by a given criteria.
      * Unlike save method executes a primitive operation without cascades, relations and other operations included.
@@ -129,108 +178,92 @@ export declare type Repository<Entity extends ObjectLiteral> = {
      * Does not check if entity exist in the database.
      */
     delete(criteria: string | string[] | number | number[] | Date | Date[] | ObjectID | ObjectID[] | FindOptionsWhere<Entity>): Promise<DeleteResult>;
+    /**
+     * Records the delete date of entities by a given criteria.
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient SOFT-DELETE query.
+     * Does not check if entity exist in the database.
+     */
+    softDelete(criteria: string | string[] | number | number[] | Date | Date[] | ObjectID | ObjectID[] | FindOptionsWhere<Entity>): Promise<UpdateResult>;
+    /**
+     * Restores entities by a given criteria.
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient SOFT-DELETE query.
+     * Does not check if entity exist in the database.
+     */
+    restore(criteria: string | string[] | number | number[] | Date | Date[] | ObjectID | ObjectID[] | FindOptionsWhere<Entity>): Promise<UpdateResult>;
     /**
      * Counts entities that match given options.
+     * Useful for pagination.
      */
-    count(options?: FindOptions<Entity>): Promise<number>;
+    count(options?: FindManyOptions<Entity>): Promise<number>;
     /**
      * Counts entities that match given conditions.
+     * Useful for pagination.
      */
-    count(conditions?: FindOptionsWhere<Entity>): Promise<number>;
+    countBy(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<number>;
     /**
-     * Finds entities that match given options.
+     * Finds entities that match given find options.
      */
-    find(options?: FindOptions<Entity>): Promise<Entity[]>;
+    find(options?: FindManyOptions<Entity>): Promise<Entity[]>;
     /**
-     * Finds entities that match given conditions.
+     * Finds entities that match given find options.
      */
-    find(conditions?: FindOptionsWhere<Entity>): Promise<Entity[]>;
+    findBy(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).
      */
-    findAndCount(options?: FindOptions<Entity>): Promise<[Entity[], number]>;
+    findAndCount(options?: FindManyOptions<Entity>): Promise<[Entity[], number]>;
     /**
-     * Finds entities that match given conditions.
+     * Finds entities that match given WHERE conditions.
      * Also counts all entities that match given conditions,
      * but ignores pagination settings (from and take options).
      */
-    findAndCount(conditions?: FindOptionsWhere<Entity>): Promise<[Entity[], number]>;
-    /**
-     * Finds entities by ids.
-     * Optionally find options can be applied.
-     */
-    findByIds(ids: any[], options?: FindOptions<Entity>): Promise<Entity[]>;
-    /**
-     * Finds entities by ids.
-     * Optionally conditions can be applied.
-     */
-    findByIds(ids: any[], conditions?: FindOptionsWhere<Entity>): Promise<Entity[]>;
-    /**
-     * Finds first entity that matches given options.
-     */
-    findOne(id?: string | number | Date | ObjectID, options?: FindOptions<Entity>): Promise<Entity | undefined>;
-    /**
-     * Finds first entity that matches given options.
-     */
-    findOne(options?: FindOptions<Entity>): Promise<Entity | undefined>;
-    /**
-     * Finds first entity that matches given conditions.
-     */
-    findOne(conditions?: FindOptionsWhere<Entity>, options?: FindOptions<Entity>): Promise<Entity | undefined>;
-    /**
-     * Finds first entity that matches given options.
-     */
-    findOneOrFail(id?: string | number | Date | ObjectID, options?: FindOptions<Entity>): Promise<Entity>;
-    /**
-     * Finds first entity that matches given options.
-     */
-    findOneOrFail(options?: FindOptions<Entity>): Promise<Entity>;
-    /**
-     * Finds first entity that matches given conditions.
-     */
-    findOneOrFail(conditions?: FindOptionsWhere<Entity>, options?: FindOptions<Entity>): Promise<Entity>;
+    findAndCountBy(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<[Entity[], number]>;
     /**
-     * Finds entities that match given options and returns observable.
-     * Whenever new data appears that matches given query observable emits new value.
-     */
-    observe<Entity>(options?: FindOptions<Entity>): Observable<Entity[]>;
-    /**
-     * Finds entities that match given conditions and returns observable.
-     * Whenever new data appears that matches given query observable emits new value.
-     */
-    observe<Entity>(conditions?: FindOptionsWhere<Entity>): Observable<Entity[]>;
-    /**
-     * Finds entities and count that match given options and returns observable.
-     * Whenever new data appears that matches given query observable emits new value.
+     * 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])
+     * })
      */
-    observeManyAndCount<Entity>(options?: FindOptions<Entity>): Observable<[Entity[], number]>;
+    findByIds(ids: any[]): Promise<Entity[]>;
     /**
-     * Finds entities and count that match given conditions and returns observable.
-     * Whenever new data appears that matches given query observable emits new value.
+     * Finds first entity by a given find options.
+     * If entity was not found in the database - returns null.
      */
-    observeManyAndCount<Entity>(conditions?: FindOptionsWhere<Entity>): Observable<[Entity[], number]>;
+    findOne(options: FindOneOptions<Entity>): Promise<Entity | null>;
     /**
-     * Finds entity that match given options and returns observable.
-     * Whenever new data appears that matches given query observable emits new value.
+     * Finds first entity that matches given where condition.
+     * If entity was not found in the database - returns null.
      */
-    observeOne<Entity>(options?: FindOptions<Entity>): Observable<Entity>;
+    findOneBy(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<Entity | null>;
     /**
-     * Finds entity that match given conditions and returns observable.
-     * Whenever new data appears that matches given query observable emits new value.
+     * 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
+     * })
      */
-    observeOne<Entity>(conditions?: FindOptionsWhere<Entity>): Observable<Entity>;
+    findOneById(id: number | string | Date | ObjectID): Promise<Entity | null>;
     /**
-     * Gets the entities count match given options and returns observable.
-     * Whenever new data appears that matches given query observable emits new value.
+     * Finds first entity by a given find options.
+     * If entity was not found in the database - rejects with error.
      */
-    observeCount<Entity>(options?: FindOptions<Entity>): Observable<number>;
+    findOneOrFail(options: FindOneOptions<Entity>): Promise<Entity>;
     /**
-     * Gets the entities count match given options and returns observable.
-     * Whenever new data appears that matches given query observable emits new value.
+     * Finds first entity that matches given where condition.
+     * If entity was not found in the database - rejects with error.
      */
-    observeCount<Entity>(conditions?: FindOptionsWhere<Entity>): Observable<number>;
+    findOneByOrFail(where: FindOptionsWhere<Entity> | FindOptionsWhere<Entity>[]): Promise<Entity>;
     /**
      * Executes a raw SQL query and returns a raw database results.
      * Raw query execution is supported only by relational databases (MongoDB is not supported).
@@ -251,4 +284,8 @@ export declare type Repository<Entity extends ObjectLiteral> = {
      * Decrements some column by provided value of the entities matched given conditions.
      */
     decrement(conditions: FindOptionsWhere<Entity>, propertyPath: string, value: number | string): Promise<UpdateResult>;
-};
+    /**
+     * Extends repository with provided functions.
+     */
+    extend<CustomRepository>(custom: CustomRepository & ThisType<Repository<Entity> & CustomRepository>): Repository<Entity> & CustomRepository;
+}

package/browser/repository/Repository.js

@@ -1,3 +1,290 @@
-
+/**
+ * Repository is supposed to work with your entity objects. Find entities, insert, update, delete, etc.
+ */
+export class Repository {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(target, manager, queryRunner) {
+        this.target = target;
+        this.manager = manager;
+        this.queryRunner = queryRunner;
+    }
+    // -------------------------------------------------------------------------
+    // Accessors
+    // -------------------------------------------------------------------------
+    /**
+     * Entity metadata of the entity current repository manages.
+     */
+    get metadata() {
+        return this.manager.connection.getMetadata(this.target);
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Creates a new query builder that can be used to build a SQL query.
+     */
+    createQueryBuilder(alias, queryRunner) {
+        return this.manager.createQueryBuilder(this.metadata.target, alias || this.metadata.targetName, queryRunner || this.queryRunner);
+    }
+    /**
+     * Checks if entity has an id.
+     * If entity composite compose ids, it will check them all.
+     */
+    hasId(entity) {
+        return this.manager.hasId(this.metadata.target, entity);
+    }
+    /**
+     * Gets entity mixed id.
+     */
+    getId(entity) {
+        return this.manager.getId(this.metadata.target, entity);
+    }
+    /**
+     * Creates a new entity instance or instances.
+     * Can copy properties from the given object into new entities.
+     */
+    create(plainEntityLikeOrPlainEntityLikes) {
+        return this.manager.create(this.metadata.target, plainEntityLikeOrPlainEntityLikes);
+    }
+    /**
+     * Merges multiple entities (or entity-like objects) into a given entity.
+     */
+    merge(mergeIntoEntity, ...entityLikes) {
+        return this.manager.merge(this.metadata.target, mergeIntoEntity, ...entityLikes);
+    }
+    /**
+     * Creates a new entity from the given plain javascript object. If entity already exist in the database, then
+     * 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.
+     *
+     * Note that given entity-like object must have an entity id / primary key to find entity by.
+     * Returns undefined if entity with given id was not found.
+     */
+    preload(entityLike) {
+        return this.manager.preload(this.metadata.target, entityLike);
+    }
+    /**
+     * Saves one or many given entities.
+     */
+    save(entityOrEntities, options) {
+        return this.manager.save(this.metadata.target, entityOrEntities, options);
+    }
+    /**
+     * Removes one or many given entities.
+     */
+    remove(entityOrEntities, options) {
+        return this.manager.remove(this.metadata.target, entityOrEntities, options);
+    }
+    /**
+     * Records the delete date of one or many given entities.
+     */
+    softRemove(entityOrEntities, options) {
+        return this.manager.softRemove(this.metadata.target, entityOrEntities, options);
+    }
+    /**
+     * Recovers one or many given entities.
+     */
+    recover(entityOrEntities, options) {
+        return this.manager.recover(this.metadata.target, entityOrEntities, options);
+    }
+    /**
+     * 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.
+     */
+    insert(entity) {
+        return this.manager.insert(this.metadata.target, entity);
+    }
+    /**
+     * Updates entity partially. Entity can be found by a given conditions.
+     * 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.
+     */
+    update(criteria, partialEntity) {
+        return this.manager.update(this.metadata.target, criteria, partialEntity);
+    }
+    /**
+     * Inserts a given entity into the database, unless a unique constraint conflicts then updates the entity
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient INSERT ... ON CONFLICT DO UPDATE/ON DUPLICATE KEY UPDATE query.
+     */
+    upsert(entityOrEntities, conflictPathsOrOptions) {
+        return this.manager.upsert(this.metadata.target, entityOrEntities, conflictPathsOrOptions);
+    }
+    /**
+     * Deletes entities by a given criteria.
+     * 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.
+     */
+    delete(criteria) {
+        return this.manager.delete(this.metadata.target, criteria);
+    }
+    /**
+     * Records the delete date of entities by a given criteria.
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient SOFT-DELETE query.
+     * Does not check if entity exist in the database.
+     */
+    softDelete(criteria) {
+        return this.manager.softDelete(this.metadata.target, criteria);
+    }
+    /**
+     * Restores entities by a given criteria.
+     * Unlike save method executes a primitive operation without cascades, relations and other operations included.
+     * Executes fast and efficient SOFT-DELETE query.
+     * Does not check if entity exist in the database.
+     */
+    restore(criteria) {
+        return this.manager.restore(this.metadata.target, criteria);
+    }
+    /**
+     * Counts entities that match given options.
+     * Useful for pagination.
+     */
+    count(options) {
+        return this.manager.count(this.metadata.target, options);
+    }
+    /**
+     * Counts entities that match given conditions.
+     * Useful for pagination.
+     */
+    countBy(where) {
+        return this.manager.countBy(this.metadata.target, where);
+    }
+    /**
+     * Finds entities that match given find options.
+     */
+    async find(options) {
+        return this.manager.find(this.metadata.target, options);
+    }
+    /**
+     * Finds entities that match given find options.
+     */
+    async findBy(where) {
+        return this.manager.findBy(this.metadata.target, where);
+    }
+    /**
+     * Finds entities that match given find options.
+     * Also counts all entities that match given conditions,
+     * but ignores pagination settings (from and take options).
+     */
+    findAndCount(options) {
+        return this.manager.findAndCount(this.metadata.target, options);
+    }
+    /**
+     * Finds entities that match given WHERE conditions.
+     * Also counts all entities that match given conditions,
+     * but ignores pagination settings (from and take options).
+     */
+    findAndCountBy(where) {
+        return this.manager.findAndCountBy(this.metadata.target, where);
+    }
+    /**
+     * 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])
+     * })
+     */
+    async findByIds(ids) {
+        return this.manager.findByIds(this.metadata.target, ids);
+    }
+    /**
+     * Finds first entity by a given find options.
+     * If entity was not found in the database - returns null.
+     */
+    async findOne(options) {
+        return this.manager.findOne(this.metadata.target, options);
+    }
+    /**
+     * Finds first entity that matches given where condition.
+     * If entity was not found in the database - returns null.
+     */
+    async findOneBy(where) {
+        return this.manager.findOneBy(this.metadata.target, where);
+    }
+    /**
+     * 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
+     * })
+     */
+    async findOneById(id) {
+        return this.manager.findOneById(this.metadata.target, id);
+    }
+    /**
+     * Finds first entity by a given find options.
+     * If entity was not found in the database - rejects with error.
+     */
+    async findOneOrFail(options) {
+        return this.manager.findOneOrFail(this.metadata.target, options);
+    }
+    /**
+     * Finds first entity that matches given where condition.
+     * If entity was not found in the database - rejects with error.
+     */
+    async findOneByOrFail(where) {
+        return this.manager.findOneByOrFail(this.metadata.target, where);
+    }
+    /**
+     * Executes a raw SQL query and returns a raw database results.
+     * Raw query execution is supported only by relational databases (MongoDB is not supported).
+     */
+    query(query, parameters) {
+        return this.manager.query(query, parameters);
+    }
+    /**
+     * Clears all the data from the given table/collection (truncates/drops it).
+     *
+     * Note: this method uses TRUNCATE and may not work as you expect in transactions on some platforms.
+     * @see https://stackoverflow.com/a/5972738/925151
+     */
+    clear() {
+        return this.manager.clear(this.metadata.target);
+    }
+    /**
+     * Increments some column by provided value of the entities matched given conditions.
+     */
+    increment(conditions, propertyPath, value) {
+        return this.manager.increment(this.metadata.target, conditions, propertyPath, value);
+    }
+    /**
+     * Decrements some column by provided value of the entities matched given conditions.
+     */
+    decrement(conditions, propertyPath, value) {
+        return this.manager.decrement(this.metadata.target, conditions, propertyPath, value);
+    }
+    /**
+     * Extends repository with provided functions.
+     */
+    extend(custom) {
+        // return {
+        //     ...this,
+        //     ...custom
+        // };
+        const thisRepo = this.constructor;
+        const { target, manager, queryRunner } = this;
+        const cls = new (class extends thisRepo {
+            constructor() {
+                super(target, manager, queryRunner);
+            }
+        })();
+        Object.assign(cls, custom);
+        return cls;
+    }
+}
 
 //# sourceMappingURL=Repository.js.map