@sentio/sdk 2.40.0 → 2.40.1-rc.10

package/src/store/codegen.ts

@@ -34,6 +34,7 @@ interface Class {
   name: string
   fields: Field[]
   annotations: string[]
+  parent?: string
   interfaces: string[]
 }
 
@@ -98,7 +99,7 @@ async function codegenInternal(schema: GraphQLSchema, source: string, target: st
     },
     {
       module: '@sentio/sdk/store',
-      types: ['Entity', 'Required', 'One', 'Many', 'Column', 'ListColumn']
+      types: ['Entity', 'Required', 'One', 'Many', 'Column', 'ListColumn', 'AbstractEntity']
     },
     {
       module: '@sentio/bigdecimal',
@@ -134,44 +135,60 @@ async function codegenInternal(schema: GraphQLSchema, source: string, target: st
       })
     }
   }
+
   for (const t of Object.values(schema.getTypeMap())) {
     if (t.name.startsWith('__')) {
       continue
     }
 
     if (t instanceof GraphQLObjectType) {
-      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({
+      if (isEntity(t)) {
+        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,
+              optional: !f.type.toString().endsWith('!'),
+              type: type.replace(' | undefined', ''),
+              annotations
+            })
+          }
+        }
+        classes.push({
+          name: t.name,
+          fields,
+          annotations: [`@Entity("${t.name}")`],
+          parent: 'AbstractEntity',
+          interfaces: t.getInterfaces().map((i) => i.name)
+        })
+      } else {
+        classes.push({
+          name: t.name,
+          fields: Object.values(t.getFields()).map((f) => ({
             name: f.name,
             optional: !f.type.toString().endsWith('!'),
-            type: type.replace(' | undefined', ''),
-            annotations
-          })
-        }
+            type: genType(f.type).replace(' | undefined', ''),
+            annotations: []
+          })),
+          annotations: [],
+          interfaces: t.getInterfaces().map((i) => i.name)
+        })
       }
-      classes.push({
-        name: t.name,
-        fields,
-        annotations: [`@Entity("${t.name}")`],
-        interfaces: t.getInterfaces().map((i) => i.name)
-      })
     }
   }
 
@@ -201,13 +218,11 @@ ${classes
   .map(
     (c) => `
 ${c.annotations.join('\n')}
-export class ${c.name} ${c.interfaces.length > 0 ? `implements ${c.interfaces.join(', ')}` : ''} {
+export class ${c.name} ${c.parent ? `extends ${c.parent}` : ''} ${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.optional ? '?' : ''}: ${f.type}`)
   .join('\n')}
-
-  constructor(data: Partial<${c.name}>) {}
-
+  ${c.annotations.some((a) => a.startsWith('@Entity')) ? `constructor(data: Partial<${c.name}>) {super()}` : ''}
 }`
   )
   .join('\n')}
@@ -256,3 +271,7 @@ function isRelationType(type: GraphQLOutputType): boolean {
     return false
   }
 }
+
+function isEntity(t: GraphQLObjectType) {
+  return t.astNode?.directives?.some((d) => d.name.value == 'entity')
+}

package/src/store/store.ts

@@ -1,19 +1,19 @@
 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 { AbstractEntity as Entity, Bytes, Float, ID, Int, Timestamp } from './types.js'
 import type { DBRequest, Entity as EntityStruct, RichValue } from '@sentio/protos'
 import { DBRequest_DBOperator, DBResponse } from '@sentio/protos'
 import { toBigInteger } from './convert.js'
 import { PluginManager } from '@sentio/runtime'
 import { Cursor } from './cursor.js'
-import { Entity, LocalCache } from './cache.js'
+import { LocalCache } from './cache.js'
 
 export interface EntityClass<T> {
   new (data: Partial<T>): T
 }
 
-function getEntityName<T>(entity: EntityClass<T> | T | string): string {
+export function getEntityName<T>(entity: EntityClass<T> | T | string): string {
   if (entity == null) {
     throw new Error("can't figure out entityName from undefined")
   }
@@ -182,7 +182,7 @@ export class Store {
 
   async list<T extends Entity, P extends keyof T, O extends Operators<T[P]>>(
     entity: EntityClass<T>,
-    filters: ListFilter<T, P, O>[],
+    filters?: ListFilter<T, P, O>[],
     cursor?: Cursor
   ) {
     if (cursor) {
@@ -191,7 +191,7 @@ export class Store {
       return response.entityList?.entities.map((data) => this.newEntity(entity, data)) || []
     }
     // TODO Array.fromAsync when upgrade to node 22
-    return this.fromAsync(this.listIterator(entity, filters))
+    return this.fromAsync(this.listIterator(entity, filters ?? []))
   }
 
   private async fromAsync<T>(gen: AsyncIterable<T>): Promise<T[]> {

package/src/store/types.ts

@@ -1,3 +1,7 @@
+import { RichStruct, RichValue } from '@sentio/protos'
+import { BigDecimalConverter, BigIntConverter } from './convert.js'
+import { getEntityName } from './store.js'
+
 export type ID = string | Uint8Array
 export type String = string
 export type Int = number
@@ -6,3 +10,56 @@ export type Boolean = boolean
 export type Timestamp = Date
 export type Bytes = Uint8Array
 export type BigInt = bigint
+
+export abstract class AbstractEntity {
+  abstract id: ID
+  private readonly _data: RichStruct
+
+  toJSON() {
+    const obj: any = {}
+
+    for (const [field, value] of Object.entries(this._data.fields)) {
+      obj[field] = toJSValue(value)
+    }
+    return obj
+  }
+
+  toString() {
+    const obj = this.toJSON()
+    return `${getEntityName(this)} ${JSON.stringify(obj)}`
+  }
+}
+
+function toJSValue(value: RichValue): any {
+  if (value.nullValue) {
+    return null
+  }
+  if (value.bytesValue) {
+    return value.bytesValue
+  }
+  if (value.stringValue) {
+    return value.stringValue
+  }
+  if (value.bigdecimalValue) {
+    return BigDecimalConverter.to(value)
+  }
+  if (value.bigintValue) {
+    return BigIntConverter.to(value)
+  }
+  if (value.boolValue) {
+    return value.boolValue
+  }
+  if (value.timestampValue) {
+    return value.timestampValue
+  }
+  if (value.floatValue) {
+    return value.floatValue
+  }
+  if (value.intValue) {
+    return value.intValue
+  }
+  if (value.listValue) {
+    return value.listValue.values.map(toJSValue)
+  }
+  throw new Error('Unknown value type:' + JSON.stringify(value))
+}