Variable Transaction

Type declaration

• [toStringTag]: string

• ReadOnly: {
      __#116662@#closed?: Observable<[], void>;
      __#116662@#participants: Set<Participant>;
      __#116662@#resources: Set<Resource>;
      __#116662@#roles: Map<{}, Participant>;
      __#116662@#shared?: Observable<[], void>;
      __#116662@#status: Status;
      __#116662@#via: string;
      __#116662@#waitingOn?: Iterable<Transaction, any, any>;
      participants: Set<Participant>;
      resources: Set<Resource>;
      status: Status;
      via: string;
      waitingOn: undefined | Iterable<Transaction, any, any>;
      __#116662@#assertAvailable(): void;
      __#116662@#executeCommit(): MaybePromise;
      __#116662@#executeCommit1(): MaybePromise;
      __#116662@#executeCommit2(): undefined | Promise<void>;
      __#116662@#executePostCommit(participants: Participant[]): MaybePromise;
      __#116662@#executePreCommit(): MaybePromise<void>;
      __#116662@#executeRollback(): undefined | Promise<void>;
      __#116662@#finalize(status: Status, why: string, finalizer: (() => MaybePromise)): undefined | Promise<void>;
      __#116662@#locksChanged(resources: Set<Resource>, how?: string): void;
      __#116662@#log(...message: unknown[]): void;
      addParticipants(...participants: Participant[]): void;
      addResources(...resources: Resource[]): Promise<void>;
      addResourcesSync(...resources: Resource[]): void;
      begin(): Promise<void>;
      beginSync(): void;
      close(): void;
      commit(): MaybePromise;
      getParticipant(role: {}): undefined | Participant;
      onClose(listener: (() => void)): void;
      onShared(listener: (() => void), once?: boolean): void;
      rollback(): undefined | Promise<void>;
      toString(): string;
      waitFor(others: Set<Transaction>): Promise<void>;
  }

  A read-only transaction you may use without context.

  • Optional__#116662@#closed?: Observable<[], void>

  • __#116662@#participants: Set<Participant>

  • __#116662@#resources: Set<Resource>

  • __#116662@#roles: Map<{}, Participant>

  • Optional__#116662@#shared?: Observable<[], void>

  • __#116662@#status: Status

  • __#116662@#via: string

  • Optional__#116662@#waitingOn?: Iterable<Transaction, any, any>

  • Readonlyparticipants: Set<Participant>

  • Readonlyresources: Set<Resource>

  • Readonlystatus: Status

  • Readonlyvia: string

  • ReadonlywaitingOn: undefined | Iterable<Transaction, any, any>

  • __#116662@#assertAvailable:function

    • __#116662@#assertAvailable(): void

    • Returns void

  • __#116662@#executeCommit:function

    • __#116662@#executeCommit(): MaybePromise

    • Returns MaybePromise

  • __#116662@#executeCommit1:function

    • __#116662@#executeCommit1(): MaybePromise

    • Returns MaybePromise

  • __#116662@#executeCommit2:function

    • __#116662@#executeCommit2(): undefined | Promise<void>

    • Returns undefined | Promise<void>

  • __#116662@#executePostCommit:function

    • __#116662@#executePostCommit(participants): MaybePromise

    • Parameters

      • participants: Participant[]

      Returns MaybePromise

  • __#116662@#executePreCommit:function

    • __#116662@#executePreCommit(): MaybePromise<void>

    • Returns MaybePromise<void>

  • __#116662@#executeRollback:function

    • __#116662@#executeRollback(): undefined | Promise<void>

    • Returns undefined | Promise<void>

  • __#116662@#finalize:function

    • __#116662@#finalize(status, why, finalizer): undefined | Promise<void>

    • Parameters

      • status: Status
      • why: string
      • finalizer: (() => MaybePromise)
        • • (): MaybePromise

          • Returns MaybePromise

      Returns undefined | Promise<void>

  • __#116662@#locksChanged:function

    • __#116662@#locksChanged(resources, how?): void

    • Parameters

      • resources: Set<Resource>
      • Optionalhow: string

      Returns void

  • __#116662@#log:function

    • __#116662@#log(...message): void

    • Parameters

      • Rest...message: unknown[]

      Returns void

  • addParticipants:function

    • addParticipants(...participants): void

    • Parameters

      • Rest...participants: Participant[]

      Returns void

  • addResources:function

    • addResources(...resources): Promise<void>

    • Parameters

      • Rest...resources: Resource[]

      Returns Promise<void>

  • addResourcesSync:function

    • addResourcesSync(...resources): void

    • Parameters

      • Rest...resources: Resource[]

      Returns void

  • begin:function

    • begin(): Promise<void>

    • Returns Promise<void>

  • beginSync:function

    • beginSync(): void

    • Returns void

  • close:function

    • close(): void

    • Returns void

  • commit:function

    • commit(): MaybePromise

    • Returns MaybePromise

  • getParticipant:function

    • getParticipant(role): undefined | Participant

    • Parameters

      • role: {}

      Returns undefined | Participant

  • onClose:function

    • onClose(listener): void

    • Parameters

      • listener: (() => void)
        • • (): void

          • Returns void

      Returns void

  • onShared:function

    • onShared(listener, once?): void

    • Parameters

      • listener: (() => void)
        • • (): void

          • Returns void

      • Optionalonce: boolean

      Returns void

  • rollback:function

    • rollback(): undefined | Promise<void>

    • Returns undefined | Promise<void>

  • toString:function

    • toString(): string

    • Returns string

  • waitFor:function

    • waitFor(others): Promise<void>

    • Parameters

      • others: Set<Transaction>

      Returns Promise<void>

• Status: typeof Status

• act:function

  • act<T>(via, actor): MaybePromise<T>

  • Perform a transactional operation. This is the only way to obtain a read/write transaction.

    The transaction will commit automatically if it is exclusive (write mode) after the actor returns.

    The transaction is destroyed when act returns. You will receive an error if you access it after it is destroyed.

    Type Parameters

    • T

    Parameters

    • via: string
    • actor: ((transaction: Transaction) => MaybePromise<T>)
      • • (transaction): MaybePromise<T>

        • Parameters

          • transaction: Transaction

          Returns MaybePromise<T>

    Returns MaybePromise<T>