@tasenor/common-node 1.12.0 → 1.13.0

package/src/import/TransactionImportHandler.ts

@@ -11,33 +11,7 @@ import { BadState, InvalidFile, NotImplemented, SystemError } from '../error'
 import clone from 'clone'
 
 /**
- * ## Importing
- *
  * This module has types used in the importing data to the system using Interactive Stateful Process.
- *
- * ### Importing Process
- *
- * The import processing goes through the following stages:
- *
- * ```mermaid
- * flowchart LR
- *    START --> segmentation
- *    segmentation --> classification
- *    classification --> analyze
- *    analyze --> execution
- *    execution --> END
- * ```
- *
- * 1. **Segmentation**: Split incoming data to smaller pieces so that parts of the original data are grouped
- *    together under unique *segmentation ID*. Each group present some meaningful unit of information
- *    belonging together called *segment*.
- * 2. **Classification**: For each segment, determine which *class* it belongs to. Classes are some
- *    defined set of qualities describing similar segments.
- * 3. **Analyze**: Based on the classification, additional information can be collected and/or calculated
- *    for each segment.
- * 4. **Execution**: Once information for each segment is complete, we can execute database insertions,
- *    REST API calls or whatever appropriate actions based on the segement data.
- *
  */
 export class TransactionImportHandler extends TextFileProcessHandler {
 
@@ -180,6 +154,13 @@ export class TransactionImportHandler extends TextFileProcessHandler {
     return newState
   }
 
+  /**
+   * Hook to post process column values.
+   */
+  async segmentationColumnPostProcess(columns: Record<string, unknown>): Promise<Record<string, unknown>> {
+    return columns
+  }
+
   /**
    * Hook to do some post proccessing for segmentation process. Collects standard fields.
    * @param state
@@ -208,7 +189,7 @@ export class TransactionImportHandler extends TextFileProcessHandler {
       // Build standard fields.
       const { textField, totalAmountField } = this.importOptions
       for (let n = 0; n < state.files[fileName].lines.length; n++) {
-        const { columns, segmentId } = state.files[fileName].lines[n]
+        let { columns, segmentId } = state.files[fileName].lines[n]
         for (const name of this.importOptions.requiredFields) {
           if (columns[name] === undefined) {
             columns[name] = ''
@@ -238,6 +219,7 @@ export class TransactionImportHandler extends TextFileProcessHandler {
         if (totalAmountField) {
           columns._totalAmountField = columns[totalAmountField]
         }
+        columns = await this.segmentationColumnPostProcess(columns) as Record<string, string>
       }
     }
 

package/src/import/TransactionRules.ts

@@ -5,178 +5,7 @@ import clone from 'clone'
 import { BadState, SystemError } from '../error'
 
 /**
- * ## Transaction rule system
- *
- * The classification of the import data uses rule system describing how to transform segmented
- * data to *transfers*, i.e. generic description of bookkeeping events. Initially in the beginning
- * of the processing the settings and rules defined for the particular importer are copied to the
- * initial state of the process. During the processing we may ask questions and add more information
- * to the process.
- *
- * So the structure of the configration is
- * ```json
- * {
- *   "language": "fi",
- *   "currency": "EUR",
- *    ...
- *   "account.income.currency.EUR": "1910",
- *    ...
- *   "rules": [...],
- *   "questions": {...},
- *   "answers": {...}
- * }
- * ```
- * There are
- * 1. Generic universal settings like *language* or *currency*.
- * 2. Then there is an account and import setting configuration that has been possibly resolved during the import process
- *    by asking from user, but which will also apply universally afterwards and are copied to the future import
- *    configuration.
- * 3. **Rules** section defines how to map segments to transfers.
- * 4. **Question** section defines UI questions to resolve some cases, that always require user interaction and
- *    cannot be resolved automatically.
- * 5. **Answers** section is a collection of responses to questions stored by each segment. They are not universally
- *    copied to the importer, but are only relevant the current import only.
- *
- * ### Settings
- *
- * The following general settings are used
- * - `currency` - A main currency of the bookkeeping database.
- * - `language` - A translation language for the imported texts.
- * - `tags.*.*.*` - A list of tags to be added for every transaction descriptions. Also some specific tags
- *                  can be specified, since `*.*.*` uses the same convention than account configurations.
- *
- * Accounts are defined as the following.
- * - `account.<reason>.<type>.<asset>` - Defines the account number to be used for the given purpose.
- *                                       Parts can be `'*'` to allow any purpose. Otherwise they are
- *                                       explained in more detail in {@link TransferAnalyzer}.
- *
- * Miscellaneous optional settings:
- * - `isTradeFeePartOfTotal` If set to `true`, assume that trading fee is included in the total.
- *                           Otherwise it is assumed to be paid on the top of the total.
- * - `recordDeposits` If set to false, skip deposits.
- * - `recordWithdrawals` If set to false, skip withdrawls.
- * - `allowShortSelling` If set, allow short selling, i.e. selling assets we don't have.
- *
- * #### Example
- * ```json
- * {
- *   "currency": "EUR",
- *   "language": "en",
- *   "tags.*.*.*": ["Lynx"],
- *   "account.deposit.currency.EUR": "1918",
- *   "account.deposit.external.EUR": "9999",
- *   "account.withdrawal.currency.EUR": "1918",
- *   "account.withdrawal.external.EUR": "9999",
- *   "account.expense.statement.INTEREST_EXPENSE": "9550",
- *   "account.expense.currency.EUR": "1918",
- *
- *   "rules": [],
- *   "questions": [],
- *   "answers": {}
- * }
- * ```
- *
- * ### Rules
- *
- * Rules sections is a list of rule definitions of form
- * ```json
- * {
- *    "name": "Name of the rule",
- *    "filter": "<expression>",
- *    "comment": "<optional description>",
- *    "options": {
- *      <optional flags>
- *    },
- *    "result": [
- *       <transfer1>, <transfer2>...
- *    ]
- * }
- * ```
- * The *name* is any string describing the rule. Rules are used so that each segment resulting from the segmentation
- * step are handled in the order of their timestamps. Lines belonging to the segment are offered one by one to the
- * *filter* expression and if returning true, the entries in *result* are concatenated together. Each entry in the
- * result is a *transfer description*.
- *
- * The filtering and result expressions has various variables set during the processing. All variables from
- * the segmentation is included. Typically they are the same as the column names in the CSV file for example.
- * See {@link TransactionRules.classifyLines} for other variables available.
- *
- * The structure of transfers are explained in {@link TransferAnalyzer}.
- *
- * The syntax of the filter and result is explained in {@link RulesEngine}.
- *
- * Currently one one boolean option is supported: `singleMatch` which means that matching any of the lines in the
- * segment suffices and the parsing result is returned immediately when matching rule is found. The rest of the
- * lines are ignored. It is useful when for example using `sum(lines, 'field')` to gather values from all lines
- * of the segment at once.
- *
- * ### Questions
- *
- * There are situation, where importer cannot deduct some part of the transfer automatically. In that case we can
- * define a question that needs to be answered every time, when the matching rule has been found. For example
- * we may determine based on the transaction data that it is related to computers but we want to know the exact
- * type of the purchase. Then we can define a question
- * ```json
- *   {
- *     "name": "Computer purchase",
- *     "label": "What category is the purchase",
- *     "ask": {
- *       "Hardware equipment": "HARDWARE",
- *       "Software": "SOFTWARE"
- *     }
- *   },
- * ```
- *
- * The question can be used in the transfer as explained in {@link TransferAnalyzer}.
- *
- * Different question types are documented in {@link TransactionUI.parseQuery}.
- *
- * ### Answers
- *
- * This section collects answers given earlier during the processing. They are grouped per segment ID per transfer.
- * For example
- * ```json
- * "d3e89d9af37dda4609bed94770fc5c52be946175": {
- *   "type": "HARDWARE"
- * },
- * ```
- * It may contain also complete transaction definition, which will override all parsing
- * ```
- *   "581e46d024678ddcddc01ae36369bf6fc54f16b2": {
- *     "transfers": [
- *       {
- *         "data": {
- *           "text": "Payment for something"
- *         },
- *         "type": "account",
- *         "asset": "8650",
- *         "amount": 59.27,
- *         "reason": "expense"
- *       },
- *       {
- *         "type": "account",
- *         "asset": "3020",
- *         "amount": -59.27,
- *         "reason": "expense"
- *       }
- *     ]
- *  }
- * ```
- * There is also a global answer section applied to all imports. If an asset has changed its name, it can be
- * stored like this in the empty segment ID:
- * ```
- *   "": {
- *     "asset-renaming": [
- *         {
- *           "date": "<YYYY-MM-DD>"
- *           "type": "stock",
- *           "old": "<OLD ASSET>"
- *           "new": "<NEW ASSET>"
- *         }
- *       ]
- *     }
- *   }
- * ```
+ * Rule handler.
  */
 export class TransactionRules {
   // TODO: Could also define extension from ProcessConfig configuration type definition and start building precise description.
@@ -391,6 +220,13 @@ export class TransactionRules {
 
     // Decide the error when passing through without finding an answer.
     if (matched) {
+      if (await this.UI.getBoolean(config, 'allowEmptyResults', 'Match was found but actually no transfers found. Should we allow this and ignore the match?')) {
+        return {
+          type: 'transfers',
+          transfers: [],
+          transactions: [],
+        }
+      }
       throw new Error(`Found matches but the result list is empty for ${JSON.stringify(lines)}.`)
     }
     throw new Error(`Could not find rules matching ${JSON.stringify(lines)}.`)

package/src/import/TransactionUI.ts

@@ -88,7 +88,21 @@ export class TransactionUI {
     const ans = await this.getSegmentAnswer(config, segment, `hasBeenRenamed.${type}.${asset}`) as undefined | boolean
 
     if (ans === undefined) {
-      throw new AskUI(await this.message(`Asset renaming question not implemented (avoid error for now by setting answer 'hasBeenRenamed.${type}.${asset}' for segment '${segment.id}').`, 'error'))
+      const text = await this.getTranslation("We don't seem to have any history for an asset '{asset}' of type '{type}'. Has it been renamed at some point?", config.language as Language)
+      const msg = await this.message(text.replace('{asset}', asset).replace('{type}', type), 'info')
+      throw new AskUI({
+        type: 'flat',
+        elements: [
+          msg,
+          {
+            type: 'yesno',
+            name: `answer.${segment.id}.hasBeenRenamed.${type}.${asset}`,
+            label: '',
+            actions: {}
+          },
+          await this.submit('Continue', 2, config.language as Language)
+        ]
+      })
     }
     return ans
   }
@@ -166,7 +180,7 @@ export class TransactionUI {
     if (defaultAccount) {
       ui.defaultValue = defaultAccount
     } else {
-      const canditates = await this.deps.getAccountCanditates(account, { ...config, plugin: config.handlers instanceof Array && config.handlers.length ? config.handlers[0] as PluginCode : undefined })
+      const canditates = await this.deps.getAccountCanditates(account, { ...config, plugin: config.handler })
       if (canditates.length) {
         ui.defaultValue = canditates[0]
         if (canditates.length > 1) {

package/src/import/TransferAnalyzer.ts

@@ -394,7 +394,7 @@ export class TransferAnalyzer {
       kind = 'investment'
       const statementEntry = shouldHaveOne('investment', 'statement')
       values.name = await this.getTranslation(`income-${statementEntry.asset}`)
-    } else if (weHave(['expense'], ['currency', 'statement']) || weHave(['expense', 'tax'], ['currency', 'statement'])) {
+    } else if (weHave(['expense'], ['currency', 'statement']) || weHave(['expense'], ['crypto', 'statement']) || weHave(['expense', 'tax'], ['currency', 'statement'])) {
       kind = 'expense'
       const statementEntry = shouldHaveOne('expense', 'statement')
       values.name = await this.getTranslation(`expense-${statementEntry.asset}`)
@@ -722,6 +722,7 @@ export class TransferAnalyzer {
               // Ot at least pass through to the short selling question.
               const renamed = await this.UI.askedRenamingOrThrow(this.config, segment, transfer.type, transfer.asset)
               if (renamed === true) {
+                // TODO: Need to implement this.
                 throw new SystemError(`Something went wrong. Asset ${transfer.type} ${transfer.asset} has been renamed but we did not encounter actual transaction for the renaming.`)
               }
             }
@@ -741,6 +742,9 @@ export class TransferAnalyzer {
               // Normal selling is valued by the value of the asset in our stock.
               transfer.value = Math.round(transferAmount * (value / amount))
               if (!transfer.value) {
+                if (isNaN(transfer.value)) {
+                  throw new SystemError(`Calculation of value for ${transfer.type} ${transfer.asset} failed (transferAmount=${JSON.stringify(transferAmount)}, value=${JSON.stringify(value)}, amount=${JSON.stringify(amount)}.`)
+                }
                 throw new SystemError(`Asset ${transfer.type} ${transfer.asset} have no value left when trading on ${segment.time}.`)
               }
             }
@@ -885,7 +889,14 @@ export class TransferAnalyzer {
       } else {
         throw new Error(`Handling non-fee '${nonFee}' not implemented.`)
       }
-      feeIsMissingFromTotal = !await this.UI.getBoolean(config, variable, 'Is transaction fee of type {type} already included in the {reason} total?'.replace('{type}', `${feeType}`).replace('{reason}', await this.getTranslation(`reason-${nonFee}`)))
+
+      feeIsMissingFromTotal = !await this.UI.getBoolean(
+        config,
+        variable,
+        'Is transaction fee of type {type} already included in the {reason} total?'.replace('{type}',
+        `${feeType}`).replace('{reason}',
+          await this.getTranslation(`reason-${nonFee}`))
+      )
 
       // Adjust asset transfers by the fee paid as asset itself, when they are missing from transfer total.
       if (feeIsMissingFromTotal) {
@@ -976,6 +987,7 @@ export class TransferAnalyzer {
             delete feesToDeduct[transfer.asset]
           }
           this.setData(transfer, data)
+          // TODO: Might actually need short-stock and short-crypto separately.
           const type = transfer.type === 'short' ? 'stock' : transfer.type
           await this.changeStock(segment.time, type, transfer.asset, transfer.amount, transfer.value)
         }
@@ -1002,9 +1014,11 @@ export class TransferAnalyzer {
         const soldAsset: AssetTransfer[] = (kind === 'short-buy'
           ? transfers.transfers.filter(t => t.reason === 'trade' && t.value && t.value > 0)
           : transfers.transfers.filter(t => t.reason === 'trade' && t.value && t.value < 0))
+
         if (soldAsset.length !== 1) {
-          throw new BadState(`Did not found unique asset that was traded from ${JSON.stringify(transfers.transfers)}`)
+          throw new BadState(`Did not found unique asset that was given out from ${JSON.stringify(transfers.transfers)}`)
         }
+
         let reason: AssetTransferReason
         let asset: VATTarget
         if (total > 0) {
@@ -1127,6 +1141,16 @@ export class TransferAnalyzer {
         amount: transfer.value === undefined ? 0 : transfer.value,
         description
       }
+      // Some accounts are not detectable in the beginning. Try once more.
+      if (!txEntry.account) {
+        const acc = await this.getAccount(transfer.reason, transfer.type, transfer.asset, segment.id)
+        if (acc) {
+          txEntry.account = acc
+        }
+      }
+      if (!txEntry.account) {
+        txEntry.account = await this.UI.throwGetAccount(this.config, `${transfer.reason}.${transfer.type}.${transfer.asset}` as AccountAddress)
+      }
       if (!txEntry.account) {
         throw new SystemError(`Cannot find account ${transfer.reason}.${transfer.type}.${transfer.asset} for entry ${JSON.stringify(txEntry)}`)
       }
@@ -1339,10 +1363,14 @@ export class TransferAnalyzer {
     if (!isTransactionImportConnector(this.handler.system.connector)) {
       throw new SystemError('Connector used is not a transaction import connector.')
     }
-    const account: AccountNumber = await this.getAccount('trade', type, asset) as AccountNumber
+    let account: AccountNumber = await this.getAccount('trade', type, asset) as AccountNumber
+    if (!account) {
+      account = await this.UI.throwGetAccount(this.config, `trade.${type}.${asset}` as AccountAddress)
+    }
     if (!account) {
-      throw new Error(`Unable to find account for ${type} ${asset}.`)
+      throw new Error(`Unable to find account for 'trade.${type}.${asset}'.`)
     }
+
     // If no records yet, fetch it using the connector.
     if (!this.stocks[account]) {
       this.stocks[account] = new StockBookkeeping(`Account ${account}`)
@@ -1368,9 +1396,12 @@ export class TransferAnalyzer {
     // Force reading the stock initial status.
     await this.getStock(time, type, asset)
 
-    const account = await this.getAccount('trade', type, asset)
+    let account = await this.getAccount('trade', type, asset)
+    if (!account) {
+      account = await this.UI.throwGetAccount(this.config, `trade.${type}.${asset}` as AccountAddress)
+    }
     if (!account) {
-      throw new Error(`Unable to find account for ${type} ${asset}.`)
+      throw new Error(`Unable to find account for 'trade.${type}.${asset}'.`)
     }
     if (!this.stocks[account]) {
       this.stocks[account] = new StockBookkeeping(`Account ${account}`)

package/src/plugins/BackendPlugin.ts

@@ -20,7 +20,7 @@ export class BackendPlugin {
   public description: string
   public path: string
   public languages: Record<string, Record<string, string>>
-  private catalog?: BackendCatalog
+  protected catalog?: BackendCatalog
 
   constructor() {
     this.id = null

package/src/plugins/ImportPlugin.ts

@@ -1,4 +1,4 @@
-import { log } from '@tasenor/common'
+import { ImportRule, log } from '@tasenor/common'
 import fs from 'fs'
 import { TransactionImportHandler } from '../import/TransactionImportHandler'
 import { TransactionUI } from '../import/TransactionUI'
@@ -205,7 +205,7 @@ export class ImportPlugin extends BackendPlugin {
    * Load and return default rules from the JSON-rules file.
    * @returns
    */
-  getRules(): JSON {
+  getRules(): ImportRule[] {
     const path = this.filePath('rules.json')
     log(`Reading rules ${path}.`)
     return JSON.parse(fs.readFileSync(path).toString('utf-8')).rules

package/src/plugins/LanguageBackendPlugin.ts

@@ -0,0 +1,22 @@
+import { BackendCatalog, Language, LanguageHandler } from '@tasenor/common'
+import { BackendPlugin } from '.'
+
+/**
+* A plugin providing translations for a language in backend.
+*/
+export class LanguageBackendPlugin extends BackendPlugin {
+  handler: LanguageHandler
+  declare protected catalog?: BackendCatalog
+
+  constructor(handler: LanguageHandler) {
+    super()
+    this.handler = handler
+    this.languages = handler.languages
+  }
+
+  getLanguages(): Set<Language> { return this.handler.getLanguages() }
+  flag(language: Language) { return this.handler.flag(language) }
+  date2str(date): string { return this.handler.date2str(date) }
+  time2str(date): string { return this.handler.time2str(date) }
+  str2date(date, sample: Date | undefined): string | undefined { return this.handler.str2date(date, sample) }
+}

package/src/plugins/ReportPlugin.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import fs from 'fs'
-import { KnexDatabase, data2csv } from '..'
+import { KnexDatabase, LanguageBackendPlugin, data2csv } from '..'
 import dayjs from 'dayjs'
 import quarterOfYear from 'dayjs/plugin/quarterOfYear'
 import { ReportOptions, ReportID, ReportFlagName, ReportItem, ReportQueryParams, ReportLine, AccountNumber, ReportColumnDefinition, PeriodModel, ReportFormat, Language, PK, ReportMeta, ReportData, ReportTotals, Report } from '@tasenor/common'
@@ -16,10 +16,13 @@ export class ReportPlugin extends BackendPlugin {
   private formats: ReportID[]
   // Is set, allow this report only on DBs having those accounting schemes.
   protected schemes: Set<string> | undefined
+  // Store translation plugin references.
+  protected languagePlugins: Partial<Record<Language, LanguageBackendPlugin>>
 
   constructor(...formats: ReportID[]) {
     super()
     this.formats = formats
+    this.languagePlugins = {}
     this.schemes = undefined
   }
 
@@ -234,6 +237,29 @@ export class ReportPlugin extends BackendPlugin {
     return sqlQuery
   }
 
+  /**
+   * Scan string for `{...}` sub-strings and translate parts.
+   */
+  translate(text: string, lang: Language): string {
+    let match
+    do {
+      match = /(\{(\d\d\d\d-\d\d-\d\d)\})/.exec(text)
+      if (match) {
+        if (!this.languagePlugins[lang]) {
+          this.languagePlugins[lang] = this.catalog?.getLanguagePlugin(lang) as LanguageBackendPlugin | undefined
+        }
+        text = text.replace(match[1], this.languagePlugins[lang]?.date2str(match[2]) || match[2])
+      } else {
+        match = /(\{(.*?)\})/.exec(text)
+        if (match) {
+          text = text.replace(match[1], this.t(match[2], lang))
+        }
+      }
+    } while (match)
+
+    return text
+  }
+
   /**
    * Construct a report data for the report.
    * @param db
@@ -252,7 +278,7 @@ export class ReportPlugin extends BackendPlugin {
    * * `useRemainingColumns` if set, extend this column index to use all the rest columns in the row.
    * * `accountDetails` if true, after this are summarized accounts under this entry.
    * * `isAccount` if true, this is an account entry.
-   * * `needLocalization` if set, value should be localized, i.e. translated via Localization component in ui.
+   * * `needLocalization` if set, value should be localized, i.e. translated according to the language selected.
    * * `name` Title of the entry.
    * * `number` Account number if the entry is an account.
    * * `values` An object with entry for each column mapping name of the columnt to the value to display.
@@ -289,8 +315,13 @@ export class ReportPlugin extends BackendPlugin {
     // Apply query filtering.
     entries = this.doFiltering(id, entries, options, settings)
 
-    // We have now relevant entries collected. Use plugin features next.
+    // Construct columns.
     const columns: ReportColumnDefinition[] = await this.getColumns(id, entries, options as ReportOptions, settings)
+    columns.forEach(column => {
+      column.title = this.translate(column.title, options.lang || 'en')
+    })
+
+    // We have now relevant entries collected. Use plugin features next.
     let data = await this.preProcess(id, entries, options, settings, columns) as ReportLine[]
     data = await this.postProcess(id, data, options, settings, columns)
     const report = {
@@ -344,7 +375,7 @@ export class ReportPlugin extends BackendPlugin {
   }
 
   /**
-   * Do post processing for report data before sending it.
+   * Do post processing for report data before sending it. By default, do translations.
    * @param id Report type.
    * @param data Calculated report data
    * @param options Report options.
@@ -353,6 +384,11 @@ export class ReportPlugin extends BackendPlugin {
    * @returns
    */
   async postProcess(id: ReportID, data: ReportLine[], options: ReportQueryParams, settings: ReportMeta, columns: ReportColumnDefinition[]): Promise<ReportLine[]> {
+    data.forEach(item => {
+      if ('needLocalization' in item && item.needLocalization && item.name) {
+        item.name = this.translate(item.name, options.lang || 'en')
+      }
+    })
     return data
   }
 

package/src/plugins/index.ts

@@ -4,6 +4,7 @@
 export * from './BackendPlugin'
 export * from './DataPlugin'
 export * from './ImportPlugin'
+export * from './LanguageBackendPlugin'
 export * from './ReportPlugin'
 export * from './SchemePlugin'
 export * from './ServicePlugin'

package/src/process/Process.ts

@@ -109,7 +109,7 @@ export class Process {
    */
   async proceedToState(action: ImportAction, state: ImportState): Promise<void> {
     const current = await this.getCurrentStep()
-    const handler = this.system.getHandler(current.handler)
+    const handler = this.system.handler
     current.action = action
     current.finished = new Date()
     current.save()
@@ -220,7 +220,7 @@ export class Process {
         await this.updateStatus()
         break
       }
-      const handler = this.system.getHandler(step.handler)
+      const handler = this.system.handler
       const state = clone(step.state)
       const action = clone(step.directions.action)
       try {
@@ -327,7 +327,7 @@ export class Process {
   async input(action: ImportAction): Promise<void> {
     this.system.logger.info(`Handling input ${JSON.stringify(action)} on process ${this}.`)
     const step = await this.getCurrentStep()
-    const handler = this.system.getHandler(step.handler)
+    const handler = this.system.handler
     let nextState
     try {
       nextState = await handler.action(this, action, clone(step.state), this.files)
@@ -349,7 +349,7 @@ export class Process {
     }
     const step = await this.getCurrentStep()
     this.system.logger.info(`Attempt of rolling back '${step}' from '${this}'.`)
-    const handler = this.system.getHandler(step.handler)
+    const handler = this.system.handler
     await handler.rollback(this, this.state)
     const current = await this.getCurrentStep()
     current.action = { rollback: true }

package/src/process/ProcessHandler.ts

@@ -95,10 +95,3 @@ export class ProcessHandler {
     throw new NotImplemented(`A handler '${this.name}' does not implement rollback()`)
   }
 }
-
-/**
- * A collection of process handlers.
- */
-export type ProcessHandlerMap = {
-  [key: string]: ProcessHandler
-}