spiceflow 1.17.11 → 1.18.0

package/src/client/index.ts

@@ -1,6 +1,4 @@
 import type { AnySpiceflow, Spiceflow } from '../spiceflow.ts'
-import superjson from 'superjson'
-import { EventSourceParserStream } from 'eventsource-parser/stream'
 
 import type { SpiceflowClient } from './types.ts'
 
@@ -10,6 +8,25 @@ import { SpiceflowFetchError } from './errors.ts'
 
 import { parseStringifiedValue } from './utils.ts'
 
+import {
+  isServer,
+  isFile,
+  hasFile,
+  createNewFile,
+  processHeaders,
+  streamSSEResponse,
+  tryParsingSSEJson,
+  superjsonDeserialize,
+  TextDecoderStream,
+  isAbortError,
+  type SSEEvent,
+} from './shared.ts'
+
+export { streamSSEResponse, TextDecoderStream }
+
+export { createSpiceflowFetch } from './fetch.ts'
+export type { SpiceflowFetch } from './fetch.ts'
+
 const method = [
   'get',
   'post',
@@ -22,177 +39,6 @@ const method = [
   'subscribe',
 ] as const
 
-const isServer = typeof FileList === 'undefined'
-
-const isFile = (v: any) => {
-  if (isServer) return v instanceof Blob
-
-  return v instanceof FileList || v instanceof File
-}
-
-// FormData is 1 level deep
-const hasFile = (obj: Record<string, any>) => {
-  if (!obj) return false
-
-  for (const key in obj) {
-    if (isFile(obj[key])) return true
-
-    if (Array.isArray(obj[key]) && (obj[key] as unknown[]).find(isFile))
-      return true
-  }
-
-  return false
-}
-
-const createNewFile = (v: File) =>
-  isServer
-    ? v
-    : new Promise<File>((resolve) => {
-        const reader = new FileReader()
-
-        reader.onload = () => {
-          const file = new File([reader.result!], v.name, {
-            lastModified: v.lastModified,
-            type: v.type,
-          })
-          resolve(file)
-        }
-
-        reader.readAsArrayBuffer(v)
-      })
-
-const processHeaders = (
-  h: SpiceflowClient.Config['headers'],
-  path: string,
-  options: RequestInit = {},
-  headers: Record<string, string> = {},
-): Record<string, string> => {
-  if (Array.isArray(h)) {
-    for (const value of h)
-      if (!Array.isArray(value))
-        headers = processHeaders(value, path, options, headers)
-      else {
-        const key = value[0]
-        if (typeof key === 'string')
-          headers[key.toLowerCase()] = value[1] as string
-        else
-          for (const [k, value] of key)
-            headers[k.toLowerCase()] = value as string
-      }
-
-    return headers
-  }
-
-  if (!h) return headers
-
-  switch (typeof h) {
-    case 'function':
-      if (typeof Headers !== 'undefined' && h instanceof Headers)
-        return processHeaders(h, path, options, headers)
-
-      const v = h(path, options)
-      if (v) return processHeaders(v, path, options, headers)
-      return headers
-
-    case 'object':
-      if (typeof Headers !== 'undefined' && h instanceof Headers) {
-        h.forEach((value, key) => {
-          headers[key.toLowerCase()] = value
-        })
-        return headers
-      }
-
-      for (const [key, value] of Object.entries(h))
-        headers[key.toLowerCase()] = value as string
-
-      return headers
-
-    default:
-      return headers
-  }
-}
-
-interface SSEEvent {
-  event?: string
-  data: any
-  id?: string
-}
-
-export class TextDecoderStream extends TransformStream<Uint8Array, string> {
-  constructor() {
-    const decoder = new TextDecoder('utf-8', {
-      fatal: true,
-      ignoreBOM: true,
-    })
-    super({
-      transform(
-        chunk: Uint8Array,
-        controller: TransformStreamDefaultController<string>,
-      ) {
-        const decoded = decoder.decode(chunk, { stream: true })
-        if (decoded.length > 0) {
-          controller.enqueue(decoded)
-        }
-      },
-      flush(controller: TransformStreamDefaultController<string>) {
-        const output = decoder.decode()
-        if (output.length > 0) {
-          controller.enqueue(output)
-        }
-      },
-    })
-  }
-}
-
-function isAbortError(error: unknown): error is Error {
-  return (
-    (error instanceof Error || error instanceof DOMException) &&
-    (error.name === 'AbortError' ||
-      error.name === 'ResponseAborted' || // Next.js
-      error.name === 'TimeoutError')
-  )
-}
-
-export async function* streamSSEResponse(
-  response: Response,
-  map: (x: SSEEvent) => any,
-): AsyncGenerator<SSEEvent> {
-  const body = response.body
-  if (!body) return
-
-  const eventStream = response.body
-    .pipeThrough(new TextDecoderStream())
-    .pipeThrough(new EventSourceParserStream())
-
-  let reader = eventStream.getReader()
-  try {
-    while (true) {
-      const { done, value: event } = await reader.read()
-      if (done) break
-      if (event?.event === 'error') {
-        throw new SpiceflowFetchError(500, superjsonDeserialize(event.data))
-      }
-      if (event) {
-        yield map({ ...event, data: event.data })
-      }
-    }
-  } catch (error) {
-    if (isAbortError(error)) {
-      return
-    }
-
-    throw error
-  }
-}
-
-function tryParsingSSEJson(data: string): any {
-  try {
-    return superjsonDeserialize(JSON.parse(data))
-  } catch (error) {
-    return data
-  }
-}
-
 const createProxy = (
   domain: string,
   config: SpiceflowClient.Config & { state?: any },
@@ -226,7 +72,13 @@ const createProxy = (
         const method = methodPaths.pop()
         const path = '/' + methodPaths.join('/')
 
-        let { fetch: fetcher = fetch, headers, onRequest, onResponse } = config
+        let {
+          fetch: fetcher = fetch,
+          headers,
+          onRequest,
+          onResponse,
+          retries = 0,
+        } = config
 
         const isGetOrHead =
           method === 'get' || method === 'head' || method === 'subscribe'
@@ -394,11 +246,46 @@ const createProxy = (
           }
 
           const url = domain + path + q
-          // console.log({ url, fetchInit })
-          const response = await (instance?.handle(
-            new Request(url, fetchInit),
-            { state: config.state },
-          ) ?? fetcher!(url, fetchInit))
+
+          const executeRequest = async (): Promise<Response> => {
+            let attempt = 0
+            let response: Response
+            let lastError: Error | null = null
+
+            while (attempt <= retries) {
+              try {
+                response = await (instance?.handle(
+                  new Request(url, fetchInit),
+                  { state: config.state },
+                ) ?? fetcher!(url, fetchInit))
+
+                if (response.status < 500 || attempt === retries) {
+                  break
+                }
+
+                lastError = new Error(
+                  `Server error: ${response.status} ${response.statusText}`,
+                )
+              } catch (err) {
+                lastError = err as Error
+                if (attempt === retries) {
+                  throw err
+                }
+              }
+
+              attempt++
+              const backoffMs = Math.min(1000 * 2 ** (attempt - 1), 10000)
+              await new Promise((resolve) => setTimeout(resolve, backoffMs))
+            }
+
+            if (!response!) {
+              throw lastError || new Error('Failed to fetch after retries')
+            }
+
+            return response
+          }
+
+          const response = await executeRequest()
 
           let data = null as any
           let error = null as any
@@ -429,8 +316,13 @@ const createProxy = (
 
           switch (response.headers.get('Content-Type')?.split(';')[0]) {
             case 'text/event-stream':
-              data = streamSSEResponse(response, (x) => {
-                return tryParsingSSEJson(x.data)
+              data = streamSSEResponse({
+                response,
+                map: (x) => {
+                  return tryParsingSSEJson(x.data)
+                },
+                executeRequest,
+                maxRetries: retries,
               })
 
               break
@@ -512,14 +404,3 @@ export const createSpiceflowClient = <const App extends AnySpiceflow>(
 
   return createProxy('http://e.ly', config || {}, [], domain)
 }
-
-function superjsonDeserialize(data: any) {
-  if (data?.__superjsonMeta) {
-    const { __superjsonMeta, ...rest } = data
-    return superjson.deserialize({
-      json: rest,
-      meta: __superjsonMeta,
-    })
-  }
-  return data
-}

package/src/client/shared.ts

@@ -0,0 +1,406 @@
+// Shared utilities used by both the proxy client and the fetch client
+import superjson from 'superjson'
+import { EventSourceParserStream } from 'eventsource-parser/stream'
+
+import type { SpiceflowClient } from './types.ts'
+import { SpiceflowFetchError } from './errors.ts'
+import { parseStringifiedValue } from './utils.ts'
+import type { AnySpiceflow } from '../spiceflow.ts'
+
+export const isServer = typeof FileList === 'undefined'
+
+export const isFile = (v: any) => {
+  if (isServer) return v instanceof Blob
+  return v instanceof FileList || v instanceof File
+}
+
+export const hasFile = (obj: Record<string, any>) => {
+  if (!obj) return false
+  for (const key in obj) {
+    if (isFile(obj[key])) return true
+    if (Array.isArray(obj[key]) && (obj[key] as unknown[]).find(isFile))
+      return true
+  }
+  return false
+}
+
+export const createNewFile = (v: File) =>
+  isServer
+    ? v
+    : new Promise<File>((resolve) => {
+        const reader = new FileReader()
+        reader.onload = () => {
+          const file = new File([reader.result!], v.name, {
+            lastModified: v.lastModified,
+            type: v.type,
+          })
+          resolve(file)
+        }
+        reader.readAsArrayBuffer(v)
+      })
+
+export const processHeaders = (
+  h: SpiceflowClient.Config['headers'],
+  path: string,
+  options: RequestInit = {},
+  headers: Record<string, string> = {},
+): Record<string, string> => {
+  if (Array.isArray(h)) {
+    for (const value of h)
+      if (!Array.isArray(value))
+        headers = processHeaders(value, path, options, headers)
+      else {
+        const key = value[0]
+        if (typeof key === 'string')
+          headers[key.toLowerCase()] = value[1] as string
+        else
+          for (const [k, value] of key)
+            headers[k.toLowerCase()] = value as string
+      }
+    return headers
+  }
+
+  if (!h) return headers
+
+  switch (typeof h) {
+    case 'function':
+      if (typeof Headers !== 'undefined' && h instanceof Headers)
+        return processHeaders(h, path, options, headers)
+      const v = h(path, options)
+      if (v) return processHeaders(v, path, options, headers)
+      return headers
+
+    case 'object':
+      if (typeof Headers !== 'undefined' && h instanceof Headers) {
+        h.forEach((value, key) => {
+          headers[key.toLowerCase()] = value
+        })
+        return headers
+      }
+      for (const [key, value] of Object.entries(h))
+        headers[key.toLowerCase()] = value as string
+      return headers
+
+    default:
+      return headers
+  }
+}
+
+export interface SSEEvent {
+  event?: string
+  data: any
+  id?: string
+}
+
+export class TextDecoderStream extends TransformStream<Uint8Array, string> {
+  constructor() {
+    const decoder = new TextDecoder('utf-8', {
+      fatal: true,
+      ignoreBOM: true,
+    })
+    super({
+      transform(
+        chunk: Uint8Array,
+        controller: TransformStreamDefaultController<string>,
+      ) {
+        const decoded = decoder.decode(chunk, { stream: true })
+        if (decoded.length > 0) {
+          controller.enqueue(decoded)
+        }
+      },
+      flush(controller: TransformStreamDefaultController<string>) {
+        const output = decoder.decode()
+        if (output.length > 0) {
+          controller.enqueue(output)
+        }
+      },
+    })
+  }
+}
+
+export function isAbortError(error: unknown): error is Error {
+  return (
+    (error instanceof Error || error instanceof DOMException) &&
+    (error.name === 'AbortError' ||
+      error.name === 'ResponseAborted' || // Next.js
+      error.name === 'TimeoutError')
+  )
+}
+
+export async function* streamSSEResponse({
+  response,
+  map,
+  executeRequest,
+  maxRetries = 0,
+}: {
+  response: Response
+  map: (x: SSEEvent) => any
+  executeRequest?: () => Promise<Response>
+  maxRetries?: number
+}): AsyncGenerator<SSEEvent> {
+  let currentResponse = response
+  let retriesLeft = maxRetries
+
+  while (true) {
+    const body = currentResponse.body
+    if (!body) return
+
+    const eventStream = body
+      .pipeThrough(new TextDecoderStream())
+      .pipeThrough(new EventSourceParserStream())
+
+    let reader = eventStream.getReader()
+
+    try {
+      while (true) {
+        const { done, value: event } = await reader.read()
+        if (done) return
+
+        if (event?.event === 'error') {
+          const error = superjsonDeserialize(event.data)
+          throw new SpiceflowFetchError(500, error)
+        }
+
+        if (event) {
+          yield map({ ...event, data: event.data })
+        }
+      }
+    } catch (error) {
+      if (isAbortError(error)) {
+        return
+      }
+
+      if (
+        executeRequest &&
+        error instanceof SpiceflowFetchError &&
+        error.status >= 500 &&
+        retriesLeft > 0
+      ) {
+        retriesLeft--
+        const backoffMs = Math.min(
+          1000 * 2 ** (maxRetries - retriesLeft - 1),
+          10000,
+        )
+        await new Promise((resolve) => setTimeout(resolve, backoffMs))
+
+        try {
+          currentResponse = await executeRequest()
+          if (currentResponse.status >= 500) {
+            if (retriesLeft === 0) {
+              throw error
+            }
+            continue
+          }
+        } catch (retryError) {
+          if (retriesLeft === 0) {
+            throw retryError
+          }
+          continue
+        }
+      } else {
+        throw error
+      }
+    }
+  }
+}
+
+export function tryParsingSSEJson(data: string): any {
+  try {
+    return superjsonDeserialize(JSON.parse(data))
+  } catch (error) {
+    return data
+  }
+}
+
+export function superjsonDeserialize(data: any) {
+  if (data?.__superjsonMeta) {
+    const { __superjsonMeta, ...rest } = data
+    return superjson.deserialize({
+      json: rest,
+      meta: __superjsonMeta,
+    })
+  }
+  return data
+}
+
+export function buildQueryString(
+  query: Record<string, string | string[] | number | boolean | object | undefined | null> | undefined,
+): string {
+  if (!query) return ''
+  let q = ''
+  const append = (key: string, value: string) => {
+    q +=
+      (q ? '&' : '?') +
+      `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
+  }
+  for (const [key, value] of Object.entries(query)) {
+    if (value === undefined || value === null) continue
+    if (Array.isArray(value)) {
+      for (const v of value) append(key, v)
+      continue
+    }
+    if (typeof value === 'object') {
+      append(key, JSON.stringify(value))
+      continue
+    }
+    append(key, `${value}`)
+  }
+  return q
+}
+
+export async function serializeBody({
+  body,
+  fetchInit,
+  isGetOrHead,
+}: {
+  body: any
+  fetchInit: RequestInit
+  isGetOrHead: boolean
+}): Promise<void> {
+  if (isGetOrHead) {
+    delete fetchInit.body
+    return
+  }
+
+  if (hasFile(body)) {
+    const formData = new FormData()
+    for (const [key, field] of Object.entries(body)) {
+      if (isServer) {
+        formData.append(key, field as any)
+        continue
+      }
+      if (field instanceof File) {
+        formData.append(key, await createNewFile(field as any))
+        continue
+      }
+      if (field instanceof FileList) {
+        for (let i = 0; i < field.length; i++)
+          formData.append(key as any, await createNewFile((field as any)[i]))
+        continue
+      }
+      if (Array.isArray(field)) {
+        for (let i = 0; i < field.length; i++) {
+          const value = (field as any)[i]
+          formData.append(
+            key as any,
+            value instanceof File ? await createNewFile(value) : value,
+          )
+        }
+        continue
+      }
+      formData.append(key, field as string)
+    }
+    fetchInit.body = formData
+  } else if (typeof body === 'object' && body !== null) {
+    ;(fetchInit.headers as Record<string, string>)['content-type'] =
+      'application/json'
+    fetchInit.body = JSON.stringify(body)
+  } else if (body !== undefined && body !== null) {
+    ;(fetchInit.headers as Record<string, string>)['content-type'] =
+      'text/plain'
+    fetchInit.body = body
+  }
+}
+
+export async function parseResponseData({
+  response,
+  executeRequest,
+  retries,
+}: {
+  response: Response
+  executeRequest: () => Promise<Response>
+  retries: number
+}): Promise<{ data: any; error: any }> {
+  let data = null as any
+  let error = null as any
+
+  switch (response.headers.get('Content-Type')?.split(';')[0]) {
+    case 'text/event-stream':
+      data = streamSSEResponse({
+        response,
+        map: (x) => tryParsingSSEJson(x.data),
+        executeRequest,
+        maxRetries: retries,
+      })
+      break
+
+    case 'application/json':
+      data = await response.json()
+      data = superjsonDeserialize(data)
+      break
+
+    case 'application/octet-stream':
+      data = await response.arrayBuffer()
+      break
+
+    case 'multipart/form-data': {
+      const temp = await response.formData()
+      data = {}
+      temp.forEach((value, key) => {
+        data[key] = value
+      })
+      break
+    }
+
+    default:
+      data = await response.text().then(parseStringifiedValue)
+  }
+
+  if (response.status >= 300 || response.status < 200) {
+    error = new SpiceflowFetchError(response.status, data || 'Unknown error')
+    data = null
+  }
+
+  return { data, error }
+}
+
+export async function executeWithRetries({
+  url,
+  fetchInit,
+  fetcher,
+  instance,
+  state,
+  retries,
+}: {
+  url: string
+  fetchInit: RequestInit
+  fetcher: typeof fetch
+  instance?: AnySpiceflow
+  state?: any
+  retries: number
+}): Promise<Response> {
+  let attempt = 0
+  let response!: Response
+  let lastError: Error | null = null
+
+  while (attempt <= retries) {
+    try {
+      response = await (instance?.handle(new Request(url, fetchInit), {
+        state,
+      }) ?? fetcher(url, fetchInit))
+
+      if (response.status < 500 || attempt === retries) {
+        break
+      }
+
+      lastError = new Error(
+        `Server error: ${response.status} ${response.statusText}`,
+      )
+    } catch (err) {
+      lastError = err as Error
+      if (attempt === retries) {
+        throw err
+      }
+    }
+
+    attempt++
+    const backoffMs = Math.min(1000 * 2 ** (attempt - 1), 10000)
+    await new Promise((resolve) => setTimeout(resolve, backoffMs))
+  }
+
+  if (!response) {
+    throw lastError || new Error('Failed to fetch after retries')
+  }
+
+  return response
+}