slim-ef/lib/uow/db-context.d.ts

An implementation of basic entity framework functionnalities in typescript

import { Connection } from 'typeorm';
import { IDbSet } from '../repository/interfaces';
import { IInternalDbSet } from '../repository/_internal.interface';
import { QuerySpecificationEvaluatorConstructor, QueryType } from '../specification/specification.interface';
import { ISavedTransaction, IDbContext, IDbContextOptionsBuilder } from './interfaces';
import { DbContextModelBuilder } from './model-builder';
import { IInternalDbContext, ProxyMetaDataInstance } from './_internal.interface';
interface IEntity {
    id?: any;
}
export declare abstract class DbContext implements IDbContext, IInternalDbContext {
    protected _connection: Connection;
    protected evaluator: QuerySpecificationEvaluatorConstructor;
    private _entitySets;
    private _new;
    private _dirty;
    private _deleted;
    private _queryRunner;
    private _modelBuilder;
    private _optionsBuilder;
    private _isUserTransaction;
    constructor(_connection: Connection, evaluator: QuerySpecificationEvaluatorConstructor);
    private _initialise;
    protected abstract onModelCreation<BaseType extends object = any>(builder: DbContextModelBuilder<BaseType>): void;
    protected abstract onConfiguring(optionsBuilder: IDbContextOptionsBuilder): void;
    set<T extends object>(type: new (...args: any) => T): IDbSet<T, T>;
    add<T extends IEntity>(...entities: T[]): void;
    unTrack<T extends IEntity>(entity: T): void;
    update<T extends IEntity>(...entities: T[]): void;
    remove<T extends IEntity>(...entities: T[]): void;
    private _throwIfNullFound;
    find<T extends IEntity>(type: any, id: any): Promise<T>;
    rollback(entityType?: any): void;
    saveChanges(): Promise<ISavedTransaction>;
    transactionIsOpen(): boolean;
    openTransaction(): Promise<void>;
    commitTransaction(): Promise<void>;
    rollbackTransaction(): Promise<void>;
    query(query: string, parameters: any[]): Promise<any>;
    loadRelatedData<T extends IEntity>(type: new (...args: []) => T, entity: T): Promise<T>;
    execute<T extends object, R = T[]>(queryable: IInternalDbSet<T>, type?: QueryType, ignoreFilters?: boolean): Promise<R>;
    getMetadata<T>(type: new (...args: any[]) => T, includePaths: string[]): Promise<ProxyMetaDataInstance<T>>;
    dispose(): void;
    private _tryOpenConnection;
    private _tryCloseConenction;
    private _dispose;
    private _setUnderlyingEntityType;
    private _getUpdates;
    private _commitDeleted;
    private _commitDirty;
    private _commitDirtyAll;
    private _commitNew;
    private _getSQLBuilder;
    private _getRepository;
}
export declare abstract class UnitOfWork extends DbContext implements Omit<Omit<DbContext, 'execute'>, 'getMetadata'> {
}
export {};