Browser SDK

npm install iii-browser-sdk

registerWorker(address: string, options: InitOptions) => ISdk

import { registerWorker } from 'iii-browser-sdk'

const worker = registerWorker('ws://localhost:49135')

registerTrigger(trigger: RegisterTriggerInput) => Trigger

const trigger = worker.registerTrigger({
  type: 'cron',
  function_id: 'my-service::process-batch',
  config: { expression: '0 */5 * * * * *' },
})

// Later, remove the trigger
trigger.unregister()

registerFunction(functionId: string, handler: RemoteFunctionHandler, options: RegisterFunctionOptions) => FunctionRef

// Local handler
const ref = worker.registerFunction(
  'greet',
  async (data: { name: string }) => ({ message: `Hello, ${data.name}!` }),
  { description: 'Returns a greeting' },
)

// Later, remove the function
ref.unregister()

trigger(request: TriggerRequest<TInput>) => Promise<TOutput>

// Synchronous invocation
const result = await worker.trigger<{ name: string }, { message: string }>({
  function_id: 'greet',
  payload: { name: 'World' },
  timeoutMs: 5000,
})
console.log(result.message) // "Hello, World!"

// Fire-and-forget
await worker.trigger({
  function_id: 'send-email',
  payload: { to: 'user@example.com' },
  action: TriggerAction.Void(),
})

// Enqueue for async processing
const receipt = await worker.trigger({
  function_id: 'process-order',
  payload: { orderId: '123' },
  action: TriggerAction.Enqueue({ queue: 'orders' }),
})

registerTriggerType(triggerType: RegisterTriggerTypeInput, handler: TriggerHandler<TConfig>) => TriggerTypeRef<TConfig>

type CronConfig = { expression: string }

worker.registerTriggerType<CronConfig>(
  { id: 'cron', description: 'Fires on a cron schedule' },
  {
    async registerTrigger({ id, function_id, config }) {
      startCronJob(id, config.expression, () =>
        worker.trigger({ function_id, payload: {} }),
      )
    },
    async unregisterTrigger({ id }) {
      stopCronJob(id)
    },
  },
)

unregisterTriggerType(triggerType: RegisterTriggerTypeInput) => void

worker.unregisterTriggerType({ id: 'cron', description: 'Fires on a cron schedule' })

addConnectionStateListener(handler: (state: IIIConnectionState) => void) => () => void

const unsub = worker.addConnectionStateListener((state) => {
  console.log('connection state:', state)
})

// Later, stop receiving updates
unsub()

shutdown() => Promise<void>

await worker.shutdown()

type IIIConnectionState = "disconnected" | "connecting" | "connected" | "reconnecting" | "failed"

type RegisterFunctionInput = Omit<RegisterFunctionMessage, "message_type">

type RegisterFunctionOptions = Omit<RegisterFunctionMessage, "message_type" | "id">

type RegisterTriggerInput = Omit<RegisterTriggerMessage, "message_type" | "id">

type RegisterTriggerTypeInput = Omit<RegisterTriggerTypeMessage, "message_type">

type RemoteFunctionHandler = (data: TInput) => Promise<TOutput>

type MergePath = string | string[]

type StreamContext = StreamAuthResult["context"]

type UpdateOp = UpdateSet | UpdateIncrement | UpdateDecrement | UpdateAppend | UpdateRemove | UpdateMerge