@tasenor/common-node 1.9.16

package/src/net/vault.ts

@@ -0,0 +1,161 @@
+import { Secret } from '@dataplug/tasenor-common'
+import { randomString } from './crypto'
+
+export const ALLOWED_VAULT_VARIABLES = [
+  'TASENOR_API_URL',
+  'API_SITE_TOKEN',
+  'DATABASE_ROOT_PASSWORD',
+  'DATABASE_ROOT_USER',
+  'DATABASE_URL',
+  'SECRET',
+  'TASENOR_SITE_TOKEN'
+]
+const validVariables = new Set(ALLOWED_VAULT_VARIABLES)
+
+export type VaultVariable = typeof ALLOWED_VAULT_VARIABLES[number]
+export type VaultValue = string
+
+/**
+ * Base class for a secret vault implementations.
+ */
+export class Vault {
+  url: string
+  values: { [key: string]: VaultValue }
+  initialized: boolean
+  secret: Secret | null
+
+  constructor(url: string) {
+    this.url = url
+    this.values = {}
+    this.initialized = false
+    this.secret = null
+  }
+
+  /**
+   * Retrieve all secret values.
+   */
+  async initialize(): Promise<void> {
+    throw new Error(`A class ${this.constructor.name} does not implement initialize().`)
+  }
+
+  /**
+   * Get a secret value.
+   * @param variable
+   * @returns
+   */
+  get(variable: VaultVariable, def: undefined | VaultValue = undefined): VaultValue {
+    if (!validVariables.has(variable)) throw new Error(`A variable ${variable} is not valid vault value.`)
+    if (!(variable in this.values)) {
+      if (def !== undefined) {
+        return def
+      }
+      throw new Error(`Cannot find variable ${variable} from the vault.`)
+    }
+    return this.values[variable]
+  }
+
+  /**
+   * Get the internally generated secret and generate new if none yet generated.
+   */
+  getPrivateSecret() {
+    if (this.secret === null) {
+      this.secret = randomString(512) as Secret
+    }
+    return this.secret
+  }
+
+  /**
+   * Set the internal secret (use only in developement).
+   */
+  setPrivateSecret(secret: Secret): void {
+    this.secret = secret
+  }
+}
+
+/**
+ * A secret vault using environment variables only.
+ */
+export class EnvironmentVault extends Vault {
+
+  async initialize(): Promise<void> {
+    for (const variable of ALLOWED_VAULT_VARIABLES) {
+      const value = process.env[variable]
+      if (value !== undefined) {
+        this.values[variable] = value
+      }
+    }
+  }
+}
+
+/**
+ * Instantiate and return the current vault based on the environment VAULT_URL.
+ */
+let currentVault: Vault | undefined
+export function getVault(): Vault {
+  if (currentVault && currentVault.url === process.env.VAULT_URL) return currentVault
+  if (!process.env.VAULT_URL) {
+    throw new Error('No VAULT_URL set and cannot instantiate the vault.')
+  }
+  const url = new URL(process.env.VAULT_URL)
+  switch (url.protocol) {
+    case 'env:':
+      currentVault = new EnvironmentVault(process.env.VAULT_URL)
+      break
+    default:
+      throw new Error(`Cannot recognize protocol ${url.protocol} of vault URL ${process.env.VAULT_URL}`)
+  }
+  return currentVault
+}
+
+/**
+ * Retrieve a value from the vault.
+ * @param variable
+ * @returns
+ */
+function get(variable: VaultVariable, def: undefined | VaultValue = undefined): VaultValue {
+  const vault = getVault()
+  if (!vault.initialized) {
+    throw new Error('Cannot use the vault before it is initialized.')
+  }
+  const value = vault.get(variable, def)
+  if (value === undefined) {
+    throw new Error(`Cannot find value ${variable} from the vault.`)
+  }
+  return value
+}
+
+/**
+ * Get the internally generated secret and generate new if none yet generated.
+ */
+function getPrivateSecret(): Secret {
+  const vault = getVault()
+  if (!vault.initialized) {
+    throw new Error('Cannot use the vault before it is initialized.')
+  }
+  return vault.getPrivateSecret()
+}
+
+/**
+ * Set the internal secret.
+ */
+function setPrivateSecret(secret: Secret): void {
+  const vault = getVault()
+  vault.setPrivateSecret(secret)
+}
+
+/**
+ * Set up the vault.
+ */
+async function initialize(): Promise<void> {
+  const vault = getVault()
+  vault.initialized = true
+  await vault.initialize()
+}
+
+export const vault = {
+  get,
+  getPrivateSecret,
+  getVault,
+  initialize,
+  setPrivateSecret
+}

package/src/plugins/BackendPlugin.ts

@@ -0,0 +1,188 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { TasenorElement, BackendCatalog, Constructor, DirectoryPath, FilePath, Language, PluginCode, PluginType, PluginUse, Version, ID, getServerRoot } from '@dataplug/tasenor-common'
+import * as path from 'path'
+import * as fs from 'fs'
+import { KnexDatabase } from '..'
+
+/**
+ * Baseclass for all plugins for back-end.
+ */
+export class BackendPlugin {
+
+  public id: ID
+  public code: PluginCode
+  public title: string
+  public version: Version | null
+  public releaseDate: Date | string | null
+  public use: PluginUse | 'unknown'
+  public type: PluginType | 'unknown'
+  public icon: string
+  public description: string
+  public path: string
+  public languages: Record<string, Record<string, string>>
+  private catalog?: BackendCatalog
+
+  constructor() {
+    this.id = null
+    this.code = '' as PluginCode
+    this.title = ''
+    this.version = null
+    this.releaseDate = null
+    this.use = 'unknown'
+    this.type = 'unknown'
+    this.icon = ''
+    this.description = ''
+    this.path = ''
+
+    // Plugin translations from language code to the translation dictionary.
+    this.languages = {
+    }
+  }
+
+  /**
+   * Hook to be executed once during installing.
+   */
+  async install(): Promise<void> {
+    // Do nothing by default.
+  }
+
+  /**
+   * Hook to be executed one during uninstalling.
+   */
+  async uninstall(): Promise<void> {
+    // Do nothing by default.
+  }
+
+  /**
+   * Hook to register hooks when launching backend.
+   */
+  load(catalog: BackendCatalog) {
+    // Do nothing by default.
+  }
+
+  /**
+   * Hook to be executed once for every database during installing.
+   * @param db Knex instance of the database.
+   */
+  async installToDb(db: KnexDatabase): Promise<void> {
+    // Do nothing by default.
+  }
+
+  /**
+   * Hook to be executed once for every database during uninstalling.
+   * @param db Knex instance of the database.
+   */
+  async uninstallFromDb(db: KnexDatabase): Promise<void> {
+    // Do nothing by default.
+  }
+
+  /**
+   * Get the full path to the directory of this plugin.
+   * @returns The path.
+   */
+  get fullPath(): DirectoryPath {
+    return this.path as DirectoryPath
+  }
+
+  /**
+   * Construct the full path to the file of this module.
+   * @param name
+   * @returns The path.
+   */
+  filePath(name: string): FilePath {
+    return `${this.fullPath}/backend/${name}` as FilePath
+  }
+
+  /**
+   * Collect meta data as a JSON object.
+   * @returns Object
+   */
+  toJSON(): Record<string, unknown> {
+    return {
+      id: this.id,
+      code: this.code,
+      title: this.title,
+      description: this.description,
+      icon: this.icon,
+      version: this.version,
+      releaseDate: this.releaseDate,
+      use: this.use,
+      type: this.type,
+      path: this.path
+    }
+  }
+
+  /**
+   * Get the UI setting description or null if the plugin has no settings.
+   */
+  getSettings(): TasenorElement | null {
+    return null
+  }
+
+  /**
+   * Do the translation for a string.
+   */
+  t(str: string, lang: Language): string {
+    if (this.catalog) {
+      return this.catalog.t(str, lang)
+    }
+    // Mainly useful for plugin testing: translate using local plugin translations if no catalog available.
+    if ((lang in this.languages) && (str in this.languages[lang])) {
+      return this.languages[lang][str]
+    }
+    return str
+  }
+
+  /**
+   * Get the settings variable values for this plugin.
+   * @param db
+   * @param name
+   */
+  async getSetting(db: KnexDatabase, name: string) {
+    const setting = await db('settings').select('value').where({ name: `${this.code}.${name}` }).first()
+    return setting ? setting.value : undefined
+  }
+
+  /**
+   * A scheduled function that is ran once an hour. The hour number is in server time.
+   */
+  async hourly(hour: number) {
+    // Do nothing by default.
+  }
+
+  /**
+   * A scheduled function that is ran once a day during night time on server time.
+   */
+  async nightly(db: KnexDatabase) {
+    // Do nothing by default.
+  }
+
+  /**
+   * Ensure private working directory for this plugin and reserved for the given database.
+   */
+  getWorkSpace(db: KnexDatabase): DirectoryPath {
+    const workdir = path.join(getServerRoot(), 'src', 'plugins', 'workspace', this.code, db.client.config.connection.database)
+
+    if (!fs.existsSync(workdir)) {
+      fs.mkdirSync(workdir, { recursive: true })
+    }
+
+    fs.chmodSync(workdir, 0o700)
+
+    return workdir as DirectoryPath
+  }
+
+  /**
+   * Create an instance of a plugin class and copy static fields into the instance.
+   * @param Class
+   * @param path
+   * @returns
+   */
+  static create(Class: Constructor<BackendPlugin>, id: ID, path: FilePath, catalog: BackendCatalog): BackendPlugin {
+    const instance = new Class()
+    instance.id = id
+    instance.path = path
+    instance.catalog = catalog
+    return instance
+  }
+}

package/src/plugins/DataPlugin.ts

@@ -0,0 +1,29 @@
+import fs from 'fs'
+import { BackendPlugin } from './BackendPlugin'
+
+/**
+ * A plugin providing mainly some kind of possibly frequently updated data source services.
+ * Data will be publicly available from API.
+ */
+export class DataPlugin extends BackendPlugin {
+
+  protected sources: string[]
+
+  constructor(...sources: string[]) {
+    super()
+    this.sources = sources
+  }
+
+  /**
+   * Provide the public knowledge this plugin is providing.
+   */
+  async getKnowledge(): Promise<Record<string, unknown>> {
+    const result = {}
+    for (const source of this.sources) {
+      const filePath = this.filePath(`${source}.json`)
+      const data = JSON.parse(fs.readFileSync(filePath).toString('utf-8'))
+      Object.assign(result, { [source]: data })
+    }
+    return result
+  }
+}

package/src/plugins/ImportPlugin.ts

@@ -0,0 +1,211 @@
+import { log } from '@dataplug/tasenor-common'
+import fs from 'fs'
+import { TransactionImportHandler } from '../import/TransactionImportHandler'
+import { TransactionUI } from '../import/TransactionUI'
+import { BackendPlugin } from './BackendPlugin'
+
+/**
+ * A plugin providing import services for one or more file formats.
+ */
+export class ImportPlugin extends BackendPlugin {
+
+  private handler: TransactionImportHandler
+  private UI: TransactionUI
+
+  constructor(handler: TransactionImportHandler) {
+    super()
+    this.handler = handler
+    this.UI = handler.UI
+    // This class is used as its own for translations. Let us initialize it.
+    this.languages = this.getLanguages()
+  }
+
+  /**
+   * Get common translations for all import plugins.
+   * @returns
+   */
+  getLanguages() {
+    return {
+      en: {
+        'account-debt-currency': 'Account for recording debt in {asset} currency',
+        'account-deposit-currency': 'Account for depositing {asset} currency',
+        'account-deposit-external': 'Account for external deposit source for {asset}',
+        'account-distribution-currency': 'Account to pay our {asset} dividends from',
+        'account-distribution-statement': 'Account to record our dividend payments for {asset}',
+        'account-dividend-currency': 'Account for recording received {asset} dividends',
+        'account-expense-currency': 'Account for expenses in {asset} currency',
+        'account-expense-statement': 'Account for recording expense {asset}',
+        'account-fee-currency': 'Account for fees in {asset} currency',
+        'account-fee-crypto': 'Account for fees in {asset} crypto currency',
+        'account-forex-currency': 'Account for {asset} foreign exchange',
+        'account-income-currency': 'Account for income in {asset} currency',
+        'account-income-statement': 'Account for recording income {asset}',
+        'account-investment-currency': 'Account for receiving investments in {asset} currency',
+        'account-investment-statement': 'Account for recording investment {asset}',
+        'account-tax-currency': 'Account for recording tax in currency {asset}',
+        'account-tax-statement': 'Account for tax statament {asset}',
+        'account-trade-crypto': 'Account for trading crypto currency {asset}',
+        'account-trade-stock': 'Account for trading stocks {asset}',
+        'account-trade-currency': 'Account for using currency {asset} for trading',
+        'account-transfer-currency': 'Account for transferring currency {asset}',
+        'account-transfer-external': 'Account for transferring to/from external source {asset}',
+        'account-withdrawal-currency': 'Account for withdrawing currency {asset}',
+        'account-withdrawal-external': 'Account for withdrawing from external source {asset}',
+        'asset-type-crypto': 'a crypto currency',
+        'asset-type-currency': 'a currency',
+        'asset-type-external': 'an external instance',
+        'asset-type-statement': 'a statement recording',
+        'asset-type-stock': 'a stock exchange traded asset',
+        'asset-type-short': 'a short position',
+        'import-text-buy': 'Buy {takeAmount} {takeAsset}',
+        'import-text-correction': '{name}',
+        'import-text-deposit': 'Deposit to {exchange} service',
+        'import-text-distribution': '{name}',
+        'import-text-dividend': 'Dividend {asset}',
+        'import-text-expense': '{name}',
+        'import-text-forex': 'Sell currency {giveAsset} for {takeAsset}',
+        'import-text-income': '{name}',
+        'import-text-investment': '{name}',
+        'import-text-sell': 'Sell {giveAmount} {giveAsset}',
+        'import-text-short-buy': 'Closing short position {takeAmount} {takeAsset}',
+        'import-text-short-sell': 'Short selling {giveAmount} {giveAsset}',
+        'import-text-tax': '{name}',
+        'import-text-trade': 'Trade {giveAmount} {giveAsset} {takeAmount} {takeAsset}',
+        'import-text-transfer': '{service} transfer',
+        'import-text-withdrawal': 'Withdrawal from {exchange} service',
+        'reason-deposit': 'deposit',
+        'reason-dividend': 'payment',
+        'reason-expense': 'expense',
+        'reason-fee': 'fee',
+        'reason-forex': 'exchange',
+        'reason-income': 'income',
+        'reason-trade': 'trading',
+        'reason-transfer': 'transfers',
+        'reason-withdrawal': 'withdrawal',
+        'note-split': 'Split',
+        'note-converted': 'Converted',
+        'note-spinoff': 'Spinoff',
+        'note-renamed': 'Renamed',
+        'note-old-name': 'Old name',
+        'note-new-name': 'New name',
+        'note-renaming': 'Renaming'
+      },
+      fi: {
+        'account-debt-currency': 'Tili veloille valuutassa {asset}',
+        'account-deposit-currency': 'Tili valuutan {asset} talletuksille',
+        'account-deposit-external': 'Vastatili ulkoisille talletuksille {asset}',
+        'account-distribution-currency': 'Tili, josta maksetaan {asset} osingot',
+        'account-distribution-statement': 'Raportointitili, johon kirjataan maksettavat osingot {asset}',
+        'account-dividend-currency': 'Tili saaduista {asset} osingoista',
+        'account-expense-currency': 'Tili kuluille {asset} valuutassa',
+        'account-expense-statement': 'Raportointitili {asset} kuluille',
+        'account-fee-currency': 'Tili käyttömaksuille {asset} valuutassa',
+        'account-fee-crypto': 'Tili käyttömaksuille {asset} kryptovaluutassa',
+        'account-forex-currency': 'Valuutanvaihtotili {asset} valuutalle',
+        'account-income-currency': 'Tili tuloille {asset} valuutassa',
+        'account-income-statement': 'Raportointitili {asset} tuloille',
+        'account-investment-currency': 'Tili saaduille sijoituksille {asset} valuutassa',
+        'account-investment-statement': 'Raportointitili sijoituksille {asset}',
+        'account-tax-currency': 'Verot {asset} valuutassa',
+        'account-tax-statement': 'Raportointitili veroille {asset}',
+        'account-trade-crypto': 'Vaihto-omaisuustili {asset} kryptovaluutalle',
+        'account-trade-stock': 'Vaihto-omaisuustili {asset} osakkeelle',
+        'account-trade-currency': 'Valuuttatili {asset} valuutalle vaihto-omaisuuden hankintaan',
+        'account-transfer-currency': 'Siirtotili {asset} valuutalle',
+        'account-transfer-external': 'Siirtotili ulkoiseen kohteeseen {asset}',
+        'account-withdrawal-currency': 'Nostotili {asset} valuutalle',
+        'account-withdrawal-external': 'Vastatili {asset} nostoille',
+        'asset-type-crypto': 'kryptovaluutta',
+        'asset-type-currency': 'valuutta',
+        'asset-type-external': 'ulkopuolinen instanssi',
+        'asset-type-statement': 'raportointi',
+        'asset-type-stock': 'osake tai vastaava',
+        'asset-type-short': 'lyhyeksi myyty positio',
+        'Do you want to import also currency deposits here?': 'Haluatko tuoda myös valuuttojen talletukset tänne?',
+        'Do you want to import also currency withdrawals here?': 'Haluatko tuoda myös valuuttojen nostot tänne?',
+        'import-text-buy': 'Osto {takeAmount} {takeAsset}',
+        'import-text-correction': '{name}',
+        'import-text-deposit': 'Talletus {exchange}-palveluun',
+        'import-text-distribution': '{name}',
+        'import-text-dividend': 'Osinko {asset}',
+        'import-text-expense': '{name}',
+        'import-text-forex': 'Valuutanvaihto',
+        'import-text-income': '{name}',
+        'import-text-investment': '{name}',
+        'import-text-sell': 'Myynti {giveAmount} {giveAsset}',
+        'import-text-short-buy': 'Suljettu lyhyeksimyynti {takeAmount} {takeAsset}',
+        'import-text-short-sell': 'Lyhyeksimyynti {giveAmount} {giveAsset}',
+        'import-text-tax': '{name}',
+        'import-text-trade': 'Vaihto {giveAmount} {giveAsset} {takeAmount} {takeAsset}',
+        'import-text-transfer': '{service} siirto',
+        'import-text-withdrawal': 'Nosto {exchange}-palvelusta',
+        'Parsing error in expression `{expr}`: {message}': 'Virhe laskukaavassa `{expr}`: {message}',
+        'reason-deposit': 'talletus',
+        'reason-dividend': 'maksu',
+        'reason-expense': 'meno',
+        'reason-fee': 'kulu',
+        'reason-forex': 'vaihto',
+        'reason-income': 'tulo',
+        'reason-trade': 'vaihdanta',
+        'reason-transfer': 'siirto',
+        'reason-withdrawal': 'nosto',
+        'Retried successfully': 'Uudelleenyritys onnistui',
+        'Retry failed': 'Uudelleenyritys ei onnistunut',
+        'Select one of the following:': 'Valitse yksi seuraavista:',
+        'Additional information needed': 'Tarvitaan lisätietoja',
+        'Based on the following imported lines': 'Seuraavien tuotujen rivien perusteella',
+        'Do you want to use the same account for all of them?': 'Haluatko käyttää samaa tiliä kaikille samanlaisille?',
+        Created: 'Luotuja',
+        Duplicates: 'Aiemmin luotuja',
+        Ignored: 'Väliinjätettyjä',
+        Skipped: 'Ohitettuja',
+        'Account Changes': 'Tilien muutokset',
+        'Process Was Successfully Completed!': 'Prosessointi saatu päätökseen onnistuneesti!',
+        'Do we allow short selling of assets?': 'Sallitaanko lyhyeksi myynti?',
+        January: 'tammikuu',
+        February: 'helmikuu',
+        March: 'maaliskuu',
+        April: 'huhtikuu',
+        May: 'toukokuu',
+        June: 'kesäkuu',
+        July: 'heinäkuu',
+        August: 'elokuu',
+        September: 'syyskuu',
+        October: 'lokakuu',
+        November: 'marraskuu',
+        December: 'joulukuu',
+        'note-split': 'splitti',
+        'note-converted': 'konvertoitu',
+        'note-spinoff': 'irtautuminen',
+        'note-renamed': 'uudelleennimeäminen',
+        'note-old-name': 'vanha nimi',
+        'note-new-name': 'uusi nimi',
+        'The account below has negative balance. If you want to record it to the separate debt account, please select another account below:': 'Tilillä {account} on negatiivinen saldo. Jos haluat kirjata negatiiviset saldot erilliselle velkatilille, valitse tili seuraavasta:',
+        'The date {date} falls outside of the period {firstDate} to {lastDate}.': 'Päivämäärä {date} on tilikauden {firstDate} - {lastDate} ulkopuolella.',
+        'What do we do with that kind of transactions?': 'Mitä tämänkaltaisille tapahtumille tulisi tehdä?',
+        'Ignore transaction': 'Jättää väliin',
+        'Halt with an error': 'Keskeyttää tuonti virheeseen',
+        'Is transaction fee of type {type} already included in the {reason} total?': 'Onko {reason}-tapahtumassa tyypin {type} kulut lisätty valmiiksi yhteissummaan?',
+        'Select contra account for imported transactions, i.e. cash account.': 'Valitse vastatili tuotaville tapahtumille (esim. kohteen käteistili).'
+      }
+    }
+  }
+
+  /**
+   * Get instance of internal handler class.
+   * @returns
+   */
+  getHandler(): TransactionImportHandler {
+    return this.handler
+  }
+
+  /**
+   * Load and return default rules from the JSON-rules file.
+   * @returns
+   */
+  getRules(): JSON {
+    const path = this.filePath('rules.json')
+    log(`Reading rules ${path}.`)
+    return JSON.parse(fs.readFileSync(path).toString('utf-8')).rules
+  }
+}