@0xtorch/csv 0.0.14 → 0.0.16

package/parseCsvRowToAction/amount.ts

@@ -1,66 +0,0 @@
-import {
-  type BigDecimal,
-  absoluteValue,
-  divide,
-  minus,
-  plus,
-  times,
-} from '@0xtorch/big-decimal'
-import type { z } from 'zod'
-import type { amountComponentSchema } from '../schemas/parser'
-import type { FormattedRow } from '../types'
-
-type CreateAmountByComponentParameters = {
-  readonly row: FormattedRow
-  readonly component: z.infer<typeof amountComponentSchema>
-}
-
-export const createAmountByComponent = ({
-  row,
-  component,
-}: CreateAmountByComponentParameters): BigDecimal => {
-  if (typeof component === 'string') {
-    return getColumnAbsAmount(row, component)
-  }
-
-  switch (component.type) {
-    case 'plus': {
-      let amount = getColumnAbsAmount(row, component.columns[0])
-      for (const column of component.columns.slice(1)) {
-        amount = plus(amount, getColumnAbsAmount(row, column))
-      }
-      return amount
-    }
-    case 'minus': {
-      let amount = getColumnAbsAmount(row, component.columns[0])
-      for (const column of component.columns.slice(1)) {
-        amount = minus(amount, getColumnAbsAmount(row, column))
-      }
-      return amount
-    }
-    case 'times': {
-      let amount = getColumnAbsAmount(row, component.columns[0])
-      for (const column of component.columns.slice(1)) {
-        amount = times(amount, getColumnAbsAmount(row, column), 18)
-      }
-      return amount
-    }
-    case 'divide': {
-      let amount = getColumnAbsAmount(row, component.columns[0])
-      for (const column of component.columns.slice(1)) {
-        amount = divide(amount, getColumnAbsAmount(row, column), 18)
-      }
-      return amount
-    }
-  }
-}
-
-const getColumnAbsAmount = (row: FormattedRow, column: string): BigDecimal => {
-  const amount = row[column]
-  if (typeof amount !== 'object') {
-    throw new TypeError(
-      `amount needs to be BigDecimal but got ${typeof amount}`,
-    )
-  }
-  return absoluteValue(amount)
-}

package/parseCsvRowToAction/asset.ts

@@ -1,93 +0,0 @@
-import type { CryptoCurrency, FiatCurrency, Nft } from '@0xtorch/core'
-import type { z } from 'zod'
-import type { assetComponentSchema } from '../schemas/parser'
-import type { FormattedRow } from '../types'
-import { createNftByNftComponent } from './nft'
-
-type CreateAssetByComponentParameters = {
-  readonly row: FormattedRow
-  readonly service: string
-  readonly symbolAssetMap: { [symbol: string]: string } | undefined
-  readonly component: z.infer<typeof assetComponentSchema>
-  readonly cryptoCurrencies: readonly CryptoCurrency[]
-  readonly fiatCurrencies: readonly FiatCurrency[]
-}
-
-export const createAssetByComponent = ({
-  row,
-  service,
-  symbolAssetMap,
-  component,
-  cryptoCurrencies,
-  fiatCurrencies,
-}: CreateAssetByComponentParameters): CryptoCurrency | FiatCurrency | Nft => {
-  switch (component.type) {
-    case 'custom': {
-      switch (component.assetType) {
-        case 'CryptoCurrency': {
-          const asset = cryptoCurrencies.find(
-            (cryptoCurrency) => cryptoCurrency.id === component.assetId,
-          )
-          if (asset === undefined) {
-            throw new Error(`asset not found: ${component.assetId}`)
-          }
-          return asset
-        }
-        case 'FiatCurrency': {
-          const asset = fiatCurrencies.find(
-            (fiatCurrency) => fiatCurrency.id === component.assetId,
-          )
-          if (asset === undefined) {
-            throw new Error(`asset not found: ${component.assetId}`)
-          }
-          return asset
-        }
-        case 'Nft': {
-          return {
-            type: 'Nft',
-            id: component.assetId,
-            updatedAt: 0,
-          }
-        }
-      }
-      throw new Error('Not reachable')
-    }
-    case 'column': {
-      const symbol = row[component.column]
-      if (typeof symbol !== 'string') {
-        throw new TypeError(
-          `symbol needs to be string but got ${typeof symbol}`,
-        )
-      }
-      if (symbolAssetMap !== undefined && symbol in symbolAssetMap) {
-        const assetId = symbolAssetMap[symbol]
-        const asset = cryptoCurrencies.find(
-          (cryptoCurrency) => cryptoCurrency.id === assetId,
-        )
-        if (asset !== undefined) {
-          return asset
-        }
-        throw new Error(`asset not found: ${assetId}`)
-      }
-
-      const upperSymbol = symbol.toUpperCase()
-      const fiat = fiatCurrencies.find(
-        (fiatCurrency) => fiatCurrency.symbol.toUpperCase() === upperSymbol,
-      )
-      if (fiat !== undefined) {
-        return fiat
-      }
-
-      const crypto = cryptoCurrencies.find(
-        (cryptoCurrency) => cryptoCurrency.symbol.toUpperCase() === upperSymbol,
-      )
-      if (crypto !== undefined) {
-        return crypto
-      }
-      throw new Error(`asset not found: ${symbol}`)
-    }
-    case 'nft': {
-      return createNftByNftComponent({ row, service, component })
-    }
-  }
-}

package/parseCsvRowToAction/condition.ts

@@ -1,39 +0,0 @@
-import type { z } from 'zod'
-import type { conditionComponentSchema } from '../schemas/parser'
-import type { FormattedRow } from '../types'
-
-type MatchConditionParameters = {
-  readonly row: FormattedRow
-  readonly component: z.infer<typeof conditionComponentSchema>
-}
-
-export const matchCondition = ({
-  row,
-  component,
-}: MatchConditionParameters): boolean => {
-  const { column, pattern } = component
-  const value = row[column]
-  if (typeof pattern === 'string' || typeof pattern === 'number') {
-    return value === pattern
-  }
-  switch (pattern.type) {
-    case 'defined': {
-      return value !== undefined
-    }
-    case 'undefined': {
-      return value === undefined
-    }
-    case 'in': {
-      if (value === undefined || typeof value === 'object') {
-        return false
-      }
-      return pattern.values.includes(value)
-    }
-    case 'not-in': {
-      if (value === undefined || typeof value === 'object') {
-        return false
-      }
-      return !pattern.values.includes(value)
-    }
-  }
-}

package/parseCsvRowToAction/index.ts

@@ -1 +0,0 @@
-export { parseCsvRowToAction } from './parseCsvRowToAction'

package/parseCsvRowToAction/nft.ts

@@ -1,28 +0,0 @@
-import type { Nft } from '@0xtorch/core'
-import type { z } from 'zod'
-import type { nftComponentSchema } from '../schemas/parser'
-import type { FormattedRow } from '../types'
-import { createTextByComponent } from './text'
-
-type CreateNftByNftComponentParameters = {
-  readonly row: FormattedRow
-  readonly service: string
-  readonly component: z.infer<typeof nftComponentSchema>
-}
-
-export const createNftByNftComponent = ({
-  row,
-  service,
-  component,
-}: CreateNftByNftComponentParameters): Nft => {
-  const id = component.id
-    .map((idComponent) =>
-      createTextByComponent({ row, service, component: idComponent }),
-    )
-    .join('')
-  return {
-    type: 'Nft',
-    id,
-    updatedAt: 0,
-  }
-}

package/parseCsvRowToAction/parseCsvRowToAction.ts

@@ -1,128 +0,0 @@
-import type { Action, CryptoCurrency, FiatCurrency } from '@0xtorch/core'
-import type { FormattedRow, Parser } from '../types'
-import { matchCondition } from './condition'
-import { createNftByNftComponent } from './nft'
-import { createTextByComponent } from './text'
-import { createTimestampByRow } from './timestamp'
-import { createTransferByComponent } from './transfer'
-
-type ParseCsvRowToActionParameters = {
-  readonly row: FormattedRow
-  readonly service: string
-  readonly parsers: readonly Parser[]
-  readonly symbolAssetMap: { [symbol: string]: string } | undefined
-  readonly accountId: string
-  readonly cryptoCurrencies: readonly CryptoCurrency[]
-  readonly fiatCurrencies: readonly FiatCurrency[]
-}
-
-export const parseCsvRowToAction = ({
-  row,
-  service,
-  parsers,
-  symbolAssetMap,
-  accountId,
-  cryptoCurrencies,
-  fiatCurrencies,
-}: ParseCsvRowToActionParameters): Action | undefined => {
-  for (const parser of parsers) {
-    try {
-      const action = parseCsvRowToActionByParser({
-        row,
-        service,
-        parser,
-        symbolAssetMap,
-        accountId,
-        cryptoCurrencies,
-        fiatCurrencies,
-      })
-      if (action !== undefined) {
-        return action
-      }
-    } catch (error) {
-      // TODO 意図しないエラーは別途記録できるようにしたい
-      console.debug(error)
-    }
-  }
-  return undefined
-}
-
-type ParseCsvRowToActionByParserParameters = {
-  readonly row: FormattedRow
-  readonly service: string
-  readonly parser: Parser
-  readonly symbolAssetMap: { [symbol: string]: string } | undefined
-  readonly accountId: string
-  readonly cryptoCurrencies: readonly CryptoCurrency[]
-  readonly fiatCurrencies: readonly FiatCurrency[]
-}
-
-const parseCsvRowToActionByParser = ({
-  row,
-  service,
-  parser,
-  symbolAssetMap,
-  accountId,
-  cryptoCurrencies,
-  fiatCurrencies,
-}: ParseCsvRowToActionByParserParameters): Action | undefined => {
-  // 合致しない condition がある場合は undefined を返す
-  for (const condition of parser.conditions) {
-    if (!matchCondition({ row, component: condition })) {
-      return undefined
-    }
-  }
-
-  return {
-    source: parser.source
-      .map((component) => createTextByComponent({ row, service, component }))
-      .join(''),
-    order: 0,
-    type: parser.action,
-    evidence: 'system-rule',
-    timestamp: createTimestampByRow({ row, column: parser.timestamp }),
-    comment:
-      parser.comment === undefined
-        ? undefined
-        : parser.comment
-            .map((component) =>
-              createTextByComponent({ row, service, component }),
-            )
-            .join(''),
-    app: undefined,
-    transfers: parser.transfers
-      .map((component) =>
-        createTransferByComponent({
-          row,
-          service,
-          symbolAssetMap,
-          component,
-          accountId,
-          cryptoCurrencies,
-          fiatCurrencies,
-        }),
-      )
-      .filter(({ amount }) => amount.value > 0n),
-    crossId:
-      parser.crossId === undefined
-        ? undefined
-        : parser.crossId
-            .map((component) =>
-              createTextByComponent({ row, service, component }),
-            )
-            .join(''),
-    crossType: parser.crossType,
-    loanId:
-      parser.loanId === undefined
-        ? undefined
-        : parser.loanId
-            .map((component) =>
-              createTextByComponent({ row, service, component }),
-            )
-            .join(''),
-    target:
-      parser.target === undefined
-        ? undefined
-        : createNftByNftComponent({ row, service, component: parser.target }),
-  }
-}

package/parseCsvRowToAction/text.ts

@@ -1,38 +0,0 @@
-import { toStringBigDecimal } from '@0xtorch/big-decimal'
-import type { z } from 'zod'
-import type { textComponentSchema } from '../schemas/parser'
-import type { FormattedRow } from '../types'
-
-type CreateTextByComponentParameters = {
-  readonly row: FormattedRow
-  readonly service: string
-  readonly component: z.infer<typeof textComponentSchema>
-}
-
-export const createTextByComponent = ({
-  row,
-  service,
-  component,
-}: CreateTextByComponentParameters): string => {
-  if (typeof component === 'string') {
-    return component
-  }
-  switch (component.type) {
-    case 'service': {
-      return service
-    }
-    case 'column': {
-      const value = row[component.column]
-      if (value === undefined) {
-        return ''
-      }
-      if (typeof value === 'string') {
-        return value
-      }
-      if (typeof value === 'number') {
-        return value.toString()
-      }
-      return toStringBigDecimal(value)
-    }
-  }
-}

package/parseCsvRowToAction/timestamp.ts

@@ -1,19 +0,0 @@
-import type { FormattedRow } from '../types'
-
-type CreateTimestampByRowParameters = {
-  readonly row: FormattedRow
-  readonly column: string
-}
-
-export const createTimestampByRow = ({
-  row,
-  column,
-}: CreateTimestampByRowParameters): number => {
-  const timestamp = row[column]
-  if (typeof timestamp !== 'number') {
-    throw new TypeError(
-      `timestamp needs to be number but got ${typeof timestamp}`,
-    )
-  }
-  return timestamp
-}

package/parseCsvRowToAction/transfer.ts

@@ -1,48 +0,0 @@
-import type { CryptoCurrency, FiatCurrency, Transfer } from '@0xtorch/core'
-import type { z } from 'zod'
-import type { transferComponentSchema } from '../schemas/parser'
-import type { FormattedRow } from '../types'
-import { createAmountByComponent } from './amount'
-import { createAssetByComponent } from './asset'
-
-type CreateTransferByComponentParameters = {
-  readonly row: FormattedRow
-  readonly service: string
-  readonly symbolAssetMap: { [symbol: string]: string } | undefined
-  readonly component: z.infer<typeof transferComponentSchema>
-  readonly accountId: string
-  readonly cryptoCurrencies: readonly CryptoCurrency[]
-  readonly fiatCurrencies: readonly FiatCurrency[]
-}
-
-export const createTransferByComponent = ({
-  row,
-  service,
-  symbolAssetMap,
-  component,
-  accountId,
-  cryptoCurrencies,
-  fiatCurrencies,
-}: CreateTransferByComponentParameters): Transfer => {
-  const {
-    direction,
-    asset: assetComponent,
-    amount: amountComponent,
-  } = component
-
-  return {
-    from: direction === 'in' ? undefined : accountId,
-    to: direction === 'in' ? accountId : undefined,
-    asset: createAssetByComponent({
-      row,
-      service,
-      symbolAssetMap,
-      component: assetComponent,
-      cryptoCurrencies,
-      fiatCurrencies,
-    }),
-    amount: createAmountByComponent({ row, component: amountComponent }),
-    price: undefined,
-    direction,
-  }
-}

package/parseCsvRowsToActions.ts

@@ -1,54 +0,0 @@
-import type { Action, CryptoCurrency, FiatCurrency } from '@0xtorch/core'
-import { parseCsvRowToAction } from './parseCsvRowToAction'
-import type { FormattedRow, Parser } from './types'
-
-type ParseCsvRowsToActionsParameters = {
-  readonly rows: readonly FormattedRow[]
-  readonly service: string
-  readonly parsers: readonly Parser[]
-  readonly symbolAssetMap: { [symbol: string]: string } | undefined
-  readonly accountId: string
-  readonly cryptoCurrencies: readonly CryptoCurrency[]
-  readonly fiatCurrencies: readonly FiatCurrency[]
-}
-
-export const parseCsvRowsToActions = ({
-  rows,
-  service,
-  parsers,
-  symbolAssetMap,
-  accountId,
-  cryptoCurrencies,
-  fiatCurrencies,
-}: ParseCsvRowsToActionsParameters): readonly Action[] => {
-  // marketCap で降順 sort
-  const sortedCryptoCurrencies = cryptoCurrencies.toSorted(
-    (a, b) => (b.market?.marketCapUsd ?? -1) - (a.market?.marketCapUsd ?? -1),
-  )
-  const actions = rows.flatMap((row) => {
-    const action = parseCsvRowToAction({
-      row,
-      service,
-      parsers,
-      symbolAssetMap,
-      accountId,
-      cryptoCurrencies: sortedCryptoCurrencies,
-      fiatCurrencies,
-    })
-    if (action === undefined) {
-      // TODO action が生成できなかった行を記録したい
-      return []
-    }
-    return action
-  })
-  const mut_sources: string[] = []
-  const mut_actions: Action[] = []
-  for (const action of actions) {
-    mut_actions.push({
-      ...action,
-      order: mut_sources.filter((source) => source === action.source).length,
-    })
-    mut_sources.push(action.source)
-  }
-  return mut_actions
-}