@0xtorch/csv 0.0.14 → 0.0.16

package/parseRowsToActions/joinValue.ts

@@ -0,0 +1,68 @@
+import { stringify } from '@0xtorch/core'
+import type { z } from 'zod'
+import type { joinValueSchema } from '../schemas/parser'
+import type { FormattedRow } from '../types'
+import { getCellValue } from './cellValue'
+import { getMathValue } from './mathValue'
+import { getSliceValue } from './sliceValue'
+import { getSplitValue } from './splitValue'
+
+export const getJoinValue = ({
+  schema,
+  rows,
+  service,
+}: {
+  schema: z.infer<typeof joinValueSchema>
+  rows: readonly FormattedRow[]
+  service: string
+}) => {
+  return schema.values
+    .map((value) => stringify(getValue({ schema: value, rows, service })))
+    .join('')
+}
+
+const getValue = ({
+  schema,
+  rows,
+  service,
+}: {
+  schema: z.infer<typeof joinValueSchema>['values'][0]
+  rows: readonly FormattedRow[]
+  service: string
+}) => {
+  if (typeof schema === 'string') {
+    return schema
+  }
+  switch (schema.type) {
+    case 'cell': {
+      return getCellValue({
+        schema,
+        rows,
+      })
+    }
+    case 'math': {
+      return getMathValue({
+        schema,
+        rows,
+        service,
+      })
+    }
+    case 'service': {
+      return service
+    }
+    case 'slice': {
+      return getSliceValue({
+        schema,
+        rows,
+        service,
+      })
+    }
+    case 'split': {
+      return getSplitValue({
+        schema,
+        rows,
+        service,
+      })
+    }
+  }
+}

package/parseRowsToActions/key.ts

@@ -0,0 +1,13 @@
+import type { FormattedRow } from '../types'
+
+type CreateKeyValueParameters = {
+  row: FormattedRow
+  key: readonly string[]
+}
+
+export const createKeyValue = ({
+  row,
+  key,
+}: CreateKeyValueParameters): string => {
+  return key.map((k) => row[k]?.toString()).join('')
+}

package/parseRowsToActions/mathValue.ts

@@ -0,0 +1,160 @@
+import {
+  type BigDecimal,
+  createBigDecimal,
+  divide,
+  minus,
+  plus,
+  times,
+} from '@0xtorch/big-decimal'
+import type { z } from 'zod'
+import type { mathValueSchema } from '../schemas/parser'
+import type { FormattedRow } from '../types'
+import { getCellValue } from './cellValue'
+import { getSliceValue } from './sliceValue'
+import { getSplitValue } from './splitValue'
+
+export const getMathValue = ({
+  schema,
+  rows,
+  service,
+}: {
+  schema: z.infer<typeof mathValueSchema>
+  rows: readonly FormattedRow[]
+  service: string
+}) => {
+  const firstValue = schema.values[0]
+  let current = getBigDecimalValue({ schema: firstValue, rows, service })
+  let operator: '+' | '-' | '*' | '/' | undefined
+  let args: BigDecimal[] = []
+  for (const value of schema.values.slice(1)) {
+    if (value === '+') {
+      if (operator !== undefined) {
+        current = calculate(operator, current, args)
+        args = []
+      }
+      operator = '+'
+      continue
+    }
+    if (value === '-') {
+      if (operator !== undefined) {
+        current = calculate(operator, current, args)
+        args = []
+      }
+      operator = '-'
+      continue
+    }
+    if (value === '*') {
+      if (operator !== undefined) {
+        current = calculate(operator, current, args)
+        args = []
+      }
+      operator = '*'
+      continue
+    }
+    if (value === '/') {
+      if (operator !== undefined) {
+        current = calculate(operator, current, args)
+        args = []
+      }
+      operator = '/'
+      continue
+    }
+    args.push(getBigDecimalValue({ schema: value, rows, service }))
+  }
+  if (operator !== undefined) {
+    current = calculate(operator, current, args)
+  }
+  return current
+}
+
+const getBigDecimalValue = ({
+  schema,
+  rows,
+  service,
+}: {
+  schema: z.infer<typeof mathValueSchema>['values'][0]
+  rows: readonly FormattedRow[]
+  service: string
+}): BigDecimal => {
+  const value = getValue({ schema, rows, service })
+  if (value === undefined) {
+    return createBigDecimal(0n)
+  }
+  if (typeof value === 'string' || typeof value === 'number') {
+    return createBigDecimal(value)
+  }
+  return value
+}
+
+const getValue = ({
+  schema,
+  rows,
+  service,
+}: {
+  schema: z.infer<typeof mathValueSchema>['values'][0]
+  rows: readonly FormattedRow[]
+  service: string
+}) => {
+  if (typeof schema === 'string') {
+    return schema
+  }
+  switch (schema.type) {
+    case 'cell': {
+      return getCellValue({
+        schema,
+        rows,
+      })
+    }
+    case 'service': {
+      return service
+    }
+    case 'slice': {
+      return getSliceValue({
+        schema,
+        rows,
+        service,
+      })
+    }
+    case 'split': {
+      return getSplitValue({
+        schema,
+        rows,
+        service,
+      })
+    }
+  }
+}
+
+const calculate = (
+  operator: '+' | '-' | '*' | '/',
+  current: BigDecimal,
+  args: BigDecimal[],
+): BigDecimal => {
+  let newValue = current
+  switch (operator) {
+    case '+': {
+      for (const arg of args) {
+        newValue = plus(newValue, arg)
+      }
+      return newValue
+    }
+    case '-': {
+      for (const arg of args) {
+        newValue = minus(newValue, arg)
+      }
+      return newValue
+    }
+    case '*': {
+      for (const arg of args) {
+        newValue = times(newValue, arg)
+      }
+      return newValue
+    }
+    case '/': {
+      for (const arg of args) {
+        newValue = divide(times(newValue, createBigDecimal(1n), 18), arg, 18)
+      }
+      return newValue
+    }
+  }
+}

package/parseRowsToActions/parse.ts

@@ -0,0 +1,108 @@
+import {
+  type Action,
+  type CryptoCurrency,
+  type FiatCurrency,
+  stringify,
+} from '@0xtorch/core'
+import type { z } from 'zod'
+import type { parserSchema } from '../schemas/parser'
+import type { FormattedRow } from '../types'
+import { getAllValue } from './allValue'
+import { getAssetById } from './asset'
+import { getCellValue } from './cellValue'
+import { isMatchPattern } from './pattern'
+import { createTransfers } from './transfer'
+
+type ParseRowsToActionsByParserParameters = {
+  rows: readonly FormattedRow[]
+  parser: z.infer<typeof parserSchema>
+  symbolAssetMap?: { readonly [symbol: string]: string }
+  service: string
+  cryptoes: readonly CryptoCurrency[]
+  fiats: readonly FiatCurrency[]
+}
+
+export const parseRowsToActionsByParser = ({
+  rows,
+  parser,
+  symbolAssetMap,
+  service,
+  cryptoes,
+  fiats,
+}: ParseRowsToActionsByParserParameters): readonly Action[] | undefined => {
+  // 合致しない condition がある場合は undefined を返す
+  for (const condition of parser.conditions) {
+    const value = getAllValue({
+      schema: condition.value,
+      rows,
+      service,
+    })
+    if (
+      !isMatchPattern({ value: stringify(value), pattern: condition.pattern })
+    ) {
+      return undefined
+    }
+  }
+
+  // generator 毎に action 生成
+  const actions: Action[] = []
+  for (const generator of parser.generators) {
+    const source = stringify(
+      getAllValue({ schema: generator.source, rows, service }),
+    )
+    const timestampValue = getCellValue({ schema: generator.timestamp, rows })
+    const timestamp =
+      typeof timestampValue === 'number'
+        ? timestampValue
+        : new Date(stringify(timestampValue)).getTime()
+    const comment =
+      generator.comment === undefined
+        ? undefined
+        : stringify(getAllValue({ schema: generator.comment, rows, service }))
+    const app =
+      generator.app === undefined
+        ? undefined
+        : stringify(getAllValue({ schema: generator.app, rows, service }))
+    const crossId =
+      generator.crossId === undefined
+        ? undefined
+        : stringify(getAllValue({ schema: generator.crossId, rows, service }))
+    const loanId =
+      generator.loanId === undefined
+        ? undefined
+        : stringify(getAllValue({ schema: generator.loanId, rows, service }))
+    const target =
+      generator.target === undefined
+        ? undefined
+        : getAssetById({
+            schema: generator.target,
+            rows,
+            service,
+          })
+    actions.push({
+      source,
+      order: 0,
+      type: generator.type,
+      timestamp,
+      evidence: 'system-rule',
+      comment,
+      app,
+      transfers: generator.transfers.flatMap((transfer) =>
+        createTransfers({
+          schema: transfer,
+          rows,
+          service,
+          symbolAssetMap,
+          cryptoes,
+          fiats,
+        }),
+      ),
+      crossId,
+      crossType: generator.crossType,
+      loanId,
+      target:
+        target === undefined || target.type !== 'Nft' ? undefined : target,
+    })
+  }
+  return actions
+}

package/parseRowsToActions/pattern.ts

@@ -0,0 +1,35 @@
+import { stringify } from '@0xtorch/core'
+import type { z } from 'zod'
+import type { patternSchema } from '../schemas/parser'
+
+export const isMatchPattern = ({
+  value,
+  pattern,
+}: {
+  value: string
+  pattern: z.infer<typeof patternSchema>
+}): boolean => {
+  const trimmedValue = value.trim()
+  if (typeof pattern === 'string') {
+    return trimmedValue === pattern
+  }
+  switch (pattern.type) {
+    case 'defined': {
+      return (
+        trimmedValue !== stringify(undefined) && trimmedValue.trim().length > 0
+      )
+    }
+    case 'undefined': {
+      return (
+        trimmedValue.trim().length === 0 ||
+        trimmedValue === stringify(undefined)
+      )
+    }
+    case 'in': {
+      return pattern.values.includes(trimmedValue)
+    }
+    case 'not-in': {
+      return !pattern.values.includes(trimmedValue)
+    }
+  }
+}

package/parseRowsToActions/simpleValue.ts

@@ -0,0 +1,29 @@
+import type { z } from 'zod'
+import type { simpleValueSchema } from '../schemas/parser'
+import type { FormattedRow } from '../types'
+import { getCellValue } from './cellValue'
+
+export const getSimpleValue = ({
+  schema,
+  rows,
+  service,
+}: {
+  schema: z.infer<typeof simpleValueSchema>
+  rows: readonly FormattedRow[]
+  service: string
+}) => {
+  if (typeof schema === 'string') {
+    return schema
+  }
+  switch (schema.type) {
+    case 'cell': {
+      return getCellValue({
+        schema,
+        rows,
+      })
+    }
+    case 'service': {
+      return service
+    }
+  }
+}

package/parseRowsToActions/sliceValue.ts

@@ -0,0 +1,51 @@
+import { stringify } from '@0xtorch/core'
+import type { z } from 'zod'
+import type { sliceValueSchema } from '../schemas/parser'
+import type { FormattedRow } from '../types'
+import { getCellValue } from './cellValue'
+import { getSplitValue } from './splitValue'
+
+export const getSliceValue = ({
+  schema,
+  rows,
+  service,
+}: {
+  schema: z.infer<typeof sliceValueSchema>
+  rows: readonly FormattedRow[]
+  service: string
+}) => {
+  const value = getValue({ schema, rows, service })
+  return stringify(value).slice(schema.start, schema.end)
+}
+
+const getValue = ({
+  schema,
+  rows,
+  service,
+}: {
+  schema: z.infer<typeof sliceValueSchema>
+  rows: readonly FormattedRow[]
+  service: string
+}) => {
+  if (typeof schema.value === 'string') {
+    return schema.value
+  }
+  switch (schema.value.type) {
+    case 'cell': {
+      return getCellValue({
+        schema: schema.value,
+        rows,
+      })
+    }
+    case 'service': {
+      return service
+    }
+    case 'split': {
+      return getSplitValue({
+        schema: schema.value,
+        rows,
+        service,
+      })
+    }
+  }
+}

package/parseRowsToActions/splitValue.ts

@@ -0,0 +1,18 @@
+import { stringify } from '@0xtorch/core'
+import type { z } from 'zod'
+import type { splitValueSchema } from '../schemas/parser'
+import type { FormattedRow } from '../types'
+import { getSimpleValue } from './simpleValue'
+
+export const getSplitValue = ({
+  schema,
+  rows,
+  service,
+}: {
+  schema: z.infer<typeof splitValueSchema>
+  rows: readonly FormattedRow[]
+  service: string
+}) => {
+  const value = getSimpleValue({ schema: schema.value, rows, service })
+  return stringify(value).split(schema.splitter)[schema.index]
+}

package/parseRowsToActions/transfer.ts

@@ -0,0 +1,167 @@
+import { type BigDecimal, createBigDecimal } from '@0xtorch/big-decimal'
+import {
+  type CryptoCurrency,
+  type FiatCurrency,
+  type Transfer,
+  stringify,
+} from '@0xtorch/core'
+import type { z } from 'zod'
+import type {
+  amountSchema,
+  targetConditionSchema,
+  transferComponentSchema,
+} from '../schemas/parser'
+import type { FormattedRow } from '../types'
+import { getAllValue } from './allValue'
+import { getAsset } from './asset'
+import { isMatchPattern } from './pattern'
+
+export const createTransfers = ({
+  schema,
+  rows,
+  service,
+  symbolAssetMap,
+  cryptoes,
+  fiats,
+}: {
+  schema: z.infer<typeof transferComponentSchema>
+  rows: readonly FormattedRow[]
+  service: string
+  symbolAssetMap?: { readonly [symbol: string]: string }
+  cryptoes: readonly CryptoCurrency[]
+  fiats: readonly FiatCurrency[]
+}): readonly Transfer[] => {
+  if (schema.target === undefined) {
+    return [
+      createSingleTransfer({
+        schema,
+        rows,
+        service,
+        symbolAssetMap,
+        cryptoes,
+        fiats,
+      }),
+    ]
+  }
+  const targetRows = filterTargetRows({
+    conditions: schema.target,
+    rows,
+  })
+  return targetRows.map((targetRow) =>
+    createSingleTransfer({
+      schema,
+      rows: [targetRow],
+      service,
+      symbolAssetMap,
+      cryptoes,
+      fiats,
+    }),
+  )
+}
+
+const filterTargetRows = ({
+  conditions,
+  rows,
+}: {
+  conditions: readonly z.infer<typeof targetConditionSchema>[]
+  rows: readonly FormattedRow[]
+}): readonly FormattedRow[] => {
+  const filteredRows: FormattedRow[] = []
+  for (const row of rows) {
+    let isMatch = true
+    for (const condition of conditions) {
+      const value = stringify(row[condition.column])
+      if (!isMatchPattern({ value, pattern: condition.pattern })) {
+        isMatch = false
+        break
+      }
+    }
+    if (isMatch) {
+      filteredRows.push(row)
+    }
+  }
+  return filteredRows
+}
+
+const createSingleTransfer = ({
+  schema,
+  rows,
+  service,
+  symbolAssetMap,
+  cryptoes,
+  fiats,
+}: {
+  schema: z.infer<typeof transferComponentSchema>
+  rows: readonly FormattedRow[]
+  service: string
+  symbolAssetMap?: { readonly [symbol: string]: string }
+  cryptoes: readonly CryptoCurrency[]
+  fiats: readonly FiatCurrency[]
+}): Transfer => {
+  const from =
+    schema.from === undefined
+      ? undefined
+      : stringify(getAllValue({ schema: schema.from, rows, service }))
+  const to =
+    schema.to === undefined
+      ? undefined
+      : stringify(getAllValue({ schema: schema.to, rows, service }))
+  return {
+    direction: schema.direction,
+    from,
+    to,
+    asset: getAsset({
+      schema: schema.asset,
+      rows,
+      service,
+      symbolAssetMap,
+      cryptoes,
+      fiats,
+    }),
+    amount: createAmount({
+      schema: schema.amount,
+      rows,
+      service,
+    }),
+  }
+}
+
+const createAmount = ({
+  schema,
+  rows,
+  service,
+}: {
+  schema: z.infer<typeof amountSchema>
+  rows: readonly FormattedRow[]
+  service: string
+}): BigDecimal => {
+  switch (schema.type) {
+    case 'decimal': {
+      const baseValue = stringify(
+        getAllValue({ schema: schema.value, rows, service }),
+      )
+      let value: bigint
+      if (baseValue === stringify(undefined)) {
+        value = 0n
+      } else if (baseValue.includes('.')) {
+        value = BigInt(Math.floor(Number(baseValue)))
+      } else {
+        value = BigInt(baseValue)
+      }
+      return {
+        value,
+        decimals: schema.decimals,
+      }
+    }
+    case 'text': {
+      const value = getAllValue({ schema: schema.value, rows, service })
+      if (value === undefined) {
+        return createBigDecimal(0n)
+      }
+      if (typeof value === 'string' || typeof value === 'number') {
+        return createBigDecimal(value)
+      }
+      return value
+    }
+  }
+}

package/schemas/{schemas.ts → format.ts}

@@ -1,11 +1,11 @@
 import { z } from 'zod'
 import { formatterSchema } from './formatter'
-import { parsersSchema } from './parser'
+import { parsersWithKeySchema } from './parser'
 
 export const csvFormatSchema = z.object({
   id: z.string(),
   service: z.string(),
   formatter: formatterSchema,
-  parsers: parsersSchema,
+  parser: parsersWithKeySchema,
   symbolAssetMap: z.record(z.string()).optional(),
 })

package/schemas/index.ts

@@ -1 +1 @@
-export { csvFormatSchema } from './schemas'
+export { csvFormatSchema } from './format'