iii-sdk 0.3.0 → 0.4.1

package/tests/stream.test.ts

@@ -1,216 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest'
-import { iii, sleep } from './utils'
-import type { StreamSetInput, StreamSetResult } from '../src/stream'
-
-type TestData = {
-  name?: string
-  value: number
-  updated?: boolean
-}
-
-describe('Stream Operations', () => {
-  const testStreamName = 'test-stream'
-  const testGroupId = 'test-group'
-  const testItemId = 'test-item'
-
-  beforeEach(async () => {
-    await iii
-      .call('stream::delete', {
-        stream_name: testStreamName,
-        group_id: testGroupId,
-        item_id: testItemId,
-      })
-      .catch(() => void 0)
-  })
-
-  describe('stream::set', () => {
-    it('should set a new stream item', async () => {
-      const testData = {
-        name: 'Test Item',
-        value: 42,
-        metadata: { created: new Date().toISOString() },
-      }
-
-      const result = await iii.call<StreamSetInput, StreamSetResult<TestData>>('stream::set', {
-        stream_name: testStreamName,
-        group_id: testGroupId,
-        item_id: testItemId,
-        data: testData,
-      })
-
-      expect(result).toBeDefined()
-      expect(result).toEqual({ old_value: null, new_value: testData })
-    })
-
-    it('should overwrite an existing stream item', async () => {
-      const initialData: TestData = { value: 1 }
-      const updatedData: TestData = { value: 2, updated: true }
-
-      await iii.call('stream::set', {
-        stream_name: testStreamName,
-        group_id: testGroupId,
-        item_id: testItemId,
-        data: initialData,
-      })
-
-      const result: StreamSetResult<TestData> = await iii.call('stream::set', {
-        stream_name: testStreamName,
-        group_id: testGroupId,
-        item_id: testItemId,
-        data: updatedData,
-      })
-
-      expect(result.old_value).toEqual(initialData)
-      expect(result.new_value).toEqual(updatedData)
-    })
-  })
-
-  describe('stream::get', () => {
-    it('should get an existing stream item', async () => {
-      const testData: TestData = { name: 'Test', value: 100 }
-
-      await iii.call('stream::set', {
-        stream_name: testStreamName,
-        group_id: testGroupId,
-        item_id: testItemId,
-        data: testData,
-      })
-
-      const result: TestData = await iii.call('stream::get', {
-        stream_name: testStreamName,
-        group_id: testGroupId,
-        item_id: testItemId,
-      })
-
-      expect(result).toBeDefined()
-      expect(result).toEqual(testData)
-    })
-
-    it('should return null for non-existent item', async () => {
-      const result = await iii.call('stream::get', {
-        stream_name: testStreamName,
-        group_id: testGroupId,
-        item_id: 'non-existent-item',
-      })
-
-      expect(result).toBeUndefined()
-    })
-  })
-
-  describe('stream::delete', () => {
-    it('should delete an existing stream item', async () => {
-      await iii.call('stream::set', {
-        stream_name: testStreamName,
-        group_id: testGroupId,
-        item_id: testItemId,
-        data: { test: true },
-      })
-
-      await iii.call('stream::delete', {
-        stream_name: testStreamName,
-        group_id: testGroupId,
-        item_id: testItemId,
-      })
-
-      const result = await iii.call('stream::get', {
-        stream_name: testStreamName,
-        group_id: testGroupId,
-        item_id: testItemId,
-      })
-
-      expect(result).toBeUndefined()
-    })
-
-    it('should handle deleting non-existent item gracefully', async () => {
-      await expect(
-        iii.call('stream::delete', {
-          stream_name: testStreamName,
-          group_id: testGroupId,
-          item_id: 'non-existent',
-        }),
-      ).resolves.not.toThrow()
-    })
-  })
-
-  describe('stream::list', () => {
-    it('should get all items in a group', async () => {
-      type TestDataWithId = TestData & { id: string }
-
-      const groupId = `stream-${Date.now()}`
-      const items: TestDataWithId[] = [
-        { id: 'stream-item1', value: 1 },
-        { id: 'stream-item2', value: 2 },
-        { id: 'stream-item3', value: 3 },
-      ]
-
-      // Set multiple items
-      for (const item of items) {
-        await iii.call('stream::set', {
-          stream_name: testStreamName,
-          group_id: groupId,
-          item_id: item.id,
-          data: item,
-        })
-      }
-
-      const result: TestDataWithId[] = await iii.call('stream::list', {
-        stream_name: testStreamName,
-        group_id: groupId,
-      })
-      const sort = (a: TestDataWithId, b: TestDataWithId) => a.id.localeCompare(b.id)
-
-      expect(Array.isArray(result)).toBe(true)
-      expect(result.length).toBeGreaterThanOrEqual(items.length)
-      expect(result.sort(sort)).toEqual(items.sort(sort))
-    })
-  })
-
-  describe('stream custom operations', () => {
-    it('should perform a custom operation on a stream item', async () => {
-      const testStreamName = `test-stream-${Date.now()}`
-      const state: Map<string, TestData> = new Map()
-
-      iii.createStream(testStreamName, {
-        get: async input => state.get(`${input.group_id}::${input.item_id}`),
-        set: async input => {
-          const key = `${input.group_id}::${input.item_id}`
-          const oldValue = state.get(key)
-          state.set(key, input.data)
-
-          return { old_value: oldValue, new_value: input.data }
-        },
-        delete: async input => {
-          const oldValue = state.get(`${input.group_id}::${input.item_id}`)
-          state.delete(`${input.group_id}::${input.item_id}`)
-          return { old_value: oldValue }
-        },
-        list: async input => {
-          return Array.from(state.keys())
-            .filter(key => key.startsWith(`${input.group_id}::`))
-            .map(key => state.get(key))
-        },
-        listGroups: async () => Array.from(state.keys()),
-        update: async () => {
-          throw new Error('Not implemented')
-        },
-      })
-
-      await sleep(1_000)
-
-      const testData: TestData = { name: 'Test', value: 100 }
-      const getArgs = {
-        stream_name: testStreamName,
-        group_id: testGroupId,
-        item_id: testItemId,
-      }
-
-      await iii.call('stream::set', { ...getArgs, data: testData })
-
-      expect(state.get(`${testGroupId}::${testItemId}`)).toEqual(testData)
-
-      await expect(iii.call('stream::get', getArgs)).resolves.toEqual(testData)
-      await iii.call('stream::delete', getArgs)
-      await expect(iii.call('stream::get', getArgs)).resolves.toEqual(undefined)
-    })
-  })
-})

package/tests/utils.ts

@@ -1,74 +0,0 @@
-// import { iii } from 'iii-sdk'
-import { init, Logger } from '../src/index'
-
-const ENGINE_WS_URL = process.env.III_BRIDGE_URL ?? 'ws://localhost:49199'
-const ENGINE_HTTP_URL = process.env.III_HTTP_URL ?? 'http://localhost:3199'
-const RETRY_LIMIT = 100
-const DELAY_MS = 100
-
-export const engineWsUrl = ENGINE_WS_URL
-export const engineHttpUrl = ENGINE_HTTP_URL
-
-export const iii = init(engineWsUrl, {
-  otel: {
-    serviceName: 'iii-tests',
-    serviceVersion: '0.0.1',
-    reconnectionConfig: {
-      maxRetries: 3,
-      initialDelayMs: 100,
-      maxDelayMs: 1000,
-    },
-  },
-  reconnectionConfig: {
-    maxRetries: 3,
-    initialDelayMs: 100,
-    maxDelayMs: 1000,
-  },
-})
-
-// Standalone logger for test utilities — no trace context needed
-export const logger = new Logger()
-
-export async function httpRequest(
-  method: string,
-  path: string,
-  // biome-ignore lint/suspicious/noExplicitAny: any is fine here
-  body?: any,
-  // biome-ignore lint/suspicious/noExplicitAny: any is fine here
-): Promise<{ status: number; data: any }> {
-  const url = `${engineHttpUrl}${path}`
-  const options: RequestInit = { method, headers: { 'Content-Type': 'application/json' } }
-
-  if (body) {
-    options.body = JSON.stringify(body)
-  }
-
-  const response = await fetch(url, options)
-  const data = await response.json().catch(() => ({}))
-
-  return { status: response.status, data }
-}
-
-export function sleep(duration: number): Promise<void> {
-  return new Promise(resolve => {
-    setTimeout(() => resolve(), duration)
-  })
-}
-
-export async function execute<T>(operation: () => Promise<T>): Promise<T> {
-  let currentAttempt = 0
-
-  while (true) {
-    try {
-      return await operation()
-    } catch (err) {
-      currentAttempt++
-
-      if (currentAttempt >= RETRY_LIMIT) {
-        throw err
-      }
-
-      await sleep(DELAY_MS)
-    }
-  }
-}