lakutata

import { ObjectLiteral } from './TypeDef.internal.36.js'; import { EntityMetadata, ColumnMetadata, RelationMetadata } from './TypeDef.internal.47.js'; import { QueryRunner } from './TypeDef.internal.40.js'; import { LoadEvent, BeforeQueryEvent, AfterQueryEvent, InsertEvent, UpdateEvent, RemoveEvent, SoftRemoveEvent, RecoverEvent, TransactionStartEvent, TransactionCommitEvent, TransactionRollbackEvent } from './TypeDef.internal.92.js'; /** * Broadcaster execution result - promises executed by operations and number of executed listeners and subscribers. */ declare class BroadcasterResult { /** * Number of executed listeners and subscribers. */ count: number; /** * Promises returned by listeners and subscribers which needs to be awaited. */ promises: Promise<any>[]; /** * Wait for all promises to settle */ wait(): Promise<BroadcasterResult>; } /** * Classes that implement this interface are subscribers that subscribe for the specific events in the ORM. */ interface EntitySubscriberInterface<Entity = any> { /** * Returns the class of the entity to which events will listen. * If this method is omitted, then subscriber will listen to events of all entities. */ listenTo?(): Function | string; /** * Called after entity is loaded from the database. * * For backward compatibility this signature is slightly different from the * others. `event` was added later but is always provided (it is only * optional in the signature so that its introduction does not break * compilation for existing subscribers). */ afterLoad?(entity: Entity, event?: LoadEvent<Entity>): Promise<any> | void; /** * Called before query is executed. */ beforeQuery?(event: BeforeQueryEvent<Entity>): Promise<any> | void; /** * Called after query is executed. */ afterQuery?(event: AfterQueryEvent<Entity>): Promise<any> | void; /** * Called before entity is inserted to the database. */ beforeInsert?(event: InsertEvent<Entity>): Promise<any> | void; /** * Called after entity is inserted to the database. */ afterInsert?(event: InsertEvent<Entity>): Promise<any> | void; /** * Called before entity is updated in the database. */ beforeUpdate?(event: UpdateEvent<Entity>): Promise<any> | void; /** * Called after entity is updated in the database. */ afterUpdate?(event: UpdateEvent<Entity>): Promise<any> | void; /** * Called before entity is removed from the database. */ beforeRemove?(event: RemoveEvent<Entity>): Promise<any> | void; /** * Called before entity is soft removed from the database. */ beforeSoftRemove?(event: SoftRemoveEvent<Entity>): Promise<any> | void; /** * Called before entity is recovered in the database. */ beforeRecover?(event: RecoverEvent<Entity>): Promise<any> | void; /** * Called after entity is removed from the database. */ afterRemove?(event: RemoveEvent<Entity>): Promise<any> | void; /** * Called after entity is soft removed from the database. */ afterSoftRemove?(event: SoftRemoveEvent<Entity>): Promise<any> | void; /** * Called after entity is recovered in the database. */ afterRecover?(event: RecoverEvent<Entity>): Promise<any> | void; /** * Called before transaction is started. */ beforeTransactionStart?(event: TransactionStartEvent): Promise<any> | void; /** * Called after transaction is started. */ afterTransactionStart?(event: TransactionStartEvent): Promise<any> | void; /** * Called before transaction is committed. */ beforeTransactionCommit?(event: TransactionCommitEvent): Promise<any> | void; /** * Called after transaction is committed. */ afterTransactionCommit?(event: TransactionCommitEvent): Promise<any> | void; /** * Called before transaction rollback. */ beforeTransactionRollback?(event: TransactionRollbackEvent): Promise<any> | void; /** * Called after transaction rollback. */ afterTransactionRollback?(event: TransactionRollbackEvent): Promise<any> | void; } interface BroadcasterEvents { BeforeQuery: (query: string, parameters: any[] | undefined) => void; AfterQuery: (query: string, parameters: any[] | undefined, success: boolean, executionTime: number | undefined, rawResults: any | undefined, error: any | undefined) => void; BeforeTransactionCommit: () => void; AfterTransactionCommit: () => void; BeforeTransactionStart: () => void; AfterTransactionStart: () => void; BeforeTransactionRollback: () => void; AfterTransactionRollback: () => void; BeforeUpdate: (metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral, updatedColumns?: ColumnMetadata[], updatedRelations?: RelationMetadata[]) => void; AfterUpdate: (metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral, updatedColumns?: ColumnMetadata[], updatedRelations?: RelationMetadata[]) => void; BeforeInsert: (metadata: EntityMetadata, entity: ObjectLiteral | undefined) => void; AfterInsert: (metadata: EntityMetadata, entity: ObjectLiteral | undefined) => void; BeforeRemove: (metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral) => void; AfterRemove: (metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral) => void; BeforeSoftRemove: (metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral) => void; AfterSoftRemove: (metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral) => void; BeforeRecover: (metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral) => void; AfterRecover: (metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral) => void; Load: (metadata: EntityMetadata, entities: ObjectLiteral[]) => void; } /** * Broadcaster provides a helper methods to broadcast events to the subscribers. */ declare class Broadcaster { private queryRunner; constructor(queryRunner: QueryRunner); broadcast<U extends keyof BroadcasterEvents>(event: U, ...args: Parameters<BroadcasterEvents[U]>): Promise<void>; /** * Broadcasts "BEFORE_INSERT" event. * Before insert event is executed before entity is being inserted to the database for the first time. * All subscribers and entity listeners who listened to this event will be executed at this point. * Subscribers and entity listeners can return promises, it will wait until they are resolved. * * Note: this method has a performance-optimized code organization, do not change code structure. */ broadcastBeforeInsertEvent(result: BroadcasterResult, metadata: EntityMetadata, entity: undefined | ObjectLiteral): void; /** * Broadcasts "BEFORE_UPDATE" event. * Before update event is executed before entity is being updated in the database. * All subscribers and entity listeners who listened to this event will be executed at this point. * Subscribers and entity listeners can return promises, it will wait until they are resolved. * * Note: this method has a performance-optimized code organization, do not change code structure. */ broadcastBeforeUpdateEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral, updatedColumns?: ColumnMetadata[], updatedRelations?: RelationMetadata[]): void; /** * Broadcasts "BEFORE_REMOVE" event. * Before remove event is executed before entity is being removed from the database. * All subscribers and entity listeners who listened to this event will be executed at this point. * Subscribers and entity listeners can return promises, it will wait until they are resolved. * * Note: this method has a performance-optimized code organization, do not change code structure. */ broadcastBeforeRemoveEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral, identifier?: ObjectLiteral): void; /** * Broadcasts "BEFORE_SOFT_REMOVE" event. * Before soft remove event is executed before entity is being soft removed from the database. * All subscribers and entity listeners who listened to this event will be executed at this point. * Subscribers and entity listeners can return promises, it will wait until they are resolved. * * Note: this method has a performance-optimized code organization, do not change code structure. */ broadcastBeforeSoftRemoveEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral, identifier?: ObjectLiteral): void; /** * Broadcasts "BEFORE_RECOVER" event. * Before recover event is executed before entity is being recovered in the database. * All subscribers and entity listeners who listened to this event will be executed at this point. * Subscribers and entity listeners can return promises, it will wait until they are resolved. * * Note: this method has a performance-optimized code organization, do not change code structure. */ broadcastBeforeRecoverEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral, identifier?: ObjectLiteral): void; /** * Broadcasts "AFTER_INSERT" event. * After insert event is executed after entity is being persisted to the database for the first time. * All subscribers and entity listeners who listened to this event will be executed at this point. * Subscribers and entity listeners can return promises, it will wait until they are resolved. * * Note: this method has a performance-optimized code organization, do not change code structure. */ broadcastAfterInsertEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, identifier?: ObjectLiteral): void; /** * Broadcasts "BEFORE_QUERY" event. */ broadcastBeforeQueryEvent(result: BroadcasterResult, query: string, parameters: undefined | any[]): void; /** * Broadcasts "AFTER_QUERY" event. */ broadcastAfterQueryEvent(result: BroadcasterResult, query: string, parameters: undefined | any[], success: boolean, executionTime: undefined | number, rawResults: undefined | any, error: undefined | any): void; /** * Broadcasts "BEFORE_TRANSACTION_START" event. */ broadcastBeforeTransactionStartEvent(result: BroadcasterResult): void; /** * Broadcasts "AFTER_TRANSACTION_START" event. */ broadcastAfterTransactionStartEvent(result: BroadcasterResult): void; /** * Broadcasts "BEFORE_TRANSACTION_COMMIT" event. */ broadcastBeforeTransactionCommitEvent(result: BroadcasterResult): void; /** * Broadcasts "AFTER_TRANSACTION_COMMIT" event. */ broadcastAfterTransactionCommitEvent(result: BroadcasterResult): void; /** * Broadcasts "BEFORE_TRANSACTION_ROLLBACK" event. */ broadcastBeforeTransactionRollbackEvent(result: BroadcasterResult): void; /** * Broadcasts "AFTER_TRANSACTION_ROLLBACK" event. */ broadcastAfterTransactionRollbackEvent(result: BroadcasterResult): void; /** * Broadcasts "AFTER_UPDATE" event. * After update event is executed after entity is being updated in the database. * All subscribers and entity listeners who listened to this event will be executed at this point. * Subscribers and entity listeners can return promises, it will wait until they are resolved. * * Note: this method has a performance-optimized code organization, do not change code structure. */ broadcastAfterUpdateEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral, updatedColumns?: ColumnMetadata[], updatedRelations?: RelationMetadata[]): void; /** * Broadcasts "AFTER_REMOVE" event. * After remove event is executed after entity is being removed from the database. * All subscribers and entity listeners who listened to this event will be executed at this point. * Subscribers and entity listeners can return promises, it will wait until they are resolved. * * Note: this method has a performance-optimized code organization, do not change code structure. */ broadcastAfterRemoveEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral, identifier?: ObjectLiteral): void; /** * Broadcasts "AFTER_SOFT_REMOVE" event. * After soft remove event is executed after entity is being soft removed from the database. * All subscribers and entity listeners who listened to this event will be executed at this point. * Subscribers and entity listeners can return promises, it will wait until they are resolved. * * Note: this method has a performance-optimized code organization, do not change code structure. */ broadcastAfterSoftRemoveEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral, identifier?: ObjectLiteral): void; /** * Broadcasts "AFTER_RECOVER" event. * After recover event is executed after entity is being recovered in the database. * All subscribers and entity listeners who listened to this event will be executed at this point. * Subscribers and entity listeners can return promises, it will wait until they are resolved. * * Note: this method has a performance-optimized code organization, do not change code structure. */ broadcastAfterRecoverEvent(result: BroadcasterResult, metadata: EntityMetadata, entity?: ObjectLiteral, databaseEntity?: ObjectLiteral, identifier?: ObjectLiteral): void; /** * @deprecated Use `broadcastLoadForAllEvent` */ broadcastLoadEventsForAll(result: BroadcasterResult, metadata: EntityMetadata, entities: ObjectLiteral[]): void; /** * Broadcasts "AFTER_LOAD" event for all given entities, and their sub-entities. * After load event is executed after entity has been loaded from the database. * All subscribers and entity listeners who listened to this event will be executed at this point. * Subscribers and entity listeners can return promises, it will wait until they are resolved. * * Note: this method has a performance-optimized code organization, do not change code structure. */ broadcastLoadEvent(result: BroadcasterResult, metadata: EntityMetadata, entities: ObjectLiteral[]): void; /** * Checks if subscriber's methods can be executed by checking if its don't listen to the particular entity, * or listens our entity. */ protected isAllowedSubscriber(subscriber: EntitySubscriberInterface<any>, target: Function | string): boolean; } export { Broadcaster }; export type { EntitySubscriberInterface };