@sentio/sdk 2.39.4-rc.1 → 2.39.4-rc.10

package/src/store/codegen.ts

@@ -1,7 +1,5 @@
 import {
-  DirectiveNode,
   GraphQLEnumType,
-  GraphQLField,
   GraphQLInterfaceType,
   GraphQLList,
   GraphQLNonNull,
@@ -9,10 +7,9 @@ import {
   GraphQLOutputType,
   GraphQLScalarType,
   GraphQLSchema,
-  Kind,
-  isObjectType,
-  isInterfaceType,
-  isListType
+  isEnumType,
+  isListType,
+  isNonNullType
 } from 'graphql'
 import * as fs from 'node:fs'
 import path from 'path'
@@ -20,6 +17,35 @@ import mkdirp from 'mkdirp'
 import { schemaFromFile } from './schema.js'
 import chalk from 'chalk'
 
+interface Import {
+  module: string
+  types: string[]
+  importType?: boolean
+}
+
+interface Field {
+  name: string
+  type: string
+  annotations: string[]
+}
+
+interface Class {
+  name: string
+  fields: Field[]
+  annotations: string[]
+  interfaces: string[]
+}
+
+interface Interface {
+  name: string
+  fields: Field[]
+}
+
+interface Enum {
+  name: string
+  values: string[]
+}
+
 export async function codegen(srcDir: string, outputDir: string) {
   for (const file of fs.readdirSync(srcDir)) {
     const f = path.join(srcDir, file)
@@ -33,27 +59,78 @@ export async function codegen(srcDir: string, outputDir: string) {
   }
 }
 
+function addTypeAnnotations(ty: GraphQLOutputType, annotations: string[]) {
+  if (isNonNullType(ty)) {
+    annotations.push('@Required')
+    addTypeAnnotations(ty.ofType, annotations)
+    return
+  }
+
+  if (isRelationType(ty)) {
+    if (isListType(ty)) {
+      annotations.push(`@Many("${ty.ofType}")`)
+    } else {
+      annotations.push(`@One("${ty}")`)
+    }
+  } else if (isEnumType(ty)) {
+    annotations.push(`@Column("String${isNonNullType(ty) ? '!' : ''}")`)
+  } else {
+    if (isListType(ty)) {
+      if (isListType(ty.ofType)) {
+        annotations.push(`@ListColumn()`)
+        addTypeAnnotations(ty.ofType, annotations)
+      } else {
+        annotations.push(`@ListColumn("${ty.ofType}")`)
+      }
+    } else {
+      annotations.push(`@Column("${ty}")`)
+    }
+  }
+}
+
 async function codegenInternal(schema: GraphQLSchema, source: string, target: string) {
-  const results: string[] = [
-    '/* Autogenerated file. Do not edit manually. */\n',
-    '/* tslint:disable */',
-    '/* eslint-disable */',
-    "import { entity, derivedFrom, DateTime, Int, Float, String, Bytes, Boolean, ID, Entity, Store } from '@sentio/sdk/store'",
-    `import { BigDecimalConverter, BigIntConverter, IntConverter, StringConverter, IDConverter, BooleanConverter, BytesConverter, DateTimeConverter, FloatConverter, StructConverter, required_, array_, enumerate_, objectId_ } from '@sentio/sdk/store'`,
-    `import { DatabaseSchema, BigDecimal } from "@sentio/sdk"`,
-    `type BigInt = bigint`
+  const imports: Import[] = [
+    {
+      module: '@sentio/sdk/store',
+      types: ['String', 'Int', 'BigInt', 'Float', 'ID', 'Bytes', 'Timestamp', 'Boolean'],
+      importType: true
+    },
+    {
+      module: '@sentio/sdk/store',
+      types: ['Entity', 'Required', 'One', 'Many', 'Column', 'ListColumn']
+    },
+    {
+      module: '@sentio/bigdecimal',
+      types: ['BigDecimal']
+    },
+    {
+      module: '@sentio/sdk',
+      types: ['DatabaseSchema']
+    }
   ]
-  const entities: string[] = []
+  const enumns: Enum[] = []
+  const interfaces: Interface[] = []
+  const classes: Class[] = []
 
   for (const t of Object.values(schema.getTypeMap())) {
     if (t.name.startsWith('__')) {
       continue
     }
     if (t instanceof GraphQLEnumType) {
-      results.push(genEnum(t))
+      enumns.push({
+        name: t.name,
+        values: t.getValues().map((v) => v.value)
+      })
     }
     if (t instanceof GraphQLInterfaceType) {
-      results.push(genInterface(t))
+      interfaces.push({
+        name: t.name,
+        fields: Object.values(t.getFields()).map((f) => ({
+          name: f.name,
+          type: genType(f.type),
+          annotations: []
+        }))
+      })
     }
   }
   for (const t of Object.values(schema.getTypeMap())) {
@@ -62,20 +139,84 @@ async function codegenInternal(schema: GraphQLSchema, source: string, target: st
     }
 
     if (t instanceof GraphQLObjectType) {
-      const entityContent = genEntity(t)
-      results.push(entityContent)
-      entities.push(t.name)
+      const fields: Field[] = []
+      for (const f of Object.values(t.getFields())) {
+        const type = genType(f.type)
+        const annotations: string[] = []
+        addTypeAnnotations(f.type, annotations)
+        if (isRelationType(f.type)) {
+          fields.push({
+            name: f.name,
+            type: `Promise<${type}>`,
+            annotations
+          })
+          const isMany = type.startsWith('Array')
+          fields.push({
+            name: f.name + 'ID' + (isMany ? 's' : ''),
+            type: isMany ? `Array<ID | undefined>` : `ID`,
+            annotations: []
+          })
+        } else {
+          fields.push({
+            name: f.name,
+            type: type,
+            annotations
+          })
+        }
+      }
+      classes.push({
+        name: t.name,
+        fields,
+        annotations: [`@Entity("${t.name}")`],
+        interfaces: t.getInterfaces().map((i) => i.name)
+      })
     }
   }
 
+  const template = `
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+${imports.map((i) => `import ${i.importType ? 'type ' : ''}{ ${i.types.join(', ')} } from '${i.module}'`).join('\n')}
+
+${enumns
+  .map(
+    (e) => `export enum ${e.name} {
+  ${e.values.map((v) => `${v} = "${v}"`).join(', ')}
+}`
+  )
+  .join('\n')}
+
+${interfaces
+  .map(
+    (i) => `export interface ${i.name} {
+  ${i.fields.map((f) => `\t${f.name}: ${f.type}`).join('\n')}
+}`
+  )
+  .join('\n')}
+
+${classes
+  .map(
+    (c) => `
+${c.annotations.join('\n')}
+export class ${c.name} ${c.interfaces.length > 0 ? `implements ${c.interfaces.join(', ')}` : ''} {
+${c.fields.map((f) => `${f.annotations.map((a) => `\n\t${a}`).join('')}\n\t${f.name}: ${f.type}`).join('\n')}
+
+  constructor(data: Partial<${c.name}>) {}
+
+}`
+  )
+  .join('\n')}
+`
+
   const contents =
-    results.join('\n') +
+    template +
     `\n
 const source = \`${source.replaceAll('`', '`')}\`
 DatabaseSchema.register({
   source,
   entities: {
-    ${entities.map((e) => `"${e}": ${e}`).join(',\n\t\t')}
+    ${classes.map((e) => `"${e.name}": ${e.name}`).join(',\n\t\t')}
   }
 })
 `
@@ -84,196 +225,30 @@ DatabaseSchema.register({
   fs.writeFileSync(target, contents)
 }
 
-const JsTypes: Record<string, string> = {
-  ID: 'string',
-  String: 'string',
-  Int: 'number',
-  Float: 'number',
-  Boolean: 'boolean',
-  BigInt: 'bigint',
-  BigDecimal: 'BigDecimal',
-  DateTime: 'Date',
-  Json: 'any',
-  Bytes: 'Uint8Array'
-}
-const graphqlTypes = Object.entries(JsTypes).reduce(
-  (acc, [k, v]) => {
-    acc[v] = k
-    return acc
-  },
-  {} as Record<string, string>
-)
-
 function genType(type: GraphQLOutputType, required?: boolean): string {
   if (type instanceof GraphQLNonNull) {
     return genType(type.ofType, true)
   } else if (type instanceof GraphQLScalarType) {
     return required ? type.name : `${type.name} | undefined`
   } else if (type instanceof GraphQLObjectType || type instanceof GraphQLInterfaceType) {
-    return type.name
+    return required ? type.name : `${type.name} | undefined`
   } else if (type instanceof GraphQLList) {
     return `Array<${genType(type.ofType)}>`
   } else if (type instanceof GraphQLEnumType) {
-    return type.name
+    return required ? type.name : `${type.name} | undefined`
   } else {
     throw new Error('Unsupported type: ' + type)
   }
 }
 
-function isObject(type: GraphQLOutputType) {
+function isRelationType(type: GraphQLOutputType): boolean {
   if (type instanceof GraphQLNonNull) {
-    return isObject(type.ofType)
-  } else if (type instanceof GraphQLList) {
-    return isObject(type.ofType)
-  }
-  return isObjectType(type) || isInterfaceType(type)
-}
-
-function isList(type: GraphQLOutputType) {
-  if (type instanceof GraphQLNonNull) {
-    return isListType(type.ofType)
-  } else {
-    return isListType(type)
-  }
-}
-
-function getElementType(type: GraphQLOutputType) {
-  if (type instanceof GraphQLNonNull) {
-    return getElementType(type.ofType)
+    return isRelationType(type.ofType)
+  } else if (type instanceof GraphQLObjectType || type instanceof GraphQLInterfaceType) {
+    return true
   } else if (type instanceof GraphQLList) {
-    return type.ofType
-  }
-  return type
-}
-
-const getConverter = (t: GraphQLOutputType): string => {
-  if (t instanceof GraphQLNonNull) {
-    return `required_(${getConverter(t.ofType)})`
-  }
-  if (t instanceof GraphQLList) {
-    return `array_(${getConverter(t.ofType)})`
-  }
-  if (t instanceof GraphQLEnumType) {
-    return `enumerate_<${t.name}>(${t.name})`
-  }
-  if (isObject(t)) {
-    return `objectId_<${genType(getElementType(t))}>()`
-  }
-  return `${t.name}Converter`
-}
-
-function genField(field: GraphQLField<any, any>) {
-  const isNonNull = field.type instanceof GraphQLNonNull
-  const directives = field.astNode?.directives?.map((d) => '\t' + directive2decorator(d) + '\n') || []
-
-  const type = genType(field.type)
-
-  if (isObject(field.type)) {
-    const t = getElementType(field.type)
-    const typeAsArg = isInterfaceType(t) ? `"${t}"` : genType(t)
-
-    if (isList(field.type)) {
-      const required = (field.type as GraphQLList<any>).ofType instanceof GraphQLNonNull
-      const converter = required ? `array_(required_(IDConverter))` : `array_(IDConverter)`
-      const returnType = required ? `ID[]` : `Array<ID | undefined>`
-      return `${directives.join()}\tget ${field.name}(): Promise<${genType(t)}[]> { return this.getFieldObjectArray(${typeAsArg}, "${field.name}") as Promise<${genType(t)}[]> }
-  set ${field.name}(value: ${type} | ID[]) { this.setObject("${field.name}", value) }
-  get ${field.name}Ids(): ${returnType} { return this.get("${field.name}", ${converter}) }`
-    }
-
-    return `${directives.join()}\tget ${field.name}(): Promise<${genType(t)} | undefined> { return this.getObject(${typeAsArg},"${field.name}") as Promise<${genType(t)} | undefined> }
-  set ${field.name}(value: ${type} | ID) { this.set("${field.name}", value, objectId_<${type}>()) }
-  get ${field.name}Id(): ID | undefined { return this.get("${field.name}", IDConverter) }`
-  }
-
-  return `${directives.join()}\tget ${field.name}(): ${type} { return this.get("${field.name}", ${getConverter(field.type)}) }
-  set ${field.name}(value: ${type}) { this.set("${field.name}", value, ${getConverter(field.type)}) }`
-}
-
-function genDataType(t: GraphQLObjectType<any, any>) {
-  let output = `type ${t.name}Data = `
-  const relationsFields = Object.values(t.getFields()).filter((f) => isObject(f.type))
-  if (relationsFields.length > 0) {
-    output += `Omit<${t.name}, ${relationsFields.map((f) => `"${f.name}"`).join(' | ')}>`
-
-    output +=
-      ' & {' +
-      relationsFields
-        .map((f) => {
-          const type = genType(getElementType(f.type))
-          return `${f.name}?: ${isList(f.type) ? `Array<ID|${type}>` : `ID | ${type}`}`
-        })
-        .join(', ') +
-      '}'
+    return isRelationType(type.ofType)
   } else {
-    output += `${t.name}`
-  }
-  return output
-}
-
-function genEntity(t: GraphQLObjectType<any, any>) {
-  const decorators = t.astNode?.directives?.filter((d) => d.name.value != 'entity').map(directive2decorator) || []
-
-  let impls = ''
-  if (t.getInterfaces().length > 0) {
-    impls +=
-      ' implements ' +
-      t
-        .getInterfaces()
-        .map((i) => i.name)
-        .join(', ')
-  }
-
-  return `
-${genDataType(t)}
-${decorators.join('\n')}
-@entity("${t.name}")
-export class ${t.name} extends Entity${impls} {
-  ${genConverters(t)}
-  constructor(data: Partial<${t.name}Data>) {
-    super(${t.name}.entityConverter.from(data))
-  }
-${Object.values(t.getFields()).map(genField).join('\n')}
-}`
-}
-
-function genConverters(t: GraphQLObjectType<any, any>) {
-  const fields = Object.values(t.getFields())
-  const converters = fields.map((f) => {
-    const type = genType(f.type)
-    const converter = getConverter(f.type)
-    return `\t\t${f.name}: ${converter},`
-  })
-  return `static entityConverter = new StructConverter({\n ${converters.join('\n')} \n})`
-}
-
-function genInterface(t: GraphQLInterfaceType) {
-  return `
-export interface ${t.name} {
-${Object.values(t.getFields())
-  .map((f) => `\t${f.name}: ${genType(f.type)}`)
-  .join('\n')}
-}`
-}
-
-export function directive2decorator(directive: DirectiveNode) {
-  let s = `@${directive.name.value}`
-  if (directive.arguments?.length) {
-    s += `(${directive.arguments
-      ?.map((arg) => {
-        return arg.value.kind === Kind.STRING ? `"${arg.value.value}"` : `${arg.value}`
-      })
-      .join(', ')})`
+    return false
   }
-  return s
-}
-
-function genEnum(t: GraphQLEnumType) {
-  return `
-export enum ${t.name} {
-${t
-  .getValues()
-  .map((v) => `\t${v.name} = "${v.value}"`)
-  .join(', ')}
-}`
 }

package/src/store/convert.ts

@@ -1,27 +1,35 @@
-import { RichStruct, RichValue, RichValue_NullValue } from '@sentio/protos'
-import { String, Int, Float, ID, Bytes, DateTime, Boolean } from './types.js'
-import { Entity } from './entity.js'
+import { RichValue, RichValue_NullValue } from '@sentio/protos'
+import type { String, Int, Float, ID, Bytes, Timestamp, Boolean } from './types.js'
 import { BigDecimal } from '@sentio/bigdecimal'
 
 export interface ValueConverter<T> {
   from: (value: T) => RichValue
   to: (value: RichValue) => T
+  required?: boolean
+  isArray?: boolean
+  isRelation?: boolean
+  relationName?: string
 }
 
+export const ValueRequiredError = new Error('Value is required but received null or undefined')
+
 export function required_<T>(converter: ValueConverter<T | undefined>): ValueConverter<T> {
+  const { from, to, ...rest } = converter
   return {
     from: (value: T | undefined) => {
       if (value == null) {
-        throw new Error('Value is required but received null or undefined')
+        throw ValueRequiredError
       }
-      return converter.from(value)
+      return from(value)
     },
     to: (value: RichValue) => {
       if (value == null || value.nullValue) {
-        throw new Error('Value is required but received null')
+        throw ValueRequiredError
       }
-      return converter.to(value)!
-    }
+      return to(value)!
+    },
+    ...rest,
+    required: true
   }
 }
 
@@ -36,7 +44,10 @@ export function array_<T>(converter: ValueConverter<T>): ValueConverter<T[]> {
     },
     to: (value: RichValue) => {
       return value.listValue?.values.map(converter.to) || []
-    }
+    },
+    isArray: true,
+    isRelation: converter.isRelation,
+    relationName: converter.relationName
   }
 }
 
@@ -58,7 +69,7 @@ export function enumerate_<T extends string | number>(values: Record<T, string>)
   }
 }
 
-export function objectId_<T>(): ValueConverter<T | ID> {
+export function objectId_<T>(entityName: string): ValueConverter<T | ID> {
   return {
     from: (value: T | ID) => {
       if (typeof value == 'string') {
@@ -66,9 +77,16 @@ export function objectId_<T>(): ValueConverter<T | ID> {
           stringValue: value
         }
       }
-      if (value instanceof Entity) {
+      if (value instanceof Uint8Array) {
+        return {
+          stringValue: `0x${Buffer.from(value).toString('hex')}`
+        }
+      }
+
+      if (typeof value == 'object') {
+        const entity = value as any
         return {
-          stringValue: value.id
+          stringValue: entity.id.toString()
         }
       }
       return {
@@ -77,7 +95,9 @@ export function objectId_<T>(): ValueConverter<T | ID> {
     },
     to(v) {
       return v.stringValue as T | ID
-    }
+    },
+    isRelation: true,
+    relationName: entityName
   }
 }
 
@@ -146,8 +166,8 @@ export const BooleanConverter: ValueConverter<Boolean | undefined> = {
   }
 }
 
-export const DateTimeConverter: ValueConverter<DateTime | undefined> = {
-  from: (value: DateTime | undefined) => {
+export const TimestampConverter: ValueConverter<Timestamp | undefined> = {
+  from: (value: Timestamp | undefined) => {
     if (value == null) {
       return {
         nullValue: RichValue_NullValue.NULL_VALUE
@@ -178,7 +198,33 @@ export const BytesConverter: ValueConverter<Bytes | undefined> = {
   }
 }
 
-export const IDConverter: ValueConverter<ID | undefined> = StringConverter
+export const IDConverter: ValueConverter<ID | undefined> = {
+  from(value: ID | undefined): RichValue {
+    if (typeof value == 'string') {
+      return {
+        stringValue: value
+      }
+    }
+    if (value instanceof Uint8Array) {
+      return {
+        stringValue: `0x${Buffer.from(value).toString('hex')}`
+      }
+    }
+    return {
+      nullValue: RichValue_NullValue.NULL_VALUE
+    }
+  },
+  to(value: RichValue): ID | undefined {
+    if (value.stringValue) {
+      return value.stringValue as ID
+    }
+    if (value.bytesValue) {
+      const v = `0x${Buffer.from(value.bytesValue).toString('hex')}`
+      return v as ID
+    }
+    return undefined
+  }
+}
 
 export const BigDecimalConverter: ValueConverter<BigDecimal | undefined> = {
   from: (value?: BigDecimal): RichValue => {
@@ -187,9 +233,8 @@ export const BigDecimalConverter: ValueConverter<BigDecimal | undefined> = {
         nullValue: RichValue_NullValue.NULL_VALUE
       }
     }
-
-    const exp = value.decimalPlaces() ?? 0
-    const s = value.multipliedBy(new BigDecimal(10).pow(exp)).toFixed()
+    const s = (value.c || []).join('')
+    const exp = -(s.length - (value.e ?? 0) - 1)
 
     return {
       bigdecimalValue: {
@@ -202,7 +247,13 @@ export const BigDecimalConverter: ValueConverter<BigDecimal | undefined> = {
     const d = v.bigdecimalValue
     if (d) {
       const i = bytesToBigInt(d.value!.data)
-      return new BigDecimal(`${i}`).dividedBy(new BigDecimal(10).pow(d.exp)).multipliedBy(d.value?.negative ? -1 : 1)
+      let ret = new BigDecimal(i.toString())
+      if (d.exp < 0) {
+        ret = ret.dividedBy(new BigDecimal(10).pow(-d.exp))
+      } else {
+        ret = ret.multipliedBy(new BigDecimal(10).pow(d.exp))
+      }
+      return ret.multipliedBy(d.value?.negative ? -1 : 1)
     }
     return undefined
   }
@@ -231,20 +282,6 @@ export const BigIntConverter: ValueConverter<bigint | undefined> = {
   }
 }
 
-export class StructConverter<T extends Entity> {
-  constructor(private converters: Record<string, ValueConverter<any>>) {}
-
-  from(data: any): RichStruct {
-    const fields: Record<string, RichValue> = {}
-    for (const [field, value] of Object.entries(data)) {
-      if (this.converters[field] !== undefined) {
-        fields[field] = this.converters[field].from(value)
-      }
-    }
-    return { fields }
-  }
-}
-
 export function bytesToBigInt(bytes: Uint8Array) {
   let intValue = BigInt(0)
   for (let i = 0; i < bytes.length; i++) {
@@ -269,3 +306,16 @@ export function toBigInteger(a: bigint) {
     data: new Uint8Array(buffer)
   }
 }
+
+export const TypeConverters: Record<string, ValueConverter<any>> = {
+  BigDecimal: BigDecimalConverter,
+  BigInt: BigIntConverter,
+  String: StringConverter,
+  Boolean: BooleanConverter,
+  Uint8Array: BytesConverter,
+  ID: IDConverter,
+  Bytes: BytesConverter,
+  Int: IntConverter,
+  Float: FloatConverter,
+  Timestamp: TimestampConverter
+}