TransactionalConnection
TransactionalConnection
The TransactionalConnection is a wrapper around the TypeORM Connection object which works in conjunction
with the Transaction decorator to implement per-request transactions. All services which access the
database should use this class rather than the raw TypeORM connection, to ensure that db changes can be
easily wrapped in transactions when required.
The service layer does not need to know about the scope of a transaction, as this is covered at the
API by the use of the Transaction decorator.
Signature
class TransactionalConnection {
constructor(connection: Connection)
rawConnection: Connection
getRepository(target: ObjectType<Entity> | EntitySchema<Entity> | string) => Repository<Entity>;
getRepository(ctx: RequestContext | undefined, target: ObjectType<Entity> | EntitySchema<Entity> | string) => Repository<Entity>;
getRepository(ctxOrTarget: RequestContext | ObjectType<Entity> | EntitySchema<Entity> | string | undefined, maybeTarget?: ObjectType<Entity> | EntitySchema<Entity> | string) => Repository<Entity>;
async startTransaction(ctx: RequestContext) => ;
async commitOpenTransaction(ctx: RequestContext) => ;
async rollBackTransaction(ctx: RequestContext) => ;
async getEntityOrThrow(ctx: RequestContext, entityType: Type<T>, id: ID, options: GetEntityOrThrowOptions<T> = {}) => Promise<T>;
findOneInChannel(ctx: RequestContext, entity: Type<T>, id: ID, channelId: ID, options: FindOneOptions = {}) => ;
findByIdsInChannel(ctx: RequestContext, entity: Type<T>, ids: ID[], channelId: ID, options: FindOneOptions) => ;
}
Members
constructor
method
type:
(connection: Connection) => TransactionalConnection
rawConnection
property
type:
Connection
The plain TypeORM Connection object. Should be used carefully as any operations
performed with this connection will not be performed within any outer
transactions.
getRepository
method
type:
(target: ObjectType<Entity> | EntitySchema<Entity> | string) => Repository<Entity>
Returns a TypeORM repository. Note that when no RequestContext is supplied, the repository will not
be aware of any existing transaction. Therefore calling this method without supplying a RequestContext
is discouraged without a deliberate reason.
getRepository
method
type:
(ctx: RequestContext | undefined, target: ObjectType<Entity> | EntitySchema<Entity> | string) => Repository<Entity>
Returns a TypeORM repository which is bound to any existing transactions. It is recommended to always pass
the RequestContext argument when possible, otherwise the queries will be executed outside of any
ongoing transactions which have been started by the Transaction decorator.
getRepository
method
type:
(ctxOrTarget: RequestContext | ObjectType<Entity> | EntitySchema<Entity> | string | undefined, maybeTarget?: ObjectType<Entity> | EntitySchema<Entity> | string) => Repository<Entity>
startTransaction
async method
type:
(ctx: RequestContext) =>
Manually start a transaction if one is not already in progress. This method should be used in
conjunction with the
'manual' mode of the Transaction decorator.
commitOpenTransaction
async method
type:
(ctx: RequestContext) =>
Manually commits any open transaction. Should be very rarely needed, since the Transaction decorator
and the internal TransactionInterceptor take care of this automatically. Use-cases include situations
in which the worker thread needs to access changes made in the current transaction, or when using the
Transaction decorator in manual mode.
rollBackTransaction
async method
type:
(ctx: RequestContext) =>
Manually rolls back any open transaction. Should be very rarely needed, since the Transaction decorator
and the internal TransactionInterceptor take care of this automatically. Use-cases include when using the
Transaction decorator in manual mode.
getEntityOrThrow
async method
type:
(ctx: RequestContext, entityType: Type<T>, id: ID, options: GetEntityOrThrowOptions<T> = {}) => Promise<T>
Finds an entity of the given type by ID, or throws an
EntityNotFoundError if none
is found. Can be configured to retry (using the retries option) in the event of the
entity not being found on the first attempt. This can be useful when attempting to access
an entity which was just created and may be inaccessible due to an ongoing transaction.
findOneInChannel
method
type:
(ctx: RequestContext, entity: Type<T>, id: ID, channelId: ID, options: FindOneOptions = {}) =>
Like the TypeOrm
Repository.findOne() method, but limits the results to
the given Channel.
findByIdsInChannel
method
type:
(ctx: RequestContext, entity: Type<T>, ids: ID[], channelId: ID, options: FindOneOptions) =>
Like the TypeOrm
Repository.findByIds() method, but limits the results to
the given Channel.