iii-sdk 0.2.0 → 0.2.1

package/tests/api-triggers.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it } from 'vitest'
+import type { ApiRequest, ApiResponse } from '../src'
+import { execute, httpRequest, iii, sleep } from './utils'
+
+describe('API Triggers', () => {
+  it('should register GET endpoint', async () => {
+    const fn = iii.registerFunction(
+      { id: 'test.api.get' },
+      async (_req: ApiRequest): Promise<ApiResponse> => ({
+        status_code: 200,
+        body: { message: 'Hello from GET' },
+      }),
+    )
+
+    const trigger = iii.registerTrigger({
+      type: 'http',
+      function_id: fn.id,
+      config: {
+        api_path: 'test/hello',
+        http_method: 'GET',
+      },
+    })
+
+    await sleep(300)
+
+    const response = await execute(async () => httpRequest('GET', '/test/hello'))
+
+    expect(response.status).toBe(200)
+    expect(response.data).toEqual({ message: 'Hello from GET' })
+
+    fn.unregister()
+    trigger.unregister()
+  })
+
+  it('should register POST endpoint with body', async () => {
+    const fn = iii.registerFunction(
+      { id: 'test.api.post' },
+      async (req: ApiRequest): Promise<ApiResponse> => {
+        const body = (req.body as Record<string, unknown>) ?? {}
+        return {
+          status_code: 201,
+          body: { received: body, created: true },
+        }
+      },
+    )
+
+    const trigger = iii.registerTrigger({
+      type: 'http',
+      function_id: fn.id,
+      config: {
+        api_path: 'test/items',
+        http_method: 'POST',
+      },
+    })
+
+    await sleep(300)
+
+    const response = await execute(async () =>
+      httpRequest('POST', '/test/items', { name: 'test item', value: 123 }),
+    )
+
+    expect(response.status).toBe(201)
+    expect(response.data.created).toBe(true)
+    expect(response.data.received).toHaveProperty('name', 'test item')
+
+    fn.unregister()
+    trigger.unregister()
+  })
+
+  it('should handle path parameters', async () => {
+    const fn = iii.registerFunction(
+      { id: 'test.api.getById' },
+      async (req: ApiRequest): Promise<ApiResponse> => ({
+        status_code: 200,
+        body: { id: req.path_params?.id },
+      }),
+    )
+
+    const trigger = iii.registerTrigger({
+      type: 'http',
+      function_id: fn.id,
+      config: {
+        api_path: 'test/items/:id',
+        http_method: 'GET',
+      },
+    })
+
+    await sleep(300)
+
+    const response = await execute(async () => httpRequest('GET', '/test/items/abc123'))
+
+    expect(response.status).toBe(200)
+    expect(response.data).toEqual({ id: 'abc123' })
+
+    fn.unregister()
+    trigger.unregister()
+  })
+
+  it('should handle query parameters', async () => {
+    const fn = iii.registerFunction(
+      { id: 'test.api.search' },
+      async (req: ApiRequest): Promise<ApiResponse> => {
+        const q = req.query_params?.q
+        const limit = req.query_params?.limit
+        const qVal = Array.isArray(q) ? q[0] : q
+        const limitVal = Array.isArray(limit) ? limit[0] : limit
+        return {
+          status_code: 200,
+          body: { query: qVal, limit: limitVal },
+        }
+      },
+    )
+
+    const trigger = iii.registerTrigger({
+      type: 'http',
+      function_id: fn.id,
+      config: {
+        api_path: 'test/search',
+        http_method: 'GET',
+      },
+    })
+
+    await sleep(300)
+
+    const response = await execute(async () => httpRequest('GET', '/test/search?q=hello&limit=10'))
+
+    expect(response.status).toBe(200)
+    expect(response.data.query).toBe('hello')
+    expect(response.data.limit).toBe('10')
+
+    fn.unregister()
+    trigger.unregister()
+  })
+
+  it('should return custom status code', async () => {
+    const fn = iii.registerFunction(
+      { id: 'test.api.notfound' },
+      async (_req: ApiRequest): Promise<ApiResponse<404>> => ({
+        status_code: 404,
+        body: { error: 'Not found' },
+      }),
+    )
+
+    const trigger = iii.registerTrigger({
+      type: 'http',
+      function_id: fn.id,
+      config: {
+        api_path: 'test/missing',
+        http_method: 'GET',
+      },
+    })
+
+    await sleep(300)
+
+    const response = await execute(async () => httpRequest('GET', '/test/missing'))
+
+    expect(response.status).toBe(404)
+    expect(response.data).toEqual({ error: 'Not found' })
+
+    fn.unregister()
+    trigger.unregister()
+  })
+})

package/tests/bridge.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest'
+import { execute, iii, sleep } from './utils'
+
+describe('Bridge Operations', () => {
+  it('should connect successfully', async () => {
+    expect(iii).toBeDefined()
+    const functions = await execute(async () => iii.listFunctions())
+    expect(Array.isArray(functions)).toBe(true)
+  })
+
+  it('should register and invoke a function', async () => {
+    let receivedData: Record<string, unknown> | undefined
+
+    const fn = iii.registerFunction({ id: 'test.echo' }, async (data: Record<string, unknown>) => {
+      receivedData = data
+      return { echoed: data }
+    })
+
+    await sleep(300)
+
+    const result = await iii.call<Record<string, unknown>, { echoed: Record<string, unknown> }>(
+      'test.echo',
+      { message: 'hello' },
+    )
+
+    expect(result).toHaveProperty('echoed')
+    expect(result.echoed).toHaveProperty('message', 'hello')
+    expect(receivedData).toHaveProperty('message', 'hello')
+
+    fn.unregister()
+  })
+
+  it('should invoke function fire-and-forget', async () => {
+    let receivedData: Record<string, unknown> | undefined
+    let resolveReceived: () => void
+    const received = new Promise<void>(r => {
+      resolveReceived = r
+    })
+
+    const fn = iii.registerFunction(
+      { id: 'test.receiver' },
+      async (data: Record<string, unknown>) => {
+        receivedData = data
+        resolveReceived?.()
+        return {}
+      },
+    )
+
+    await sleep(300)
+
+    iii.callVoid('test.receiver', { value: 42 })
+
+    await Promise.race([
+      received,
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error('Timeout waiting for fire-and-forget')), 5000),
+      ),
+    ])
+
+    expect(receivedData).toHaveProperty('value', 42)
+
+    fn.unregister()
+  })
+
+  it('should list registered functions', async () => {
+    const fn1 = iii.registerFunction({ id: 'test.list.func1' }, async () => ({}))
+    const fn2 = iii.registerFunction({ id: 'test.list.func2' }, async () => ({}))
+
+    await sleep(300)
+
+    const functions = await iii.listFunctions()
+    const functionIds = functions.map(f => f.function_id)
+
+    expect(functionIds).toContain('test.list.func1')
+    expect(functionIds).toContain('test.list.func2')
+
+    fn1.unregister()
+    fn2.unregister()
+  })
+
+  it('should reject when invoking non-existent function', async () => {
+    await expect(iii.call('nonexistent.function', {}, 2000)).rejects.toThrow()
+  })
+})

package/tests/exports.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest'
+import { init, getContext, withContext, Logger } from '../src/index'
+import { initOtel, shutdownOtel, getTracer, getMeter, getLogger } from '../src/telemetry'
+
+describe('Package Exports', () => {
+  it('should export main SDK symbols', () => {
+    expect(init).toBeDefined()
+    expect(typeof init).toBe('function')
+    expect(getContext).toBeDefined()
+    expect(withContext).toBeDefined()
+    expect(Logger).toBeDefined()
+  })
+
+  it('should import stream module', async () => {
+    await expect(import('../src/stream')).resolves.toBeDefined()
+  })
+
+  it('should import state module', async () => {
+    const stateModule = await import('../src/state')
+    expect(stateModule).toBeDefined()
+    expect(stateModule.StateEventType).toBeDefined()
+    expect(Object.keys(stateModule).length).toBeGreaterThan(0)
+  })
+
+  it('should export telemetry utilities', () => {
+    expect(initOtel).toBeDefined()
+    expect(typeof initOtel).toBe('function')
+    expect(shutdownOtel).toBeDefined()
+    expect(typeof shutdownOtel).toBe('function')
+    expect(getTracer).toBeDefined()
+    expect(typeof getTracer).toBe('function')
+    expect(getMeter).toBeDefined()
+    expect(typeof getMeter).toBe('function')
+    expect(getLogger).toBeDefined()
+    expect(typeof getLogger).toBe('function')
+  })
+})