@0xtorch/csv 0.0.1

package/_types/schemas/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../schemas/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM1B,CAAA"}

package/_types/types.d.ts

@@ -0,0 +1,13 @@
+import type { z } from 'zod';
+import type { csvFormatSchema } from './schemas';
+import type { formatterSchema } from './schemas/formatter';
+import type { formatterValueSchema } from './schemas/formatterTypes';
+import type { parserSchema } from './schemas/parser';
+export type CsvFormat = z.infer<typeof csvFormatSchema>;
+export type Formatter = z.infer<typeof formatterSchema>;
+export type FormatterValue = z.infer<typeof formatterValueSchema>;
+export type FormattedRow = {
+    [column: string]: FormatterValue;
+};
+export type Parser = z.infer<typeof parserSchema>;
+//# sourceMappingURL=types.d.ts.map

package/_types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAC5B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAC1D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAA;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAEpD,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEvD,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEvD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,MAAM,MAAM,YAAY,GAAG;IACzB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAAA;CACjC,CAAA;AAED,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}

package/formatCsvRows.ts

@@ -0,0 +1,97 @@
+import {
+  bigDecimalNegativeTextSchema,
+  bigDecimalPositiveTextSchema,
+  bigDecimalTextSchema,
+  blankTextSchema,
+  datetimeJpTextSchema,
+  iso8601TextSchema,
+  stringTextSchema,
+} from './schemas/formatterTypes'
+import type { FormattedRow, Formatter, FormatterValue } from './types'
+
+type RawRow = {
+  [column: string]: string
+}
+
+type FormatCsvRowsParameters = {
+  readonly rows: readonly RawRow[]
+  readonly formatter: Formatter
+}
+
+export const formatCsvRows = ({
+  rows,
+  formatter,
+}: FormatCsvRowsParameters): readonly FormattedRow[] =>
+  rows.map((row) => formatCsvRow(row, formatter))
+
+const formatCsvRow = (row: RawRow, formatter: Formatter): FormattedRow =>
+  Object.fromEntries(
+    Object.entries(formatter).map(
+      ([column, schemaTypes]): [string, FormatterValue] => {
+        // column に一致する column が無かったらエラー
+        if (!(column in row)) {
+          throw new Error(`The column '${column}' does not exist in the CSV`)
+        }
+        const value = row[column]
+        // schema types を順番に調査
+        for (const schemaType of schemaTypes) {
+          switch (schemaType) {
+            case 'blank': {
+              const parsed = blankTextSchema.safeParse(value)
+              if (!parsed.success) {
+                break
+              }
+              return [column, parsed.data]
+            }
+            case 'string': {
+              const parsed = stringTextSchema.safeParse(value)
+              if (!parsed.success) {
+                break
+              }
+              return [column, parsed.data]
+            }
+            case 'big-decimal': {
+              const parsed = bigDecimalTextSchema.safeParse(value)
+              if (!parsed.success) {
+                break
+              }
+              return [column, parsed.data]
+            }
+            case 'big-decimal-negative': {
+              const parsed = bigDecimalNegativeTextSchema.safeParse(value)
+              if (!parsed.success) {
+                break
+              }
+              return [column, parsed.data]
+            }
+            case 'big-decimal-positive': {
+              const parsed = bigDecimalPositiveTextSchema.safeParse(value)
+              if (!parsed.success) {
+                break
+              }
+              return [column, parsed.data]
+            }
+            case 'iso8601': {
+              const parsed = iso8601TextSchema.safeParse(value)
+              if (!parsed.success) {
+                break
+              }
+              return [column, parsed.data]
+            }
+            case 'datetime-jp': {
+              const parsed = datetimeJpTextSchema.safeParse(value)
+              if (!parsed.success) {
+                break
+              }
+              return [column, parsed.data]
+            }
+          }
+        }
+        // schema に一致したら値を返す
+        // 一致する schema type が無かったらエラー
+        throw new Error(
+          `The column "${column}"'s value "${value}" does not match schema: [${schemaTypes.join(',')}]`,
+        )
+      },
+    ),
+  )

package/index.ts

@@ -0,0 +1,5 @@
+export { parseCsvFileToAccountActions } from './parseCsvFileToAccountActions'
+export { parseCsvFileToText } from './parseCsvFileToText'
+export { parseCsvText } from './parseCsvText'
+export { csvFormatSchema } from './schemas'
+export type { CsvFormat } from './types'

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@0xtorch/csv",
+  "version": "0.0.1",
+  "description": "Cryptorch CSV extension",
+  "keywords": [
+    "cryptorch",
+    "csv"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:0xtorch/csv.git"
+  },
+  "license": "MIT",
+  "author": "0xnekoya <nekoya.bc@gmail.com>",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./_types/index.d.ts",
+      "import": "./_esm/index.js",
+      "default": "./_cjs/index.js"
+    }
+  },
+  "main": "./_cjs/index.js",
+  "module": "./_esm/index.js",
+  "types": "./_types/index.d.ts",
+  "typings": "./_types/index.d.ts",
+  "files": [
+    "*",
+    "!**/*.tsbuildinfo",
+    "!**/*.test.ts",
+    "!**/*.test.ts.snap",
+    "!**/*.test-d.ts",
+    "!**/*.bench.ts",
+    "!tsconfig.build.json"
+  ],
+  "dependencies": {
+    "@0xtorch/big-decimal": "^0.0.10",
+    "@0xtorch/core": "^0.0.18",
+    "encoding-japanese": "^2.1.0",
+    "papaparse": "^5.4.1",
+    "zod": "^3.22.4"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/encoding-japanese": "^2.0.5",
+    "@types/papaparse": "^5.3.14"
+  }
+}

package/parseCsvFileToAccountActions.ts

@@ -0,0 +1,40 @@
+import type { AccountAction, CryptoCurrency, FiatCurrency } from '@0xtorch/core'
+import { formatCsvRows } from './formatCsvRows'
+import { parseCsvFileToText } from './parseCsvFileToText'
+import { parseCsvRowsToAccountActions } from './parseCsvRowsToAccountActions'
+import { parseCsvText } from './parseCsvText'
+import type { CsvFormat } from './types'
+
+type ParseCsvFileToAccountActionsParameters = {
+  readonly file: File
+  readonly format: CsvFormat
+  readonly accountId: string
+  readonly cryptoCurrencies: readonly CryptoCurrency[]
+  readonly fiatCurrencies: readonly FiatCurrency[]
+}
+
+export const parseCsvFileToAccountActions = async ({
+  file,
+  format: { service, formatter, parsers, symbolAssetMap },
+  accountId,
+  cryptoCurrencies,
+  fiatCurrencies,
+}: ParseCsvFileToAccountActionsParameters): Promise<
+  readonly AccountAction[]
+> => {
+  const text = await parseCsvFileToText(file)
+  const rows = formatCsvRows({
+    rows: parseCsvText(text),
+    formatter,
+  })
+  const actions = parseCsvRowsToAccountActions({
+    rows,
+    service,
+    parsers,
+    symbolAssetMap,
+    accountId,
+    cryptoCurrencies,
+    fiatCurrencies,
+  })
+  return actions
+}

package/parseCsvFileToText.ts

@@ -0,0 +1,11 @@
+import { convert } from 'encoding-japanese'
+
+export const parseCsvFileToText = async (file: File): Promise<string> => {
+  const buffers = await file.arrayBuffer()
+  const codes = new Uint8Array(buffers)
+  const unicodeString = convert(codes, {
+    to: 'UNICODE',
+    type: 'string',
+  })
+  return unicodeString
+}

package/parseCsvRowToNormalAction/asset.ts

@@ -0,0 +1,92 @@
+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,
+          }
+        }
+      }
+      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/parseCsvRowToNormalAction/condition.ts

@@ -0,0 +1,39 @@
+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/parseCsvRowToNormalAction/index.ts

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

package/parseCsvRowToNormalAction/nft.ts

@@ -0,0 +1,27 @@
+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,
+  }
+}

package/parseCsvRowToNormalAction/parseCsvRowToNormalAction.ts

@@ -0,0 +1,146 @@
+import type {
+  BaseNormalAction,
+  CryptoCurrency,
+  FiatCurrency,
+  NormalAction,
+} from '@0xtorch/core'
+import { parseBaseNormalActionToNormalAction } 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 ParseCsvRowToNormalActionParameters = {
+  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[]
+}
+
+type ParseCsvRowToNormalActionReturnTypes =
+  | {
+      readonly action: NormalAction
+      readonly source: string
+    }
+  | undefined
+
+export const parseCsvRowToNormalAction = ({
+  row,
+  service,
+  parsers,
+  symbolAssetMap,
+  accountId,
+  cryptoCurrencies,
+  fiatCurrencies,
+}: ParseCsvRowToNormalActionParameters): ParseCsvRowToNormalActionReturnTypes => {
+  for (const parser of parsers) {
+    try {
+      const action = parseCsvRowToNormalActionByParser({
+        row,
+        service,
+        parser,
+        symbolAssetMap,
+        accountId,
+        cryptoCurrencies,
+        fiatCurrencies,
+      })
+      if (action !== undefined) {
+        return action
+      }
+    } catch (error) {
+      // TODO 意図しないエラーは別途記録できるようにしたい
+      console.debug(error)
+      continue
+    }
+  }
+  return undefined
+}
+
+type ParseCsvRowToNormalActionByParserParameters = {
+  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 parseCsvRowToNormalActionByParser = ({
+  row,
+  service,
+  parser,
+  symbolAssetMap,
+  accountId,
+  cryptoCurrencies,
+  fiatCurrencies,
+}: ParseCsvRowToNormalActionByParserParameters): ParseCsvRowToNormalActionReturnTypes => {
+  // 合致しない condition がある場合は undefined を返す
+  for (const condition of parser.conditions) {
+    if (!matchCondition({ row, component: condition })) {
+      return undefined
+    }
+  }
+
+  const baseAction: BaseNormalAction = {
+    action: 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,
+      }),
+    ),
+    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 }),
+  }
+
+  const action = parseBaseNormalActionToNormalAction(baseAction)
+  const source = parser.source
+    .map((component) => createTextByComponent({ row, service, component }))
+    .join('')
+
+  return {
+    action,
+    source,
+  }
+}

package/parseCsvRowToNormalAction/text.ts

@@ -0,0 +1,37 @@
+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 ''
+      } else if (typeof value === 'string') {
+        return value
+      } else if (typeof value === 'number') {
+        return value.toString()
+      } else {
+        return toStringBigDecimal(value)
+      }
+    }
+  }
+}

package/parseCsvRowToNormalAction/timestamp.ts

@@ -0,0 +1,19 @@
+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/parseCsvRowToNormalAction/transfer.ts

@@ -0,0 +1,55 @@
+import { absoluteValue } from '@0xtorch/big-decimal'
+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 { 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
+
+  const amount = row[amountComponent]
+  if (typeof amount !== 'object') {
+    throw new TypeError(
+      `amount needs to be BigDecimal but got ${typeof amount}`,
+    )
+  }
+
+  return {
+    from: direction === 'in' ? undefined : accountId,
+    to: direction === 'in' ? accountId : undefined,
+    asset: createAssetByComponent({
+      row,
+      service,
+      symbolAssetMap,
+      component: assetComponent,
+      cryptoCurrencies,
+      fiatCurrencies,
+    }),
+    amount: absoluteValue(amount),
+    price: undefined,
+    direction,
+  }
+}