@sentio/sdk 2.39.4-rc.8 → 2.39.4

package/src/store/decorators.ts

@@ -15,8 +15,8 @@ import {
   TypeConverters,
   ValueConverter
 } from './convert.js'
-import { getStore } from './store.js'
 import { RichStruct } from '@sentio/protos'
+import { getStore } from './store.js'
 
 type Constructor = { new (...args: any[]): any }
 
@@ -28,73 +28,77 @@ function handleError(entity: string, key: string, fn: () => any) {
   }
 }
 
-export function Entity(name: string) {
+export function Entity(entityName: string) {
   return function <T extends Constructor>(BaseClass: T) {
-    return class extends BaseClass {
-      static entityName = name
-      readonly _data: RichStruct = { fields: {}, entityName: 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'
 
-      constructor(...args: any[]) {
-        super()
-        const meta = (BaseClass as any).meta
-        for (const [propertyKey, t] of Object.entries(meta)) {
-          const converter = t as ValueConverter<any>
-          if (converter.isRelation && converter.relationName) {
-            const relationName = converter.relationName
-            const idGetter = () => {
-              return handleError(name, propertyKey, () => converter.to(this._data.fields[propertyKey]))
+        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)
             }
-            const idSetter = (value: any) => {
-              this._data.fields[propertyKey] = handleError(name, propertyKey, () => converter.from(value))
+          },
+          set: function (value) {
+            if (value instanceof Promise) {
+              value.then((v) => {
+                idSetter.call(this, v)
+              })
+            } else {
+              idSetter.call(this, value)
             }
-            const idKey = converter.isArray ? propertyKey + 'IDs' : propertyKey + 'ID'
-
-            Object.defineProperty(this, idKey, {
-              get: idGetter,
-              set: idSetter
-            })
-
-            Object.defineProperty(this, propertyKey, {
-              get: () => {
-                const ids = idGetter()
-                if (Array.isArray(ids)) {
-                  return Promise.all(
-                    ids.map((id) => {
-                      return getStore()?.get(relationName, id)
-                    })
-                  )
-                } else {
-                  return getStore()?.get(relationName, ids)
-                }
-              },
-              set: (value) => {
-                if (value instanceof Promise) {
-                  value.then((v) => {
-                    idSetter(v)
-                  })
-                } else {
-                  idSetter(value)
-                }
-              }
-            })
-          } else {
-            Object.defineProperty(this, propertyKey, {
-              get: () => {
-                return handleError(name, propertyKey, () => converter.to(this._data.fields[propertyKey]))
-              },
-              set: (value) => {
-                this._data.fields[propertyKey] = handleError(name, propertyKey, () => converter.from(value))
-              }
-            })
           }
-          const initData = args[0]
-          if (initData) {
-            for (const [key, value] of Object.entries(initData)) {
-              if (this.hasOwnProperty(key)) {
-                this[key] = 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: {} }
+      static entityName = entityName
+      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])
         }
       }
     }

package/src/store/schema.ts

@@ -1,5 +1,6 @@
 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', 'Timestamp', 'JSON', 'Bytes', 'ID']
 
@@ -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
 }
 

package/src/store/store.ts

@@ -2,7 +2,7 @@ import { StoreContext } from './context.js'
 import { DatabaseSchema } from '../core/index.js'
 import { BigDecimal } from '@sentio/bigdecimal'
 import { Bytes, Float, ID, Int, Timestamp } from './types.js'
-import type { RichStruct, RichValue } from '@sentio/protos'
+import type { Entity as EntityStruct, RichValue } from '@sentio/protos'
 import { DBRequest_DBOperator, DBResponse } from '@sentio/protos'
 import { toBigInteger } from './convert.js'
 import { PluginManager } from '@sentio/runtime'
@@ -17,20 +17,36 @@ export interface EntityClass<T> {
   new (data: Partial<T>): T
 }
 
+function getEntityName<T>(entity: EntityClass<T> | T | string): string {
+  if (entity == null) {
+    throw new Error("can't figure out entityName from undefined")
+  }
+  if (typeof entity == 'string') {
+    return entity
+  }
+  if (typeof entity == 'function') {
+    return (entity as any).entityName
+  }
+  if (typeof entity == 'object') {
+    return (entity.constructor as any).entityName
+  }
+  throw new Error(`can't figure out entityName from ${typeof entity}`)
+}
+
 export class Store {
   constructor(private readonly context: StoreContext) {}
 
   async get<T extends Entity>(entity: EntityClass<T> | string, id: ID): Promise<T | undefined> {
     const promise = this.context.sendRequest({
       get: {
-        entity: typeof entity == 'string' ? entity : entity.prototype.entityName,
+        entity: getEntityName(entity),
         id: id.toString()
       }
     })
 
     const data = (await promise) as DBResponse
-    if (data.entities?.entities[0]) {
-      const entityData = data.entities.entities[0]
+    if (data.entityList?.entities[0]) {
+      const entityData = data.entityList?.entities[0]
       return this.newEntity(entity, entityData)
     }
 
@@ -45,18 +61,17 @@ export class Store {
     if (id) {
       if (Array.isArray(id)) {
         for (const i of id) {
-          const items = (entity as any).prototype.entityName
-          request.entity.push(items)
+          request.entity.push(getEntityName(entity))
           request.id.push(i.toString())
         }
       } else {
-        request.entity.push((entity as any).prototype.entityName)
+        request.entity.push(getEntityName(entity))
         request.id.push(id)
       }
     } else {
       const entities = Array.isArray(entity) ? entity : [entity]
       for (const e of entities) {
-        request.entity.push(e.constructor.prototype.entityName)
+        request.entity.push(getEntityName(entity))
         request.id.push((e as Entity).id.toString())
       }
     }
@@ -70,7 +85,7 @@ export class Store {
     const entities = Array.isArray(entity) ? entity : [entity]
     const promise = this.context.sendRequest({
       upsert: {
-        entity: entities.map((e) => e.constructor.prototype.entityName),
+        entity: entities.map((e) => getEntityName(e)),
         // data: entities.map((e) => serialize(e.data)),
         id: entities.map((e) => e.id.toString()),
         entityData: entities.map((e: any) => e._data)
@@ -80,13 +95,13 @@ export class Store {
     await promise
   }
 
-  async *list<T extends Entity>(entity: EntityClass<T>, filters?: ListFilter<T>[]) {
+  async *listIterator<T extends Entity>(entity: EntityClass<T>, filters?: ListFilter<T>[]) {
     let cursor: string | undefined = undefined
 
     while (true) {
       const promise = this.context.sendRequest({
         list: {
-          entity: entity.prototype.entityName,
+          entity: getEntityName(entity),
           cursor,
           filters:
             filters?.map((f) => ({
@@ -97,7 +112,7 @@ export class Store {
         }
       })
       const response = (await promise) as DBResponse
-      for (const data of response.entities?.entities || []) {
+      for (const data of response.entityList?.entities || []) {
         yield this.newEntity(entity, data)
       }
       if (!response.nextCursor) {
@@ -107,12 +122,25 @@ export class Store {
     }
   }
 
-  private newEntity<T extends Entity>(entity: EntityClass<T> | string, data: RichStruct) {
+  async list<T extends Entity>(entity: EntityClass<T>, filters?: ListFilter<T>[]) {
+    // TODO Array.fromAsync when upgrade to node 22
+    return this.fromAsync(this.listIterator(entity, filters))
+  }
+
+  private async fromAsync<T>(gen: AsyncIterable<T>): Promise<T[]> {
+    const out: T[] = []
+    for await (const x of gen) {
+      out.push(x)
+    }
+    return out
+  }
+
+  private newEntity<T extends Entity>(entity: EntityClass<T> | string, data: EntityStruct) {
     if (typeof entity == 'string') {
       let en = DatabaseSchema.findEntity(entity)
       if (!en) {
         // it is an interface
-        en = DatabaseSchema.findEntity(data.entityName)
+        en = DatabaseSchema.findEntity(data.entity)
         if (!en) {
           throw new Error(`Entity ${entity} not found`)
         }
@@ -121,7 +149,7 @@ export class Store {
     }
 
     const res = new (entity as EntityClass<T>)({}) as T
-    ;(res as any)._data = data
+    ;(res as any)._data = data.data
     return res
   }
 }

package/src/store/types.ts

@@ -1,29 +1,8 @@
-export type ID = (string | Uint8Array) & { __id__?: void }
+export type ID = string | Uint8Array
 export type String = string
-export type Int = number & { __int__?: void }
+export type Int = number
 export type Float = number
 export type Boolean = boolean
 export type Timestamp = Date
 export type Bytes = Uint8Array
 export type BigInt = bigint
-
-export class Struct<T = unknown, S = unknown> {
-  readonly TYPE!: T
-  constructor(readonly schema: S) {}
-}
-export type Infer<T extends Struct<any>> = T['TYPE']
-export type ObjectSchema = Record<string, Struct<any, any>>
-
-export function object<S extends ObjectSchema>(schema: S): Struct<ObjectType<S>, S> {
-  return new Struct(schema ?? null)
-}
-
-export type Simplify<T> = T extends any[] | Date ? T : { [K in keyof T]: T[K] } & NonNullable<unknown>
-
-export type ObjectType<S extends ObjectSchema> = Simplify<{ [K in keyof S]: Infer<S[K]> }>
-
-const StringStruct = new Struct<string, null>(null)
-
-const UU = object({
-  test: StringStruct
-})

package/src/utils/price.ts

@@ -88,10 +88,12 @@ export async function getPriceByTypeOrSymbolInternal(
       return res.price
     })
     .catch((e) => {
-      if (e.code === Status.NOT_FOUND) {
-        setTimeout(() => {
-          priceMap.delete(key)
-        }, 1000)
+      setTimeout(() => {
+        priceMap.delete(key)
+      }, 1000)
+
+      if (e.code === Status.NOT_FOUND || e.code === Status.UNKNOWN) {
+        console.error('price not found for ', JSON.stringify(coinId), ' at ', dateStr)
         return undefined
       }
       // TODO maybe use small set of error