@sentio/sdk 2.36.2-rc.1 → 2.37.0-rc.10

package/src/store/context.ts

@@ -0,0 +1 @@
+export { StoreContext } from '@sentio/runtime'

package/src/store/decorators.ts

@@ -0,0 +1,32 @@
+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
+  }
+}
+
+export function derivedFrom(field: string) {
+  return function (target: any, context: any) {}
+}
+
+export function unique(field: string) {
+  return function (target: any, context: any) {}
+}
+
+export function index(field: string[]) {
+  return function (target: any, context: any) {}
+}
+
+export function fulltext(query: string) {
+  return function (target: any, context: any) {}
+}
+
+export function cardinality(value: number) {
+  return function (target: any, context: any) {}
+}
+
+export function byteWeight(value: number) {
+  return function (target: any, context: any) {}
+}

package/src/store/entity.ts

@@ -0,0 +1,71 @@
+import { ID } from './types.js'
+import { PluginManager } from '@sentio/runtime'
+import { Store } from './store.js'
+
+export interface EntityClass<T extends Entity> {
+  new (data: any): T
+}
+
+export class Entity {
+  get id(): ID {
+    return this.get('id')
+  }
+
+  data: Record<string, any> = {}
+  constructor(data: any) {
+    Object.entries(data).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        this.data[key] = value.map((v) => this.getIdFromEntity(v))
+      } else {
+        this.data[key] = this.getIdFromEntity(value)
+      }
+    })
+  }
+
+  private getIdFromEntity(entity: any): any {
+    if (entity instanceof Entity) {
+      return entity.id
+    } else if (typeof entity === 'object' && entity.id) {
+      return entity.id
+    }
+    return entity
+  }
+
+  private getStore() {
+    const dbContext = PluginManager.INSTANCE.dbContextLocalStorage.getStore()
+    if (dbContext) {
+      return new Store(dbContext)
+    }
+    return undefined
+  }
+
+  get<T>(field: string): T {
+    return this.data[field]
+  }
+
+  set<T>(field: string, value: T | T[] | ID | ID[]): void {
+    if (Array.isArray(value) && value instanceof Entity) {
+      this.data[field] = value.map((v) => (v as Entity).id)
+    } else if (value instanceof Entity) {
+      this.data[field] = (value as Entity).id
+    }
+    this.data[field] = value
+  }
+
+  protected getFieldObject<T extends Entity>(entity: EntityClass<T> | string, field: string): Promise<T | undefined> {
+    const id = this.data[field]
+    return id ? (this.getStore()?.get(entity, id) as Promise<T>) : Promise.resolve(undefined)
+  }
+
+  protected getFieldObjectArray<T extends Entity>(entity: EntityClass<T>, field: string): Promise<T[]> {
+    const ids = this.data[field]
+    const promises = ids.map((id: string) => this.getStore()?.get(entity, id))
+    return Promise.all(promises) as Promise<T[]>
+  }
+
+  toString(): string {
+    const entityName = this.constructor.prototype.entityName
+    const id = this.id
+    return `${entityName}#${id} ${JSON.stringify(this.data)}`
+  }
+}

package/src/store/index.ts

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

package/src/store/run.ts

@@ -0,0 +1,10 @@
+import { codegen } from './codegen.js'
+
+if (process.argv.length > 3) {
+  const srcFile = process.argv[2]
+  const targetDir = process.argv[3]
+  await codegen(srcFile, targetDir)
+} else {
+  console.error('Not enough argument')
+  process.exit(1)
+}

package/src/store/schema.ts

@@ -0,0 +1,35 @@
+import { buildASTSchema, DocumentNode, extendSchema, GraphQLSchema, parse, validateSchema } from 'graphql/index.js'
+import * as fs from 'node:fs'
+
+const customScalars = ['BigInt', 'BigDecimal', 'DateTime', 'JSON', 'Bytes', 'ID']
+
+const baseSchema = buildASTSchema(
+  parse(`
+    directive @entity on OBJECT
+    directive @query on INTERFACE
+    directive @derivedFrom(field: String!) on FIELD_DEFINITION
+    directive @unique on FIELD_DEFINITION
+    directive @index(fields: [String!] unique: Boolean) repeatable on OBJECT | FIELD_DEFINITION
+    directive @fulltext(query: String!) on FIELD_DEFINITION
+    directive @cardinality(value: Int!) on OBJECT | FIELD_DEFINITION
+    directive @byteWeight(value: Float!) on FIELD_DEFINITION
+    directive @variant on OBJECT # legacy
+    directive @jsonField on OBJECT # legacy
+    ${customScalars.map((name) => 'scalar ' + name).join('\n')}
+`)
+)
+
+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]
+  }
+  return schema
+}
+
+export function schemaFromFile(filePath: string) {
+  const source = fs.readFileSync(filePath, 'utf-8')
+  const doc = parse(source)
+  return { schema: buildSchema(doc), source }
+}

package/src/store/store.ts

@@ -0,0 +1,80 @@
+import { Entity, EntityClass } from './entity.js'
+import { StoreContext } from './context.js'
+import { DatabaseSchema } from '../core/index.js'
+
+export class Store {
+  constructor(private readonly context: StoreContext) {}
+
+  async get<T extends Entity>(entity: EntityClass<T> | string, id: string): Promise<T | undefined> {
+    const promise = this.context.sendRequest({
+      get: {
+        entity: typeof entity == 'string' ? entity : entity.prototype.entityName,
+        id
+      }
+    })
+
+    const data = (await promise) as any
+    if (data?.['id'] != null) {
+      return this.newEntity(entity, data)
+    }
+    return undefined
+  }
+
+  async delete(entity: EntityClass<any>, id: string | string[]): Promise<void> {
+    const toBeDeleted = []
+    if (Array.isArray(id)) {
+      for (const i of id) {
+        toBeDeleted.push({ entity: entity.prototype.entityName, id: i })
+      }
+    } else {
+      toBeDeleted.push({ entity: entity.prototype.entityName, id })
+    }
+    await this.context.sendRequest({
+      delete: {
+        entity: toBeDeleted.map((e) => e.entity) as string[],
+        id: toBeDeleted.map((e) => e.id) as string[]
+      }
+    })
+  }
+
+  async upsert<T extends Entity>(entity: T | T[]): Promise<void> {
+    const entities = Array.isArray(entity) ? entity : [entity]
+    const promise = this.context.sendRequest({
+      upsert: {
+        entity: entities.map((e) => e.constructor.prototype.entityName),
+        data: entities.map((e) => e.data),
+        id: entities.map((e) => e.id)
+      }
+    })
+
+    await promise
+  }
+
+  async list<T extends Entity>(entity: EntityClass<T>, limit?: number, offset?: number): Promise<T[]> {
+    const promise = this.context.sendRequest({
+      list: {
+        entity: entity.constructor.prototype.entityName,
+        limit,
+        offset
+      }
+    })
+
+    const list = (await promise) as any[]
+    return list.map((data) => {
+      return this.newEntity(entity, data)
+    })
+  }
+
+  private newEntity<T extends Entity>(entity: EntityClass<T> | string, data: any) {
+    if (typeof entity == 'string') {
+      const en = DatabaseSchema.findEntity(entity)
+      if (!en) {
+        // it is an interface
+        return new Entity(data) as T
+      }
+      entity = en
+    }
+
+    return new (entity as EntityClass<T>)(data)
+  }
+}

package/src/store/types.ts

@@ -0,0 +1,10 @@
+export type { BigDecimal } from '@sentio/bigdecimal'
+
+export type ID = string
+export type String = string
+export type Int = number
+export type Float = number
+export type Boolean = boolean
+export type DateTime = Date
+export type Json = any
+export type Bytes = Uint8Array

package/src/testing/test-processor-server.ts

@@ -2,12 +2,16 @@ import {
   AccountConfig,
   ContractConfig,
   DataBinding,
+  DeepPartial,
   Empty,
   ProcessBindingResponse,
   ProcessBindingsRequest,
   ProcessConfigRequest,
   ProcessConfigResponse,
   ProcessorServiceImplementation,
+  ProcessStreamRequest,
+  ProcessStreamResponse,
+  ServerStreamingMethodResult,
   StartRequest
 } from '@sentio/protos'
 import { CallContext } from 'nice-grpc-common'
@@ -80,7 +84,14 @@ export class TestProcessorServer implements ProcessorServiceImplementation {
     return this.service.processBindings({ bindings: [request] }, context)
   }
 
-  processBindingsStream(request: AsyncIterable<DataBinding>, context: CallContext) {
-    return this.service.processBindingsStream(request, context)
+  processBindingsStream(
+    requests: AsyncIterable<ProcessStreamRequest>,
+    context: CallContext
+  ): ServerStreamingMethodResult<DeepPartial<ProcessStreamResponse>> {
+    throw new Error('Method not implemented.')
   }
+
+  // processBindingsStream(request: AsyncIterable<ProcessStreamRequest>, context: CallContext) {
+  //   return this.service.processBindingsStream(request, context)
+  // }
 }