@brainfish-ai/devdoc 0.1.41 → 0.1.43

package/renderer/lib/api-docs/codegen/definitions.ts

@@ -1,297 +0,0 @@
-/**
- * Code generation definitions for supported languages/libraries
- * Based on HTTPSnippet supported targets
- */
-
-export const CodegenDefinitions = [
-  // Shell
-  {
-    name: 'shell-curl',
-    lang: 'shell',
-    client: 'curl',
-    caption: 'cURL',
-    category: 'Shell',
-  },
-  {
-    name: 'shell-httpie',
-    lang: 'shell',
-    client: 'httpie',
-    caption: 'HTTPie',
-    category: 'Shell',
-  },
-  {
-    name: 'shell-wget',
-    lang: 'shell',
-    client: 'wget',
-    caption: 'Wget',
-    category: 'Shell',
-  },
-
-  // JavaScript
-  {
-    name: 'javascript-fetch',
-    lang: 'javascript',
-    client: 'fetch',
-    caption: 'Fetch',
-    category: 'JavaScript',
-  },
-  {
-    name: 'javascript-axios',
-    lang: 'javascript',
-    client: 'axios',
-    caption: 'Axios',
-    category: 'JavaScript',
-  },
-  {
-    name: 'javascript-jquery',
-    lang: 'javascript',
-    client: 'jquery',
-    caption: 'jQuery',
-    category: 'JavaScript',
-  },
-  {
-    name: 'javascript-xhr',
-    lang: 'javascript',
-    client: 'xhr',
-    caption: 'XMLHttpRequest',
-    category: 'JavaScript',
-  },
-
-  // Node.js
-  {
-    name: 'node-fetch',
-    lang: 'node',
-    client: 'fetch',
-    caption: 'Node Fetch',
-    category: 'Node.js',
-  },
-  {
-    name: 'node-axios',
-    lang: 'node',
-    client: 'axios',
-    caption: 'Axios',
-    category: 'Node.js',
-  },
-  {
-    name: 'node-native',
-    lang: 'node',
-    client: 'native',
-    caption: 'HTTP',
-    category: 'Node.js',
-  },
-
-  // Python
-  {
-    name: 'python-requests',
-    lang: 'python',
-    client: 'requests',
-    caption: 'Requests',
-    category: 'Python',
-  },
-  {
-    name: 'python-python3',
-    lang: 'python',
-    client: 'python3',
-    caption: 'http.client',
-    category: 'Python',
-  },
-
-  // Go
-  {
-    name: 'go-native',
-    lang: 'go',
-    client: 'native',
-    caption: 'Native',
-    category: 'Go',
-  },
-
-  // Java
-  {
-    name: 'java-okhttp',
-    lang: 'java',
-    client: 'okhttp',
-    caption: 'OkHttp',
-    category: 'Java',
-  },
-  {
-    name: 'java-unirest',
-    lang: 'java',
-    client: 'unirest',
-    caption: 'Unirest',
-    category: 'Java',
-  },
-
-  // C#
-  {
-    name: 'csharp-httpclient',
-    lang: 'csharp',
-    client: 'httpclient',
-    caption: 'HttpClient',
-    category: 'C#',
-  },
-  {
-    name: 'csharp-restsharp',
-    lang: 'csharp',
-    client: 'restsharp',
-    caption: 'RestSharp',
-    category: 'C#',
-  },
-
-  // Ruby
-  {
-    name: 'ruby-native',
-    lang: 'ruby',
-    client: 'native',
-    caption: 'Net::HTTP',
-    category: 'Ruby',
-  },
-
-  // PHP
-  {
-    name: 'php-curl',
-    lang: 'php',
-    client: 'curl',
-    caption: 'cURL',
-    category: 'PHP',
-  },
-  {
-    name: 'php-guzzle',
-    lang: 'php',
-    client: 'guzzle',
-    caption: 'Guzzle',
-    category: 'PHP',
-  },
-
-  // Swift
-  {
-    name: 'swift-nsurlsession',
-    lang: 'swift',
-    client: 'nsurlsession',
-    caption: 'URLSession',
-    category: 'Swift',
-  },
-
-  // Kotlin
-  {
-    name: 'kotlin-okhttp',
-    lang: 'kotlin',
-    client: 'okhttp',
-    caption: 'OkHttp',
-    category: 'Kotlin',
-  },
-
-  // Rust
-  {
-    name: 'rust-reqwest',
-    lang: 'rust',
-    client: 'reqwest',
-    caption: 'Reqwest',
-    category: 'Rust',
-  },
-
-  // C
-  {
-    name: 'c-libcurl',
-    lang: 'c',
-    client: 'libcurl',
-    caption: 'libcurl',
-    category: 'C',
-  },
-
-  // PowerShell
-  {
-    name: 'powershell-webrequest',
-    lang: 'powershell',
-    client: 'webrequest',
-    caption: 'Invoke-WebRequest',
-    category: 'PowerShell',
-  },
-  {
-    name: 'powershell-restmethod',
-    lang: 'powershell',
-    client: 'restmethod',
-    caption: 'Invoke-RestMethod',
-    category: 'PowerShell',
-  },
-
-  // Clojure
-  {
-    name: 'clojure-clj_http',
-    lang: 'clojure',
-    client: 'clj_http',
-    caption: 'clj-http',
-    category: 'Clojure',
-  },
-
-  // Objective-C
-  {
-    name: 'objc-nsurlsession',
-    lang: 'objc',
-    client: 'nsurlsession',
-    caption: 'NSURLSession',
-    category: 'Objective-C',
-  },
-
-  // OCaml
-  {
-    name: 'ocaml-cohttp',
-    lang: 'ocaml',
-    client: 'cohttp',
-    caption: 'CoHTTP',
-    category: 'OCaml',
-  },
-
-  // R
-  {
-    name: 'r-httr',
-    lang: 'r',
-    client: 'httr',
-    caption: 'httr',
-    category: 'R',
-  },
-
-  // HTTP
-  {
-    name: 'http-http1.1',
-    lang: 'http',
-    client: 'http1.1',
-    caption: 'HTTP 1.1',
-    category: 'Raw',
-  },
-] as const
-
-export type CodegenName = (typeof CodegenDefinitions)[number]['name']
-export type CodegenLang = (typeof CodegenDefinitions)[number]['lang']
-export type CodegenClient = (typeof CodegenDefinitions)[number]['client']
-export type CodegenCategory = (typeof CodegenDefinitions)[number]['category']
-
-export interface CodegenDefinition {
-  name: CodegenName
-  lang: CodegenLang
-  client: CodegenClient
-  caption: string
-  category: CodegenCategory
-}
-
-/**
- * Get codegen definitions grouped by category
- */
-export function getCodegenByCategory(): Record<string, CodegenDefinition[]> {
-  const grouped: Record<string, CodegenDefinition[]> = {}
-  
-  for (const def of CodegenDefinitions) {
-    if (!grouped[def.category]) {
-      grouped[def.category] = []
-    }
-    grouped[def.category].push(def as CodegenDefinition)
-  }
-  
-  return grouped
-}
-
-/**
- * Find a codegen definition by name
- */
-export function findCodegenByName(name: CodegenName): CodegenDefinition | undefined {
-  return CodegenDefinitions.find((def) => def.name === name) as CodegenDefinition | undefined
-}

package/renderer/lib/api-docs/codegen/har.ts

@@ -1,251 +0,0 @@
-/**
- * HAR (HTTP Archive) Request Builder
- * Converts BrainfishRESTRequest to HAR format for HTTPSnippet
- */
-
-import type { BrainfishRESTRequest, FormDataKeyValue } from '../types'
-
-// HAR format types based on HAR 1.2 spec
-// http://www.softwareishard.com/blog/har-12-spec/
-
-export interface HarHeader {
-  name: string
-  value: string
-}
-
-export interface HarQueryString {
-  name: string
-  value: string
-}
-
-export interface HarParam {
-  name: string
-  value?: string
-  fileName?: string
-  contentType?: string
-}
-
-export interface HarPostData {
-  mimeType: string
-  text?: string
-  params?: HarParam[]
-}
-
-export interface HarCookie {
-  name: string
-  value: string
-  path?: string
-  domain?: string
-  expires?: string
-  httpOnly?: boolean
-  secure?: boolean
-}
-
-export interface HarRequest {
-  method: string
-  url: string
-  httpVersion: string
-  cookies: HarCookie[]
-  headers: HarHeader[]
-  queryString: HarQueryString[]
-  postData?: HarPostData
-  headersSize: number
-  bodySize: number
-}
-
-/**
- * Build HAR headers from request headers
- */
-function buildHarHeaders(request: BrainfishRESTRequest): HarHeader[] {
-  return request.headers
-    .filter((header) => header.active)
-    .map((header) => ({
-      name: header.key,
-      value: header.value,
-    }))
-}
-
-/**
- * Build HAR query strings from request params
- */
-function buildHarQueryStrings(request: BrainfishRESTRequest): HarQueryString[] {
-  return request.params
-    .filter((param) => param.active)
-    .map((param) => ({
-      name: param.key,
-      value: param.value,
-    }))
-}
-
-/**
- * Build HAR post params for form data
- */
-function buildHarPostParams(body: FormDataKeyValue[]): HarParam[] {
-  const result: HarParam[] = []
-  
-  for (const entry of body) {
-    if (!entry.active) continue
-    
-    if (entry.isFile) {
-      // Handle file entries
-      const values = Array.isArray(entry.value) ? entry.value : [entry.value]
-      for (let i = 0; i < values.length; i++) {
-        result.push({
-          name: entry.key,
-          fileName: entry.key,
-          contentType: entry.contentType || 'application/octet-stream',
-        })
-      }
-    } else {
-      result.push({
-        name: entry.key,
-        value: entry.value as string,
-        contentType: entry.contentType,
-      })
-    }
-  }
-  
-  return result
-}
-
-/**
- * Parse URL-encoded body string to params
- */
-function parseUrlEncodedBody(body: string): HarParam[] {
-  if (!body) return []
-
-  return body.split('\n').map((line) => {
-    const colonIndex = line.indexOf(':')
-    if (colonIndex === -1) {
-      return { name: line.trim(), value: '' }
-    }
-    const key = line.slice(0, colonIndex).trim()
-    const value = line.slice(colonIndex + 1).trim()
-    return { name: key, value }
-  })
-}
-
-/**
- * Build HAR post data from request body
- */
-function buildHarPostData(request: BrainfishRESTRequest): HarPostData | undefined {
-  const { contentType, body } = request.body
-
-  if (!contentType || !body) return undefined
-
-  // Handle form data types
-  if (contentType === 'application/x-www-form-urlencoded') {
-    return {
-      mimeType: contentType,
-      params: typeof body === 'string' ? parseUrlEncodedBody(body) : [],
-    }
-  }
-
-  if (contentType === 'multipart/form-data') {
-    return {
-      mimeType: contentType,
-      params: Array.isArray(body) ? buildHarPostParams(body) : [],
-    }
-  }
-
-  // Handle text-based content types (JSON, XML, HTML, plain text)
-  return {
-    mimeType: contentType,
-    text: typeof body === 'string' ? body : JSON.stringify(body),
-  }
-}
-
-/**
- * Add authentication headers to the request
- */
-function addAuthHeaders(request: BrainfishRESTRequest, headers: HarHeader[]): HarHeader[] {
-  const { auth } = request
-  const result = [...headers]
-
-  if (!auth.authActive) return result
-
-  switch (auth.authType) {
-    case 'basic': {
-      if (auth.username && auth.password) {
-        const credentials = btoa(`${auth.username}:${auth.password}`)
-        result.push({
-          name: 'Authorization',
-          value: `Basic ${credentials}`,
-        })
-      }
-      break
-    }
-    case 'bearer': {
-      if (auth.token) {
-        result.push({
-          name: 'Authorization',
-          value: `Bearer ${auth.token}`,
-        })
-      }
-      break
-    }
-    case 'api-key': {
-      if (auth.key && auth.value) {
-        if (auth.addTo === 'HEADERS') {
-          result.push({
-            name: auth.key,
-            value: auth.value,
-          })
-        }
-      }
-      break
-    }
-    // oauth-2 and inherit would need more complex handling
-  }
-
-  return result
-}
-
-/**
- * Build URL with query parameters for API key auth
- */
-function buildUrlWithApiKeyAuth(request: BrainfishRESTRequest): string {
-  let url = request.endpoint
-
-  // Add API key to query params if configured
-  if (
-    request.auth.authActive &&
-    request.auth.authType === 'api-key' &&
-    request.auth.addTo === 'QUERY_PARAMS' &&
-    request.auth.key &&
-    request.auth.value
-  ) {
-    const separator = url.includes('?') ? '&' : '?'
-    url = `${url}${separator}${encodeURIComponent(request.auth.key)}=${encodeURIComponent(request.auth.value)}`
-  }
-
-  return url
-}
-
-/**
- * Convert BrainfishRESTRequest to HAR Request format
- */
-export function buildHarRequest(request: BrainfishRESTRequest): HarRequest {
-  const headers = addAuthHeaders(request, buildHarHeaders(request))
-  const url = buildUrlWithApiKeyAuth(request)
-
-  // Add content-type header if body exists and not already present
-  if (request.body.contentType && !headers.some((h) => h.name.toLowerCase() === 'content-type')) {
-    headers.push({
-      name: 'Content-Type',
-      value: request.body.contentType,
-    })
-  }
-
-  return {
-    method: request.method,
-    url,
-    httpVersion: 'HTTP/1.1',
-    cookies: [],
-    headers,
-    queryString: buildHarQueryStrings(request),
-    postData: buildHarPostData(request),
-    headersSize: -1,
-    bodySize: -1,
-  }
-}

package/renderer/lib/api-docs/codegen/index.ts

@@ -1,159 +0,0 @@
-/**
- * Code Generation Utility
- * Generates code snippets for API requests in various languages
- * Uses server-side API route to run httpsnippet (avoids browser compatibility issues)
- */
-
-import type { BrainfishRESTRequest } from '../types'
-import { buildHarRequest } from './har'
-import { CodegenDefinitions, findCodegenByName, type CodegenName } from './definitions'
-
-export { CodegenDefinitions, findCodegenByName, getCodegenByCategory } from './definitions'
-export type { CodegenName, CodegenDefinition, CodegenCategory } from './definitions'
-
-export interface CodegenResult {
-  success: boolean
-  code?: string
-  error?: string
-}
-
-/**
- * Generate code snippet for a request (async - calls server API)
- * @param codegenName The codegen target name (e.g., 'shell-curl', 'javascript-fetch')
- * @param request The Brainfish REST request to generate code for
- * @returns Promise<CodegenResult> with generated code or error
- */
-export async function generateCodeAsync(
-  codegenName: CodegenName,
-  request: BrainfishRESTRequest
-): Promise<CodegenResult> {
-  try {
-    const codegenInfo = findCodegenByName(codegenName)
-    
-    if (!codegenInfo) {
-      return {
-        success: false,
-        error: `Unknown code generator: ${codegenName}`,
-      }
-    }
-
-    // Build HAR request from Brainfish request
-    const harRequest = buildHarRequest(request)
-
-    // Call server-side API to generate code
-    const response = await fetch('/api/codegen', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        harRequest,
-        lang: codegenInfo.lang,
-        client: codegenInfo.client,
-      }),
-    })
-
-    const result = await response.json()
-    
-    if (result.success) {
-      return {
-        success: true,
-        code: result.code,
-      }
-    }
-
-    return {
-      success: false,
-      error: result.error || 'Code generation failed',
-    }
-  } catch (error) {
-    console.error('Code generation error:', error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Unknown error during code generation',
-    }
-  }
-}
-
-/**
- * Synchronous version that returns a placeholder - use generateCodeAsync for actual code
- * This exists for backwards compatibility with synchronous code
- */
-export function generateCode(
-  codegenName: CodegenName,
-  request: BrainfishRESTRequest
-): CodegenResult {
-  // For synchronous calls, we can't make API requests
-  // Return a placeholder that indicates async is needed
-  const codegenInfo = findCodegenByName(codegenName)
-  
-  if (!codegenInfo) {
-    return {
-      success: false,
-      error: `Unknown code generator: ${codegenName}`,
-    }
-  }
-
-  // Generate a simple placeholder based on the request
-  // This will be replaced by the async version in the UI
-  const url = request.endpoint
-  const method = request.method
-
-  // Simple cURL as fallback
-  let code = `curl --request ${method} \\\n  --url '${url}'`
-  
-  request.headers.filter(h => h.active).forEach(h => {
-    code += ` \\\n  --header '${h.key}: ${h.value}'`
-  })
-
-  if (request.body.body && method !== 'GET' && method !== 'HEAD') {
-    const bodyStr = typeof request.body.body === 'string' 
-      ? request.body.body 
-      : JSON.stringify(request.body.body)
-    code += ` \\\n  --data '${bodyStr}'`
-  }
-
-  return {
-    success: true,
-    code,
-  }
-}
-
-/**
- * Get the Monaco editor language for a codegen target
- */
-export function getMonacoLanguage(codegenName: CodegenName): string {
-  const def = findCodegenByName(codegenName)
-  if (!def) return 'plaintext'
-
-  const languageMap: Record<string, string> = {
-    shell: 'shell',
-    javascript: 'javascript',
-    node: 'javascript',
-    python: 'python',
-    go: 'go',
-    java: 'java',
-    csharp: 'csharp',
-    ruby: 'ruby',
-    php: 'php',
-    swift: 'swift',
-    kotlin: 'kotlin',
-    rust: 'rust',
-    c: 'c',
-    powershell: 'powershell',
-    clojure: 'clojure',
-    objc: 'objective-c',
-    ocaml: 'plaintext', // Monaco doesn't have OCaml
-    r: 'r',
-    http: 'plaintext',
-  }
-
-  return languageMap[def.lang] || 'plaintext'
-}
-
-/**
- * Get all available codegen targets
- */
-export function getAvailableCodegens(): typeof CodegenDefinitions {
-  return CodegenDefinitions
-}