@sentio/sdk 4.0.0-rc.2 → 4.0.0-rc.4

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

@@ -2,30 +2,34 @@ import {
   type AccountConfig,
   type ContractConfig,
   type DataBinding,
+  type DBResponse,
   type Empty,
   EmptySchema,
-  type PreprocessStreamRequest,
   type ProcessBindingResponse,
   ProcessBindingResponseSchema,
   ProcessBindingsRequestSchema,
   ProcessConfigRequestSchema,
   type ProcessConfigResponse,
+  type ProcessResult,
   type ProcessStreamRequest,
-  ProcessStreamResponseSchema,
+  ProcessStreamRequestSchema,
+  ProcessStreamResponseV3Schema,
   StartRequestSchema,
   type TemplateInstance,
+  TemplateInstanceSchema,
   type TimeseriesResult,
   UpdateTemplatesRequestSchema
 } from '@sentio/protos'
 import { create, type MessageInitShape } from '@bufbuild/protobuf'
 import { type HandlerContext } from '@connectrpc/connect'
 import {
+  DataBindingContext,
   Endpoints,
   IDataBindingContext,
+  mergeProcessResults,
   PluginManager,
-  ProcessorServiceImpl,
   State,
-  StoreContext
+  ProcessorServiceImplV3
 } from '@sentio/runtime'
 
 import { AptosFacet } from './aptos-facet.js'
@@ -40,7 +44,7 @@ import { DatabaseSchemaState } from '../core/database-schema.js'
 import { IotaFacet } from './iota-facet.js'
 import { ChainInfo } from '@sentio/chain'
 
-type ProcessStreamResponseInit = MessageInitShape<typeof ProcessStreamResponseSchema>
+type ProcessStreamResponseV3Init = MessageInitShape<typeof ProcessStreamResponseV3Schema>
 
 export const TEST_CONTEXT = {} as HandlerContext
 
@@ -52,10 +56,11 @@ export function cleanTest() {
 }
 
 export class TestProcessorServer {
-  service: ProcessorServiceImpl
+  service: ProcessorServiceImplV3
   contractConfigs: ContractConfig[]
   accountConfigs: AccountConfig[]
   storeContext: TestStoreContext
+  private nextProcessId = 1
 
   aptos: AptosFacet
   eth: EthFacet
@@ -69,7 +74,7 @@ export class TestProcessorServer {
   constructor(loader: () => Promise<any>, httpEndpoints: Record<string, string> = {}) {
     cleanTest()
 
-    this.service = new ProcessorServiceImpl(loader)
+    this.service = new ProcessorServiceImplV3(loader)
     this.aptos = new AptosFacet(this)
     this.solana = new SolanaFacet(this)
     this.eth = new EthFacet(this)
@@ -84,8 +89,8 @@ export class TestProcessorServer {
     }
 
     // start a memory database for testing
-    const subject = new Subject<ProcessStreamResponseInit>()
-    this.storeContext = new TestStoreContext(subject, 1)
+    const subject = new Subject<ProcessStreamResponseV3Init>()
+    this.storeContext = new TestStoreContext(subject, 1, this.service)
     this._db = new MemoryDatabase(this.storeContext)
   }
 
@@ -104,7 +109,8 @@ export class TestProcessorServer {
   }
 
   stop(request: Empty = create(EmptySchema), context = TEST_CONTEXT) {
-    return this.service.stop(request, context)
+    this._db.stop()
+    return request
   }
 
   async getConfig(
@@ -121,43 +127,96 @@ export class TestProcessorServer {
     context: HandlerContext = TEST_CONTEXT
   ): Promise<ProcessBindingResponse> {
     const req = create(ProcessBindingsRequestSchema, request)
-    return PluginManager.INSTANCE.dbContextLocalStorage.run(this.storeContext, async () => {
-      const ret = await this.service.processBindings(req, context)
-      if (ret.result?.states?.configUpdated) {
-        // template may changed
+    return this.processBindingList(req.bindings, context)
+  }
+
+  async processBinding(request: DataBinding, context: HandlerContext = TEST_CONTEXT): Promise<ProcessBindingResponse> {
+    return this.processBindingList([request], context)
+  }
+
+  private async processBindingList(
+    bindings: DataBinding[],
+    context: HandlerContext = TEST_CONTEXT
+  ): Promise<ProcessBindingResponse> {
+    const results: ProcessResult[] = []
+    for (const binding of bindings) {
+      const result = await this.processBindingV3(binding, context)
+      results.push(result)
+
+      if (result.states?.configUpdated) {
         await PluginManager.INSTANCE.updateTemplates(
           create(UpdateTemplatesRequestSchema, {
-            chainId: req.bindings[0].chainId,
+            chainId: binding.chainId,
             templateInstances: this.storeContext.templateInstances
           })
         )
       }
-      return create(ProcessBindingResponseSchema, ret)
+    }
+    return create(ProcessBindingResponseSchema, {
+      result: mergeProcessResults(results)
     })
   }
 
-  async processBinding(request: DataBinding, context: HandlerContext = TEST_CONTEXT): Promise<ProcessBindingResponse> {
-    const ret = await PluginManager.INSTANCE.dbContextLocalStorage.run(this.storeContext, () => {
-      return this.service.processBindings(create(ProcessBindingsRequestSchema, { bindings: [request] }), context)
-    })
-    if (ret.result?.states?.configUpdated) {
-      // template may changed
-      await PluginManager.INSTANCE.updateTemplates(
-        create(UpdateTemplatesRequestSchema, {
-          chainId: request.chainId,
-          templateInstances: this.storeContext.templateInstances
-        })
-      )
-    }
-    return create(ProcessBindingResponseSchema, ret)
-  }
+  private processBindingV3(request: DataBinding, context: HandlerContext): Promise<ProcessResult> {
+    const processId = this.nextProcessId++
+    const subject = this.storeContext.subject
 
-  processBindingsStream(requests: AsyncIterable<ProcessStreamRequest>, context: HandlerContext): never {
-    throw new Error('Method not implemented.')
+    return new Promise((resolve, reject) => {
+      const subscription = subject.subscribe({
+        next: (response) => {
+          if (response.processId !== processId) {
+            return
+          }
+          if (response.value?.case === 'tplRequest') {
+            this.storeContext.applyTemplateRequest(
+              (response.value.value.templates ?? []).map((template) => create(TemplateInstanceSchema, template)),
+              response.value.value.remove ?? false
+            )
+          }
+          if (response.value?.case === 'result') {
+            subscription.unsubscribe()
+            // The service always emits a fully-formed ProcessResult message here; use it directly.
+            // Do NOT re-`create(ProcessResultSchema, ...)` — that re-validates every field and throws
+            // on results carrying loosely-typed values (e.g. a hex string in an int32 field), which
+            // the old unary processBindings path passed through untouched.
+            const result = response.value.value as ProcessResult
+            // The V3 service reports handler failures as a result with `states.error` set (via
+            // DataBindingContext.error) rather than erroring the stream. Surface it as a thrown
+            // error so tests observe the same behavior as the old unary processBindings path.
+            if (result.states?.error) {
+              reject(new Error(result.states.error))
+            } else {
+              resolve(result)
+            }
+          }
+        },
+        error: (e) => {
+          subscription.unsubscribe()
+          reject(e)
+        }
+      })
+
+      this.service
+        .handleRequest(
+          create(ProcessStreamRequestSchema, {
+            processId,
+            value: {
+              case: 'binding',
+              value: request
+            }
+          }),
+          undefined,
+          subject
+        )
+        .catch((e) => {
+          subscription.unsubscribe()
+          reject(e)
+        })
+    })
   }
 
-  preprocessBindingsStream(requests: AsyncIterable<PreprocessStreamRequest>, context: HandlerContext): never {
-    throw new Error('Method not implemented.')
+  processBindingsStream(requests: AsyncIterable<ProcessStreamRequest>, context: HandlerContext) {
+    return this.service.processBindingsStream(requests, context)
   }
 
   // processBindingsStream(request: AsyncIterable<ProcessStreamRequest>, context: HandlerContext) {
@@ -172,17 +231,37 @@ export class TestProcessorServer {
   }
 }
 
-class TestStoreContext extends StoreContext implements IDataBindingContext {
+class TestStoreContext extends DataBindingContext implements IDataBindingContext {
   constructor(
-    readonly subject: Subject<ProcessStreamResponseInit>,
-    processId: number
+    subject: Subject<ProcessStreamResponseV3Init>,
+    processId: number,
+    private readonly service: ProcessorServiceImplV3
   ) {
-    super(subject, processId)
+    super(processId, subject)
   }
 
   templateInstances: TemplateInstance[] = []
 
-  sendTemplateRequest(templates: Array<TemplateInstance>, remove: boolean): void {
+  result(dbResult: DBResponse, processId = this.processId): void {
+    // Resolve a request issued directly from this context (e.g. `service.store.get(...)` in a test,
+    // which goes through the TestStoreContext rather than a per-binding context). opIds are globally
+    // unique, so this is a no-op when the request originated from the service's per-binding context.
+    super.result(dbResult)
+    // Forward to the service's per-binding context for requests issued while processing a binding.
+    void this.service.handleRequest(
+      create(ProcessStreamRequestSchema, {
+        processId,
+        value: {
+          case: 'dbResult',
+          value: dbResult
+        }
+      }),
+      undefined,
+      this.subject
+    )
+  }
+
+  applyTemplateRequest(templates: Array<TemplateInstance>, remove: boolean): void {
     if (remove) {
       this.templateInstances = this.templateInstances.filter(
         (i) => !templates.find((t) => t.templateId === i.templateId && t.contract?.address === i.contract?.address)
@@ -191,7 +270,12 @@ class TestStoreContext extends StoreContext implements IDataBindingContext {
       this.templateInstances.push(...templates)
     }
   }
+
+  sendTemplateRequest(templates: Array<TemplateInstance>, remove: boolean): void {
+    this.applyTemplateRequest(templates, remove)
+  }
+
   sendTimeseriesRequest(timeseries: Array<TimeseriesResult>): void {
-    throw new Error('Method not implemented.')
+    // Test helpers currently expose metric/event/export results through ProcessResult.
   }
 }