@sentio/sdk 2.39.3 → 2.39.4-rc.10

package/src/store/convert.ts

@@ -0,0 +1,321 @@
+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 ValueRequiredError
+      }
+      return from(value)
+    },
+    to: (value: RichValue) => {
+      if (value == null || value.nullValue) {
+        throw ValueRequiredError
+      }
+      return to(value)!
+    },
+    ...rest,
+    required: true
+  }
+}
+
+export function array_<T>(converter: ValueConverter<T>): ValueConverter<T[]> {
+  return {
+    from: (value: T[]) => {
+      return {
+        listValue: {
+          values: value.map(converter.from)
+        }
+      }
+    },
+    to: (value: RichValue) => {
+      return value.listValue?.values.map(converter.to) || []
+    },
+    isArray: true,
+    isRelation: converter.isRelation,
+    relationName: converter.relationName
+  }
+}
+
+export function enumerate_<T extends string | number>(values: Record<T, string>): ValueConverter<T> {
+  return {
+    from: (value?: T) => {
+      if (value == null) {
+        return {
+          nullValue: RichValue_NullValue.NULL_VALUE
+        }
+      }
+      return {
+        stringValue: values[value]
+      }
+    },
+    to(v: RichValue): T {
+      return v.stringValue as T
+    }
+  }
+}
+
+export function objectId_<T>(entityName: string): ValueConverter<T | ID> {
+  return {
+    from: (value: T | ID) => {
+      if (typeof value == 'string') {
+        return {
+          stringValue: value
+        }
+      }
+      if (value instanceof Uint8Array) {
+        return {
+          stringValue: `0x${Buffer.from(value).toString('hex')}`
+        }
+      }
+
+      if (typeof value == 'object') {
+        const entity = value as any
+        return {
+          stringValue: entity.id.toString()
+        }
+      }
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    },
+    to(v) {
+      return v.stringValue as T | ID
+    },
+    isRelation: true,
+    relationName: entityName
+  }
+}
+
+/* eslint-disable */
+export const StringConverter: ValueConverter<String | undefined> = {
+  from: (value?: String) => {
+    if (value == null) {
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    }
+    return {
+      stringValue: value
+    }
+  },
+  to(v) {
+    return v.stringValue
+  }
+}
+
+export const IntConverter: ValueConverter<Int | undefined> = {
+  from: (value?: Int) => {
+    if (value == null) {
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    }
+    return {
+      intValue: value
+    }
+  },
+  to(v) {
+    return v.intValue
+  }
+}
+
+export const FloatConverter: ValueConverter<Float | undefined> = {
+  from: (value?: Float) => {
+    if (value == null) {
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    }
+    return {
+      floatValue: value
+    }
+  },
+  to(v) {
+    return v.floatValue
+  }
+}
+
+export const BooleanConverter: ValueConverter<Boolean | undefined> = {
+  from: (value?: Boolean) => {
+    if (value == null) {
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    }
+    return {
+      boolValue: value
+    }
+  },
+  to(v) {
+    return v.boolValue
+  }
+}
+
+export const TimestampConverter: ValueConverter<Timestamp | undefined> = {
+  from: (value: Timestamp | undefined) => {
+    if (value == null) {
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    }
+    return {
+      timestampValue: value
+    }
+  },
+  to(v) {
+    return v.timestampValue
+  }
+}
+
+export const BytesConverter: ValueConverter<Bytes | undefined> = {
+  from: (value?: Bytes) => {
+    if (value == null) {
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    }
+    return {
+      bytesValue: value
+    }
+  },
+  to(v) {
+    return v.bytesValue
+  }
+}
+
+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 => {
+    if (value == null) {
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    }
+    const s = (value.c || []).join('')
+    const exp = -(s.length - (value.e ?? 0) - 1)
+
+    return {
+      bigdecimalValue: {
+        value: toBigInteger(BigInt(s)),
+        exp: exp
+      }
+    }
+  },
+  to(v) {
+    const d = v.bigdecimalValue
+    if (d) {
+      const i = bytesToBigInt(d.value!.data)
+      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
+  }
+}
+
+export const BigIntConverter: ValueConverter<bigint | undefined> = {
+  from: (value?: bigint) => {
+    if (value == null) {
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    }
+    return {
+      bigintValue: toBigInteger(value)
+    }
+  },
+  to(v) {
+    if (v.bigintValue) {
+      let res = bytesToBigInt(v.bigintValue?.data)
+      if (v.bigintValue.negative) {
+        res = -res
+      }
+      return res
+    }
+    return undefined
+  }
+}
+
+export function bytesToBigInt(bytes: Uint8Array) {
+  let intValue = BigInt(0)
+  for (let i = 0; i < bytes.length; i++) {
+    intValue = intValue * BigInt(256) + BigInt(bytes[i])
+  }
+  return intValue
+}
+
+export function toBigInteger(a: bigint) {
+  const negative = a < 0
+  if (negative) {
+    a = -a
+  }
+  let hex = a.toString(16)
+  if (hex.length % 2 === 1) {
+    hex = '0' + hex
+  }
+  const buffer = Buffer.from(hex, 'hex')
+
+  return {
+    negative: negative,
+    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
+}

package/src/store/decorators.ts

@@ -1,32 +1,201 @@
+import 'reflect-metadata'
+import {
+  array_,
+  BigDecimalConverter,
+  BigIntConverter,
+  BooleanConverter,
+  BytesConverter,
+  FloatConverter,
+  IDConverter,
+  IntConverter,
+  objectId_,
+  required_,
+  StringConverter,
+  TimestampConverter,
+  TypeConverters,
+  ValueConverter
+} from './convert.js'
+import { RichStruct } from '@sentio/protos'
+import { getStore } from './store.js'
+
 type Constructor = { new (...args: any[]): any }
 
-export function entity(name: string) {
-  return function <T extends Constructor>(constructor: T, context: any) {
-    constructor.prototype.entityName = name
-    return constructor
+function handleError(entity: string, key: string, fn: () => any) {
+  try {
+    return fn()
+  } catch (e) {
+    throw new Error(`Get property "${key}" from Entity "${entity}" failed: ${e.message}`)
+  }
+}
+
+export function Entity(name: string) {
+  return function <T extends Constructor>(BaseClass: T) {
+    Object.defineProperty(BaseClass, 'entityName', {
+      value: name
+    })
+
+    const meta: Record<string, ValueConverter<any>> = (BaseClass as any).meta || {}
+    const target = BaseClass.prototype
+    for (const [propertyKey, type] of Object.entries(meta)) {
+      if (type.isRelation && type.relationName) {
+        const relationName = type.relationName
+        const idGetter = function (this: any) {
+          return handleError(this.constructor.entityName, propertyKey, () => type!.to(this._data.fields[propertyKey]))
+        }
+        const idSetter = function (this: any, value: any) {
+          this._data.fields[propertyKey] = handleError(this.constructor.entityName, propertyKey, () =>
+            type!.from(value)
+          )
+        }
+        const idKey = type.isArray ? propertyKey + 'IDs' : propertyKey + 'ID'
+
+        Reflect.defineProperty(target, idKey, {
+          get: idGetter,
+          set: idSetter
+        })
+        Reflect.defineProperty(target, propertyKey, {
+          get: function () {
+            const ids = idGetter.call(this)
+            if (Array.isArray(ids)) {
+              return Promise.all(
+                ids.map((id) => {
+                  return getStore()?.get(relationName, id)
+                })
+              )
+            } else {
+              return getStore()?.get(relationName, ids)
+            }
+          },
+          set: function (value) {
+            if (value instanceof Promise) {
+              value.then((v) => {
+                idSetter.call(this, v)
+              })
+            } else {
+              idSetter.call(this, value)
+            }
+          }
+        })
+      } else {
+        Reflect.defineProperty(target, propertyKey, {
+          configurable: true,
+          get: function () {
+            return handleError(this.constructor.entityName, propertyKey, () => type!.to(this._data.fields[propertyKey]))
+          },
+          set: function (value) {
+            this._data.fields[propertyKey] = handleError(this.constructor.entityName, propertyKey, () =>
+              type!.from(value)
+            )
+          }
+        })
+      }
+    }
+
+    return class extends BaseClass {
+      readonly _data: RichStruct = { fields: {} }
+      constructor(...args: any[]) {
+        super()
+        for (const key of Object.getOwnPropertyNames(this)) {
+          if (BaseClass.prototype.hasOwnProperty(key)) {
+            delete this[key]
+          }
+        }
+        if (args[0]) {
+          Object.assign(this, args[0])
+        }
+      }
+    }
   }
 }
 
-export function derivedFrom(field: string) {
-  return function (target: any, context: any) {}
+export function Column(type: string) {
+  return function (target: any, propertyKey: string) {
+    let required = false
+    if (type.endsWith('!')) {
+      required = true
+      type = type.slice(0, -1)
+    }
+    let typeConverter = TypeConverters[type]
+    if (!typeConverter) {
+      throw new Error(`Unsupported type ${type}`)
+    }
+    if (required) {
+      typeConverter = required_(typeConverter)
+    }
+    column(typeConverter)(target, propertyKey)
+  }
 }
 
-export function unique(field: string) {
-  return function (target: any, context: any) {}
+export function ListColumn(type: string = '') {
+  return function (target: any, propertyKey: string) {
+    let required = false
+    if (type.endsWith('!')) {
+      required = true
+      type = type.slice(0, -1)
+    }
+
+    let typeConverter = TypeConverters[type]
+    if (!typeConverter) {
+      // support list of list
+      const meta = target.constructor.meta || {}
+      const type = meta[propertyKey]
+      if (type) {
+        typeConverter = type
+      } else {
+        throw new Error(`Can't find inner type convert`)
+      }
+    }
+    if (required) {
+      typeConverter = required_(typeConverter)
+    }
+    column(array_(typeConverter))(target, propertyKey)
+  }
 }
 
-export function index(field: string[]) {
-  return function (target: any, context: any) {}
+export function column(type?: ValueConverter<any>) {
+  return function (target: any, propertyKey: string) {
+    const reflectType = Reflect.getMetadata('design:type', target, propertyKey)
+    if (!type) {
+      const typeName = reflectType.name
+      type = TypeConverters[typeName]
+      if (!type) {
+        throw new Error(`Unsupported type ${typeName}`)
+      }
+    }
+
+    const meta = target.constructor.meta || {}
+    meta[propertyKey] = type
+    target.constructor.meta = meta
+  }
 }
 
-export function fulltext(query: string) {
-  return function (target: any, context: any) {}
+export const IDColumn = column(IDConverter)
+export const IntColumn = column(IntConverter)
+export const FloatColumn = column(FloatConverter)
+export const BigDecimalColumn = column(BigDecimalConverter)
+export const BigIntColumn = column(BigIntConverter)
+export const StringColumn = column(StringConverter)
+export const BooleanColumn = column(BooleanConverter)
+export const TimestampColumn = column(TimestampConverter)
+export const BytesColumn = column(BytesConverter)
+
+export function Required(target: any, propertyKey: string) {
+  const meta = target.constructor.meta || {}
+  const type = meta[propertyKey]
+  if (type) {
+    meta[propertyKey] = required_(type)
+  }
+  target.constructor.meta = meta
 }
 
-export function cardinality(value: number) {
-  return function (target: any, context: any) {}
+export function One(entity: string) {
+  return function (target: any, propertyKey: string) {
+    column(objectId_(entity))(target, propertyKey)
+  }
 }
 
-export function byteWeight(value: number) {
-  return function (target: any, context: any) {}
+export function Many(entity: string) {
+  return function (target: any, propertyKey: string) {
+    column(array_(objectId_(entity)))(target, propertyKey)
+  }
 }

package/src/store/index.ts

@@ -1,5 +1,5 @@
 export * from './decorators.js'
 export * from './types.js'
-export * from './entity.js'
 export * from './store.js'
 export * from './context.js'
+export * from './convert.js'

package/src/store/schema.ts

@@ -1,7 +1,8 @@
 import { buildASTSchema, DocumentNode, extendSchema, GraphQLSchema, parse, validateSchema } from 'graphql/index.js'
 import * as fs from 'node:fs'
+import { GraphQLObjectType, GraphQLOutputType, isListType, isNonNullType } from 'graphql'
 
-const customScalars = ['BigInt', 'BigDecimal', 'DateTime', 'JSON', 'Bytes', 'ID']
+const customScalars = ['BigInt', 'BigDecimal', 'Timestamp', 'JSON', 'Bytes', 'ID']
 
 const baseSchema = buildASTSchema(
   parse(`
@@ -19,12 +20,51 @@ const baseSchema = buildASTSchema(
 `)
 )
 
+function getElemType(type: GraphQLOutputType) {
+  if (isNonNullType(type)) {
+    return getElemType(type.ofType)
+  }
+  if (isListType(type)) {
+    return getElemType(type.ofType)
+  }
+  return type
+}
+
+function checkRelations(schema: GraphQLSchema) {
+  for (const t of Object.values(schema.getTypeMap())) {
+    if (t.name.startsWith('__')) {
+      continue
+    }
+    if (t instanceof GraphQLObjectType) {
+      for (const f of Object.values(t.getFields())) {
+        if (f.astNode) {
+          for (const d of f.astNode.directives ?? []) {
+            if (d.name.value === 'derivedFrom') {
+              const arg = (d.arguments ?? []).find((a) => a.name.value === 'field')
+              if (!arg || !arg.value || arg.value.kind !== 'StringValue') {
+                throw new Error(`@derivedFrom directive must have a 'field' argument`)
+              }
+              const fieldName = arg.value.value
+              const targetType = getElemType(f.type) as GraphQLObjectType
+              // Check if the target type has a field with the same name
+              if (!targetType.getFields()[fieldName]) {
+                throw new Error(`Field '${fieldName}' not found in type '${targetType.name}'`)
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
 export function buildSchema(doc: DocumentNode): GraphQLSchema {
   const schema = extendSchema(baseSchema, doc)
   const errors = validateSchema(schema).filter((err) => !/query root/i.test(err.message))
   if (errors.length > 0) {
     throw errors[0]
   }
+  checkRelations(schema)
   return schema
 }