Class ProcessMiddleware

plugins/process-resources/src/middleware.ts:40–299

 * @public
 */
export class ProcessMiddleware extends BasePresentationMiddleware implements PresentationMiddleware {
  private constructor (client: Client, next?: PresentationMiddleware) {
    super(client, next)
  }

  async notifyTx (...tx: Tx[]): Promise<void> {
    await this.provideNotifyTx(...tx)
  }

  async close (): Promise<void> {
    await this.provideClose()
  }

  static create (client: Client, next?: PresentationMiddleware): ProcessMiddleware {
    return new ProcessMiddleware(client, next)
  }

  private readonly txFactory = new TxOperations(this.client, getCurrentAccount().primarySocialId).txFactory

  async tx (tx: Tx): Promise<TxResult> {
    const preTx: Array<TxCUD<Doc>> = []
    const postTx: Array<TxCUD<Doc>> = []
    await this.handleTx(preTx, postTx, tx)

    if (preTx.length > 0 || postTx.length > 0) {
      if (TxProcessor.isExtendsCUD(tx._class)) {
        const applyIf = this.txFactory.createTxApplyIf(
          core.space.Tx,
          generateId(),
          [],
          [],
          [...preTx, tx as TxCUD<Doc>, ...postTx],
          'process',
          true
        )
        return await this.provideTx(applyIf)
      }
    }

    return await this.provideTx(tx)
  }

  private async handleTx (preTx: Array<TxCUD<Doc>>, postTx: Array<TxCUD<Doc>>, ...txes: Tx[]): Promise<void> {
    for (const etx of txes) {
      if (etx._class === core.class.TxApplyIf) {
        const applyIf = etx as TxApplyIf
        await this.handleTx(preTx, postTx, ...applyIf.txes)
      }

      await this.handleCardCreate(postTx, etx)
      await this.handleCardUpdate(preTx, etx)
      await this.handleTagAdd(postTx, etx)
      await this.handleToDoDone(preTx, etx)
      await this.handleApproveRequest(preTx, etx)
    }
  }

  private async handleCardUpdate (preTx: Array<TxCUD<Doc>>, etx: Tx): Promise<void> {