@stackql/provider-utils 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackql/provider-utils",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Utilities for building StackQL providers from OpenAPI specifications.",
   "type": "module",
   "main": "./src/index.js",

package/src/docgen/generator.js

@@ -18,10 +18,11 @@ export async function generateDocs(options) {
     console.log(`documenting ${providerName}...`);
 
     const docsDir = path.join(outputDir, `docs`);
+    const servicesDir = path.join(docsDir, `services`);
    
     // Remove directory if it exists, then create it fresh
     fs.existsSync(docsDir) && fs.rmSync(docsDir, { recursive: true, force: true });
-    fs.mkdirSync(docsDir, { recursive: true });
+    fs.mkdirSync(servicesDir, { recursive: true });
 
     // Check for provider data files
     console.log(providerDataDir);
@@ -58,16 +59,16 @@ export async function generateDocs(options) {
         servicesForIndex.push(serviceName);
         const filePath = path.join(serviceDir, file);
         totalServicesCount++;
-        const serviceFolder = `${docsDir}/${serviceName}`;
+        const serviceFolder = `${servicesDir}/${serviceName}`;
         await createDocsForService(filePath, providerName, serviceName, serviceFolder);
     }
 
     console.log(`Processed ${totalServicesCount} services`);
 
     // Count total resources
-    totalResourcesCount = fs.readdirSync(`${docsDir}`, { withFileTypes: true })
+    totalResourcesCount = fs.readdirSync(`${servicesDir}`, { withFileTypes: true })
         .filter(dirent => dirent.isDirectory())
-        .map(dirent => fs.readdirSync(`${docsDir}/${dirent.name}`).length)
+        .map(dirent => fs.readdirSync(`${servicesDir}/${dirent.name}`).length)
         .reduce((a, b) => a + b, 0);
 
     console.log(`Processed ${totalResourcesCount} resources`);
@@ -264,12 +265,12 @@ ${secondColumnLinks}
 function generateResourceLinks(providerName, serviceName, resources) {
     // Generate resource links for the service index
     const resourceLinks = resources.map((resource) => {
-        return `<a href="/${serviceName}/${resource.name}/">${resource.name}</a>`;
+        return `<a href="/services/${serviceName}/${resource.name}/">${resource.name}</a>`;
     });
     return resourceLinks.join('<br />\n');
 }
 
 // Function to convert services to markdown links
 function servicesToMarkdown(providerName, servicesList) {
-    return servicesList.map(service => `<a href="/${service}/">${service}</a><br />`).join('\n');
+    return servicesList.map(service => `<a href="/services/${service}/">${service}</a><br />`).join('\n');
 }

package/src/docgen/helpers.js

@@ -25,53 +25,12 @@ export function getIndefiniteArticle(resourceName) {
 
 export function sanitizeHtml(text) {
   return text
-    // Replace "<" unless it's followed by "a", "/a", "b", "/b", "strong"
-    .replace(/<(?!\/?(?:a|b|strong)\b)/gi, '&lt;')
-    // Replace ">" unless it's preceded by "</a", "<a ...>", "</b", "<b ...>", "</strong", or "<strong ...>"
-    .replace(/(?<!<\/?(?:a|b|strong)[^>]*)>/gi, '&gt;')
-    // Add quotes around unquoted href values (within <a ...>)
-    .replace(/(<a\b[^>]*?)href=([^"' \t\r\n>]+)/gi, '$1href="$2"')
-    // Special handling for code tags - remove them if they contain * or _
-    .replace(/<code>([\s\S]*?)<\/code>/gi, (match, content) => {
-      if (content.includes('*') || content.includes('_')) {
-        // If code block has problematic characters, remove the code tags
-        // and escape the special characters
-        return content
-          .replace(/\*/g, '&ast;')   // Escape asterisks
-          .replace(/_/g, '&lowbar;') // Escape underscores
-          .replace(/\[/g, '&#91;')   // Escape brackets
-          .replace(/\]/g, '&#93;')
-          .replace(/\(/g, '&#40;')   // Escape parentheses
-          .replace(/\)/g, '&#41;');
-      }
-      // Otherwise keep the code tags
-      return match;
-    })
-    // Wrap backticked text with <code> but only if it doesn't contain * or _
-    .replace(/`([^`]+)`/g, (match, content) => {
-      if (content.includes('*') || content.includes('_')) {
-        // If backticked content has problematic characters, don't add code tags
-        return content
-          .replace(/\*/g, '&ast;')
-          .replace(/_/g, '&lowbar;')
-          .replace(/\[/g, '&#91;')
-          .replace(/\]/g, '&#93;')
-          .replace(/\(/g, '&#40;')
-          .replace(/\)/g, '&#41;');
-      }
-      return `<code>${content}</code>`;
-    })
-    // Replace { and }
     .replace(/{/g, '&#123;')
     .replace(/}/g, '&#125;')
-    // Escape backslash
-    .replace(/\\/g, '\\\\')
-    // Replace " with &quot; UNLESS inside <code>...</code> OR inside an href="...".
-    .replace(/(<code>[\s\S]*?<\/code>)|(\bhref="[^"]*")|"/gi, (m, code, href) => {
-      if (code) return code;          // keep code blocks untouched
-      if (href) return href;          // keep href="..." quotes untouched
-      return '&quot;';                // everything else: replace "
-    });
+    .replace(/>/g, '&gt;')
+    .replace(/</g, '&lt;')
+    // edge case
+    .replace(/&#125;_&#123;/g, '&#125;&#95;&#123;')
 }
 
 export function getSqlMethodsWithOrderedFields(resourceData, dereferencedAPI, sqlVerb) {
@@ -427,30 +386,37 @@ function getHttpOperationInfo(dereferencedAPI, path, httpVerb, mediaType, openAP
     }
 
     const schema = responseObj.content[mediaType].schema;
-    
+
+    const { respProps, respDescription } = getHttpRespBody(schema, objectKey);
+
+    return {
+        respProps,
+        respDescription: responseObj.description ? responseObj.description : respDescription,
+        opDescription,
+        requestBody
+    };
+}
+
+function getHttpRespBody(schema, objectKey) {
+
     if (schema.type === 'array') {
         return {
-            respProps: schema.items.properties || {},
-            respDescription: schema.items.description || responseObj.description || '',
-            opDescription,
-            requestBody
-        };
+         respProps: schema.items.properties || {},
+         respDescription: schema.items.description || '',
+        }
     } else if (schema.type === 'object') {
         return {
-            respProps: schema.properties || {},
-            respDescription: schema.description || responseObj.description || '',
-            opDescription,
-            requestBody
+         respProps: schema.properties || {},
+         respDescription: schema.description || '',
         };
     } else {
-        // For primitive types or when schema structure is unexpected
         return {
             respProps: {},
-            respDescription: schema.description || responseObj.description || '',
-            opDescription,
-            requestBody
+            respDescription: '',
         };
     }
+
+
 }
 
 function getHttpOperationParams(dereferencedAPI, path, httpVerb) {