@stack-spot/portal-network 0.149.0 → 0.150.0

package/src/client/ai.ts

@@ -220,20 +220,20 @@ class AIClient extends ReactQueryNetworkClient {
   */
   addFavoriteStackAi = this.mutation(removeAuthorizationParam(addFavoriteV1AiStacksStackIdFavoritePost))
   /**
-  * Removes the resource of type Stack AI from the list of favorites.
-  */
+   * Removes the resource of type Stack AI from the list of favorites.
+   */
   removeFavoriteStackAi = this.mutation(removeAuthorizationParam(deleteFavoriteV1AiStacksStackIdFavoriteDelete))
   /**
-    * Updates a Quick Command
-  */
+   * Updates a Quick Command
+   */
   updateQuickCommand = this.mutation(removeAuthorizationParam(updateQuickCommandV1QuickCommandsSlugPatch))
   /**
    * Adds the resource of type Quick Command to the list of favorites.
    */
   addFavoriteQuickCommand = this.mutation(removeAuthorizationParam(addFavoriteV1QuickCommandsSlugFavoritePost))
   /**
-    * Removes the resource of type Quick Command from the list of favorites.
-  */
+   * Removes the resource of type Quick Command from the list of favorites.
+   */
   removeFavoriteQuickCommand = this.mutation(removeAuthorizationParam(deleteFavoriteV1QuickCommandsSlugFavoriteDelete))
 
   private static async toolsOfAgent(agentId?: string) {

package/src/client/secrets.ts

@@ -52,8 +52,8 @@ class SecretClient extends ReactQueryNetworkClient {
   deleteSecretValue = this.mutation(deleteSecretValue)
 
   /**
- * Encrypt a value
- */
+   * Encrypt a value
+   */
   encrypt = this.mutation(encrypt)
 }
 

package/src/index.ts

@@ -35,6 +35,8 @@ export { StreamJsonError } from './error/StreamJsonError'
 export { NetworkClient } from './network/NetworkClient'
 export { queryClient } from './network/react-query-client'
 export { OperationResult, OperationVariables, UseQueryObjectOptions } from './network/types'
+export { StreamingStatus } from './types'
+export { StreamedArray } from './utils/StreamedArray'
 export { StreamedJson } from './utils/StreamedJson'
 export { useExtendedList } from './utils/use-extended-list'
-
+export { useStreamedArray } from './utils/use-streamed-array'

package/src/types.ts

@@ -0,0 +1 @@
+export type StreamingStatus = 'pending' | 'success' | 'error'

package/src/utils/StreamedArray.tsx

@@ -0,0 +1,146 @@
+import { CompletablePromise } from '@stack-spot/opa'
+import { StreamCanceledError } from '../error/StreamCanceledError'
+import { StreamError } from '../error/StreamError'
+import { StreamJsonError } from '../error/StreamJsonError'
+import { FetchEventStream } from '../network/types'
+import { StreamingStatus } from '../types'
+
+type OnChangeListener<T> = (value: T[]) => void
+
+interface ConstructorParams {
+  /**
+   * The promises that result in the EventStreams to build the final array.
+   */
+  eventsPromises: Promise<FetchEventStream>[],
+  /**
+   * A controller to abort the streaming.
+   */
+  abortController?: AbortController,
+  /**
+   * A minimum number of milliseconds to wait before calling onChange listeners.
+   * @default 50
+   */
+  minChangeIntervalMS?: number,
+  /***
+   * Aborts this stream when the signal is aborted.
+   */
+  signal?: AbortSignal,
+}
+
+/**
+ * An array represented by a stream where each event contains an item of the array as a JSON string. This can be watched as the stream runs.
+ */
+export class StreamedArray<T> {
+  private onChangeListeners: OnChangeListener<T>[] = []
+  private error: StreamError | undefined
+  private data: T[] = []
+  private fullPromise = new CompletablePromise<T[]>()
+  private abortController: AbortController | undefined
+
+  /**
+   * @param response the fetch response.
+   * @param minChangeIntervalMS a stream can be too fast. This sets a minimum interval between running the listeners. The default is 50ms.
+   */
+  constructor({ eventsPromises, abortController, minChangeIntervalMS = 50, signal }: ConstructorParams) {
+    this.abortController = abortController ?? new AbortController()
+    eventsPromises.forEach(eventsPromise => this.run(eventsPromise, minChangeIntervalMS))
+    if (signal) {
+      signal.addEventListener('abort', () => this.cancel())
+    }
+  }
+
+  private async run(eventsPromise: Promise<FetchEventStream>, minChangeIntervalMS: number) {
+    let lastChangeCall = 0
+    try {
+      const events = await eventsPromise
+      let flushed = true
+      for await (const event of events) {
+        if (this.error) return
+        if (event.data) {
+          this.data.push(JSON.parse(event.data))
+          if (new Date().getTime() - lastChangeCall >= minChangeIntervalMS) {
+            this.onChangeListeners.forEach(l => l(this.data))
+            lastChangeCall = new Date().getTime()
+            flushed = true
+          } else {
+            flushed = false
+          }
+        }
+      }
+      if (!flushed) this.onChangeListeners.forEach(l => l(this.data))
+    } catch (error: any) {
+      if (error instanceof DOMException && error.name === 'AbortError') this.fail(new StreamCanceledError())
+      if (error instanceof SyntaxError) this.fail(new StreamJsonError())
+      else if (error instanceof StreamError) this.fail(error)
+      else this.fail(new StreamError(error?.message || `${error}`))
+    }
+    if (!this.error) this.complete()
+  }
+
+  private clear() {
+    this.onChangeListeners = []
+    this.abortController = undefined
+  }
+
+  private fail(error: any) {
+    this.error = error
+    this.fullPromise.reject(this.error)
+    this.clear()
+  }
+
+  private complete() {
+    this.fullPromise.resolve(this.data)
+    this.clear()
+  }
+
+  /**
+   * Returns the full value of the array once the stream finishes.
+   */
+  getValue(): Promise<T[]> {
+    return this.fullPromise.promise
+  }
+
+  /**
+   * Returns the streamed array with every item streamed until now. This will be the complete array if the stream has finished.
+   */
+  getPartialValue(): T[] {
+    return this.data
+  }
+
+  /**
+   * Watches the array as it's streamed. This doesn't wait for the value to be complete.
+   * 
+   * The listener is called whenever the value changes.
+   * 
+   * @param listener the function to call with the new value.
+   * @returns a function that, when called, removes the listener.
+   */
+  onChange(listener: (value: T[]) => void) {
+    if (this.fullPromise.resolved) {
+      listener(this.data)
+      return () => {}
+    }
+    this.onChangeListeners.push(listener)
+    return () => {
+      const index = this.onChangeListeners?.findIndex(l => l === listener)
+      if (index !== undefined && index >= 0) this.onChangeListeners?.splice(index, 1)
+    }
+  }
+
+  getStatus(): StreamingStatus {
+    if (this.error) return 'error'
+    if (this.fullPromise.resolved) return 'success'
+    return 'pending'
+  }
+
+  getError() {
+    return this.error
+  }
+
+  /**
+   * If this is a stream and it's not yet finished, calling this function cancels the stream.
+   */
+  cancel() {
+    this.abortController?.abort(new StreamCanceledError())
+  }
+}

package/src/utils/StreamedJson.tsx

@@ -3,8 +3,8 @@ import { StreamCanceledError } from '../error/StreamCanceledError'
 import { StreamError } from '../error/StreamError'
 import { StreamJsonError } from '../error/StreamJsonError'
 import { FetchEventStream } from '../network/types'
+import { StreamingStatus } from '../types'
 
-type StreamingStatus = 'pending' | 'success' | 'error'
 type OnChangeListener<T> = (value: Partial<T>) => void
 
 interface ConstructorParams<T> {

package/src/utils/use-streamed-array.ts

@@ -0,0 +1,17 @@
+import { useEffect, useState } from 'react'
+import { StreamingStatus } from '../types'
+import { StreamedArray } from './StreamedArray'
+
+export function useStreamedArray<T>(stream: StreamedArray<T> | undefined) {
+  const [array, setArray] = useState<T[]>(stream?.getPartialValue() ?? [])
+  const [status, setStatus] = useState<StreamingStatus>(stream?.getStatus() ?? 'pending')
+  useEffect(() => {
+    setArray(stream?.getPartialValue() ?? [])
+    setStatus(stream?.getStatus() ?? 'pending')
+    return stream?.onChange((values) => {
+      setArray(values)
+      setStatus(stream.getStatus())
+    })
+  }, [stream])
+  return [array, status]
+}