Node.js SDK

npm install iii-sdk

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

import { registerWorker } from 'iii-sdk'

const worker = registerWorker(process.env.III_URL ?? 'ws://localhost:49134', {
  workerName: 'my-worker',
})

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: HttpInvocationConfig | RemoteFunctionHandler<any, any>, options: RegisterFunctionOptions) => FunctionRef

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

// HTTP invocation
const lambdaRef = worker.registerFunction(
  'external::my-lambda',
  {
    url: 'https://abc123.lambda-url.us-east-1.on.aws',
    method: 'POST',
    timeout_ms: 30_000,
    auth: { type: 'bearer', token_key: 'LAMBDA_AUTH_TOKEN' },
  },
  { description: 'Proxied Lambda function' },
)

// 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' })

shutdown() => Promise<void>

process.on('SIGTERM', async () => {
  await worker.shutdown()
  process.exit(0)
})

type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue }

type StreamRequest = Omit<InternalHttpRequest<TBody>, "response">

type RemoteFunctionHandler = (data: TInput, metadata?: JsonValue) => Promise<TOutput>

type ChannelDirection = typeof ChannelDirection[keyof typeof ChannelDirection]

type ChannelItem = { type: "text"; value: string } | { type: "binary"; value: Uint8Array }

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 IIIConnectionState = "disconnected" | "connecting" | "connected" | "reconnecting" | "failed"