@robosystems/client 0.2.47 → 0.2.48

package/extensions/LedgerClient.ts

@@ -15,6 +15,8 @@ import {
   createSchedule,
   createStructure,
   deleteMappingAssociation,
+  getAccountRollups,
+  getClosingBookStructures,
   getLedgerAccountTree,
   getLedgerEntity,
   getLedgerSummary,
@@ -35,7 +37,9 @@ import {
 } from '../sdk.gen'
 import type {
   AccountListResponse,
+  AccountRollupsResponse,
   AccountTreeResponse,
+  ClosingBookStructuresResponse,
   ClosingEntryResponse,
   CreateClosingEntryRequest,
   CreateScheduleRequest,
@@ -750,4 +754,47 @@ export class LedgerClient {
       amount: data.amount,
     }
   }
+
+  // ── Closing Book ─────────────────────────────────────────────────────
+
+  /**
+   * Get all closing book structure categories for the sidebar.
+   * Returns statements, account rollups, schedules, trial balance,
+   * and period close grouped into categories.
+   */
+  async getClosingBookStructures(graphId: string): Promise<ClosingBookStructuresResponse> {
+    const response = await getClosingBookStructures({
+      path: { graph_id: graphId },
+    })
+
+    if (response.error) {
+      throw new Error(`Get closing book structures failed: ${JSON.stringify(response.error)}`)
+    }
+
+    return response.data as ClosingBookStructuresResponse
+  }
+
+  /**
+   * Get account rollups — CoA accounts grouped by reporting element with balances.
+   * Shows how company-specific accounts roll up to standardized reporting lines.
+   */
+  async getAccountRollups(
+    graphId: string,
+    options?: { mappingId?: string; startDate?: string; endDate?: string }
+  ): Promise<AccountRollupsResponse> {
+    const response = await getAccountRollups({
+      path: { graph_id: graphId },
+      query: {
+        mapping_id: options?.mappingId,
+        start_date: options?.startDate,
+        end_date: options?.endDate,
+      },
+    })
+
+    if (response.error) {
+      throw new Error(`Get account rollups failed: ${JSON.stringify(response.error)}`)
+    }
+
+    return response.data as AccountRollupsResponse
+  }
 }

package/extensions/OperationClient.test.ts

@@ -1,5 +1,60 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { OperationClient } from './OperationClient'
+import { EventType } from './SSEClient'
+
+// Mock EventSource for SSE tests
+class MockEventSource {
+  url: string
+  withCredentials: boolean
+  readyState: number = 0
+  onopen: ((event: any) => void) | null = null
+  onerror: ((event: any) => void) | null = null
+  onmessage: ((event: any) => void) | null = null
+  private eventListeners: Map<string, Set<(event: any) => void>> = new Map()
+
+  static CONNECTING = 0
+  static OPEN = 1
+  static CLOSED = 2
+
+  constructor(url: string, options?: { withCredentials?: boolean }) {
+    this.url = url
+    this.withCredentials = options?.withCredentials ?? false
+    setTimeout(() => {
+      this.readyState = MockEventSource.OPEN
+      if (this.onopen) {
+        this.onopen({ type: 'open' })
+      }
+    }, 0)
+  }
+
+  addEventListener(event: string, listener: (event: any) => void) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, new Set())
+    }
+    this.eventListeners.get(event)!.add(listener)
+  }
+
+  removeEventListener(event: string, listener: (event: any) => void) {
+    const listeners = this.eventListeners.get(event)
+    if (listeners) listeners.delete(listener)
+  }
+
+  dispatchEvent(event: any) {
+    const listeners = this.eventListeners.get(event.type)
+    if (listeners) listeners.forEach((l) => l(event))
+    return true
+  }
+
+  close() {
+    this.readyState = MockEventSource.CLOSED
+  }
+
+  simulateMessage(eventType: string, data: any) {
+    const event = { type: eventType, data: JSON.stringify(data), lastEventId: '' }
+    const listeners = this.eventListeners.get(eventType)
+    if (listeners) listeners.forEach((l) => l(event))
+  }
+}
 
 // Helper to create proper mock Response objects
 function createMockResponse(data: any, options: { ok?: boolean; status?: number } = {}) {
@@ -123,6 +178,149 @@ describe('OperationClient', () => {
     })
   })
 
+  describe('monitorOperation', () => {
+    beforeEach(() => {
+      global.EventSource = MockEventSource as any
+    })
+
+    it('should resolve with success on OPERATION_COMPLETED', async () => {
+      const resultPromise = operationClient.monitorOperation('op_sse_1')
+
+      // Wait for SSE connection to establish
+      await new Promise((r) => setTimeout(r, 20))
+
+      // Get the SSE client and simulate completion
+      const sseClients = (operationClient as any).sseClients as Map<string, any>
+      const sseClient = sseClients.get('op_sse_1')
+      const eventSource = (sseClient as any).eventSource as MockEventSource
+      eventSource.simulateMessage(EventType.OPERATION_COMPLETED, {
+        result: { graph_id: 'graph_done' },
+        metadata: { took: 5000 },
+      })
+
+      const result = await resultPromise
+
+      expect(result.success).toBe(true)
+      expect(result.result).toEqual({ graph_id: 'graph_done' })
+    })
+
+    it('should resolve with error on OPERATION_ERROR', async () => {
+      const resultPromise = operationClient.monitorOperation('op_sse_err')
+
+      await new Promise((r) => setTimeout(r, 20))
+
+      const sseClients = (operationClient as any).sseClients as Map<string, any>
+      const sseClient = sseClients.get('op_sse_err')
+      const eventSource = (sseClient as any).eventSource as MockEventSource
+      eventSource.simulateMessage(EventType.OPERATION_ERROR, {
+        message: 'Processing failed',
+      })
+
+      const result = await resultPromise
+
+      expect(result.success).toBe(false)
+      expect(result.error).toBe('Processing failed')
+    })
+
+    it('should resolve with cancelled on OPERATION_CANCELLED', async () => {
+      const resultPromise = operationClient.monitorOperation('op_sse_cancel')
+
+      await new Promise((r) => setTimeout(r, 20))
+
+      const sseClients = (operationClient as any).sseClients as Map<string, any>
+      const sseClient = sseClients.get('op_sse_cancel')
+      const eventSource = (sseClient as any).eventSource as MockEventSource
+      eventSource.simulateMessage(EventType.OPERATION_CANCELLED, {})
+
+      const result = await resultPromise
+
+      expect(result.success).toBe(false)
+      expect(result.error).toBe('Operation cancelled')
+    })
+
+    it('should call onProgress callback', async () => {
+      const progressUpdates: any[] = []
+
+      const resultPromise = operationClient.monitorOperation('op_progress', {
+        onProgress: (p) => progressUpdates.push(p),
+      })
+
+      await new Promise((r) => setTimeout(r, 20))
+
+      const sseClients = (operationClient as any).sseClients as Map<string, any>
+      const sseClient = sseClients.get('op_progress')
+      const eventSource = (sseClient as any).eventSource as MockEventSource
+
+      // Send progress then completion
+      eventSource.simulateMessage(EventType.OPERATION_PROGRESS, {
+        message: 'Step 1 of 3',
+        progress_percent: 33,
+      })
+
+      eventSource.simulateMessage(EventType.OPERATION_COMPLETED, {
+        result: { done: true },
+      })
+
+      await resultPromise
+
+      expect(progressUpdates).toHaveLength(1)
+      expect(progressUpdates[0].message).toBe('Step 1 of 3')
+      expect(progressUpdates[0].progressPercent).toBe(33)
+    })
+
+    it('should timeout after specified duration', async () => {
+      const resultPromise = operationClient.monitorOperation('op_timeout', {
+        timeout: 100,
+      })
+
+      await expect(resultPromise).rejects.toThrow('Operation timeout after 100ms')
+    })
+  })
+
+  describe('waitForOperation', () => {
+    beforeEach(() => {
+      global.EventSource = MockEventSource as any
+    })
+
+    it('should return result on success', async () => {
+      const resultPromise = operationClient.waitForOperation('op_wait')
+
+      await new Promise((r) => setTimeout(r, 20))
+
+      const sseClients = (operationClient as any).sseClients as Map<string, any>
+      const sseClient = sseClients.get('op_wait')
+      const eventSource = (sseClient as any).eventSource as MockEventSource
+      eventSource.simulateMessage(EventType.OPERATION_COMPLETED, {
+        result: { data: 'done' },
+      })
+
+      const result = await resultPromise
+
+      expect(result).toEqual({ data: 'done' })
+    })
+
+    it('should throw on failure', async () => {
+      const resultPromise = operationClient.waitForOperation('op_wait_fail')
+
+      await new Promise((r) => setTimeout(r, 20))
+
+      const sseClients = (operationClient as any).sseClients as Map<string, any>
+      const sseClient = sseClients.get('op_wait_fail')
+      const eventSource = (sseClient as any).eventSource as MockEventSource
+      eventSource.simulateMessage(EventType.OPERATION_ERROR, {
+        message: 'Server error',
+      })
+
+      await expect(resultPromise).rejects.toThrow('Server error')
+    })
+
+    it('should timeout with specified duration', async () => {
+      await expect(operationClient.waitForOperation('op_wait_timeout', 100)).rejects.toThrow(
+        'Operation timeout'
+      )
+    })
+  })
+
   describe('configuration', () => {
     it('should accept JWT token in config', () => {
       const client = new OperationClient({

package/extensions/QueryClient.test.ts

@@ -237,10 +237,166 @@ describe('QueryClient', () => {
     })
   })
 
+  describe('executeQuery - stream mode with NDJSON', () => {
+    it('should parse NDJSON streaming response', async () => {
+      const ndjsonBody = [
+        '{"columns":["name","age"],"rows":[["Alice",30],["Bob",25]]}',
+        '{"rows":[["Charlie",35]]}',
+        '',
+      ].join('\n')
+
+      // Create a ReadableStream from the NDJSON string
+      const stream = new ReadableStream({
+        start(controller) {
+          controller.enqueue(new TextEncoder().encode(ndjsonBody))
+          controller.close()
+        },
+      })
+
+      const mockStreamResponse = {
+        data: undefined,
+        error: undefined,
+        response: {
+          ok: true,
+          status: 200,
+          headers: new Headers({ 'content-type': 'application/x-ndjson' }),
+          body: stream,
+          json: async () => ({}),
+        },
+      }
+
+      // Mock the SDK function via fetch
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        headers: new Headers({ 'content-type': 'application/x-ndjson' }),
+        body: stream,
+        json: async () => mockStreamResponse,
+        text: async () => JSON.stringify(mockStreamResponse),
+      })
+
+      // We can't easily test the full stream mode through the SDK mock
+      // because the SDK parses the response. Test the NDJSON parser directly instead.
+      const parser = (queryClient as any).parseNDJSONResponse.bind(queryClient)
+
+      const ndjsonStream = new ReadableStream({
+        start(controller) {
+          controller.enqueue(
+            new TextEncoder().encode(
+              '{"columns":["name"],"rows":[["Alice"],["Bob"]]}\n{"rows":[["Charlie"]]}\n'
+            )
+          )
+          controller.close()
+        },
+      })
+
+      const mockResp = {
+        body: ndjsonStream,
+        headers: new Headers({ 'content-type': 'application/x-ndjson' }),
+      }
+
+      const result = await parser(mockResp, 'graph_1')
+
+      expect(result.columns).toEqual(['name'])
+      expect(result.data).toEqual([['Alice'], ['Bob'], ['Charlie']])
+      expect(result.row_count).toBe(3)
+      expect(result.graph_id).toBe('graph_1')
+    })
+
+    it('should handle NDJSON with data key instead of rows', async () => {
+      const parser = (queryClient as any).parseNDJSONResponse.bind(queryClient)
+
+      const stream = new ReadableStream({
+        start(controller) {
+          controller.enqueue(
+            new TextEncoder().encode(
+              '{"columns":["id"],"data":[{"id":1},{"id":2}],"execution_time_ms":50}\n'
+            )
+          )
+          controller.close()
+        },
+      })
+
+      const result = await parser({ body: stream }, 'graph_1')
+
+      expect(result.data).toEqual([{ id: 1 }, { id: 2 }])
+      expect(result.row_count).toBe(2)
+      expect(result.execution_time_ms).toBe(50)
+    })
+
+    it('should throw on NDJSON parse errors', async () => {
+      const parser = (queryClient as any).parseNDJSONResponse.bind(queryClient)
+
+      const stream = new ReadableStream({
+        start(controller) {
+          controller.enqueue(new TextEncoder().encode('not valid json\n'))
+          controller.close()
+        },
+      })
+
+      await expect(parser({ body: stream }, 'graph_1')).rejects.toThrow('NDJSON parsing failed')
+    })
+
+    it('should throw when body is not readable', async () => {
+      const parser = (queryClient as any).parseNDJSONResponse.bind(queryClient)
+
+      await expect(parser({ body: null }, 'graph_1')).rejects.toThrow(
+        'Response body is not readable'
+      )
+    })
+
+    it('should track max execution_time_ms across chunks', async () => {
+      const parser = (queryClient as any).parseNDJSONResponse.bind(queryClient)
+
+      const stream = new ReadableStream({
+        start(controller) {
+          controller.enqueue(
+            new TextEncoder().encode(
+              '{"columns":["x"],"rows":[[1]],"execution_time_ms":10}\n' +
+                '{"rows":[[2]],"execution_time_ms":50}\n' +
+                '{"rows":[[3]],"execution_time_ms":25}\n'
+            )
+          )
+          controller.close()
+        },
+      })
+
+      const result = await parser({ body: stream }, 'graph_1')
+
+      expect(result.execution_time_ms).toBe(50) // max across chunks
+      expect(result.row_count).toBe(3)
+    })
+  })
+
+  describe('streamQuery', () => {
+    it('should yield all data items when result is non-streaming', async () => {
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({
+          data: [{ id: 1 }, { id: 2 }, { id: 3 }],
+          columns: ['id'],
+          row_count: 3,
+          execution_time_ms: 10,
+        })
+      )
+
+      const items: any[] = []
+      for await (const item of queryClient.streamQuery('graph_1', 'MATCH (n) RETURN n')) {
+        items.push(item)
+      }
+
+      expect(items).toEqual([{ id: 1 }, { id: 2 }, { id: 3 }])
+    })
+  })
+
   describe('close', () => {
     it('should close without error when no SSE client exists', () => {
       expect(() => queryClient.close()).not.toThrow()
     })
+
+    it('should be safe to call multiple times', () => {
+      queryClient.close()
+      expect(() => queryClient.close()).not.toThrow()
+    })
   })
 
   describe('QueuedQueryError', () => {
@@ -259,5 +415,18 @@ describe('QueryClient', () => {
       expect(error.name).toBe('QueuedQueryError')
       expect(error.queueInfo).toEqual(queueInfo)
     })
+
+    it('should be instanceof Error', () => {
+      const error = new QueuedQueryError({
+        status: 'queued',
+        operation_id: 'op_1',
+        queue_position: 1,
+        estimated_wait_seconds: 5,
+        message: 'Queued',
+      })
+
+      expect(error).toBeInstanceOf(Error)
+      expect(error).toBeInstanceOf(QueuedQueryError)
+    })
   })
 })