@brainfish-ai/devdoc 0.1.42 → 0.1.43

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

@@ -1,223 +0,0 @@
-/**
- * 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

@@ -1,282 +0,0 @@
-/**
- * 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

@@ -1,35 +0,0 @@
-/**
- * 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 }