feat(springwolf-ui): validate AsyncAPI specification against springwolf-ui schema (springwolf#1219)

Co-authored-by: Timon Back <[email protected]>

Author: sam0r040

springwolf-ui/package-lock.json

@@ -22,6 +22,7 @@
     "@angular/platform-browser": "^19.2.0",
     "@angular/platform-browser-dynamic": "^19.2.0",
     "@angular/router": "^19.2.0",
+    "ajv": "^8.17.1",
     "ngx-markdown": "^19.1.0",
     "prism-code-editor": "^3.4.0",
     "rxjs": "^7.8.2",
@@ -41,6 +42,7 @@
     "jest": "^29.7.0",
     "jest-junit": "^16.0.0",
     "jest-preset-angular": "^14.5.3",
+    "ts-json-schema-generator": "^2.3.0",
     "typescript": "^5.8.2"
   },
   "overrides": {

springwolf-ui/package.json

@@ -12,6 +12,7 @@ import { provideMarkdown } from "ngx-markdown";
 import { AssetService, IAssetService } from "./service/asset.service";
 import { AsyncApiService } from "./service/asyncapi/asyncapi.service";
 import { AsyncApiMapperService } from "./service/asyncapi/asyncapi-mapper.service";
+import { AsyncApiValidatorService } from "./service/asyncapi/validator/asyncapi-validator.service";
 import {
   INotificationService,
   NotificationService,
@@ -34,6 +35,7 @@ export const appConfig: ApplicationConfig = {
     { provide: IAssetService, useClass: AssetService },
     AsyncApiService,
     AsyncApiMapperService,
+    AsyncApiValidatorService,
     { provide: INotificationService, useClass: NotificationService },
     PublisherService,
     { provide: IUiService, useClass: UiService },

springwolf-ui/src/app/app.config.ts

@@ -3,11 +3,12 @@ import { AsyncApi } from "../../models/asyncapi.model";
 import { HttpClient } from "@angular/common/http";
 import { Injectable } from "@angular/core";
 import { Observable, shareReplay, switchMap } from "rxjs";
-import { filter, map } from "rxjs/operators";
+import { filter, map, tap } from "rxjs/operators";
 import { EndpointService } from "../endpoint.service";
 import { AsyncApiMapperService } from "./asyncapi-mapper.service";
 import { ServerAsyncApi } from "./models/asyncapi.model";
 import { IUiService } from "../ui.service";
+import { AsyncApiValidatorService } from "./validator/asyncapi-validator.service";
 
 @Injectable()
 export class AsyncApiService {
@@ -16,7 +17,8 @@ export class AsyncApiService {
   constructor(
     private http: HttpClient,
     private asyncApiMapperService: AsyncApiMapperService,
-    private uiService: IUiService
+    private uiService: IUiService,
+    private asyncApiValidatorService: AsyncApiValidatorService
   ) {
     this.docs = this.uiService.isGroup$.pipe(
       switchMap((group) => {
@@ -26,6 +28,7 @@ export class AsyncApiService {
             : EndpointService.getDocsForGroupEndpoint(group);
         return this.http.get<ServerAsyncApi>(url);
       }),
+      tap((item) => this.asyncApiValidatorService.validate(item)),
       map((item) => this.asyncApiMapperService.toAsyncApi(item)),
       filter((item): item is AsyncApi => item !== undefined),
       shareReplay()

springwolf-ui/src/app/service/asyncapi/asyncapi.service.ts

@@ -7,9 +7,19 @@ export interface ServerAsyncApiInfo {
     name?: string;
     url?: string;
     email?: string;
+
+    // allow any additional fields
+    [key: string]: unknown;
   };
   license?: {
     name?: string;
     url?: string;
+
+    // allow any additional fields
+    [key: string]: unknown;
   };
+  termsOfService?: string;
+
+  // allow any additional fields
+  [key: string]: unknown;
 }

springwolf-ui/src/app/service/asyncapi/models/info.models.ts

@@ -7,6 +7,7 @@ export interface ServerOperations {
 
 export interface ServerOperation {
   action: string;
+  title?: string;
   description?: string;
   channel: {
     $ref: string;

springwolf-ui/src/app/service/asyncapi/models/operations.model.ts

@@ -0,0 +1,62 @@
+/* SPDX-License-Identifier: Apache-2.0 */
+import Ajv from "ajv";
+import { createGenerator } from "ts-json-schema-generator";
+import path from "node:path";
+import expectedSchema from "./server-async-api.schema.json";
+import { exampleSchemas } from "../../mock/example-data";
+import * as fs from "node:fs";
+
+const config = {
+  path: path.join(__dirname, "../models/asyncapi.model.ts"),
+  tsconfig: path.join(__dirname, "../../../../../tsconfig.json"),
+  type: "ServerAsyncApi",
+};
+const serverJsonSchema = createGenerator(config).createSchema("ServerAsyncApi");
+
+describe("AsyncApiValidatorService", () => {
+  const ajv = new Ajv({
+    allErrors: true,
+    removeAdditional: true, // allow additional properties (no strict mode) in test
+  });
+
+  it("should compile to the checked-in schema", () => {
+    // when
+    const validate = ajv.compile(serverJsonSchema);
+
+    // then
+    fs.writeFile(
+      path.join(__dirname, "server-async-api.schema.actual.json"),
+      JSON.stringify(validate.schema, null, 2),
+      (err) => {
+        if (err) throw err;
+      }
+    );
+
+    expect(validate.schema).toStrictEqual(expectedSchema);
+  });
+
+  for (const [plugin, pluginSchema] of Object.entries(exampleSchemas)) {
+    const pluginSchemaGroups = {
+      ...pluginSchema.groups,
+      default: pluginSchema.value,
+    };
+
+    for (const [group, schema] of Object.entries(pluginSchemaGroups)) {
+      it(
+        "should verify AsyncApi schema is valid - " +
+          plugin +
+          " example and group " +
+          group,
+        () => {
+          // when
+          const validate = ajv.compile(serverJsonSchema);
+          const isValid = validate(schema);
+
+          // then
+          expect(validate.errors).toBeNull();
+          expect(isValid).toBeTruthy();
+        }
+      );
+    }
+  }
+});

springwolf-ui/src/app/service/asyncapi/validator/asyncapi-validator.service.spec.ts

@@ -0,0 +1,31 @@
+/* SPDX-License-Identifier: Apache-2.0 */
+import { Injectable } from "@angular/core";
+import Ajv from "ajv";
+import expectedSchema from "./server-async-api.schema.json";
+import { ServerAsyncApi } from "../models/asyncapi.model";
+
+@Injectable()
+export class AsyncApiValidatorService {
+  // private readonly ajv = new Ajv({allErrors: true, removeAdditional: true});
+  private readonly ajvInStrictMode = new Ajv({
+    allErrors: true,
+    removeAdditional: false,
+  });
+
+  public validate(item: ServerAsyncApi) {
+    // const validate = this.ajv.compile(expectedSchema);
+    // const isValid = validate(item)
+    // if(!isValid) {
+    // console.warn("Validation error while parsing asyncapi file in Springwolf format", validate.errors)
+    // }
+
+    const validateStrict = this.ajvInStrictMode.compile(expectedSchema);
+    const isValidInStrictMode = validateStrict(item);
+    if (!isValidInStrictMode) {
+      console.info(
+        "Validation error while parsing asyncapi file in Springwolf format (strict mode)",
+        validateStrict.errors
+      );
+    }
+  }
+}