refactor: add Parser class

src/custom-operations/index.ts

@@ -1,27 +1,28 @@
 import { applyTraitsV2, applyTraitsV3 } from './apply-traits';
 import { parseSchemasV2 } from './parse-schema';
 
+import type { Parser } from '../parser';
 import type { ParseOptions } from "../parse";
 import type { DetailedAsyncAPI } from "../types";
 
-export async function customOperations(detailed: DetailedAsyncAPI, options: ParseOptions): Promise<void> {
+export async function customOperations(parser: Parser, detailed: DetailedAsyncAPI, options: ParseOptions): Promise<void> {
   switch (detailed.semver.major) {
-    case 2: return operationsV2(detailed, options);
-    case 3: return operationsV3(detailed, options);
+    case 2: return operationsV2(parser, detailed, options);
+    case 3: return operationsV3(parser, detailed, options);
   }
 }
 
-async function operationsV2(detailed: DetailedAsyncAPI, options: ParseOptions): Promise<void> {
+async function operationsV2(parser: Parser, detailed: DetailedAsyncAPI, options: ParseOptions): Promise<void> {
   if (options.applyTraits) {
     applyTraitsV2(detailed.parsed);
   }
   if (options.parseSchemas) {
-    await parseSchemasV2(detailed);
+    await parseSchemasV2(parser, detailed);
   }
 }
 
-async function operationsV3(detailed: DetailedAsyncAPI, options: ParseOptions): Promise<void> {
+async function operationsV3(parser: Parser, detailed: DetailedAsyncAPI, options: ParseOptions): Promise<void> {
   if (options.applyTraits) {
     applyTraitsV3(detailed.parsed);
   }
-}
+}

src/custom-operations/parse-schema.ts

@@ -4,6 +4,7 @@ import { toPath } from 'lodash';
 import { parseSchema, getDefaultSchemaFormat } from '../schema-parser';
 import { xParserOriginalSchemaFormat } from '../constants';
 
+import type { Parser } from '../parser';
 import type { ParseSchemaInput } from "../schema-parser";
 import type { DetailedAsyncAPI } from "../types";
 
@@ -20,7 +21,7 @@ const customSchemasPathsV2 = [
   '$.components.messages.*',
 ];
 
-export async function parseSchemasV2(detailed: DetailedAsyncAPI) {
+export async function parseSchemasV2(parser: Parser, detailed: DetailedAsyncAPI) {
   const defaultSchemaFormat = getDefaultSchemaFormat(detailed.parsed.asyncapi as string);
   const parseItems: Array<ToParseItem> = [];
 
@@ -57,10 +58,10 @@ export async function parseSchemasV2(detailed: DetailedAsyncAPI) {
     });
   });
 
-  return Promise.all(parseItems.map(parseSchemaV2));
+  return Promise.all(parseItems.map(item => parseSchemaV2(parser, item)));
 }
 
-async function parseSchemaV2(item: ToParseItem) {
+async function parseSchemaV2(parser: Parser, item: ToParseItem) {
   item.value[xParserOriginalSchemaFormat] = item.input.schemaFormat;
-  item.value.payload = await parseSchema(item.input);
+  item.value.payload = await parseSchema(parser, item.input);
 }

src/index.ts

@@ -1,15 +1,11 @@
 export * from './models';
 
-export { lint, validate } from './lint';
-export { parse } from './parse';
+export { Parser } from './parser';
 export { stringify, unstringify } from './stringify';
-
-export { registerSchemaParser } from './schema-parser';
 export { AsyncAPISchemaParser } from './schema-parser/asyncapi-schema-parser';
 
+export type { AsyncAPISemver, Diagnostic, SchemaValidateResult } from './types';
 export type { LintOptions, ValidateOptions, ValidateOutput } from './lint';
+export type { ParseInput, ParseOptions, ParseOutput } from './parse';
 export type { StringifyOptions } from './stringify';
-export type { ParseOptions } from './parse';
-export type { AsyncAPISemver, ParserInput, ParserOutput, Diagnostic, SchemaValidateResult } from './types';
-
 export type { ValidateSchemaInput, ParseSchemaInput, SchemaParser } from './schema-parser'

src/lint.ts

@@ -1,22 +1,19 @@
-import {
-  IConstructorOpts,
-  IRunOpts,
-  Spectral,
-  Ruleset,
-  RulesetDefinition,
-} from "@stoplight/spectral-core";
-import { asyncapi as aasRuleset } from "@stoplight/spectral-rulesets";
-
+import { Document } from "@stoplight/spectral-core";
+import { Yaml } from "@stoplight/spectral-parsers";
 import { toAsyncAPIDocument, normalizeInput, hasWarningDiagnostic, hasErrorDiagnostic } from "./utils";
 
+import type { IRunOpts } from "@stoplight/spectral-core";
+import type { Parser } from './parser';
 import type { AsyncAPIDocumentInterface } from "./models/asyncapi";
-import type { ParserInput, Diagnostic } from "./types";
+import type { ParseInput } from "./parse";
+import type { Diagnostic } from "./types";
 
-export interface LintOptions extends IConstructorOpts, IRunOpts {
-  ruleset?: RulesetDefinition | Ruleset;
+export interface LintOptions extends IRunOpts {
+  path?: string;
 }
 
-export interface ValidateOptions extends LintOptions {
+export interface ValidateOptions extends IRunOpts {
+  path?: string;
   allowedSeverity?: {
     warning?: boolean;
   };
@@ -27,20 +24,24 @@ export interface ValidateOutput {
   diagnostics: Diagnostic[];
 }
 
-export async function lint(asyncapi: ParserInput, options?: LintOptions): Promise<Diagnostic[] | undefined> {
+export async function lint(parser: Parser, asyncapi: ParseInput, options?: LintOptions): Promise<Diagnostic[]> {
+  const result = await validate(parser, asyncapi, options);
+  return result.diagnostics;
+}
+
+export async function validate(parser: Parser, asyncapi: ParseInput, options: ValidateOptions = {}): Promise<ValidateOutput> {
   if (toAsyncAPIDocument(asyncapi)) {
-    return;
+    return {
+      validated: asyncapi,
+      diagnostics: [],
+    }
   }
-  const document = normalizeInput(asyncapi as Exclude<ParserInput, AsyncAPIDocumentInterface>);
-  return (await validate(document, options)).diagnostics;
-}
 
-export async function validate(asyncapi: string, options?: ValidateOptions): Promise<ValidateOutput> {
-  const { ruleset, allowedSeverity, ...restOptions } = normalizeOptions(options);
-  const spectral = new Spectral(restOptions);
+  const stringifiedDocument = normalizeInput(asyncapi as Exclude<ParseInput, AsyncAPIDocumentInterface>);
+  const document = new Document(stringifiedDocument, Yaml, options.path);
 
-  spectral.setRuleset(ruleset!);
-  let { resolved, results } = await spectral.runWithResolved(asyncapi);
+  const { allowedSeverity } = normalizeOptions(options);
+  let { resolved, results } = await parser.spectral.runWithResolved(document);
 
   if (
     hasErrorDiagnostic(results) ||
@@ -53,8 +54,6 @@ export async function validate(asyncapi: string, options?: ValidateOptions): Pro
 }
 
 const defaultOptions: ValidateOptions = {
-  // TODO: fix that type
-  ruleset: aasRuleset as any,
   allowedSeverity: {
     warning: true,
   }
@@ -65,7 +64,6 @@ function normalizeOptions(options?: ValidateOptions): ValidateOptions {
   }
   // shall copy
   options = { ...defaultOptions, ...options };
-
   // severity
   options.allowedSeverity = { ...defaultOptions.allowedSeverity, ...(options.allowedSeverity || {}) };
 

src/parse.ts

@@ -2,21 +2,28 @@ import { AsyncAPIDocumentInterface, newAsyncAPIDocument } from "./models";
 
 import { customOperations } from './custom-operations';
 import { validate } from "./lint";
-import { stringify, unstringify } from './stringify';
 import { createDetailedAsyncAPI, normalizeInput, toAsyncAPIDocument } from "./utils";
 
 import { xParserSpecParsed } from './constants';
 
-import type { ParserInput, ParserOutput } from './types';
+import type { Parser } from './parser';
 import type { ValidateOptions } from './lint';
+import type { MaybeAsyncAPI, Diagnostic } from './types';
+
+export type ParseInput = string | MaybeAsyncAPI | AsyncAPIDocumentInterface;
+export interface ParseOutput {
+  source: ParseInput;
+  parsed: AsyncAPIDocumentInterface | undefined;
+  diagnostics: Diagnostic[]; 
+}
 
 export interface ParseOptions {
   applyTraits?: boolean;
   parseSchemas?: boolean;
   validateOptions?: ValidateOptions;
 }
 
-export async function parse(asyncapi: ParserInput, options?: ParseOptions): Promise<ParserOutput> {
+export async function parse(parser: Parser, asyncapi: ParseInput, options?: ParseOptions): Promise<ParseOutput> {
   let maybeDocument = toAsyncAPIDocument(asyncapi);
   if (maybeDocument) {
     return { 
@@ -27,10 +34,10 @@ export async function parse(asyncapi: ParserInput, options?: ParseOptions): Prom
   }
 
   try {
-    const document = normalizeInput(asyncapi as Exclude<ParserInput, AsyncAPIDocumentInterface>);
+    const document = normalizeInput(asyncapi as Exclude<ParseInput, AsyncAPIDocumentInterface>);
     options = normalizeOptions(options);
 
-    const { validated, diagnostics } = await validate(document, options.validateOptions);
+    const { validated, diagnostics } = await validate(parser, document, options.validateOptions);
     if (validated === undefined) {
       return {
         source: asyncapi,
@@ -39,14 +46,12 @@ export async function parse(asyncapi: ParserInput, options?: ParseOptions): Prom
       };
     }
 
-    const doc = {
-      ...(validated as Record<string, any>),
-      [xParserSpecParsed]: true,
-    }
-    const parsed = unstringify(stringify(doc))?.json()!;
+    // unfreeze the object - Spectral makes resolved document "freezed" 
+    const validatedDoc = JSON.parse(JSON.stringify(validated));
+    validatedDoc[String(xParserSpecParsed)] = true;
 
-    const detailed = createDetailedAsyncAPI(asyncapi as string | Record<string, unknown>, parsed);
-    await customOperations(detailed, options);
+    const detailed = createDetailedAsyncAPI(asyncapi as string | Record<string, unknown>, validatedDoc);
+    await customOperations(parser, detailed, options);
     const parsedDoc = newAsyncAPIDocument(detailed);
 
     return { 

src/parser.ts

@@ -0,0 +1,48 @@
+import { Spectral } from "@stoplight/spectral-core";
+import { asyncapi as aasRuleset } from "@stoplight/spectral-rulesets";
+
+import { parse } from "./parse";
+import { lint, validate } from "./lint";
+import { registerSchemaParser } from './schema-parser';
+
+import type { IConstructorOpts } from "@stoplight/spectral-core";
+import type { ParseInput, ParseOptions } from "./parse";
+import type { LintOptions, ValidateOptions } from "./lint";
+import type { SchemaParser } from './schema-parser';
+
+export interface ParserOptions {
+  spectral?: Spectral | IConstructorOpts;
+}
+
+export class Parser {
+  public readonly parserRegistry = new Map<string, SchemaParser>();
+  public readonly spectral: Spectral;
+
+  constructor(options?: ParserOptions) {
+    const { spectral } = options || {};
+    if (spectral instanceof Spectral) {
+      this.spectral = spectral;
+    } else {
+      this.spectral = new Spectral(spectral);
+    }
+
+    // TODO: fix type
+    this.spectral.setRuleset(aasRuleset as any);
+  }
+
+  parse(asyncapi: ParseInput, options?: ParseOptions) {
+    return parse(this, asyncapi, options);
+  }
+
+  lint(asyncapi: ParseInput, options?: LintOptions) {
+    return lint(this, asyncapi, options);
+  }
+
+  validate(asyncapi: ParseInput, options?: ValidateOptions) {
+    return validate(this, asyncapi, options);
+  }
+
+  registerSchemaParser(parser: SchemaParser) {
+    return registerSchemaParser(this, parser);
+  }
+}

src/schema-parser/index.ts

@@ -1,3 +1,4 @@
+import type { Parser } from '../parser';
 import type { DetailedAsyncAPI, SchemaValidateResult } from '../types';
 
 export interface ValidateSchemaInput<D = unknown, M = unknown> {
@@ -24,44 +25,38 @@ export interface SchemaParser<D = unknown, M = unknown> {
   getMimeTypes: () => Array<string>;
 }
 
-const PARSERS = new Map<string, SchemaParser>();
-
-export async function validateSchema(input: ParseSchemaInput) {
-  const parser = getSchemaParser(input.schemaFormat);
-  if (parser === undefined) {
+export async function validateSchema(parser: Parser, input: ParseSchemaInput) {
+  const schemaParser = parser.parserRegistry.get(input.schemaFormat);
+  if (schemaParser === undefined) {
     // throw appropriate error
     throw new Error();
   }
-  return parser.validate(input);
+  return schemaParser.validate(input);
 }
 
-export async function parseSchema(input: ParseSchemaInput) {
-  const parser = getSchemaParser(input.schemaFormat);
-  if (parser === undefined) {
+export async function parseSchema(parser: Parser, input: ParseSchemaInput) {
+  const schemaParser = parser.parserRegistry.get(input.schemaFormat);
+  if (schemaParser === undefined) {
     return;
   }
-  return parser.parse(input);
+  return schemaParser.parse(input);
 }
 
-export function registerSchemaParser(parser: SchemaParser) {
+export function registerSchemaParser(parser: Parser, schemaParser: SchemaParser) {
   if (
-    typeof parser !== 'object' 
-      || typeof parser.validate !== 'function' 
-      || typeof parser.parse !== 'function' 
-      || typeof parser.getMimeTypes !== 'function'
+    typeof schemaParser !== 'object' 
+      || typeof schemaParser.validate !== 'function' 
+      || typeof schemaParser.parse !== 'function' 
+      || typeof schemaParser.getMimeTypes !== 'function'
   ) {
     throw new Error('custom parser must have "parse()", "validate()" and "getMimeTypes()" functions.');
   }
 
-  parser.getMimeTypes().forEach(schemaFormat => {
-    PARSERS.set(schemaFormat, parser);
+  schemaParser.getMimeTypes().forEach(schemaFormat => {
+    parser.parserRegistry.set(schemaFormat, schemaParser);
   });
 }
 
-export function getSchemaParser(mimeType: string) {
-  return PARSERS.get(mimeType);
-}
-
 export function getDefaultSchemaFormat(asyncapiVersion: string) {
   return `application/vnd.aai.asyncapi;version=${asyncapiVersion}`;
 }

src/types.ts

@@ -1,5 +1,4 @@
 import type { ISpectralDiagnostic, IFunctionResult } from '@stoplight/spectral-core';
-import type { AsyncAPIDocumentInterface } from './models/asyncapi';
 
 export type MaybeAsyncAPI = { asyncapi: string } & Record<string, unknown>;
 export interface AsyncAPISemver {
@@ -16,17 +15,5 @@ export interface DetailedAsyncAPI {
   semver: AsyncAPISemver;
 }
 
-export type ParserInput = string | MaybeAsyncAPI | AsyncAPIDocumentInterface;
-
 export type Diagnostic = ISpectralDiagnostic;
 export type SchemaValidateResult = IFunctionResult;
-
-export interface ParserOutput {
-  source: ParserInput;
-  parsed: AsyncAPIDocumentInterface | undefined;
-  diagnostics: Diagnostic[]; 
-}
-
-export interface Constructor<T> {
-  new (...args: any[]): T
-}

src/utils.ts

@@ -62,6 +62,9 @@ export function getSemver(version: string): AsyncAPISemver {
 }
 
 export function normalizeInput(asyncapi: string | MaybeAsyncAPI): string {
+  if (typeof asyncapi === 'string') {
+    return asyncapi;
+  }
   return JSON.stringify(asyncapi, undefined, 2);
 };