@brainfish-ai/devdoc 0.1.21

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

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

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

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