@sentio/sdk 2.39.3 → 2.39.4-rc.1

package/src/store/convert.ts

@@ -0,0 +1,271 @@
+import { RichStruct, RichValue, RichValue_NullValue } from '@sentio/protos'
+import { String, Int, Float, ID, Bytes, DateTime, Boolean } from './types.js'
+import { Entity } from './entity.js'
+import { BigDecimal } from '@sentio/bigdecimal'
+
+export interface ValueConverter<T> {
+  from: (value: T) => RichValue
+  to: (value: RichValue) => T
+}
+
+export function required_<T>(converter: ValueConverter<T | undefined>): ValueConverter<T> {
+  return {
+    from: (value: T | undefined) => {
+      if (value == null) {
+        throw new Error('Value is required but received null or undefined')
+      }
+      return converter.from(value)
+    },
+    to: (value: RichValue) => {
+      if (value == null || value.nullValue) {
+        throw new Error('Value is required but received null')
+      }
+      return converter.to(value)!
+    }
+  }
+}
+
+export function array_<T>(converter: ValueConverter<T>): ValueConverter<T[]> {
+  return {
+    from: (value: T[]) => {
+      return {
+        listValue: {
+          values: value.map(converter.from)
+        }
+      }
+    },
+    to: (value: RichValue) => {
+      return value.listValue?.values.map(converter.to) || []
+    }
+  }
+}
+
+export function enumerate_<T extends string | number>(values: Record<T, string>): ValueConverter<T> {
+  return {
+    from: (value?: T) => {
+      if (value == null) {
+        return {
+          nullValue: RichValue_NullValue.NULL_VALUE
+        }
+      }
+      return {
+        stringValue: values[value]
+      }
+    },
+    to(v: RichValue): T {
+      return v.stringValue as T
+    }
+  }
+}
+
+export function objectId_<T>(): ValueConverter<T | ID> {
+  return {
+    from: (value: T | ID) => {
+      if (typeof value == 'string') {
+        return {
+          stringValue: value
+        }
+      }
+      if (value instanceof Entity) {
+        return {
+          stringValue: value.id
+        }
+      }
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    },
+    to(v) {
+      return v.stringValue as T | ID
+    }
+  }
+}
+
+/* eslint-disable */
+export const StringConverter: ValueConverter<String | undefined> = {
+  from: (value?: String) => {
+    if (value == null) {
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    }
+    return {
+      stringValue: value
+    }
+  },
+  to(v) {
+    return v.stringValue
+  }
+}
+
+export const IntConverter: ValueConverter<Int | undefined> = {
+  from: (value?: Int) => {
+    if (value == null) {
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    }
+    return {
+      intValue: value
+    }
+  },
+  to(v) {
+    return v.intValue
+  }
+}
+
+export const FloatConverter: ValueConverter<Float | undefined> = {
+  from: (value?: Float) => {
+    if (value == null) {
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    }
+    return {
+      floatValue: value
+    }
+  },
+  to(v) {
+    return v.floatValue
+  }
+}
+
+export const BooleanConverter: ValueConverter<Boolean | undefined> = {
+  from: (value?: Boolean) => {
+    if (value == null) {
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    }
+    return {
+      boolValue: value
+    }
+  },
+  to(v) {
+    return v.boolValue
+  }
+}
+
+export const DateTimeConverter: ValueConverter<DateTime | undefined> = {
+  from: (value: DateTime | undefined) => {
+    if (value == null) {
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    }
+    return {
+      timestampValue: value
+    }
+  },
+  to(v) {
+    return v.timestampValue
+  }
+}
+
+export const BytesConverter: ValueConverter<Bytes | undefined> = {
+  from: (value?: Bytes) => {
+    if (value == null) {
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    }
+    return {
+      bytesValue: value
+    }
+  },
+  to(v) {
+    return v.bytesValue
+  }
+}
+
+export const IDConverter: ValueConverter<ID | undefined> = StringConverter
+
+export const BigDecimalConverter: ValueConverter<BigDecimal | undefined> = {
+  from: (value?: BigDecimal): RichValue => {
+    if (value == null) {
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    }
+
+    const exp = value.decimalPlaces() ?? 0
+    const s = value.multipliedBy(new BigDecimal(10).pow(exp)).toFixed()
+
+    return {
+      bigdecimalValue: {
+        value: toBigInteger(BigInt(s)),
+        exp: exp
+      }
+    }
+  },
+  to(v) {
+    const d = v.bigdecimalValue
+    if (d) {
+      const i = bytesToBigInt(d.value!.data)
+      return new BigDecimal(`${i}`).dividedBy(new BigDecimal(10).pow(d.exp)).multipliedBy(d.value?.negative ? -1 : 1)
+    }
+    return undefined
+  }
+}
+
+export const BigIntConverter: ValueConverter<bigint | undefined> = {
+  from: (value?: bigint) => {
+    if (value == null) {
+      return {
+        nullValue: RichValue_NullValue.NULL_VALUE
+      }
+    }
+    return {
+      bigintValue: toBigInteger(value)
+    }
+  },
+  to(v) {
+    if (v.bigintValue) {
+      let res = bytesToBigInt(v.bigintValue?.data)
+      if (v.bigintValue.negative) {
+        res = -res
+      }
+      return res
+    }
+    return undefined
+  }
+}
+
+export class StructConverter<T extends Entity> {
+  constructor(private converters: Record<string, ValueConverter<any>>) {}
+
+  from(data: any): RichStruct {
+    const fields: Record<string, RichValue> = {}
+    for (const [field, value] of Object.entries(data)) {
+      if (this.converters[field] !== undefined) {
+        fields[field] = this.converters[field].from(value)
+      }
+    }
+    return { fields }
+  }
+}
+
+export function bytesToBigInt(bytes: Uint8Array) {
+  let intValue = BigInt(0)
+  for (let i = 0; i < bytes.length; i++) {
+    intValue = intValue * BigInt(256) + BigInt(bytes[i])
+  }
+  return intValue
+}
+
+export function toBigInteger(a: bigint) {
+  const negative = a < 0
+  if (negative) {
+    a = -a
+  }
+  let hex = a.toString(16)
+  if (hex.length % 2 === 1) {
+    hex = '0' + hex
+  }
+  const buffer = Buffer.from(hex, 'hex')
+
+  return {
+    negative: negative,
+    data: new Uint8Array(buffer)
+  }
+}

package/src/store/entity.ts

@@ -1,6 +1,8 @@
 import { ID } from './types.js'
 import { PluginManager } from '@sentio/runtime'
 import { Store } from './store.js'
+import { RichStruct } from '@sentio/protos'
+import { array_, IDConverter, required_, ValueConverter } from './convert.js'
 
 export interface EntityClass<T extends Entity> {
   new (data: any): T
@@ -8,24 +10,25 @@ export interface EntityClass<T extends Entity> {
 
 export class Entity {
   get id(): ID {
-    return this.get('id')
+    return this.get('id', required_(IDConverter))
   }
 
-  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)
+  protected fromPojo(data: any, converters: Record<string, ValueConverter<any>>) {
+    for (const [field, value] of Object.entries(data)) {
+      if (converters[field] !== undefined) {
+        this.set(field, value, converters[field])
       }
-    })
+    }
+  }
+
+  constructor(private _data: RichStruct = { fields: {} }) {}
+
+  setData(data: RichStruct) {
+    this._data = data
   }
 
   private getIdFromEntity(entity: any): any {
-    if (entity instanceof Entity) {
-      return entity.id
-    } else if (typeof entity === 'object' && entity.id) {
+    if (typeof entity === 'object' && entity.id) {
       return entity.id
     }
     return entity
@@ -39,26 +42,32 @@ export class Entity {
     return undefined
   }
 
-  get<T>(field: string): T {
-    return this.data[field]
+  get<T>(field: string, converter: ValueConverter<T>): T {
+    const value = this._data.fields[field]
+    return converter.to(value)
   }
 
-  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
+  set<T>(field: string, value: T, serializer: ValueConverter<T>): void {
+    if (Array.isArray(value)) {
+      this._data.fields[field] = {
+        listValue: { values: value.map((v) => serializer.from(v)) }
+      }
+    } else {
+      this._data.fields[field] = serializer.from(value)
     }
-    this.data[field] = value
   }
 
-  protected getFieldObject<T extends Entity>(entity: EntityClass<T> | string, field: string): Promise<T | undefined> {
-    const id = this.data[field]
+  protected getObject<T extends Entity>(entity: EntityClass<T> | string, field: string): Promise<T | undefined> {
+    const id = this.get(field, IDConverter)
     return id ? (this.getStore()?.get(entity, id) as Promise<T>) : Promise.resolve(undefined)
   }
 
+  protected setObject(field: string, value: any): void {
+    this.set(field, this.getIdFromEntity(value), IDConverter)
+  }
+
   protected getFieldObjectArray<T extends Entity>(entity: EntityClass<T>, field: string): Promise<T[]> {
-    const ids = this.data[field]
+    const ids = this.get(field, array_(IDConverter))
     const promises = ids.map((id: string) => this.getStore()?.get(entity, id))
     return Promise.all(promises) as Promise<T[]>
   }
@@ -66,6 +75,10 @@ export class Entity {
   toString(): string {
     const entityName = this.constructor.prototype.entityName
     const id = this.id
-    return `${entityName}#${id} ${JSON.stringify(this.data)}`
+    return `${entityName}#${id} ${JSON.stringify(this._data)}`
+  }
+
+  serialize(): RichStruct {
+    return this._data
   }
 }

package/src/store/index.ts

@@ -3,3 +3,4 @@ export * from './types.js'
 export * from './entity.js'
 export * from './store.js'
 export * from './context.js'
+export * from './convert.js'

package/src/store/store.ts

@@ -2,6 +2,12 @@ import { Entity, EntityClass } from './entity.js'
 import { StoreContext } from './context.js'
 import { DatabaseSchema } from '../core/index.js'
 import { BigDecimal } from '@sentio/bigdecimal'
+import { Bytes, DateTime, Float, ID, Int } from './types.js'
+import { DBRequest_DBOperator, DBResponse } from '@sentio/protos'
+import type { RichStruct, RichValue } from '@sentio/protos'
+import { toBigInteger } from './convert.js'
+
+type Value = ID | string | Int | Float | boolean | DateTime | Bytes | BigDecimal | bigint
 
 export class Store {
   constructor(private readonly context: StoreContext) {}
@@ -14,10 +20,12 @@ export class Store {
       }
     })
 
-    const data = (await promise) as any
-    if (data?.['id'] != null) {
-      return this.newEntity(entity, data)
+    const data = (await promise) as DBResponse
+    if (data.entities?.entities[0]) {
+      const entityData = data.entities.entities[0]
+      return this.newEntity(entity, entityData)
     }
+
     return undefined
   }
 
@@ -43,65 +51,127 @@ export class Store {
     const promise = this.context.sendRequest({
       upsert: {
         entity: entities.map((e) => e.constructor.prototype.entityName),
-        data: entities.map((e) => serialize(e.data)),
-        id: entities.map((e) => e.id)
+        // data: entities.map((e) => serialize(e.data)),
+        id: entities.map((e) => e.id),
+        entityData: entities.map((e) => e.serialize())
       }
     })
 
     await promise
   }
 
-  async list<T extends Entity>(entity: EntityClass<T>, limit?: number, offset?: number): Promise<T[]> {
-    const promise = this.context.sendRequest({
-      list: {
-        entity: entity.prototype.entityName,
-        limit,
-        offset
-      }
-    })
+  async *list<T extends Entity>(entity: EntityClass<T>, filters?: ListFilter<T>[]) {
+    let cursor: string | undefined = undefined
 
-    const list = (await promise) as any[]
-    return list.map((data) => {
-      return this.newEntity(entity, data)
-    })
+    while (true) {
+      const promise = this.context.sendRequest({
+        list: {
+          entity: entity.prototype.entityName,
+          cursor,
+          filters:
+            filters?.map((f) => ({
+              field: f.field as string,
+              op: ops[f.op],
+              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.entities?.entities || []) {
+        yield this.newEntity(entity, data)
+      }
+      if (!response.nextCursor) {
+        break
+      }
+      cursor = response.nextCursor
+    }
   }
 
-  private newEntity<T extends Entity>(entity: EntityClass<T> | string, data: any) {
+  private newEntity<T extends Entity>(entity: EntityClass<T> | string, data: RichStruct) {
     if (typeof entity == 'string') {
       const en = DatabaseSchema.findEntity(entity)
       if (!en) {
         // it is an interface
-        return new Entity(data) as T
+        return new Entity() as T
       }
       entity = en
     }
 
-    return new (entity as EntityClass<T>)(data)
+    const res = new (entity as EntityClass<T>)({}) as T
+    res.setData(data)
+    return res
   }
 }
 
-function serialize(data: Record<string, any>) {
-  const ret: Record<string, any> = {}
-  for (const [k, v] of Object.entries(data)) {
-    if (v instanceof Entity) {
-      ret[k] = v.id
-    } else if (Array.isArray(v) && v[0] instanceof Entity) {
-      ret[k] = v.map((e) => e.id)
-    } else if (typeof v === 'bigint') {
-      ret[k] = v.toString()
-    } else if (typeof v === 'object') {
-      if (v instanceof Date) {
-        ret[k] = v.toISOString()
-      } else if (v instanceof Uint8Array) {
-        ret[k] = Buffer.from(v).toString('hex')
-      } else if (v instanceof BigDecimal) {
-        ret[k] = v.toString()
-      } else {
-        ret[k] = serialize(v)
-      }
-    } else {
-      ret[k] = v
+export type Operators = '=' | '!=' | '<' | '<=' | '>' | '>=' | 'in' | 'not in'
+
+export interface ListFilter<T extends Entity> {
+  field: keyof T
+  op: Operators
+  value: Value | Value[] | null
+}
+
+export interface ListOptions<T extends Entity> {
+  cursor: string
+}
+
+const ops: Record<Operators, DBRequest_DBOperator> = {
+  '=': DBRequest_DBOperator.EQ,
+  '!=': DBRequest_DBOperator.NE,
+  '<': DBRequest_DBOperator.LT,
+  '<=': DBRequest_DBOperator.LE,
+  '>': DBRequest_DBOperator.GT,
+  '>=': DBRequest_DBOperator.GE,
+  in: DBRequest_DBOperator.IN,
+  'not in': DBRequest_DBOperator.NOT_IN
+}
+
+function serialize(v: any): RichValue {
+  if (v == null) {
+    return { nullValue: 0 }
+  }
+  if (typeof v == 'boolean') {
+    return { boolValue: v }
+  }
+  if (typeof v == 'string') {
+    return { stringValue: v }
+  }
+
+  if (typeof v == 'number') {
+    return { floatValue: v }
+  }
+  if (typeof v == 'bigint') {
+    return {
+      bigintValue: toBigInteger(v)
+    }
+  }
+
+  if (v instanceof BigDecimal) {
+    return serializeBigDecimal(v)
+  }
+
+  if (v instanceof Date) {
+    return {
+      timestampValue: v
     }
   }
-  return ret
+
+  if (v instanceof Uint8Array) {
+    return { bytesValue: v }
+  }
+
+  if (Array.isArray(v)) {
+    return {
+      listValue: { values: v.map((v) => serialize(v)) }
+    }
+  }
+  return {
+    nullValue: 0
+  }
+}
+
+function serializeBigDecimal(v: BigDecimal): RichValue {
+  return {
+    bigdecimalValue: undefined
+  }
 }

package/src/store/types.ts

@@ -1,10 +1,7 @@
-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