@brainfish-ai/devdoc 0.1.41 → 0.1.43

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

@@ -0,0 +1,258 @@
+/**
+ * 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'
+    }
+];
+/**
+ * Get codegen definitions grouped by category
+ */ export function getCodegenByCategory() {
+    const grouped = {};
+    for (const def of CodegenDefinitions){
+        if (!grouped[def.category]) {
+            grouped[def.category] = [];
+        }
+        grouped[def.category].push(def);
+    }
+    return grouped;
+}
+/**
+ * Find a codegen definition by name
+ */ export function findCodegenByName(name) {
+    return CodegenDefinitions.find((def)=>def.name === name);
+}

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

@@ -0,0 +1,171 @@
+/**
+ * HAR (HTTP Archive) Request Builder
+ * Converts BrainfishRESTRequest to HAR format for HTTPSnippet
+ */ /**
+ * Build HAR headers from request headers
+ */ function buildHarHeaders(request) {
+    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) {
+    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) {
+    const result = [];
+    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,
+                contentType: entry.contentType
+            });
+        }
+    }
+    return result;
+}
+/**
+ * Parse URL-encoded body string to params
+ */ function parseUrlEncodedBody(body) {
+    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) {
+    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, headers) {
+    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;
+            }
+    }
+    return result;
+}
+/**
+ * Build URL with query parameters for API key auth
+ */ function buildUrlWithApiKeyAuth(request) {
+    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) {
+    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.js

@@ -0,0 +1,118 @@
+/**
+ * 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 { buildHarRequest } from './har';
+import { CodegenDefinitions, findCodegenByName } from './definitions';
+export { CodegenDefinitions, findCodegenByName, getCodegenByCategory } from './definitions';
+/**
+ * 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, request) {
+    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, request) {
+    // 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) {
+    const def = findCodegenByName(codegenName);
+    if (!def) return 'plaintext';
+    const languageMap = {
+        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',
+        r: 'r',
+        http: 'plaintext'
+    };
+    return languageMap[def.lang] || 'plaintext';
+}
+/**
+ * Get all available codegen targets
+ */ export function getAvailableCodegens() {
+    return CodegenDefinitions;
+}

package/renderer/lib/api-docs/factories.js

@@ -0,0 +1,136 @@
+/**
+ * Factory Functions for Brainfish API Documentation
+ * 
+ * Creates instances of BrainfishCollection and BrainfishRESTRequest
+ * with proper defaults and unique IDs.
+ */ /**
+ * Generates a URL-friendly slug from a string
+ * Converts to lowercase, replaces spaces and special chars with hyphens
+ */ function slugify(str) {
+    return str.toLowerCase().replace(/[{}]/g, '') // Remove braces from path params
+    .replace(/[^a-z0-9]+/g, '-') // Replace non-alphanumeric with hyphens
+    .replace(/^-+|-+$/g, '') // Remove leading/trailing hyphens
+    .replace(/-+/g, '-') // Collapse multiple hyphens
+    ;
+}
+/**
+ * Generates a human-readable, deterministic ID for requests
+ * Uses operationId if available, otherwise method + path
+ */ function generateRequestId(method, path, operationId) {
+    if (operationId) {
+        // Use operationId directly (it's already unique per spec)
+        return slugify(operationId);
+    }
+    // Generate from method + path: "get-users-id" for "GET /users/{id}"
+    const pathSlug = slugify(path);
+    return `${method.toLowerCase()}-${pathSlug}`;
+}
+/**
+ * Generates a unique ID for collections
+ * If a seed is provided, generates a deterministic slug-based ID
+ */ function generateCollectionId(name) {
+    if (name) {
+        return `coll-${slugify(name)}`;
+    }
+    return `coll_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+/**
+ * Creates a BrainfishRESTRequest with defaults
+ * Generates human-readable, deterministic IDs based on operationId or method+path
+ */ export function makeBrainfishRESTRequest(request) {
+    // Extract path from endpoint (remove base URL)
+    const path = request.endpoint ? request.endpoint.replace(/^https?:\/\/[^/]+/, '') || '/' : '/';
+    // Generate human-readable ID
+    const id = generateRequestId(request.method || 'GET', path, request.operationId);
+    return {
+        id,
+        name: request.name || 'Untitled Request',
+        description: request.description ?? null,
+        method: request.method || 'GET',
+        endpoint: request.endpoint || '',
+        params: request.params || [],
+        headers: request.headers || [],
+        auth: request.auth || {
+            authType: 'none',
+            authActive: true
+        },
+        body: request.body || {
+            contentType: null,
+            body: null
+        },
+        requestVariables: request.requestVariables || [],
+        responses: request.responses || {},
+        tags: request.tags || []
+    };
+}
+/**
+ * Creates a BrainfishCollection with defaults
+ * If name is provided, generates a deterministic ID
+ */ export function makeBrainfishCollection(collection) {
+    return {
+        id: generateCollectionId(collection.name),
+        name: collection.name || 'Untitled Collection',
+        description: collection.description ?? null,
+        folders: collection.folders || [],
+        requests: collection.requests || [],
+        variables: collection.variables || [],
+        auth: collection.auth || {
+            authType: 'inherit',
+            authActive: true
+        },
+        headers: collection.headers || []
+    };
+}
+/**
+ * Creates a default BrainfishRESTRequest
+ */ export function getDefaultBrainfishRESTRequest() {
+    return makeBrainfishRESTRequest({
+        name: 'Untitled Request',
+        description: null,
+        method: 'GET',
+        endpoint: '',
+        params: [],
+        headers: [],
+        auth: {
+            authType: 'none',
+            authActive: true
+        },
+        body: {
+            contentType: null,
+            body: null
+        },
+        requestVariables: [],
+        responses: {},
+        tags: []
+    });
+}
+/**
+ * Creates a default BrainfishCollection
+ */ export function getDefaultBrainfishCollection() {
+    return makeBrainfishCollection({
+        name: 'Untitled Collection',
+        description: null,
+        folders: [],
+        requests: [],
+        variables: [],
+        auth: {
+            authType: 'inherit',
+            authActive: true
+        },
+        headers: []
+    });
+}
+/**
+ * Creates a BrainfishRESTResponseOriginalRequest
+ */ export function makeBrainfishRESTResponseOriginalRequest(request) {
+    return {
+        name: request.name,
+        method: request.method,
+        endpoint: request.endpoint,
+        params: request.params,
+        headers: request.headers,
+        body: request.body,
+        auth: request.auth,
+        requestVariables: request.requestVariables
+    };
+}

package/renderer/lib/api-docs/{index.ts → index.js}

@@ -2,16 +2,11 @@
  * Brainfish API Documentation - Main Export
  * 
  * This module exports all types, factories, and utilities for the API documentation system.
- */
-
-// Types
-export * from './types'
-
+ */ // Types
+export * from './types';
 // Factories
-export * from './factories'
-
+export * from './factories';
 // Utils
-export * from './utils'
-
+export * from './utils';
 // Parsers
-export * from './parsers/openapi'
+export * from './parsers/openapi';