@brainfish-ai/devdoc 0.1.48 → 0.1.49

package/renderer/lib/docs-navigation.js

@@ -4,20 +4,26 @@
  * These functions provide simple URL updates without state management.
  * The URL is the single source of truth - components derive their state from the URL.
  * 
- * URL Schema:
- * - #tab/page/{slug}                  → Doc page (docs view)
- * - #tab/endpoint/{id}                → API endpoint (docs view)
- * - #tab/endpoint/{id}/playground     → API endpoint (playground view)
- * - #tab/endpoint/{id}/notes          → API endpoint (notes view)
- * - #tab/page/{slug}/notes            → Doc page (notes view)
+ * URL Schema (path-based for SEO):
+ * - /[tab]/page/[slug]                  → Doc page (docs view)
+ * - /[tab]/endpoint/[id]                → API endpoint (docs view)
+ * - /[tab]/endpoint/[id]/playground     → API endpoint (playground view)
+ * - /[tab]/endpoint/[id]/notes          → API endpoint (notes view)
+ * - /[tab]/page/[slug]/notes            → Doc page (notes view)
  */ /**
+ * Helper to update URL and trigger popstate for React to pick up the change
+ */ function pushPath(path) {
+    window.history.pushState(null, '', path);
+    window.dispatchEvent(new PopStateEvent('popstate'));
+}
+/**
  * Navigate to a documentation page
  * @param tab - Tab ID (e.g., 'guides', 'graphql-api')
  * @param slug - Page slug (e.g., 'graphql/introduction')
  * @param view - View mode (docs, playground, notes). Defaults to 'docs'
  */ export function navigateToPage(tab, slug, view) {
     const viewSuffix = view && view !== 'docs' ? `/${view}` : '';
-    window.location.hash = `${tab}/page/${slug}${viewSuffix}`;
+    pushPath(`/${tab}/page/${slug}${viewSuffix}`);
 }
 /**
  * Navigate to an API endpoint or GraphQL operation
@@ -26,77 +32,80 @@
  * @param view - View mode (docs, playground, notes). Defaults to 'docs'
  */ export function navigateToEndpoint(tab, id, view) {
     const viewSuffix = view && view !== 'docs' ? `/${view}` : '';
-    window.location.hash = `${tab}/endpoint/${id}${viewSuffix}`;
+    pushPath(`/${tab}/endpoint/${id}${viewSuffix}`);
 }
 /**
  * Navigate to a section within a page (scroll to element)
  * @param tab - Tab ID
  * @param sectionId - Section/heading ID to scroll to
  */ export function navigateToSection(tab, sectionId) {
-    window.location.hash = `${tab}/section/${sectionId}`;
+    pushPath(`/${tab}/section/${sectionId}`);
 }
 /**
  * Navigate to a tab (show default content for that tab)
  * @param tab - Tab ID
  */ export function navigateToTab(tab) {
-    window.location.hash = tab;
+    pushPath(`/${tab}`);
 }
 /**
  * Switch view mode while keeping the current content
  * @param view - View mode to switch to
  */ export function switchView(view) {
-    const hash = window.location.hash.slice(1);
-    if (!hash) return;
+    const pathname = window.location.pathname;
+    if (!pathname || pathname === '/') return;
     // Remove existing view suffix if present
-    const cleanHash = hash.replace(/\/(playground|notes)$/, '');
+    const cleanPath = pathname.replace(/\/(playground|notes)$/, '');
     // Add new view suffix (unless switching to docs, which is the default)
     const viewSuffix = view !== 'docs' ? `/${view}` : '';
-    window.location.hash = `${cleanHash}${viewSuffix}`;
+    pushPath(`${cleanPath}${viewSuffix}`);
 }
 /**
  * Clear current selection, optionally staying on a tab
  * @param tab - Optional tab to stay on
  */ export function clearSelection(tab) {
     if (tab) {
-        window.location.hash = tab;
+        pushPath(`/${tab}`);
     } else {
-        // Remove hash entirely using pushState to avoid scroll jump
-        window.history.pushState(null, '', window.location.pathname + window.location.search);
+        pushPath('/');
     }
 }
 /**
  * Update URL without triggering navigation (for history management)
- * @param hash - Hash value (without #)
- */ export function updateUrlSilently(hash) {
-    window.history.replaceState(null, '', `#${hash}`);
+ * @param path - Path value (without leading /)
+ */ export function updateUrlSilently(path) {
+    const fullPath = path.startsWith('/') ? path : `/${path}`;
+    window.history.replaceState(null, '', fullPath);
 }
 /**
  * Push a new URL to history (for back/forward navigation)
- * @param hash - Hash value (without #)
- */ export function pushUrl(hash) {
-    window.history.pushState(null, '', `#${hash}`);
+ * @param path - Path value (without leading /)
+ */ export function pushUrl(path) {
+    const fullPath = path.startsWith('/') ? path : `/${path}`;
+    pushPath(fullPath);
 }
 /**
- * Build hash URL strings (for href attributes)
- */ export const hashUrls = {
+ * Build URL strings (for href attributes)
+ */ export const urls = {
     page: (tab, slug, view)=>{
         const viewSuffix = view && view !== 'docs' ? `/${view}` : '';
-        return `#${tab}/page/${slug}${viewSuffix}`;
+        return `/${tab}/page/${slug}${viewSuffix}`;
     },
     endpoint: (tab, id, view)=>{
         const viewSuffix = view && view !== 'docs' ? `/${view}` : '';
-        return `#${tab}/endpoint/${id}${viewSuffix}`;
+        return `/${tab}/endpoint/${id}${viewSuffix}`;
     },
-    section: (tab, sectionId)=>`#${tab}/section/${sectionId}`,
-    tab: (tab)=>`#${tab}`
+    section: (tab, sectionId)=>`/${tab}/section/${sectionId}`,
+    tab: (tab)=>`/${tab}`
 };
 /**
- * Parse a hash URL into its components
- * @param hash - Hash value (with or without #)
+ * Parse a URL path into its components
+ * @param path - Path value (with or without leading /)
  * @returns Parsed components
- */ export function parseHashUrl(hash) {
-    const cleanHash = hash.startsWith('#') ? hash.slice(1) : hash;
-    if (!cleanHash) {
+ */ export function parseUrl(path) {
+    // Remove leading slash and hash if present
+    let cleanPath = path.startsWith('#') ? path.slice(1) : path;
+    cleanPath = cleanPath.startsWith('/') ? cleanPath.slice(1) : cleanPath;
+    if (!cleanPath) {
         return {
             tab: null,
             type: null,
@@ -104,7 +113,7 @@
             view: 'docs'
         };
     }
-    const parts = cleanHash.split('/');
+    const parts = cleanPath.split('/');
     const tab = parts[0] || null;
     const type = parts[1];
     // Check if last part is a view mode
@@ -129,12 +138,12 @@
     };
 }
 /**
- * Check if two hash URLs point to the same content (ignoring view mode)
- * @param hash1 - First hash
- * @param hash2 - Second hash
+ * Check if two URLs point to the same content (ignoring view mode)
+ * @param path1 - First path
+ * @param path2 - Second path
  * @returns True if they point to the same content
- */ export function isSameContent(hash1, hash2) {
-    const parsed1 = parseHashUrl(hash1);
-    const parsed2 = parseHashUrl(hash2);
+ */ export function isSameContent(path1, path2) {
+    const parsed1 = parseUrl(path1);
+    const parsed2 = parseUrl(path2);
     return parsed1.tab === parsed2.tab && parsed1.type === parsed2.type && parsed1.id === parsed2.id;
 }

package/renderer/lib/rate-limit.js

@@ -0,0 +1,203 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * IP-based Rate Limiting Utility
+ * 
+ * Uses CacheUtils (Vercel KV in production, node-cache locally) for storage.
+ * Implements a sliding window rate limiter with configurable limits.
+ * 
+ * Usage:
+ * ```typescript
+ * import { RateLimiter } from '@/lib/rate-limit';
+ * 
+ * const limiter = new RateLimiter({
+ *   prefix: 'suggestions',
+ *   limit: 10,           // 10 requests
+ *   windowSeconds: 60,   // per 60 seconds
+ * });
+ * 
+ * // In your API route:
+ * const { success, remaining, reset } = await limiter.check(request);
+ * if (!success) {
+ *   return new Response('Too Many Requests', { 
+ *     status: 429,
+ *     headers: {
+ *       'X-RateLimit-Limit': limit.toString(),
+ *       'X-RateLimit-Remaining': '0',
+ *       'X-RateLimit-Reset': reset.toString(),
+ *       'Retry-After': Math.ceil((reset - Date.now()) / 1000).toString(),
+ *     }
+ *   });
+ * }
+ * ```
+ */ import { CacheUtils } from '@/lib/cache';
+/**
+ * Get client IP from request headers
+ * Handles various proxy scenarios (Vercel, Cloudflare, nginx, etc.)
+ */ export function getClientIp(request) {
+    const headers = request.headers;
+    // Vercel / general proxy
+    const xForwardedFor = headers.get('x-forwarded-for');
+    if (xForwardedFor) {
+        // Take the first IP (original client) from the chain
+        const firstIp = xForwardedFor.split(',')[0].trim();
+        if (firstIp) return firstIp;
+    }
+    // Vercel-specific
+    const xRealIp = headers.get('x-real-ip');
+    if (xRealIp) return xRealIp;
+    // Cloudflare
+    const cfConnectingIp = headers.get('cf-connecting-ip');
+    if (cfConnectingIp) return cfConnectingIp;
+    // True-Client-IP (Akamai, Cloudflare Enterprise)
+    const trueClientIp = headers.get('true-client-ip');
+    if (trueClientIp) return trueClientIp;
+    return null;
+}
+/**
+ * Rate limiter class using sliding window algorithm
+ */ export class RateLimiter {
+    /**
+   * Generate cache key for rate limiting
+   */ getCacheKey(identifier) {
+        return `ratelimit:${this.config.prefix}:${identifier}`;
+    }
+    /**
+   * Check if request is allowed and update counter
+   */ async check(request) {
+        const { limit, windowSeconds, skipIps, getIdentifier } = this.config;
+        // Get identifier (IP or custom)
+        const identifier = getIdentifier ? getIdentifier(request) : getClientIp(request);
+        // If we can't identify the client, allow the request but log it
+        if (!identifier) {
+            console.warn('[RateLimiter] Could not identify client, allowing request');
+            return {
+                success: true,
+                remaining: limit,
+                reset: Date.now() + windowSeconds * 1000,
+                count: 0,
+                limit
+            };
+        }
+        // Skip rate limiting for certain IPs
+        if (skipIps?.includes(identifier)) {
+            return {
+                success: true,
+                remaining: limit,
+                reset: Date.now() + windowSeconds * 1000,
+                count: 0,
+                limit
+            };
+        }
+        const cacheKey = this.getCacheKey(identifier);
+        const now = Date.now();
+        // Get current rate limit entry
+        let entry = await CacheUtils.get(cacheKey);
+        // If no entry or window has expired, create new window
+        if (!entry || entry.resetAt <= now) {
+            entry = {
+                count: 1,
+                resetAt: now + windowSeconds * 1000
+            };
+            await CacheUtils.set(cacheKey, entry, windowSeconds);
+            return {
+                success: true,
+                remaining: limit - 1,
+                reset: entry.resetAt,
+                count: 1,
+                limit
+            };
+        }
+        // Window still active, check if limit exceeded
+        if (entry.count >= limit) {
+            console.log(`[RateLimiter] Rate limit exceeded for ${identifier} on ${this.config.prefix}`);
+            return {
+                success: false,
+                remaining: 0,
+                reset: entry.resetAt,
+                count: entry.count,
+                limit
+            };
+        }
+        // Increment counter
+        entry.count += 1;
+        const remainingTtl = Math.ceil((entry.resetAt - now) / 1000);
+        await CacheUtils.set(cacheKey, entry, remainingTtl);
+        return {
+            success: true,
+            remaining: limit - entry.count,
+            reset: entry.resetAt,
+            count: entry.count,
+            limit
+        };
+    }
+    /**
+   * Create rate limit headers for response
+   */ static createHeaders(result) {
+        const headers = {
+            'X-RateLimit-Limit': result.limit.toString(),
+            'X-RateLimit-Remaining': result.remaining.toString(),
+            'X-RateLimit-Reset': result.reset.toString()
+        };
+        if (!result.success) {
+            const retryAfter = Math.ceil((result.reset - Date.now()) / 1000);
+            headers['Retry-After'] = Math.max(1, retryAfter).toString();
+        }
+        return headers;
+    }
+    /**
+   * Create a 429 Too Many Requests response
+   */ static tooManyRequestsResponse(result, message) {
+        return new Response(JSON.stringify({
+            error: 'Too Many Requests',
+            message: message || 'Rate limit exceeded. Please try again later.',
+            retryAfter: Math.ceil((result.reset - Date.now()) / 1000)
+        }), {
+            status: 429,
+            headers: {
+                'Content-Type': 'application/json',
+                ...RateLimiter.createHeaders(result)
+            }
+        });
+    }
+    constructor(config){
+        _define_property(this, "config", void 0);
+        this.config = {
+            skipIps: [
+                '127.0.0.1',
+                '::1'
+            ],
+            ...config
+        };
+    }
+}
+// Pre-configured rate limiters for common use cases
+export const rateLimiters = {
+    /** Suggestions API: 30 requests per minute */ suggestions: new RateLimiter({
+        prefix: 'suggestions',
+        limit: 30,
+        windowSeconds: 60
+    }),
+    /** Chat API: 20 requests per minute */ chat: new RateLimiter({
+        prefix: 'chat',
+        limit: 20,
+        windowSeconds: 60
+    }),
+    /** General API: 100 requests per minute */ general: new RateLimiter({
+        prefix: 'general',
+        limit: 100,
+        windowSeconds: 60
+    })
+};
+export default RateLimiter;