apidocly 1.0.3

package/lib/generator/index.js

@@ -0,0 +1,334 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { minifyCSS, minifyAndObfuscateJSAsync, minifyJSON } = require('../utils/minifier');
+
+const TEMPLATE_DIR = path.join(__dirname, '../../template');
+
+// Encryption settings
+const ENCRYPTION_ALGORITHM = 'aes-256-gcm';
+const PBKDF2_ITERATIONS = 100000;
+const SALT_LENGTH = 16;
+const IV_LENGTH = 12;
+const KEY_LENGTH = 32;
+const AUTH_TAG_LENGTH = 16;
+
+async function generateDocs(apiData, config, outputPath, options = {}) {
+  const { singleFile, verbose } = options;
+
+  if (!fs.existsSync(outputPath)) {
+    fs.mkdirSync(outputPath, { recursive: true });
+  }
+
+  const password = config.password || null;
+  let authData = null;
+
+  if (password) {
+    const isEncrypted = !password.startsWith('sha256:');
+    authData = {
+      hash: hashPassword(password),
+      message: config.passwordMessage || 'Enter password to view API documentation',
+      encrypted: isEncrypted,
+      // Encryption params for client-side decryption
+      pbkdf2Iterations: PBKDF2_ITERATIONS,
+      saltLength: SALT_LENGTH,
+      ivLength: IV_LENGTH,
+      authTagLength: AUTH_TAG_LENGTH
+    };
+  }
+
+  // Always save version history for version switching feature
+  saveVersionHistory(apiData, config, outputPath, verbose);
+
+  generateApiDataFile(apiData, outputPath, password, authData);
+
+  if (singleFile) {
+    await generateSingleFile(apiData, config, outputPath);
+  } else {
+    await generateMultipleFiles(apiData, config, outputPath);
+  }
+
+  if (verbose) {
+    console.log(`  Generated documentation at: ${outputPath}`);
+  }
+}
+
+function hashPassword(password) {
+  if (password.startsWith('sha256:')) {
+    return password.slice(7);
+  }
+
+  return crypto.createHash('sha256').update(password).digest('hex');
+}
+
+function getPlainPassword(password) {
+  // If password starts with sha256:, we can't encrypt (need plain password)
+  if (password.startsWith('sha256:')) {
+    return null;
+  }
+  return password;
+}
+
+function encryptData(data, password) {
+  const salt = crypto.randomBytes(SALT_LENGTH);
+  const iv = crypto.randomBytes(IV_LENGTH);
+
+  // Derive key from password using PBKDF2
+  const key = crypto.pbkdf2Sync(password, salt, PBKDF2_ITERATIONS, KEY_LENGTH, 'sha256');
+
+  // Encrypt with AES-256-GCM
+  const cipher = crypto.createCipheriv(ENCRYPTION_ALGORITHM, key, iv);
+
+  const jsonData = JSON.stringify(data);
+  let encrypted = cipher.update(jsonData, 'utf8');
+  encrypted = Buffer.concat([encrypted, cipher.final()]);
+
+  const authTag = cipher.getAuthTag();
+
+  // Combine: salt + iv + authTag + encrypted data
+  const combined = Buffer.concat([salt, iv, authTag, encrypted]);
+
+  return combined.toString('base64');
+}
+
+function generateApiDataFile(apiData, outputPath, password = null, authData = null) {
+  let content;
+
+  if (password) {
+    const plainPassword = getPlainPassword(password);
+
+    if (plainPassword) {
+      // Encrypt the API data
+      const encryptedData = encryptData(apiData, plainPassword);
+      content = `var apiDataEncrypted="${encryptedData}";var apiDataAuth=${minifyJSON(authData)};var apiData=null;`;
+    } else {
+      // Can't encrypt with hash-only password, warn and use unencrypted
+      console.warn('Warning: Cannot encrypt API data with pre-hashed password. Use plain password for encryption.');
+      content = `var apiDataEncrypted=null;var apiDataAuth=${minifyJSON(authData)};var apiData=${minifyJSON(apiData)};`;
+    }
+  } else {
+    // No password, no encryption
+    content = `var apiDataEncrypted=null;var apiDataAuth=null;var apiData=${minifyJSON(apiData)};`;
+  }
+
+  fs.writeFileSync(path.join(outputPath, 'api_data.js'), content, 'utf8');
+}
+
+async function generateMultipleFiles(apiData, config, outputPath) {
+  let htmlTemplate = fs.readFileSync(path.join(TEMPLATE_DIR, 'index.html'), 'utf8');
+
+  // Generate cache version from current timestamp
+  const cacheVersion = Date.now().toString(36);
+
+  htmlTemplate = htmlTemplate
+    .replace(/\{\{PROJECT_TITLE\}\}/g, config.title || config.name)
+    .replace(/\{\{PROJECT_NAME\}\}/g, config.name)
+    .replace(/\{\{PROJECT_VERSION\}\}/g, config.version)
+    .replace(/\{\{CACHE_VERSION\}\}/g, cacheVersion);
+
+  fs.writeFileSync(path.join(outputPath, 'index.html'), htmlTemplate, 'utf8');
+
+  // Minify and write CSS
+  const cssDir = path.join(outputPath, 'css');
+  if (!fs.existsSync(cssDir)) {
+    fs.mkdirSync(cssDir, { recursive: true });
+  }
+  const cssContent = fs.readFileSync(path.join(TEMPLATE_DIR, 'css/style.css'), 'utf8');
+  fs.writeFileSync(path.join(cssDir, 'style.css'), minifyCSS(cssContent), 'utf8');
+
+  // Minify and write JS using Terser
+  const jsDir = path.join(outputPath, 'js');
+  if (!fs.existsSync(jsDir)) {
+    fs.mkdirSync(jsDir, { recursive: true });
+  }
+  const mainJsContent = fs.readFileSync(path.join(TEMPLATE_DIR, 'js/main.js'), 'utf8');
+  const mainJsMinified = await minifyAndObfuscateJSAsync(mainJsContent);
+  fs.writeFileSync(path.join(jsDir, 'main.js'), mainJsMinified, 'utf8');
+
+  const authJsContent = fs.readFileSync(path.join(TEMPLATE_DIR, 'js/auth.js'), 'utf8');
+  const authJsMinified = await minifyAndObfuscateJSAsync(authJsContent);
+  fs.writeFileSync(path.join(jsDir, 'auth.js'), authJsMinified, 'utf8');
+}
+
+async function generateSingleFile(apiData, config, outputPath) {
+  const css = minifyCSS(fs.readFileSync(path.join(TEMPLATE_DIR, 'css/style.css'), 'utf8'));
+  const mainJs = await minifyAndObfuscateJSAsync(fs.readFileSync(path.join(TEMPLATE_DIR, 'js/main.js'), 'utf8'));
+  const authJs = await minifyAndObfuscateJSAsync(fs.readFileSync(path.join(TEMPLATE_DIR, 'js/auth.js'), 'utf8'));
+  const apiDataJs = `var apiData=${minifyJSON(apiData)};`;
+
+  const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta name="theme-color" content="#09090b">
+  <title>${escapeHtml(config.title || config.name)}</title>
+  <style>
+${css}
+  </style>
+</head>
+<body>
+  <div id="login-container"></div>
+
+  <div id="app" class="app hidden">
+    <aside class="sidebar">
+      <div class="sidebar-header">
+        <h1>${escapeHtml(config.name)}</h1>
+        <div class="version">v${escapeHtml(config.version)}</div>
+      </div>
+
+      <div class="sidebar-search">
+        <input type="text" class="search-input" placeholder="Search endpoints..." id="search-input">
+      </div>
+
+      <nav class="sidebar-nav" id="nav-container">
+      </nav>
+    </aside>
+
+    <main class="main">
+      <header class="main-header">
+        <h2 id="current-section">API Documentation</h2>
+        <button class="logout-btn hidden" id="logout-btn">Logout</button>
+      </header>
+
+      <div class="content" id="content-container">
+      </div>
+    </main>
+
+    <button class="mobile-toggle" id="mobile-toggle">
+      <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+        <line x1="3" y1="12" x2="21" y2="12"></line>
+        <line x1="3" y1="6" x2="21" y2="6"></line>
+        <line x1="3" y1="18" x2="21" y2="18"></line>
+      </svg>
+    </button>
+  </div>
+
+  <script>
+${apiDataJs}
+  </script>
+  <script>
+${authJs}
+  </script>
+  <script>
+${mainJs}
+  </script>
+</body>
+</html>`;
+
+  fs.writeFileSync(path.join(outputPath, 'index.html'), html, 'utf8');
+}
+
+function escapeHtml(str) {
+  if (!str) return '';
+  return String(str)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function saveVersionHistory(apiData, config, outputPath, verbose) {
+  const versionsDir = path.join(outputPath, 'versions');
+
+  if (!fs.existsSync(versionsDir)) {
+    fs.mkdirSync(versionsDir, { recursive: true });
+  }
+
+  const version = apiData.project.version || '1.0.0';
+  const timestamp = new Date().toISOString();
+  const versionFilename = `v${version.replace(/\./g, '_')}.json`;
+  const versionPath = path.join(versionsDir, versionFilename);
+
+  // Load existing versions index
+  const versionsIndexPath = path.join(versionsDir, 'index.json');
+  let versionsIndex = [];
+
+  if (fs.existsSync(versionsIndexPath)) {
+    try {
+      versionsIndex = JSON.parse(fs.readFileSync(versionsIndexPath, 'utf8'));
+    } catch (e) {
+      versionsIndex = [];
+    }
+  }
+
+  // Check if this version already exists
+  const existingIndex = versionsIndex.findIndex(v => v.version === version);
+
+  // Create version entry
+  const versionEntry = {
+    version: version,
+    filename: versionFilename,
+    timestamp: timestamp,
+    endpointCount: countEndpoints(apiData),
+    groupCount: apiData.groups.length
+  };
+
+  if (existingIndex >= 0) {
+    // Update existing version
+    versionsIndex[existingIndex] = versionEntry;
+  } else {
+    // Add new version
+    versionsIndex.push(versionEntry);
+  }
+
+  // Sort versions (newest first)
+  versionsIndex.sort((a, b) => {
+    const aVer = a.version.split('.').map(Number);
+    const bVer = b.version.split('.').map(Number);
+    for (let i = 0; i < Math.max(aVer.length, bVer.length); i++) {
+      const aNum = aVer[i] || 0;
+      const bNum = bVer[i] || 0;
+      if (aNum !== bNum) return bNum - aNum;
+    }
+    return 0;
+  });
+
+  // Save version data (without generator timestamp to allow comparison)
+  const versionData = {
+    ...apiData,
+    generator: {
+      ...apiData.generator,
+      versionSavedAt: timestamp
+    }
+  };
+
+  fs.writeFileSync(versionPath, JSON.stringify(versionData, null, 2), 'utf8');
+
+  // Save versions index
+  fs.writeFileSync(versionsIndexPath, JSON.stringify(versionsIndex, null, 2), 'utf8');
+
+  // Load all version data to embed in versions.js (for file:// protocol support)
+  const allVersionData = {};
+  for (const v of versionsIndex) {
+    const vPath = path.join(versionsDir, v.filename);
+    if (fs.existsSync(vPath)) {
+      try {
+        allVersionData[v.filename] = JSON.parse(fs.readFileSync(vPath, 'utf8'));
+      } catch (e) {
+        // Skip if can't read
+      }
+    }
+  }
+
+  // Generate versions.js for frontend
+  // Include withCompare setting and embedded version data for file:// protocol support
+  const withCompare = config.template && config.template.withCompare ? true : false;
+  const versionsJs = `var apiVersions=${JSON.stringify(versionsIndex)};var apiVersionsConfig={withCompare:${withCompare}};var apiVersionsData=${JSON.stringify(allVersionData)};`;
+  fs.writeFileSync(path.join(outputPath, 'versions.js'), versionsJs, 'utf8');
+
+  if (verbose) {
+    console.log(`  Saved version ${version} to history (${versionsIndex.length} versions total)`);
+  }
+}
+
+function countEndpoints(apiData) {
+  let count = 0;
+  for (const group of apiData.groups) {
+    count += group.endpoints.length;
+  }
+  return count;
+}
+
+module.exports = { generateDocs, hashPassword };

package/lib/index.js

@@ -0,0 +1,59 @@
+const { loadConfig } = require('./utils/config-loader');
+const { scanFiles } = require('./utils/file-scanner');
+const { parseFiles } = require('./parser');
+const { buildApiData } = require('./generator/data-builder');
+const { generateDocs } = require('./generator');
+
+async function generate(options = {}) {
+  const {
+    input,
+    output,
+    config: configPath,
+    includePrivate = false,
+    singleFile = false,
+    verbose = false
+  } = options;
+
+  const config = loadConfig(configPath, input);
+
+  if (verbose) {
+    console.log(`  Project: ${config.name} v${config.version}`);
+  }
+
+  const files = await scanFiles(input, { verbose });
+
+  if (files.length === 0) {
+    throw new Error('No source files found in the input path');
+  }
+
+  const { endpoints, defines } = parseFiles(files, { verbose });
+
+  if (endpoints.length === 0) {
+    throw new Error('No API documentation blocks found in source files');
+  }
+
+  const apiData = buildApiData(endpoints, config, { includePrivate });
+
+  await generateDocs(apiData, config, output, { singleFile, verbose });
+
+  return {
+    endpoints: endpoints.length,
+    groups: apiData.groups.length,
+    defines: defines.size
+  };
+}
+
+function createDoc(comment) {
+  const { parseAnnotations } = require('./parser/annotations');
+  return parseAnnotations(comment);
+}
+
+module.exports = {
+  generate,
+  createDoc,
+  loadConfig: require('./utils/config-loader').loadConfig,
+  scanFiles: require('./utils/file-scanner').scanFiles,
+  parseFiles: require('./parser').parseFiles,
+  buildApiData: require('./generator/data-builder').buildApiData,
+  generateDocs: require('./generator').generateDocs
+};

package/lib/parser/annotations.js

@@ -0,0 +1,230 @@
+const ANNOTATION_PATTERNS = {
+  api: /^@api\s+\{(\w+)\}\s+(\S+)(?:\s+(.*))?$/m,
+  apiName: /^@apiName\s+(.+)$/m,
+  apiGroup: /^@apiGroup\s+(.+)$/m,
+  apiVersion: /^@apiVersion\s+(.+)$/m,
+  apiDescription: /^@apiDescription\s+([\s\S]*?)(?=(?:^@api|\Z))/m,
+  apiPermission: /^@apiPermission\s+(.+)$/m,
+  apiDeprecated: /^@apiDeprecated(?:\s+(.*))?$/m,
+  apiPrivate: /^@apiPrivate$/m,
+  apiIgnore: /^@apiIgnore(?:\s+(.*))?$/m,
+  apiSampleRequest: /^@apiSampleRequest\s+(.+)$/m,
+  apiDefine: /^@apiDefine\s+(\w+)(?:\s+(.*))?$/m,
+  apiUse: /^@apiUse\s+(\w+)$/gm
+};
+
+const PARAM_PATTERNS = {
+  apiParam: /^@apiParam(?:\s+\(([^)]+)\))?\s+(?:\{([^}]+)\})?\s*(\[)?(\w+(?:\.\w+)*)(?:=([^\]"\s]+|"[^"]*"))?\]?\s*(.*)?$/gm,
+  apiQuery: /^@apiQuery(?:\s+\(([^)]+)\))?\s+(?:\{([^}]+)\})?\s*(\[)?(\w+(?:\.\w+)*)(?:=([^\]"\s]+|"[^"]*"))?\]?\s*(.*)?$/gm,
+  apiBody: /^@apiBody(?:\s+\(([^)]+)\))?\s+(?:\{([^}]+)\})?\s*(\[)?(\w+(?:\.\w+)*)(?:=([^\]"\s]+|"[^"]*"))?\]?\s*(.*)?$/gm,
+  apiHeader: /^@apiHeader(?:\s+\(([^)]+)\))?\s+(?:\{([^}]+)\})?\s*(\[)?(\w+(?:\.\w+)*)(?:=([^\]"\s]+|"[^"]*"))?\]?\s*(.*)?$/gm,
+  apiSuccess: /^@apiSuccess(?:\s+\(([^)]+)\))?\s+(?:\{([^}]+)\})?\s*(\w+(?:\.\w+)*)\s*(.*)?$/gm,
+  apiError: /^@apiError(?:\s+\(([^)]+)\))?\s+(?:\{([^}]+)\})?\s*(\w+(?:\.\w+)*)\s*(.*)?$/gm
+};
+
+const EXAMPLE_PATTERNS = {
+  apiExample: /^@apiExample(?:\s+\{([^}]+)\})?\s+(.+)\n([\s\S]*?)(?=\n@api[A-Z]|\n\s*\n|$(?!\n))/gm,
+  apiSuccessExample: /^@apiSuccessExample(?:\s+\{([^}]+)\})?\s*(.*)?\n([\s\S]*?)(?=\n@api[A-Z]|\n\s*\n|$(?!\n))/gm,
+  apiErrorExample: /^@apiErrorExample(?:\s+\{([^}]+)\})?\s*(.*)?\n([\s\S]*?)(?=\n@api[A-Z]|\n\s*\n|$(?!\n))/gm,
+  apiParamExample: /^@apiParamExample(?:\s+\{([^}]+)\})?\s*(.*)?\n([\s\S]*?)(?=\n@api[A-Z]|\n\s*\n|$(?!\n))/gm,
+  apiHeaderExample: /^@apiHeaderExample(?:\s+\{([^}]+)\})?\s*(.*)?\n([\s\S]*?)(?=\n@api[A-Z]|\n\s*\n|$(?!\n))/gm
+};
+
+function parseAnnotations(block) {
+  // Normalize line endings
+  block = block.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+
+  const result = {
+    type: null,
+    method: null,
+    path: null,
+    title: '',
+    name: null,
+    group: 'Default',
+    version: '1.0.0',
+    description: '',
+    permission: null,
+    deprecated: false,
+    deprecatedText: null,
+    private: false,
+    ignore: false,
+    sampleRequest: null,
+    params: [],
+    query: [],
+    body: [],
+    headers: [],
+    success: [],
+    error: [],
+    examples: [],
+    successExamples: [],
+    errorExamples: [],
+    paramExamples: [],
+    headerExamples: [],
+    define: null,
+    uses: []
+  };
+
+  const apiMatch = block.match(ANNOTATION_PATTERNS.api);
+  if (apiMatch) {
+    result.type = 'endpoint';
+    result.method = apiMatch[1].toUpperCase();
+    result.path = apiMatch[2];
+    result.title = apiMatch[3] || '';
+  }
+
+  const defineMatch = block.match(ANNOTATION_PATTERNS.apiDefine);
+  if (defineMatch) {
+    result.type = 'define';
+    result.define = {
+      name: defineMatch[1],
+      title: defineMatch[2] || ''
+    };
+  }
+
+  const nameMatch = block.match(ANNOTATION_PATTERNS.apiName);
+  if (nameMatch) result.name = nameMatch[1].trim();
+
+  const groupMatch = block.match(ANNOTATION_PATTERNS.apiGroup);
+  if (groupMatch) result.group = groupMatch[1].trim();
+
+  const versionMatch = block.match(ANNOTATION_PATTERNS.apiVersion);
+  if (versionMatch) result.version = versionMatch[1].trim();
+
+  const descMatch = block.match(ANNOTATION_PATTERNS.apiDescription);
+  if (descMatch) result.description = descMatch[1].trim();
+
+  const permMatch = block.match(ANNOTATION_PATTERNS.apiPermission);
+  if (permMatch) result.permission = permMatch[1].trim();
+
+  const deprecatedMatch = block.match(ANNOTATION_PATTERNS.apiDeprecated);
+  if (deprecatedMatch) {
+    result.deprecated = true;
+    result.deprecatedText = deprecatedMatch[1] || null;
+  }
+
+  if (ANNOTATION_PATTERNS.apiPrivate.test(block)) {
+    result.private = true;
+  }
+
+  const ignoreMatch = block.match(ANNOTATION_PATTERNS.apiIgnore);
+  if (ignoreMatch) {
+    result.ignore = true;
+  }
+
+  const sampleMatch = block.match(ANNOTATION_PATTERNS.apiSampleRequest);
+  if (sampleMatch) result.sampleRequest = sampleMatch[1].trim();
+
+  let useMatch;
+  while ((useMatch = ANNOTATION_PATTERNS.apiUse.exec(block)) !== null) {
+    result.uses.push(useMatch[1]);
+  }
+
+  result.params = parseParamBlock(block, PARAM_PATTERNS.apiParam, 'Parameter');
+  result.query = parseParamBlock(block, PARAM_PATTERNS.apiQuery, 'Query');
+  result.body = parseParamBlock(block, PARAM_PATTERNS.apiBody, 'Body');
+  result.headers = parseParamBlock(block, PARAM_PATTERNS.apiHeader, 'Header');
+  result.success = parseResponseBlock(block, PARAM_PATTERNS.apiSuccess, 'Success 200');
+  result.error = parseResponseBlock(block, PARAM_PATTERNS.apiError, 'Error 4xx');
+
+  result.examples = parseExampleBlock(block, EXAMPLE_PATTERNS.apiExample);
+  result.successExamples = parseExampleBlock(block, EXAMPLE_PATTERNS.apiSuccessExample);
+  result.errorExamples = parseExampleBlock(block, EXAMPLE_PATTERNS.apiErrorExample);
+  result.paramExamples = parseExampleBlock(block, EXAMPLE_PATTERNS.apiParamExample);
+  result.headerExamples = parseExampleBlock(block, EXAMPLE_PATTERNS.apiHeaderExample);
+
+  return result;
+}
+
+function parseParamBlock(block, pattern, defaultGroup) {
+  const params = [];
+  let match;
+  const regex = new RegExp(pattern.source, 'gm');
+
+  while ((match = regex.exec(block)) !== null) {
+    const [, group, type, optional, field, defaultValue, description] = match;
+
+    params.push({
+      group: group || defaultGroup,
+      type: parseType(type),
+      field: field,
+      optional: !!optional,
+      defaultValue: defaultValue ? defaultValue.replace(/^"|"$/g, '') : null,
+      description: description ? description.trim() : ''
+    });
+  }
+
+  return params;
+}
+
+function parseResponseBlock(block, pattern, defaultGroup) {
+  const responses = [];
+  let match;
+  const regex = new RegExp(pattern.source, 'gm');
+
+  while ((match = regex.exec(block)) !== null) {
+    const [, group, type, field, description] = match;
+
+    responses.push({
+      group: group || defaultGroup,
+      type: parseType(type),
+      field: field,
+      description: description ? description.trim() : ''
+    });
+  }
+
+  return responses;
+}
+
+function parseExampleBlock(block, pattern) {
+  const examples = [];
+  let match;
+  const regex = new RegExp(pattern.source, 'gm');
+
+  while ((match = regex.exec(block)) !== null) {
+    const [, type, title, content] = match;
+
+    examples.push({
+      type: type || 'json',
+      title: title ? title.trim() : '',
+      content: content ? content.trim() : ''
+    });
+  }
+
+  return examples;
+}
+
+function parseType(typeStr) {
+  if (!typeStr) return { name: 'String', isArray: false, allowedValues: null, size: null };
+
+  const result = {
+    name: 'String',
+    isArray: false,
+    allowedValues: null,
+    size: null
+  };
+
+  let type = typeStr.trim();
+
+  if (type.endsWith('[]')) {
+    result.isArray = true;
+    type = type.slice(0, -2);
+  }
+
+  const allowedMatch = type.match(/^(\w+)=(.+)$/);
+  if (allowedMatch) {
+    type = allowedMatch[1];
+    result.allowedValues = allowedMatch[2].split(',').map(v => v.replace(/^"|"$/g, '').trim());
+  }
+
+  const sizeMatch = type.match(/^(\w+)\{(.+)\}$/);
+  if (sizeMatch) {
+    type = sizeMatch[1];
+    result.size = sizeMatch[2];
+  }
+
+  result.name = type.charAt(0).toUpperCase() + type.slice(1).toLowerCase();
+
+  return result;
+}
+
+module.exports = { parseAnnotations, ANNOTATION_PATTERNS, PARAM_PATTERNS, EXAMPLE_PATTERNS };

package/lib/parser/index.js

@@ -0,0 +1,86 @@
+const fs = require('fs');
+const { extractCommentBlocks } = require('./languages');
+const { parseAnnotations } = require('./annotations');
+const { getLanguage } = require('../utils/file-scanner');
+
+function parseFile(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  const language = getLanguage(filePath);
+
+  if (!language) return [];
+
+  const blocks = extractCommentBlocks(content, language);
+  const parsed = blocks.map(block => parseAnnotations(block));
+
+  return parsed.map(item => ({
+    ...item,
+    sourceFile: filePath
+  }));
+}
+
+function parseFiles(files, options = {}) {
+  const { verbose } = options;
+  const allBlocks = [];
+  const defines = new Map();
+
+  for (const file of files) {
+    try {
+      const blocks = parseFile(file);
+      allBlocks.push(...blocks);
+    } catch (error) {
+      if (verbose) {
+        console.log(`  Warning: Could not parse ${file}: ${error.message}`);
+      }
+    }
+  }
+
+  for (const block of allBlocks) {
+    if (block.type === 'define' && block.define) {
+      defines.set(block.define.name, block);
+    }
+  }
+
+  for (const block of allBlocks) {
+    if (block.uses && block.uses.length > 0) {
+      for (const useName of block.uses) {
+        const defineBlock = defines.get(useName);
+        if (defineBlock) {
+          mergeDefine(block, defineBlock);
+        }
+      }
+    }
+  }
+
+  const endpoints = allBlocks.filter(block =>
+    block.type === 'endpoint' && !block.ignore
+  );
+
+  if (verbose) {
+    console.log(`  Parsed ${endpoints.length} API endpoints`);
+    console.log(`  Found ${defines.size} @apiDefine blocks`);
+  }
+
+  return { endpoints, defines };
+}
+
+function mergeDefine(target, source) {
+  if (source.description && !target.description) {
+    target.description = source.description;
+  }
+
+  if (source.permission && !target.permission) {
+    target.permission = source.permission;
+  }
+
+  target.params = [...target.params, ...source.params];
+  target.query = [...target.query, ...source.query];
+  target.body = [...target.body, ...source.body];
+  target.headers = [...target.headers, ...source.headers];
+  target.success = [...target.success, ...source.success];
+  target.error = [...target.error, ...source.error];
+  target.examples = [...target.examples, ...source.examples];
+  target.successExamples = [...target.successExamples, ...source.successExamples];
+  target.errorExamples = [...target.errorExamples, ...source.errorExamples];
+}
+
+module.exports = { parseFile, parseFiles };