@brainfish-ai/devdoc 0.1.21

package/renderer/lib/api-docs/playground/request-builder.ts

@@ -0,0 +1,223 @@
+/**
+ * Request Builder
+ * 
+ * Builds HTTP requests from BrainfishRESTRequest
+ * Ported and simplified from Hoppscotch's EffectiveURL and request building logic
+ */
+
+import type {
+  BrainfishRESTRequest,
+  BrainfishRESTAuth,
+  BrainfishRESTReqBody,
+} from '../types'
+
+export interface BuiltRequest {
+  url: string
+  method: string
+  headers: Record<string, string>
+  body?: BodyInit
+}
+
+/**
+ * Builds auth headers from auth configuration
+ */
+function buildAuthHeaders(
+  auth: BrainfishRESTAuth
+): Record<string, string> {
+  const headers: Record<string, string> = {}
+
+  if (auth.authType === 'basic' && auth.authActive) {
+    const credentials = btoa(`${auth.username}:${auth.password}`)
+    headers['Authorization'] = `Basic ${credentials}`
+  } else if (auth.authType === 'bearer' && auth.authActive) {
+    headers['Authorization'] = `Bearer ${auth.token}`
+  } else if (auth.authType === 'api-key' && auth.authActive) {
+    if (auth.addTo === 'HEADERS') {
+      headers[auth.key] = auth.value
+    }
+  } else if (auth.authType === 'oauth-2' && auth.authActive) {
+    // For OAuth2, we'll use the token if available
+    if (auth.grantTypeInfo.token) {
+      headers['Authorization'] = `Bearer ${auth.grantTypeInfo.token}`
+    }
+  }
+
+  return headers
+}
+
+/**
+ * Builds auth query parameters
+ */
+function buildAuthParams(auth: BrainfishRESTAuth): Record<string, string> {
+  const params: Record<string, string> = {}
+
+  if (auth.authType === 'api-key' && auth.authActive) {
+    if (auth.addTo === 'QUERY_PARAMS') {
+      params[auth.key] = auth.value
+    }
+  }
+
+  return params
+}
+
+/**
+ * Builds request body from body configuration
+ */
+function buildRequestBody(
+  body: BrainfishRESTReqBody,
+  bodyValue?: string
+): BodyInit | undefined {
+  if (!body.body || body.contentType === null) {
+    return undefined
+  }
+
+  // Use provided bodyValue if available (from playground editor)
+  if (bodyValue !== undefined && bodyValue !== null) {
+    if (body.contentType === 'application/json') {
+      // Return as-is - user might be editing
+      return bodyValue
+    } else if (body.contentType === 'application/x-www-form-urlencoded') {
+      // Parse as form data
+      const params = new URLSearchParams()
+      bodyValue.split('\n').forEach((line) => {
+        const [key, ...valueParts] = line.split(':')
+        if (key && valueParts.length > 0) {
+          params.append(key.trim(), valueParts.join(':').trim())
+        }
+      })
+      return params.toString()
+    }
+    return bodyValue
+  }
+
+  // Use body from request
+  if (Array.isArray(body.body)) {
+    // Form data
+    if (body.contentType === 'multipart/form-data') {
+      const formData = new FormData()
+      body.body.forEach((item) => {
+        // Note: In a real implementation, isFile would indicate a file upload
+        // For now, we just append the string value
+        if (typeof item.value === 'string') {
+          formData.append(item.key, item.value)
+        } else {
+          // File or Blob value
+          formData.append(item.key, item.value as Blob)
+        }
+      })
+      return formData
+    } else if (body.contentType === 'application/x-www-form-urlencoded') {
+      // URL encoded form
+      const params = new URLSearchParams()
+      body.body.forEach((item) => {
+        if (typeof item.value === 'string') {
+          params.append(item.key, item.value)
+        }
+      })
+      return params
+    }
+  } else if (typeof body.body === 'string') {
+    return body.body
+  }
+
+  return undefined
+}
+
+/**
+ * Builds the final URL with path variables and query parameters
+ */
+function buildURL(
+  endpoint: string,
+  params: Array<{ key: string; value: string; active: boolean }>,
+  variables: Array<{ key: string; value: string; active?: boolean }>,
+  authParams: Record<string, string>
+): string {
+  // Replace path variables (<<variable>> or {variable})
+  let url = endpoint
+  variables.forEach((variable) => {
+    // Replace <<variable>> pattern
+    url = url.replace(new RegExp(`<<${variable.key}>>`, 'g'), variable.value || '')
+    // Replace {variable} pattern
+    url = url.replace(new RegExp(`\\{${variable.key}\\}`, 'g'), variable.value || '')
+  })
+
+  // Build query string
+  const queryParams = new URLSearchParams()
+  
+  // Add request params
+  params
+    .filter((p) => p.active && p.key)
+    .forEach((param) => {
+      queryParams.append(param.key, param.value)
+    })
+
+  // Add auth params
+  Object.entries(authParams).forEach(([key, value]) => {
+    queryParams.append(key, value)
+  })
+
+  // Append query string to URL
+  const queryString = queryParams.toString()
+  if (queryString) {
+    const separator = url.includes('?') ? '&' : '?'
+    url = `${url}${separator}${queryString}`
+  }
+
+  return url
+}
+
+/**
+ * Builds a complete HTTP request from BrainfishRESTRequest
+ */
+export function buildRequest(
+  request: BrainfishRESTRequest,
+  options?: {
+    params?: Array<{ key: string; value: string; active: boolean }>
+    headers?: Array<{ key: string; value: string; active: boolean }>
+    body?: string | null
+    variables?: Array<{ key: string; value: string; active: boolean }>
+  }
+): BuiltRequest {
+  // Use provided values or fall back to request defaults
+  const params = options?.params || request.params
+  const headers = options?.headers || request.headers
+  const variables = options?.variables || request.requestVariables
+  const bodyValue = options?.body
+
+  // Build auth headers and params
+  const authHeaders = buildAuthHeaders(request.auth)
+  const authParams = buildAuthParams(request.auth)
+
+  // Build URL
+  const url = buildURL(request.endpoint, params, variables, authParams)
+
+  // Build body
+  const body = buildRequestBody(request.body, bodyValue ?? undefined)
+
+  // Build headers
+  const finalHeaders: Record<string, string> = { ...authHeaders }
+  
+  headers
+    .filter((h) => h.active && h.key)
+    .forEach((header) => {
+      finalHeaders[header.key] = header.value
+    })
+
+  // Add content-type if body exists (but don't override if already set)
+  if (body && request.body.contentType && !finalHeaders['Content-Type']) {
+    finalHeaders['Content-Type'] = request.body.contentType
+  }
+  
+  // For POST/PUT/PATCH requests without body, add default Content-Type
+  // Some APIs require this header even for empty requests
+  if (!finalHeaders['Content-Type'] && ['POST', 'PUT', 'PATCH'].includes(request.method)) {
+    finalHeaders['Content-Type'] = 'application/json'
+  }
+
+  return {
+    url,
+    method: request.method,
+    headers: finalHeaders,
+    body,
+  }
+}

package/renderer/lib/api-docs/playground/request-runner.ts

@@ -0,0 +1,282 @@
+/**
+ * Request Runner
+ * 
+ * Executes HTTP requests via backend proxy to bypass CORS
+ * and ensure auth headers are sent properly.
+ * Supports streaming responses for SSE endpoints.
+ */
+
+import type { BrainfishRESTRequest } from '../types'
+import type { PlaygroundResponse } from './types'
+import { buildRequest } from './request-builder'
+
+export interface RequestRunnerOptions {
+  params?: Array<{ key: string; value: string; active: boolean }>
+  headers?: Array<{ key: string; value: string; active: boolean }>
+  body?: string | null
+  variables?: Array<{ key: string; value: string; active: boolean }>
+  signal?: AbortSignal
+  /** Callback for streaming responses - called for each chunk */
+  onChunk?: (chunk: string, accumulated: string) => void
+  /** Callback when streaming starts with metadata */
+  onStreamStart?: (metadata: { status: number; statusText: string; headers: Record<string, string> }) => void
+}
+
+/**
+ * Executes a REST request via the backend proxy
+ */
+export async function executeRequest(
+  request: BrainfishRESTRequest,
+  options: RequestRunnerOptions = {}
+): Promise<PlaygroundResponse> {
+  try {
+    // Build the request
+    const builtRequest = buildRequest(request, options)
+
+    // Send request through our backend proxy
+    const proxyResponse = await fetch('/api/proxy', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        url: builtRequest.url,
+        method: builtRequest.method,
+        headers: builtRequest.headers,
+        requestBody: builtRequest.body instanceof FormData 
+          ? undefined // FormData not supported through JSON proxy
+          : builtRequest.body,
+      }),
+      signal: options.signal,
+    })
+
+    if (!proxyResponse.ok) {
+      const errorData = await proxyResponse.json().catch(() => ({}))
+      return {
+        status: proxyResponse.status,
+        statusText: proxyResponse.statusText,
+        headers: {},
+        body: JSON.stringify(errorData),
+        responseTime: 0,
+        size: 0,
+        error: errorData.error || 'Proxy request failed',
+      }
+    }
+
+    const result = await proxyResponse.json()
+    
+    return {
+      status: result.status,
+      statusText: result.statusText,
+      headers: result.headers || {},
+      body: result.body,
+      responseTime: result.responseTime || 0,
+      size: result.size || 0,
+      error: result.error,
+    }
+  } catch (error) {
+    if (error instanceof Error && error.name === 'AbortError') {
+      throw new Error('Request cancelled')
+    }
+
+    return {
+      status: 0,
+      statusText: 'Error',
+      headers: {},
+      body: null,
+      responseTime: 0,
+      size: 0,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    }
+  }
+}
+
+/**
+ * Executes a streaming request (for SSE endpoints)
+ * Falls back to regular request if the endpoint isn't actually SSE
+ */
+export async function executeStreamingRequest(
+  request: BrainfishRESTRequest,
+  options: RequestRunnerOptions = {}
+): Promise<PlaygroundResponse> {
+  const startTime = Date.now()
+  
+  try {
+    const builtRequest = buildRequest(request, options)
+
+    // Use streaming proxy
+    const response = await fetch('/api/proxy-stream', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        url: builtRequest.url,
+        method: builtRequest.method,
+        headers: builtRequest.headers,
+        requestBody: builtRequest.body instanceof FormData 
+          ? undefined 
+          : builtRequest.body,
+      }),
+      signal: options.signal,
+    })
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}))
+      return {
+        status: response.status,
+        statusText: response.statusText,
+        headers: {},
+        body: JSON.stringify(errorData),
+        responseTime: Date.now() - startTime,
+        size: 0,
+        error: errorData.error || 'Proxy request failed',
+      }
+    }
+
+    const contentType = response.headers.get('content-type') || ''
+    
+    // Check if streaming response (our proxy wraps SSE responses as SSE)
+    const isProxyStreaming = contentType.includes('text/event-stream')
+    
+    if (isProxyStreaming && response.body) {
+      const reader = response.body.getReader()
+      const decoder = new TextDecoder()
+      let accumulated = ''
+      let metadata: { status: number; statusText: string; headers: Record<string, string> } | null = null
+      let totalSize = 0
+      let buffer = ''
+
+      try {
+        while (true) {
+          const { done, value } = await reader.read()
+          if (done) break
+
+          buffer += decoder.decode(value, { stream: true })
+          
+          // Process complete SSE events (ending with \n\n)
+          const events = buffer.split('\n\n')
+          buffer = events.pop() || '' // Keep incomplete event in buffer
+
+          for (const eventStr of events) {
+            const lines = eventStr.split('\n')
+            for (const line of lines) {
+              if (line.startsWith('data: ')) {
+                try {
+                  const event = JSON.parse(line.slice(6))
+                  
+                  if (event.type === 'metadata') {
+                    metadata = {
+                      status: event.status,
+                      statusText: event.statusText,
+                      headers: event.headers,
+                    }
+                    options.onStreamStart?.(metadata)
+                  } else if (event.type === 'chunk') {
+                    // Accumulate raw SSE data - formatting happens in response viewer
+                    accumulated += event.data
+                    totalSize += event.size || 0
+                    options.onChunk?.(event.data, accumulated)
+                  } else if (event.type === 'done') {
+                    totalSize = event.totalSize || totalSize
+                  } else if (event.type === 'error') {
+                    return {
+                      status: metadata?.status || 0,
+                      statusText: metadata?.statusText || 'Error',
+                      headers: metadata?.headers || {},
+                      body: accumulated,
+                      responseTime: Date.now() - startTime,
+                      size: totalSize,
+                      error: event.error,
+                      isStreaming: true,
+                    }
+                  }
+                } catch {
+                  // Ignore parse errors for partial data
+                }
+              }
+            }
+          }
+        }
+      } catch (readError) {
+        // Handle read errors gracefully
+        if (readError instanceof Error && readError.name === 'AbortError') {
+          throw readError
+        }
+      }
+
+      return {
+        status: metadata?.status || 200,
+        statusText: metadata?.statusText || 'OK',
+        headers: metadata?.headers || {},
+        body: accumulated,
+        responseTime: Date.now() - startTime,
+        size: totalSize,
+        isStreaming: true,
+      }
+    }
+
+    // Non-streaming response from streaming proxy (endpoint wasn't SSE)
+    const result = await response.json()
+    return {
+      status: result.status,
+      statusText: result.statusText,
+      headers: result.headers || {},
+      body: result.body,
+      responseTime: Date.now() - startTime,
+      size: result.size || 0,
+      error: result.error,
+      isStreaming: false,
+    }
+  } catch (error) {
+    if (error instanceof Error && error.name === 'AbortError') {
+      throw new Error('Request cancelled')
+    }
+
+    return {
+      status: 0,
+      statusText: 'Error',
+      headers: {},
+      body: null,
+      responseTime: Date.now() - startTime,
+      size: 0,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    }
+  }
+}
+
+/**
+ * Creates a cancelable request execution
+ */
+export function createCancelableRequest(
+  request: BrainfishRESTRequest,
+  options: RequestRunnerOptions = {}
+): {
+  execute: () => Promise<PlaygroundResponse>
+  cancel: () => void
+} {
+  const abortController = new AbortController()
+
+  return {
+    execute: () => executeRequest(request, { ...options, signal: abortController.signal }),
+    cancel: () => abortController.abort(),
+  }
+}
+
+/**
+ * Creates a cancelable streaming request execution
+ */
+export function createCancelableStreamingRequest(
+  request: BrainfishRESTRequest,
+  options: RequestRunnerOptions = {}
+): {
+  execute: () => Promise<PlaygroundResponse>
+  cancel: () => void
+} {
+  const abortController = new AbortController()
+
+  return {
+    execute: () => executeStreamingRequest(request, { ...options, signal: abortController.signal }),
+    cancel: () => abortController.abort(),
+  }
+}

package/renderer/lib/api-docs/playground/types.ts

@@ -0,0 +1,35 @@
+/**
+ * Playground Types
+ * 
+ * Types for the API playground (Try It Out functionality)
+ */
+
+import type { BrainfishRESTRequest } from '../types'
+
+export interface PlaygroundRequest {
+  request: BrainfishRESTRequest
+  // Editable values (user can modify before sending)
+  params: Array<{ key: string; value: string; active: boolean }>
+  headers: Array<{ key: string; value: string; active: boolean }>
+  body: string | null
+  variables: Array<{ key: string; value: string; active: boolean }>
+}
+
+export interface PlaygroundResponse {
+  status: number
+  statusText: string
+  headers: Record<string, string>
+  body: string | Blob | null
+  responseTime: number
+  size: number
+  error?: string
+  /** Whether this was a streaming response (SSE) */
+  isStreaming?: boolean
+}
+
+export type PlaygroundResponseState = 
+  | { type: 'idle' }
+  | { type: 'loading' }
+  | { type: 'streaming'; response: PlaygroundResponse }
+  | { type: 'success'; response: PlaygroundResponse }
+  | { type: 'error'; error: string; response?: PlaygroundResponse }