Options
All
  • Public
  • Public/Protected
  • All
Menu

Class EntityManager

Hierarchy

  • EntityManager

Index

Constructors

Properties

Methods

Constructors

constructor

Properties

Protected Readonly client

client: MongoClient

Protected Readonly exceptionFactory

exceptionFactory: ExceptionFactory

Protected log

log: Debugger = ...

Protected Readonly models

models: Map<string, ClassConstructor<any>> = ...

Protected Readonly repositories

repositories: Map<string, any> = ...

Protected Readonly sessionLoaderService

sessionLoaderService: SessionLoaderService

Methods

clearSessionContext

  • clearSessionContext(): void

count

  • count<Model>(classType: ClassConstructor<Model>, query: Filter<Model>, options?: CountDocumentsOptions): Promise<number>

createIndexs

  • createIndexs<Model>(model: ClassConstructor<Model>): Promise<undefined | string[]>

Protected deleteCascade

  • deleteCascade<Model>(classType: ClassConstructor<Model>, entity: WithId<Model>): Promise<void>

deleteMany

  • deleteMany<Model>(classType: ClassConstructor<Model>, query: Filter<Model>, options?: DeleteOptions): Promise<DeleteResult>

deleteOne

  • deleteOne<Model>(classType: ClassConstructor<Model>, query: Filter<Model>, options?: DeleteOptions): Promise<DeleteResult>

find

  • find<Model>(classType: ClassConstructor<Model>, query: Filter<Model>, options?: FindOptions<Model>): Promise<FindCursor<WithId<Model>>>

  • Type parameters

    Parameters

    • classType: ClassConstructor<Model>
    • query: Filter<Model>
    • options: FindOptions<Model> = {}

    Returns Promise<FindCursor<WithId<Model>>>

findOne

  • findOne<Model>(classType: ClassConstructor<Model>, query: Filter<Model>, options?: FindOptions<Document>): Promise<undefined | WithId<Model>>

  • Type parameters

    Parameters

    • classType: ClassConstructor<Model>
    • query: Filter<Model>
    • options: FindOptions<Document> = {}

    Returns Promise<undefined | WithId<Model>>

fromPlain

  • fromPlain<Model>(classType: ClassConstructor<Model>, data: object, options?: ClassTransformOptions): Model

getClient

  • getClient(): MongoClient

getCollection

  • getCollection<Model>(nameOrInstance: Model | ClassConstructor<Model>, databaseName?: string): Collection<Document>

getCollectionName

  • getCollectionName<Model>(nameOrInstance: Model | ClassConstructor<Model>): string

getDatabase

  • getDatabase(databaseName?: string): Db

getModel

  • getModel(id: string): undefined | ClassConstructor<any>

getModels

  • getModels(): Map<string, ClassConstructor<any>>

getRelationship

  • getRelationship<R>(obj: any, property: string, options?: FindOptions<Document>): Promise<undefined | WithId<R>>

getRelationships

  • getRelationships<R>(obj: any, property: string, options?: FindOptions<Document>): Promise<WithId<R>[]>

getRepository

  • getRepository<Model, R>(classType: ClassConstructor<Model>): R

getSessionContext

  • getSessionContext(): ClientSessionContext

getSessionLoaderService

isIdQuery

  • isIdQuery(query: any): boolean

isIdsQuery

  • isIdsQuery(query: any): boolean

merge

  • merge<Model>(entity: Model, data: Model, excludePrefixes?: string[]): Model

registerModel

  • registerModel<Model>(name: string, model: ClassConstructor<Model>): Promise<EntityManager>

registerRepository

  • registerRepository<Model, R>(name: string, repository: R): EntityManager

save

  • save<Model>(entity: Model | WithId<Model>, options?: (InsertOneOptions & { skipValidation?: boolean; validatorOptions?: ValidatorOptions }) & (UpdateOptions & { skipValidation?: boolean; validatorOptions?: ValidatorOptions })): Promise<WithId<Model>>

  • Type parameters

    Parameters

    • entity: Model | WithId<Model>
    • options: (InsertOneOptions & { skipValidation?: boolean; validatorOptions?: ValidatorOptions }) & (UpdateOptions & { skipValidation?: boolean; validatorOptions?: ValidatorOptions }) = {}

    Returns Promise<WithId<Model>>

setSessionContext

  • setSessionContext(mongoSession: ClientSession): void

startSessionWithTransaction

  • startSessionWithTransaction(transactionFn: (session: ClientSession) => Promise<any>, options?: { sessionOptions?: ClientSessionOptions; transactionOptions?: TransactionOptions; useContext?: boolean }): Promise<ClientSession>

  • To avoid Transaction Errors, it is important to keep a sequential approach in the way transactions are commited to the session. ie: do not to use Promise.all (parallel execution) in your transaction function as it could cause inconsistencies in the order in which transactions will be committed to the session.

    Parameters

    • transactionFn: (session: ClientSession) => Promise<any>
        • (session: ClientSession): Promise<any>

        • Parameters

          • session: ClientSession

          Returns Promise<any>

    • options: { sessionOptions?: ClientSessionOptions; transactionOptions?: TransactionOptions; useContext?: boolean } = {}
      • Optional sessionOptions?: ClientSessionOptions
      • Optional transactionOptions?: TransactionOptions
      • Optional useContext?: boolean

    Returns Promise<ClientSession>

validate

  • validate<Model>(obj: Model, validatorOptions?: ValidatorOptions, throwError?: boolean): Promise<ValidationError[]>

watch

  • watch<Model>(classType: ClassConstructor<Model>, pipes?: Document[], options?: ChangeStreamOptions): ChangeStream<WithId<Model>>

  • Type parameters

    Parameters

    • classType: ClassConstructor<Model>
    • Optional pipes: Document[]
    • options: ChangeStreamOptions = {}

    Returns ChangeStream<WithId<Model>>