Design of CKB-independent component of Kuai runtime about kuai HOT 8 CLOSED

/*
 * field decorated by @State will be registered as an internal state
 */
@Actor(id: symbol)
class CustomActor extends Actor<CustomState> {
  @State()
  state_a: CustomState['state_a']
}

type Status = ok | error | continue | timeout | stop

class Actor<State, Message> {
  
  /*
   * functions to send messages
   */

  // make a synchronous call
  function call (
    address: ActorAddress,
    message: CustomMessage,
    timeout?: number
  ): {
    status: Status,
    message: CustomMessage,
  }

  // make an asynchronous call
  function cast (
    address: ActorAddress,
    message: CustomMessage,
  ): void

  // send message synchronized to named actors running in specified nodes
  function multi_call (
    nodes: Array<Node>,
    name: string, // registered actor name
    message: CustomMessage,
  ): {
    responses: Array<{
      status: Status,
      message: CustomMessage,
    }>
  }

  // broadcast messages to named actors running in specified nodes
  function abcast (
    nodes: Array<Node>,
    name: string, // registered actor name
    message: CustomMessage,
  ): void

  // reply to the sender in a synchronized call
  function reply (
    client: ActorAddress,
    message: CustomMessage,
  ): void

  /*
   * functions for lifecycle
   */

  // start an actor outside the supervision tree
  function start (
    actorConstructor: ActorConstructor,
    init: CustomState,
    options?: Record<string, string>
  ): {
    status: Status,
    address: ActorAddress,
  }

  // start an actor within the supervision tree
  function startLink (
    actorConstructor: ActorConstructor,
    init: CustomState,
    options?: Record<string, string> 
  ): {
    status: Status,
    address: ActorAddress,
  }

  // stop a actor
  function stop (
    actor: ActorAddress,
    reason: string,
  ): void

}

class CustomActor extends Actor<CustomState, CustomMessage>{

  /*
   * callback behaviors are injected by decorators, and matched by Symbols
   */

  // invoked when the actor is activated
  @Init()
  constructor (
    init: CustomState
  ): { 
    status: Status,
    state: CustomState,
  }

  // invoked when the actor is deactivated
  @Terminate()
  function (
    status: stop,
    reason: string,
    state: CustomState,
  )

  // invoked to handle synchronous call messages, the sender will wait for the response
  @HandleCall(pattern: Symbol)
  function (
    message: CustomMessage,
    from: ActorAddress,
    state: CustomState
  ): {
    status: Status,
    message: CustomMessage,
    state: CustomState,
  }

  // invoked to handle asynchronous call messages, the send won't wait for the response
  @HandleCast(pattern: Symbol)
  function (
    message: CustomMessage,
    state: CustomState,
  ): {
    status: Status,
    state: CustomState,
  }

  // invoked to handle `continue` instruction returned by the previous call
  @HandleContinue()
  function (
    message: CustomMessage,
    state: CustomState,
  }: {
    status: Status,
    state: CustomState,
  }

  // invoked to handle all other unmatched messages
  @HandleInfo()
  function (
    message: any,
    state: CustomState,
  ): {
    status: Status,
    state: CustomState,
  }

  // invoked to inspect internal state of the actor
  @FormatStatus()
  function (
    reason: string,
    state: CustomState,
    context: Context,
  ): void
}

abstract class Registry {
  /*
   * bind an actor into the container
   */
  bind(Actor): symbol

  /*
   * get an actor from the container
   */
  get(Actor): actor

  /*
   * remove Actor from the container
   */
  unbind(Actor): void

  /*
   * create a child registry for hierarchy
   */
  createChild(): Registry
}

@Application()
class App {
  actor: Actor // IoC container will instantiate an Actor instance and assign it to `app.actor`

  createActorDynamically(){
    const customActor = Registry.get(CustomActor) // IoC container will instantiate an CustomActor
  }
}

@Application()
class App {
  actor: Actor

  send(actor: Actor, message: Message) {
    Actor.call(actor.id, message) // redisClient.xAdd(message.pattern, actor.id, message.body)
  }
}

@Actor()
class CustomActor extends Actor {
  @HandleCall(pattern) // read the message from MQ and matched by this handler
  handlePattern(message: Message, from: ActorAddress, state: State) {
    // business logic
  }
}

class App {
  actor: Actor

  terminateActor(actor: Actor) {
    Actor.terminate(actor.id) // send a Symbol('terminate') signal to actor and will be matched by @Terminate()
  }
}

/*
 * Configuration will be instantiated by IoC container on launch
 */
@Actor()
class Configuration extends Actor {
  @State()
  config: Record<string, string>

  @Init()
  constructor(init: Record<'env', 'develop' | 'test' | 'production'>) {
    const base = this.base()
    const extended = this[env]?.()
    this.config.set({ ...base, ...extended })
  }
}

  /*
   * functions to send messages
   */

  // make a synchronous call
  function call (
    address: ActorAddress,
    message: CustomMessage,
    timeout?: number
  ): {
    status: Status,
    message: CustomMessage,
  }

  // send message synchronized to named actors running in specified nodes
  function multi_call (
    nodes: Array<Node>,
    name: string, // registered actor name
    message: CustomMessage,
  ): {
    responses: Array<{
      status: Status,
      message: CustomMessage,
    }>
  }