@sentio/sdk 2.39.7-rc.3 → 2.39.7-rc.31

package/src/store/store.ts

@@ -6,6 +6,7 @@ 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'
+import { Cursor } from './cursor.js'
 
 type Value = ID | string | Int | Float | boolean | Timestamp | Bytes | BigDecimal | bigint
 
@@ -95,14 +96,60 @@ export class Store {
     await promise
   }
 
-  async *listIterator<T extends Entity>(entity: EntityClass<T>, filters?: ListFilter<T>[]) {
+  async *listIterator<T extends Entity, P extends keyof T, O extends Operators<T[P]>>(
+    entity: EntityClass<T>,
+    filters: ListFilter<T, P, O>[]
+  ) {
     let cursor: string | undefined = undefined
 
     while (true) {
-      const promise = this.context.sendRequest({
+      const response: DBResponse = await this.listRequest(entity, filters || [], cursor)
+      for (const data of response.entityList?.entities || []) {
+        yield this.newEntity(entity, data)
+      }
+      console.debug(
+        'list returned ',
+        response.entityList?.entities?.length,
+        ' entities, next cursor',
+        response?.nextCursor
+      )
+      if (!response.nextCursor) {
+        break
+      }
+      cursor = response.nextCursor
+    }
+  }
+
+  async *listBatched<T extends Entity, P extends keyof T, O extends Operators<T[P]>>(
+    entity: EntityClass<T>,
+    filters: ListFilter<T, P, O>[],
+    batchSize = 100
+  ) {
+    let cursor: string | undefined = undefined
+
+    while (true) {
+      const response: DBResponse = await this.listRequest(entity, filters || [], cursor, batchSize)
+      const entities = (response.entityList?.entities || []).map((data) => this.newEntity(entity, data))
+      yield entities
+      if (!response.nextCursor) {
+        break
+      }
+      cursor = response.nextCursor
+    }
+  }
+
+  private async listRequest<T extends Entity, P extends keyof T, O extends Operators<T[P]>>(
+    entity: EntityClass<T>,
+    filters: ListFilter<T, P, O>[],
+    cursor: string | undefined,
+    pageSize?: number
+  ): Promise<DBResponse> {
+    return (await this.context.sendRequest(
+      {
         list: {
           entity: getEntityName(entity),
           cursor,
+          pageSize,
           filters:
             filters?.map((f) => ({
               field: f.field as string,
@@ -110,19 +157,21 @@ export class Store {
               value: { values: Array.isArray(f.value) ? f.value.map((v) => serialize(v)) : [serialize(f.value)] }
             })) || []
         }
-      })
-      const response = (await promise) as DBResponse
-      for (const data of response.entityList?.entities || []) {
-        yield this.newEntity(entity, data)
-      }
-      if (!response.nextCursor) {
-        break
-      }
-      cursor = response.nextCursor
-    }
+      },
+      60
+    )) as DBResponse
   }
 
-  async list<T extends Entity>(entity: EntityClass<T>, filters?: ListFilter<T>[]) {
+  async list<T extends Entity, P extends keyof T, O extends Operators<T[P]>>(
+    entity: EntityClass<T>,
+    filters: ListFilter<T, P, O>[],
+    cursor?: Cursor
+  ) {
+    if (cursor) {
+      const response = await this.listRequest(entity, filters || [], cursor.cursor, cursor.pageSize)
+      cursor.cursor = response.nextCursor
+      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))
   }
@@ -154,19 +203,68 @@ export class Store {
   }
 }
 
-export type Operators = '=' | '!=' | '<' | '<=' | '>' | '>=' | 'in' | 'not in'
+type ArrayOperators = 'in' | 'not in' | 'has all' | 'has any'
 
-export interface ListFilter<T extends Entity> {
-  field: keyof T
-  op: Operators
-  value: Value | Value[] | null
-}
+export type Operators<T> =
+  T extends Array<any>
+    ? 'in' | 'not in' | '=' | '!=' | 'has all' | 'has any'
+    : T extends Int
+      ? '=' | '!=' | '<' | '<=' | '>' | '>=' | 'in' | 'not in'
+      : T extends Float
+        ? '=' | '!=' | '<' | '<=' | '>' | '>=' | 'in' | 'not in'
+        : T extends Bytes
+          ? '=' | '!=' | 'in' | 'not in'
+          : T extends ID
+            ? '=' | '!=' | 'like' | 'not like' | 'in' | 'not in'
+            : T extends string
+              ? '=' | '!=' | 'like' | 'not like' | 'in' | 'not in'
+              : T extends Timestamp
+                ? '=' | '!=' | '<' | '<=' | '>' | '>=' | 'in' | 'not in'
+                : T extends boolean
+                  ? '=' | '!=' | 'in' | 'not in'
+                  : T extends BigDecimal
+                    ? '=' | '!=' | '<' | '<=' | '>' | '>=' | 'in' | 'not in'
+                    : T extends bigint
+                      ? '=' | '!=' | '<' | '<=' | '>' | '>=' | 'in' | 'not in'
+                      : '=' | '!=' | 'in' | 'not in'
+
+type CompatibleValue<T, O extends Operators<T>> = O extends ArrayOperators
+  ? T extends Array<infer U>
+    ? U[]
+    : T[]
+  :
+      | (T extends bigint
+          ? bigint
+          : T extends Int
+            ? number
+            : T extends Float
+              ? number
+              : T extends Bytes
+                ? Bytes | string
+                : T extends ID
+                  ? ID | string
+                  : T extends BigDecimal
+                    ? BigDecimal | number
+                    : T extends Int
+                      ? number
+                      : T)
+      | Nullable<O>
 
-export interface ListOptions<T extends Entity> {
-  cursor: string
+type Nullable<O> = O extends '=' | '!=' ? null : never
+
+export type ListFilter<T extends Entity, P extends keyof T, O extends Operators<T[P]>> = {
+  field: P
+  op: O
+  value: CompatibleValue<T[P], O>
 }
 
-const ops: Record<Operators, DBRequest_DBOperator> = {
+export type ArrayFilter<T extends Entity, P extends keyof T, O extends Operators<T[P]>> = [
+  P,
+  O,
+  CompatibleValue<T[P], O>
+]
+
+const ops: Record<Operators<any>, DBRequest_DBOperator> = {
   '=': DBRequest_DBOperator.EQ,
   '!=': DBRequest_DBOperator.NE,
   '<': DBRequest_DBOperator.LT,
@@ -174,7 +272,11 @@ const ops: Record<Operators, DBRequest_DBOperator> = {
   '>': DBRequest_DBOperator.GT,
   '>=': DBRequest_DBOperator.GE,
   in: DBRequest_DBOperator.IN,
-  'not in': DBRequest_DBOperator.NOT_IN
+  'not in': DBRequest_DBOperator.NOT_IN,
+  like: DBRequest_DBOperator.LIKE,
+  'not like': DBRequest_DBOperator.NOT_LIKE,
+  'has all': DBRequest_DBOperator.HAS_ALL,
+  'has any': DBRequest_DBOperator.HAS_ANY
 }
 
 function serialize(v: any): RichValue {