@sentio/sdk 2.59.0-rc.9 → 2.59.0

package/src/fuel/fuel-processor-template.ts

@@ -8,6 +8,7 @@ import { FuelBlock, FuelLog, FuelTransaction } from './types.js'
 import { DEFAULT_FUEL_FETCH_CONFIG, FuelFetchConfig } from './transaction.js'
 import { FuelProcessor, FuelProcessorConfig, getOptionsSignature } from './fuel-processor.js'
 import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
+import { HandlerOptions } from '../core/index.js'
 
 export class FuelProcessorTemplateProcessorState extends ListStateStorage<FuelBaseProcessorTemplate<Contract>> {
   static INSTANCE = new FuelProcessorTemplateProcessorState()
@@ -21,6 +22,7 @@ export abstract class FuelBaseProcessorTemplate<TContract extends Contract> {
     handler: (block: FuelBlock, ctx: FuelContractContext<TContract>) => PromiseOrVoid
     blockInterval?: HandleInterval
     timeIntervalInMinutes?: HandleInterval
+    handlerOptions?: HandlerOptions<object, FuelBlock>
     // fetchConfig?: FuelFetchConfig
   }[] = []
 
@@ -28,13 +30,14 @@ export abstract class FuelBaseProcessorTemplate<TContract extends Contract> {
     logIdFilter: string | string[]
     handlerName: string
     handler: (logs: FuelLog<any>, ctx: FuelContractContext<TContract>) => PromiseOrVoid
+    handlerOptions?: HandlerOptions<object, FuelLog<any>>
     // fetchConfig?: FuelFetchConfig
   }[] = []
 
   transactionHandlers: {
     handlerName: string
     handler: (transaction: FuelTransaction, ctx: FuelContractContext<TContract>) => PromiseOrVoid
-    fetchConfig: FuelFetchConfig
+    handlerOptions?: HandlerOptions<FuelFetchConfig, FuelTransaction>
   }[] = []
 
   constructor() {
@@ -62,13 +65,13 @@ export abstract class FuelBaseProcessorTemplate<TContract extends Contract> {
     const processor = this.bindInternal({ ...options, chainId: ctx.chainId })
 
     for (const eh of this.logHandlers) {
-      processor.onLog(eh.logIdFilter, eh.handler, eh.handlerName)
+      processor.onLog(eh.logIdFilter, eh.handler, eh.handlerOptions, eh.handlerName)
     }
     for (const bh of this.blockHandlers) {
-      processor.onInterval(bh.handler, bh.timeIntervalInMinutes, bh.blockInterval, bh.handlerName)
+      processor.onInterval(bh.handler, bh.timeIntervalInMinutes, bh.blockInterval, bh.handlerOptions, bh.handlerName)
     }
     for (const th of this.transactionHandlers) {
-      processor.onTransaction(th.handler, undefined, th.handlerName)
+      processor.onTransaction(th.handler, th.handlerOptions, th.handlerName)
     }
 
     const instance: TemplateInstance = {
@@ -94,13 +97,15 @@ export abstract class FuelBaseProcessorTemplate<TContract extends Contract> {
 
   protected onLog<T>(
     logIdFilter: string | string[],
-    handler: (logs: FuelLog<T>, ctx: FuelContractContext<TContract>) => PromiseOrVoid
+    handler: (logs: FuelLog<T>, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
+    handlerOptions: HandlerOptions<object, FuelLog<T>> = {}
     // fetchConfig?: Partial<FuelFetchConfig>
   ) {
     this.logHandlers.push({
       logIdFilter,
       handlerName: getHandlerName(),
-      handler
+      handler,
+      handlerOptions
       // fetchConfig: { ...fetchConfig}
     })
     return this
@@ -140,14 +145,16 @@ export abstract class FuelBaseProcessorTemplate<TContract extends Contract> {
   public onInterval(
     handler: (block: FuelBlock, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
     timeInterval: HandleInterval | undefined,
-    blockInterval: HandleInterval | undefined
+    blockInterval: HandleInterval | undefined,
+    handlerOptions: HandlerOptions<object, FuelBlock> = {}
     // fetchConfig?: FuelFetchConfig
   ) {
     this.blockHandlers.push({
       handlerName: getHandlerName(),
       handler,
       timeIntervalInMinutes: timeInterval,
-      blockInterval
+      blockInterval,
+      handlerOptions
       // fetchConfig: { ...fetchConfig }
     })
     return this
@@ -155,12 +162,12 @@ export abstract class FuelBaseProcessorTemplate<TContract extends Contract> {
 
   protected onTransaction(
     handler: (transaction: FuelTransaction, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
-    config: FuelFetchConfig = DEFAULT_FUEL_FETCH_CONFIG
+    handlerOptions: HandlerOptions<FuelFetchConfig, FuelTransaction> = DEFAULT_FUEL_FETCH_CONFIG
   ) {
     this.transactionHandlers.push({
       handlerName: getHandlerName(),
       handler,
-      fetchConfig: config
+      handlerOptions
     })
     return this
   }

package/src/fuel/fuel-processor.ts

@@ -27,7 +27,7 @@ import {
   FuelTransaction,
   ReceiptHandler
 } from './types.js'
-import { PromiseOrVoid } from '../core/index.js'
+import { PromiseOrVoid, HandlerOptions } from '../core/index.js'
 import { ServerError, Status } from 'nice-grpc'
 import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
 
@@ -88,7 +88,7 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
 
   public onTransaction(
     handler: (transaction: FuelTransaction, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
-    config: FuelFetchConfig = DEFAULT_FUEL_FETCH_CONFIG,
+    handlerOptions?: HandlerOptions<FuelFetchConfig, FuelTransaction>,
     handlerName = getHandlerName()
   ) {
     const callHandler = {
@@ -115,7 +115,21 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
       },
       fetchConfig: {
         filters: [],
-        ...config
+        ...handlerOptions
+      },
+      partitionHandler: async (call: Data_FuelTransaction): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const abiMap = this.config.abi
+            ? {
+                [this.config.address]: this.config.abi
+              }
+            : {}
+          const tx = await decodeFuelTransactionWithAbi(call.transaction, abiMap, this.provider)
+          return p(tx)
+        }
+        return p
       }
     }
     this.txHandlers.push(callHandler)
@@ -184,15 +198,7 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
           return ctx.stopAndGetResult()
         } catch (e) {
           console.error(e)
-          return {
-            gauges: [],
-            counters: [],
-            events: [],
-            exports: [],
-            states: {
-              configUpdated: false
-            }
-          }
+          return ProcessResult.fromPartial({})
         }
       },
       fetchConfig: {
@@ -206,6 +212,7 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
   public onLog<T>(
     logIdFilter: string | string[],
     handler: (logs: FuelLog<T>, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
+    handlerOptions?: HandlerOptions<object, FuelLog<T>>,
     handlerName = getHandlerName()
   ) {
     const logIds = new Set(Array.isArray(logIdFilter) ? logIdFilter : [logIdFilter])
@@ -244,6 +251,25 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
         log: {
           logIds: Array.from(logIds)
         }
+      },
+      partitionHandler: async (data: Data_FuelReceipt): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          try {
+            const tx = await decodeFuelTransaction(data.transaction, this.provider)
+            const index = Number(data.receiptIndex)
+            const receipt = tx.receipts[index]
+            const log = decodeLog(receipt, this.config.abi)
+            if (log) {
+              return p({ receiptIndex: index, ...log })
+            }
+          } catch (e) {
+            console.error(e)
+          }
+          return undefined
+        }
+        return p
       }
     } as ReceiptHandler
     this.receiptHandlers.push(logHandler)
@@ -255,7 +281,8 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
    */
   public onTransfer(
     filter: ContractTransferFilter,
-    handler: (transfer: ReceiptTransfer | ReceiptTransferOut, ctx: FuelContractContext<TContract>) => PromiseOrVoid
+    handler: (transfer: ReceiptTransfer | ReceiptTransferOut, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
+    handlerOptions?: HandlerOptions<object, ReceiptTransfer | ReceiptTransferOut>
   ) {
     const { from, to, assetId } = filter
     const h = {
@@ -288,6 +315,22 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
           to,
           assetId
         }
+      },
+      partitionHandler: async (data: Data_FuelReceipt): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          try {
+            const tx = await decodeFuelTransaction(data.transaction, this.provider)
+            const index = Number(data.receiptIndex)
+            const receipt = tx.receipts[index] as ReceiptTransfer | ReceiptTransferOut
+            return p(receipt)
+          } catch (e) {
+            console.error(e)
+          }
+          return undefined
+        }
+        return p
       }
     } as ReceiptHandler
     this.receiptHandlers.push(h)
@@ -298,8 +341,8 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
     handler: (block: FuelBlock, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
     timeInterval: HandleInterval | undefined,
     blockInterval: HandleInterval | undefined,
+    handlerOptions?: HandlerOptions<object, FuelBlock>,
     handlerName = getHandlerName()
-    // fetchConfig: Partial<FuelFetchConfig> | undefined
   ): this {
     if (timeInterval) {
       if (timeInterval.backfillInterval < timeInterval.recentInterval) {
@@ -346,6 +389,31 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
         )
         await handler(block, ctx)
         return ctx.stopAndGetResult()
+      },
+      partitionHandler: async (data: Data_FuelBlock): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          const header = data.block
+          if (!header) return undefined
+          const block: FuelBlock = {
+            id: header.id,
+            height: bn(header.height),
+            time: header.time,
+            header: {
+              applicationHash: header.applicationHash,
+              daHeight: bn(header.daHeight),
+              eventInboxRoot: header.eventInboxRoot,
+              messageOutboxRoot: header.messageOutboxRoot,
+              prevRoot: header.prevRoot,
+              stateTransitionBytecodeVersion: header.stateTransitionBytecodeVersion,
+              transactionsCount: header.transactionsCount,
+              transactionsRoot: header.transactionsRoot
+            }
+          }
+          return p(block)
+        }
+        return p
       }
     })
     return this
@@ -354,8 +422,8 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
   public onBlockInterval(
     handler: (block: FuelBlock, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
     blockInterval = 250,
-    backfillBlockInterval = 1000
-    // fetchConfig?: Partial<FuelFetchConfig>
+    backfillBlockInterval = 1000,
+    handlerOptions?: HandlerOptions<object, FuelBlock>
   ): this {
     return this.onInterval(
       handler,
@@ -363,22 +431,22 @@ export class FuelProcessor<TContract extends Contract> implements FuelBaseProces
       {
         recentInterval: blockInterval,
         backfillInterval: backfillBlockInterval
-      }
-      // fetchConfig,
+      },
+      handlerOptions
     )
   }
 
   public onTimeInterval(
     handler: (block: FuelBlock, ctx: FuelContractContext<TContract>) => PromiseOrVoid,
     timeIntervalInMinutes = 60,
-    backfillTimeIntervalInMinutes = 240
-    // fetchConfig?: Partial<FuelFetchConfig>,
+    backfillTimeIntervalInMinutes = 240,
+    handlerOptions?: HandlerOptions<object, FuelBlock>
   ): this {
     return this.onInterval(
       handler,
       { recentInterval: timeIntervalInMinutes, backfillInterval: backfillTimeIntervalInMinutes },
-      undefined
-      // fetchConfig
+      undefined,
+      handlerOptions
     )
   }
 }

package/src/fuel/types.ts

@@ -29,12 +29,14 @@ export type CallHandler<T> = {
   handler: (call: T) => Promise<ProcessResult>
   fetchConfig?: Partial<FuelCallHandlerConfig>
   assetConfig?: Partial<FuelAssetHandlerConfig>
+  partitionHandler?: (call: T) => Promise<string | undefined>
 }
 
 export type ReceiptHandler = {
   handlerName: string
   handler: (receipt: Data_FuelReceipt) => Promise<ProcessResult>
   receiptConfig?: Partial<FuelReceiptHandlerConfig>
+  partitionHandler?: (receipt: Data_FuelReceipt) => Promise<string | undefined>
 }
 
 export type BlockHandler = {
@@ -43,6 +45,7 @@ export type BlockHandler = {
   handler: (block: Data_FuelBlock) => Promise<ProcessResult>
   handlerName: string
   fetchConfig?: Partial<OnIntervalConfig>
+  partitionHandler?: (block: Data_FuelBlock) => Promise<string | undefined>
 }
 
 export interface FuelLog<T> {

package/src/move/filter.ts

@@ -38,6 +38,7 @@ export class EventHandler<T> {
   handlerName: string
   handler: (event: T) => Promise<ProcessResult>
   fetchConfig: MoveFetchConfig
+  partitionHandler?: (event: T) => Promise<string | undefined>
 }
 
 export class CallHandler<T> {
@@ -45,6 +46,7 @@ export class CallHandler<T> {
   handlerName: string
   handler: (call: T) => Promise<ProcessResult>
   fetchConfig: MoveFetchConfig
+  partitionHandler?: (call: T) => Promise<string | undefined>
 }
 
 export class ObjectChangeHandler<T> {
@@ -57,6 +59,7 @@ export class ResourceChangeHandler<T> {
   handlerName: string
   handler: (call: T) => Promise<ProcessResult>
   type: string
+  partitionHandler?: (call: T) => Promise<string | undefined>
 }
 
 export class ResourceIntervalHandler {
@@ -66,6 +69,7 @@ export class ResourceIntervalHandler {
   handler: (resource: Data_AptResource) => Promise<ProcessResult>
   handlerName: string
   fetchConfig: MoveAccountFetchConfig
+  partitionHandler?: (resource: Data_AptResource) => Promise<string | undefined>
 }
 
 export class TransactionIntervalHandler {
@@ -74,4 +78,5 @@ export class TransactionIntervalHandler {
   handler: (tx: Data_AptCall) => Promise<ProcessResult>
   handlerName: string
   fetchConfig: MoveFetchConfig
+  partitionHandler?: (tx: Data_AptCall) => Promise<string | undefined>
 }

package/src/move/shared-network-codegen.ts

@@ -96,12 +96,12 @@ export abstract class SharedNetworkCodegen<NetworkType, ModuleTypes, StructType>
 
     const camelFuncName = upperFirst(camel(func.name))
     const source = `
-  onEntry${camelFuncName}(func: (call: ${moduleName}.${camelFuncName}Payload, ctx: ${this.PREFIX}Context) => void, filter?: CallFilter, fetchConfig?: Partial<MoveFetchConfig>): ${moduleName} {
+  onEntry${camelFuncName}(func: (call: ${moduleName}.${camelFuncName}Payload, ctx: ${this.PREFIX}Context) => void, filter?: CallFilter, handlerOptions?: HandlerOptions<MoveFetchConfig, ${moduleName}.${camelFuncName}Payload>): ${moduleName} {
     this.onEntryFunctionCall(func, {
       ...filter,
       function: '${module.name}::${func.name}'
     },
-    fetchConfig)
+    handlerOptions)
     return this
   }`
 
@@ -113,8 +113,8 @@ export abstract class SharedNetworkCodegen<NetworkType, ModuleTypes, StructType>
     const source = `
 onEvent${struct.name}(func: (event: ${moduleName}.${normalizeToJSName(struct.name)}Instance, ctx: ${
       this.PREFIX
-    }Context) => void, fetchConfig?: Partial<MoveFetchConfig>, eventFilter?: Omit<EventFilter, "type"|"account">): ${moduleName} {
-  this.onMoveEvent(func, {...eventFilter ?? {}, type: '${module.name}::${struct.name}' }, fetchConfig)
+    }Context) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, ${moduleName}.${normalizeToJSName(struct.name)}Instance>, eventFilter?: Omit<EventFilter, "type"|"account">): ${moduleName} {
+  this.onMoveEvent(func, {...eventFilter ?? {}, type: '${module.name}::${struct.name}' }, handlerOptions)
   return this
 }`
     return source
@@ -123,6 +123,7 @@ onEvent${struct.name}(func: (event: ${moduleName}.${normalizeToJSName(struct.nam
   generateImports() {
     return `
     import { CallFilter, MoveFetchConfig, EventFilter } from "@sentio/sdk/move"
+    import { HandlerOptions } from "@sentio/sdk"
     import {
       ${this.PREFIX}BindOptions, ${this.PREFIX}BaseProcessor,
       ${this.PREFIX}Network, TypedFunctionPayload,

package/src/solana/solana-processor.ts

@@ -5,6 +5,7 @@ import { SolanaBindOptions } from './solana-options.js'
 import { ListStateStorage } from '@sentio/runtime'
 import { Labels } from '../core/index.js'
 import { SolanaChainId } from '@sentio/chain'
+import { HandlerOptions } from '../core/handler-options.js'
 
 type IndexConfigure = {
   startSlot: bigint
@@ -17,12 +18,17 @@ export interface InstructionCoder {
 
 export type SolanaInstructionHandler = (instruction: Instruction, ctx: SolanaContext, accounts?: string[]) => void
 
+export interface InstructionHandlerEntry {
+  handler: SolanaInstructionHandler
+  handlerOptions?: HandlerOptions<object, Instruction>
+}
+
 export class SolanaProcessorState extends ListStateStorage<SolanaBaseProcessor> {
   static INSTANCE: SolanaProcessorState = new SolanaProcessorState()
 }
 
 export class SolanaBaseProcessor {
-  public instructionHandlerMap: Map<string, SolanaInstructionHandler> = new Map()
+  public instructionHandlerMap: Map<string, InstructionHandlerEntry> = new Map()
   address: string
   endpoint: string
   contractName: string
@@ -61,8 +67,12 @@ export class SolanaBaseProcessor {
     SolanaProcessorState.INSTANCE.addValue(this)
   }
 
-  public onInstruction(instructionName: string, handler: SolanaInstructionHandler) {
-    this.instructionHandlerMap.set(instructionName, handler)
+  public onInstruction(
+    instructionName: string,
+    handler: SolanaInstructionHandler,
+    handlerOptions?: HandlerOptions<object, Instruction>
+  ) {
+    this.instructionHandlerMap.set(instructionName, { handler, handlerOptions })
     return this
   }
 
@@ -78,21 +88,33 @@ export class SolanaBaseProcessor {
     return null
   }
 
-  public getInstructionHandler(parsedInstruction: Instruction): SolanaInstructionHandler | undefined {
+  public getInstructionHandler(parsedInstruction: Instruction): InstructionHandlerEntry | undefined {
     return this.instructionHandlerMap.get(parsedInstruction.name)
   }
 
   public async handleInstruction(
     parsedInstruction: Instruction,
     accounts: string[],
-    handler: SolanaInstructionHandler,
+    handlerEntry: InstructionHandlerEntry,
     slot: bigint
   ): Promise<ProcessResult> {
     const ctx = new SolanaContext(this.contractName, this.network, this.address, slot, this.baseLabels)
-    await handler(parsedInstruction, ctx, accounts)
+    await handlerEntry.handler(parsedInstruction, ctx, accounts)
     return ctx.stopAndGetResult()
   }
 
+  public async getPartitionKey(
+    parsedInstruction: Instruction,
+    handlerEntry: InstructionHandlerEntry
+  ): Promise<string | undefined> {
+    const p = handlerEntry.handlerOptions?.partitionKey
+    if (!p) return undefined
+    if (typeof p === 'function') {
+      return p(parsedInstruction)
+    }
+    return p
+  }
+
   public startSlot(startSlot: bigint | number) {
     this.config.startSlot = BigInt(startSlot)
     return this

package/src/stark/starknet-processor.ts

@@ -1,12 +1,13 @@
 import { Data_StarknetEvent, ProcessResult } from '@sentio/protos'
 import { StarknetChainId } from '@sentio/chain'
-import { CallData, constants, events, ParsedEvent, RpcProvider } from 'starknet'
+import { CallData, events, ParsedEvent, RpcProvider } from 'starknet'
 import { StarknetContext } from './context.js'
 import { StarknetEvent } from './event.js'
 import { ListStateStorage, mergeProcessResults } from '@sentio/runtime'
 import { StarknetProcessorConfig } from './types.js'
 import { StarknetContractView } from './contract.js'
 import { getHandlerName, proxyProcessor } from '../utils/metrics.js'
+import { HandlerOptions } from '../core/handler-options.js'
 
 export class StarknetProcessor {
   callHandlers: CallHandler<Data_StarknetEvent>[] = []
@@ -42,7 +43,8 @@ export class StarknetProcessor {
 
   public onEvent(
     event: string | string[],
-    handler: (events: StarknetEvent<ParsedEvent>, ctx: StarknetContext<StarknetContractView>) => void | Promise<void>
+    handler: (events: StarknetEvent<ParsedEvent>, ctx: StarknetContext<StarknetContractView>) => void | Promise<void>,
+    handlerOptions?: HandlerOptions<object, StarknetEvent<ParsedEvent>>
   ) {
     const eventFilter = Array.isArray(event) ? event : [event]
     if (!this.config.abi) {
@@ -83,18 +85,33 @@ export class StarknetProcessor {
           return mergeProcessResults(results)
         } catch (e) {
           console.error(e)
-          return {
-            gauges: [],
-            counters: [],
-            events: [],
-            exports: [],
-            states: {
-              configUpdated: false
+          return ProcessResult.fromPartial({})
+        }
+      },
+      eventFilter,
+      partitionHandler: async (call: Data_StarknetEvent): Promise<string | undefined> => {
+        const p = handlerOptions?.partitionKey
+        if (!p) return undefined
+        if (typeof p === 'function') {
+          try {
+            const eventData = [call.result] as any[]
+            const abiEvents = events.getAbiEvents(abi)
+            const abiStructs = CallData.getAbiStruct(abi)
+            const abiEnums = CallData.getAbiEnum(abi)
+            const parsedEvents = events.parseEvents(eventData, abiEvents, abiStructs, abiEnums)
+            if (parsedEvents.length > 0) {
+              const { from_address, transaction_hash } = call.result!
+              const e = new StarknetEvent(from_address, transaction_hash, parsedEvents[0])
+              return p(e)
             }
+            return undefined
+          } catch (e) {
+            console.error(e)
+            return undefined
           }
         }
-      },
-      eventFilter
+        return p
+      }
     }
     this.callHandlers.push(callHandler)
     return this
@@ -105,14 +122,15 @@ export type CallHandler<T> = {
   handlerName: string
   handler: (call: T) => Promise<ProcessResult>
   eventFilter?: string[]
+  partitionHandler?: (call: T) => Promise<string | undefined>
 }
 
 function getRpcEndpoint(chainId: StarknetChainId | string) {
   switch (chainId) {
     case StarknetChainId.STARKNET_MAINNET:
-      return constants.NetworkName.SN_MAIN
+      return 'https://starknet-mainnet.g.alchemy.com/starknet/version/rpc/v0_8/8sD5yitBslIYCPFzSq_Q1ObJHqPlZxFw'
     default:
-      return constants.NetworkName.SN_SEPOLIA
+      return 'https://starknet-sepolia.g.alchemy.com/starknet/version/rpc/v0_8/8sD5yitBslIYCPFzSq_Q1ObJHqPlZxFw'
   }
 }
 

package/src/store/codegen.ts

@@ -48,6 +48,8 @@ interface Class {
   annotations: string[]
   parent?: string
   interfaces: string[]
+  timeseries?: boolean
+  immutable?: boolean
 }
 
 interface Interface {
@@ -111,7 +113,7 @@ async function codegenInternal(schema: GraphQLSchema, source: string, target: st
     },
     {
       module: '@sentio/sdk/store',
-      types: ['Entity', 'Required', 'One', 'Many', 'Column', 'ListColumn', 'AbstractEntity']
+      types: ['Entity', 'Required', 'One', 'Many', 'Column', 'ListColumn', 'AbstractEntity', 'getStore', 'UpdateValues']
     },
     {
       module: '@sentio/bigdecimal',
@@ -154,6 +156,18 @@ async function codegenInternal(schema: GraphQLSchema, source: string, target: st
     }
 
     if (t instanceof GraphQLObjectType) {
+      if (isTimeseries(t)) {
+        // check id is int8
+        const idField = t.getFields()['id']
+        if (!idField || !isNonNullType(idField.type) || idField.type.toString() !== 'Int8!') {
+          throw new Error(`Timeseries entity ${t.name} must have an id field of type Int8!`)
+        }
+        // check if it has a timestamp field
+        const timestampField = t.getFields()['timestamp']
+        if (!timestampField || !isNonNullType(timestampField.type) || timestampField.type.toString() !== 'Timestamp!') {
+          throw new Error(`Timeseries entity ${t.name} must have a timestamp field of type Timestamp!`)
+        }
+      }
       if (isEntity(t)) {
         const fields: Field[] = []
         const methods: Method[] = []
@@ -177,7 +191,7 @@ async function codegenInternal(schema: GraphQLSchema, source: string, target: st
                 methods.push({
                   name: f.name,
                   returnType: `Promise<${type}>`,
-                  body: `return this.store.get(${elemType(f.type)}, [{field: '${derivedField}', op: '=', value: this.id}])?.[0]`,
+                  body: `return this.store.list(${elemType(f.type)}, [{field: '${derivedField}', op: '=', value: this.id}]).then((r) => r?.[0])`,
                   annotations: []
                 })
               }
@@ -228,6 +242,8 @@ async function codegenInternal(schema: GraphQLSchema, source: string, target: st
         }
         classes.push({
           name: t.name,
+          timeseries: isTimeseries(t),
+          immutable: isImmutable(t),
           fields,
           methods,
           annotations: [`@Entity("${t.name}")`],
@@ -282,6 +298,12 @@ interface ${c.name}ConstructorInput {
 ${c.fields
   .filter((f) => !f.type.startsWith('Promise<')) // Filter out Promise fields
   .map((f) => {
+    if (c.timeseries && f.name == 'timestamp') {
+      return `  timestamp?: Timestamp;`
+    }
+    if (c.timeseries && f.name == 'id') {
+      return `  id?: Int8;`
+    }
     const isRequired = f.annotations.some((a) => a.includes('@Required'))
     return `  ${f.private ? 'private ' : ''}${f.name}${isRequired ? '' : '?'}: ${f.type.replace(' | undefined', '')};`
   })
@@ -297,6 +319,14 @@ ${c.fields
   .join('\n')}
   ${isEntity ? `constructor(data: ${c.name}ConstructorInput) {super()}` : ''}
   ${(c.methods ?? []).map(genMethod).join('\n')}
+  
+  ${
+    isEntity && !c.immutable
+      ? `static update(values: UpdateValues<${c.name}ConstructorInput>): Promise<void> {
+    return getStore().update(${c.name}, values)
+  }`
+      : ``
+  }
 }`
   })
   .join('\n')}
@@ -367,6 +397,24 @@ function isEntity(t: GraphQLObjectType) {
   return t.astNode?.directives?.some((d) => d.name.value == 'entity')
 }
 
+function isTimeseries(t: GraphQLObjectType) {
+  return t.astNode?.directives?.some(
+    (d) =>
+      d.name.value == 'entity' &&
+      d.arguments?.some((a) => a.name.value == 'timeseries' && a.value.kind == 'BooleanValue' && a.value.value == true)
+  )
+}
+
+function isImmutable(t: GraphQLObjectType) {
+  return (
+    t.astNode?.directives?.some(
+      (d) =>
+        d.name.value == 'entity' &&
+        d.arguments?.some((a) => a.name.value == 'immutable' && a.value.kind == 'BooleanValue' && a.value.value == true)
+    ) || isTimeseries(t)
+  )
+}
+
 function isDerived(f: GraphQLField<any, any>) {
   return f.astNode?.directives?.some((d) => d.name.value == 'derivedFrom')
 }