feat(asyncapi-plugin): enhance schema parsing with @redocly/openapi-core integration

Author: radist2s

packages/asyncapi-plugin/package.json

@@ -35,12 +35,14 @@
     "@qraft/plugin": "workspace:*",
     "ansi-colors": "^4.1.3",
     "commander": "^14.0.2",
+    "js-yaml": "^4.1.0",
     "ora": "^8.2.0"
   },
   "devDependencies": {
     "@asyncapi/parser": "^3.4.0",
     "@openapi-qraft/eslint-config": "workspace:*",
     "@openapi-qraft/rollup-config": "workspace:*",
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.16.5",
     "eslint": "^9.39.1",
     "memfs": "^4.11.1",

packages/asyncapi-plugin/src/lib/readSchema.ts

@@ -1,9 +1,11 @@
 import type { Readable } from 'node:stream';
 // eslint-disable-next-line import-x/no-extraneous-dependencies
 import type { AsyncAPIDocumentInterface } from '@asyncapi/parser';
+import fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
 // eslint-disable-next-line import-x/no-extraneous-dependencies
-import { fromFile, fromURL, Parser } from '@asyncapi/parser';
+import { Parser } from '@asyncapi/parser';
+import { load } from 'js-yaml';
 
 export interface AsyncAPISchemaResult {
   document: AsyncAPIDocumentInterface;
@@ -28,17 +30,21 @@ export async function readSchema(
 
   if (source instanceof URL) {
     if (source.protocol === 'file:') {
-      parseResult = await fromFile(parser, fileURLToPath(source)).parse();
+      rawSchemaSource = fs.readFileSync(fileURLToPath(source), 'utf-8');
+      parseResult = await parser.parse(rawSchemaSource);
     } else {
-      parseResult = await fromURL(parser, source.toString()).parse();
+      rawSchemaSource = await fetchContent(source.toString());
+      parseResult = await parser.parse(rawSchemaSource);
     }
   } else if (
     typeof source === 'string' &&
     (source.startsWith('http://') || source.startsWith('https://'))
   ) {
-    parseResult = await fromURL(parser, source).parse();
+    rawSchemaSource = await fetchContent(source);
+    parseResult = await parser.parse(rawSchemaSource);
   } else if (typeof source === 'string') {
-    parseResult = await fromFile(parser, source).parse();
+    rawSchemaSource = fs.readFileSync(source, 'utf-8');
+    parseResult = await parser.parse(rawSchemaSource);
   } else {
     rawSchemaSource = await streamToString(source);
     parseResult = await parser.parse(rawSchemaSource);
@@ -57,16 +63,35 @@ export async function readSchema(
   }
 
   const rawSchema = rawSchemaSource
-    ? (JSON.parse(rawSchemaSource) as Record<string, unknown>)
+    ? parseRawSchema(rawSchemaSource)
     : (document.json() as Record<string, unknown>);
 
   return { document, rawSchema };
 }
 
+function parseRawSchema(content: string): Record<string, unknown> {
+  const trimmed = content.trim();
+  if (trimmed[0] === '{' || trimmed[0] === '[') {
+    return JSON.parse(trimmed);
+  }
+  return load(trimmed) as Record<string, unknown>;
+}
+
+async function fetchContent(url: string): Promise<string> {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch ${url}: ${response.status} ${response.statusText}`
+    );
+  }
+  return response.text();
+}
+
 async function streamToString(stream: Readable): Promise<string> {
-  const chunks: Buffer[] = [];
+  let result = '';
+  stream.setEncoding('utf-8');
   for await (const chunk of stream) {
-    chunks.push(Buffer.from(chunk));
+    result += chunk;
   }
-  return Buffer.concat(chunks).toString('utf-8');
+  return result;
 }