@sentio/runtime 2.36.2-rc.1 → 2.37.0-rc.3

package/src/index.ts

@@ -5,3 +5,4 @@ export * from './endpoints.js'
 export * from './chain-config.js'
 export * from './service.js'
 export { GLOBAL_CONFIG, type GlobalConfig } from './global-config.js'
+export * from './db-context.js'

package/src/plugin.ts

@@ -1,4 +1,6 @@
 import { DataBinding, HandlerType, ProcessConfigResponse, ProcessResult, StartRequest } from '@sentio/protos'
+import { StoreContext } from './db-context.js'
+import { AsyncLocalStorage } from 'node:async_hooks'
 
 export abstract class Plugin {
   name: string
@@ -13,6 +15,7 @@ export abstract class Plugin {
   stateDiff(config: ProcessConfigResponse): boolean {
     return false
   }
+
   async processBinding(request: DataBinding): Promise<ProcessResult> {
     return ProcessResult.create()
   }
@@ -21,6 +24,7 @@ export abstract class Plugin {
 export class PluginManager {
   static INSTANCE = new PluginManager()
 
+  dbContextLocalStorage = new AsyncLocalStorage<StoreContext | undefined>()
   plugins: Plugin[] = []
   typesToPlugin = new Map<HandlerType, Plugin>()
 
@@ -54,11 +58,13 @@ export class PluginManager {
     return this.plugins.some((plugin) => plugin.stateDiff(config))
   }
 
-  processBinding(request: DataBinding): Promise<ProcessResult> {
+  processBinding(request: DataBinding, dbContext?: StoreContext): Promise<ProcessResult> {
     const plugin = this.typesToPlugin.get(request.handlerType)
     if (!plugin) {
       throw new Error(`No plugin for ${request.handlerType}`)
     }
-    return plugin.processBinding(request)
+    return this.dbContextLocalStorage.run(dbContext, () => {
+      return plugin.processBinding(request)
+    })
   }
 }

package/src/service.ts

@@ -1,8 +1,11 @@
 import { CallContext, ServerError, Status } from 'nice-grpc'
-import { RichServerError, DebugInfo } from 'nice-grpc-error-details'
+import { DebugInfo, RichServerError } from 'nice-grpc-error-details'
+import { from } from 'ix/Ix.dom.asynciterable.js'
+import { withAbort } from 'ix/Ix.dom.asynciterable.operators.js'
 
 import {
   DataBinding,
+  Empty,
   HandlerType,
   ProcessBindingResponse,
   ProcessBindingsRequest,
@@ -10,14 +13,15 @@ import {
   ProcessConfigResponse,
   ProcessorServiceImplementation,
   ProcessResult,
-  StartRequest,
-  Empty
+  ProcessStreamRequest,
+  StartRequest
 } from '@sentio/protos'
 
 import { PluginManager } from './plugin.js'
 import { errorString, mergeProcessResults } from './utils.js'
 import { freezeGlobalConfig, GLOBAL_CONFIG } from './global-config.js'
 
+import { StoreContext } from './db-context.js'
 ;(BigInt.prototype as any).toJSON = function () {
   return this.toString()
 }
@@ -153,19 +157,34 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     return result
   }
 
-  async *processBindingsStream(requests: AsyncIterable<DataBinding>, context: CallContext) {
-    for await (const request of requests) {
-      const result = await this.processBinding(request)
-      // let updated = false
-      // if (PluginManager.INSTANCE.stateDiff(this.processorConfig)) {
-      //   await this.configure()
-      //   updated = true
-      // }
-      yield {
-        result,
-        configUpdated: result.states?.configUpdated || false
-      }
+  async *processBindingsStream(requests: AsyncIterable<ProcessStreamRequest>, context: CallContext) {
+    if (!this.started) {
+      throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
     }
+
+    const dbContext = new StoreContext()
+    new Promise(async (resolve, reject) => {
+      for await (const request of requests) {
+        if (request.binding) {
+          const binding = request.binding
+          PluginManager.INSTANCE.processBinding(binding, dbContext).then((result) => {
+            dbContext.subject.next({
+              result,
+              processId: request.processId
+            })
+            // dbContext.subject.complete()
+            recordRuntimeInfo(result, binding.handlerType)
+          })
+        }
+        if (request.dbResult) {
+          dbContext.result(request.dbResult)
+        }
+      }
+      resolve(null)
+    }).then(() => {
+      dbContext.subject.complete()
+    })
+    yield* from(dbContext.subject).pipe(withAbort(context.signal))
   }
 }