feat: update parser-js to v2

package.json

@@ -37,7 +37,7 @@
     "@asyncapi/generator": "^1.12.0",
     "@asyncapi/html-template": "^0.28.4",
     "@asyncapi/markdown-template": "^1.3.3",
-    "@asyncapi/parser": "^1.13.1",
+    "@asyncapi/parser": "^2.1.0",
     "@types/jest": "^27.4.0",
     "@types/qs": "^6.9.7",
     "ajv": "^6.12.6",

src/adapters/http/client.ts

@@ -23,15 +23,15 @@ class HttpClientAdapter extends Adapter {
     let headers = {}
     const authConfig = await clientAuthConfig(this.serverName)
     const serverUrl = this.serverUrlExpanded
-    for (const channelName of this.channelNames) {
-      const channelInfo = this.parsedAsyncAPI.channel(channelName)
-      const httpChannelBinding = channelInfo.binding('http')
-      const channelServers = channelInfo.servers()
+    for (const channelName of this.channelAddresses) {
+      const channelInfo = this.parsedAsyncAPI.channels().get(channelName)
+      const httpChannelBinding = channelInfo.bindings().get('http')
+      const channelServers = channelInfo.servers().all().map(e => e.id())
       const isChannelServers =
         !channelServers.length || channelServers.includes(message.serverName)
       if (httpChannelBinding && isChannelServers) {
-        const method = httpChannelBinding.method
-        let url = `${serverUrl}/${channelName}`
+        const method = httpChannelBinding.json().method
+        let url = new URL( serverUrl + this.parsedAsyncAPI.channels().get(channelName).address())
         const gleeAuth = new GleeAuth(
           this.AsyncAPIServer,
           this.parsedAsyncAPI,

src/adapters/http/server.ts

@@ -93,7 +93,7 @@ class HttpAdapter extends Adapter {
         this.httpResponses.set(this.serverName, res)
         let { pathname } = new URL(req.url, serverUrl)
         pathname = pathname.startsWith('/') ? pathname.substring(1) : pathname
-        if (!this.parsedAsyncAPI.channel(pathname)) {
+        if (!this.parsedAsyncAPI.channels().get(pathname)) {
           res.end('HTTP/1.1 404 Not Found1\r\n\r\n')
           const err = new Error(
             `A client attempted to connect to channel ${pathname} but this channel is not defined in your AsyncAPI file. here`
@@ -105,8 +105,8 @@ class HttpAdapter extends Adapter {
         const searchParams = { query }
         const payload = body
         const httpChannelBinding = this.parsedAsyncAPI
-          .channel(pathname)
-          .binding('http')
+          .channels().get(pathname)
+          .bindings().get('http')
         if (httpChannelBinding) {
           this._checkHttpBinding(
             req,

src/adapters/kafka/index.ts

@@ -15,10 +15,10 @@ class KafkaAdapter extends Adapter {
       'kafka'
     )
     const auth: KafkaAuthConfig = await this.getAuthConfig(kafkaOptions?.auth)
-    const securityRequirements = (this.AsyncAPIServer.security() || []).map(
+    const securityRequirements = this.AsyncAPIServer.security().map(
       (sec) => {
-        const secName = Object.keys(sec.json())[0]
-        return this.parsedAsyncAPI.components().securityScheme(secName)
+        const secName = Object.keys(sec.values())[0]
+        return this.parsedAsyncAPI.components().securitySchemes().get(secName)
       }
     )
     const userAndPasswordSecurityReq = securityRequirements.find(

src/adapters/mqtt/index.ts

@@ -2,7 +2,7 @@ import mqtt, { IPublishPacket, MqttClient, QoS } from 'mqtt'
 import Adapter from '../../lib/adapter.js'
 import GleeMessage from '../../lib/message.js'
 import { MqttAuthConfig, MqttAdapterConfig } from '../../lib/index.js'
-import { SecurityScheme } from '@asyncapi/parser'
+import { SecuritySchemesInterface as SecurityScheme } from '@asyncapi/parser'
 import { logLineWithIcon } from '../../lib/logger.js'
 
 interface IMQTTHeaders {
@@ -42,22 +42,27 @@ class MqttAdapter extends Adapter {
   }
 
   private getSecurityReqs() {
-    const securityRequirements = (this.AsyncAPIServer.security() || []).map(
-      (sec) => {
-        const secName = Object.keys(sec.json())[0]
-        return this.parsedAsyncAPI.components().securityScheme(secName)
+
+    let userAndPasswordSecurityReq
+    let X509SecurityReq
+
+    const securityRequirements = this.AsyncAPIServer.security().map(e => e.map(e => e.scheme()))
+
+    securityRequirements.forEach(security => {
+      for (const sec of security) {
+        if(sec.type() === 'userPassword') {
+          userAndPasswordSecurityReq = sec
+        }
+
+        if (sec.type() === 'x509') {
+          X509SecurityReq = sec
+        }
       }
-    )
-    const userAndPasswordSecurityReq = securityRequirements.find(
-      (sec) => sec.type() === 'userPassword'
-    )
-    const X509SecurityReq = securityRequirements.find(
-      (sec) => sec.type() === 'X509'
-    )
+    })
 
     return {
       userAndPasswordSecurityReq,
-      X509SecurityReq,
+      X509SecurityReq
     }
   }
 
@@ -127,8 +132,7 @@ class MqttAdapter extends Adapter {
 
   private subscribe(channels: string[]) {
     channels.forEach((channel) => {
-      const operation = this.parsedAsyncAPI.channel(channel).publish()
-      const binding = operation.binding('mqtt')
+      const binding = this.parsedAsyncAPI.channels().get(channel).bindings().get('mqtt').value()
       this.client.subscribe(channel, {
         qos: binding?.qos ? binding.qos : 0,
       }, (err, granted) => {
@@ -154,8 +158,8 @@ class MqttAdapter extends Adapter {
     )
     const auth: MqttAuthConfig = await this.getAuthConfig(mqttOptions?.auth)
     const subscribedChannels = this.getSubscribedChannels()
-    const mqttServerBinding = this.AsyncAPIServer.binding('mqtt')
-    const mqtt5ServerBinding = this.AsyncAPIServer.binding('mqtt5')
+    const mqttServerBinding = this.AsyncAPIServer.bindings().get('mqtt')
+    const mqtt5ServerBinding = this.AsyncAPIServer.bindings().get('mqtt5')
 
     const { userAndPasswordSecurityReq, X509SecurityReq } =
       this.getSecurityReqs()
@@ -205,8 +209,7 @@ class MqttAdapter extends Adapter {
 
   _send(message: GleeMessage): Promise<void> {
     return new Promise((resolve, reject) => {
-      const operation = this.parsedAsyncAPI.channel(message.channel).subscribe()
-      const binding = operation ? operation.binding('mqtt') : undefined
+      const binding = this.parsedAsyncAPI.channels().get(message.channel).bindings().get('mqtt').value()
       this.client.publish(
         message.channel,
         message.payload,

src/adapters/ws/client.ts

@@ -38,7 +38,7 @@ class WsClientAdapter extends Adapter {
         this.serverName,
         authConfig
       )
-      let url = new URL(this.AsyncAPIServer.url() + channel)
+      let url = new URL(this.AsyncAPIServer.url() + this.parsedAsyncAPI.channels().get(channel).address())
       if (authConfig) {
         const modedAuth = await gleeAuth.processClientAuth(url, headers, {})
         headers = modedAuth.headers
@@ -47,7 +47,7 @@ class WsClientAdapter extends Adapter {
       this.clients.push({
         channel,
         client: new ws(url, { headers }),
-        binding: this.parsedAsyncAPI.channel(channel).binding('ws'),
+        binding: this.parsedAsyncAPI.channels().get(channel).bindings().get('ws'),
       })
     }
 
@@ -77,13 +77,12 @@ class WsClientAdapter extends Adapter {
   private getWsChannels() {
     const channels = []
     for (const channel of this.channelNames) {
-      if (this.parsedAsyncAPI.channel(channel).hasBinding('ws')) {
-        if (this.parsedAsyncAPI.channel(channel).hasServers()) {
+      if (this.parsedAsyncAPI.channels().get(channel).bindings().get('ws')) {
+        if (this.parsedAsyncAPI.channels().get(channel).servers().all().length !== 0) { // NOSONAR
           if (
             this.parsedAsyncAPI
-              .channel(channel)
-              .servers()
-              .includes(this.serverName)
+              .channels().get(channel)
+              .servers().get(this.serverName)
           ) {
             channels.push(channel)
           }

src/adapters/ws/server.ts

@@ -99,7 +99,7 @@ class WebSocketsAdapter extends Adapter {
       pathname = pathname.substring(1)
     }
 
-    if (!this.parsedAsyncAPI.channel(pathname)) {
+    if (!this.parsedAsyncAPI.channels().get(pathname)) {
       this.emitPathnameError(socket, pathname)
     }
 
@@ -232,8 +232,8 @@ class WebSocketsAdapter extends Adapter {
       )
 
       const wsChannelBinding = this.parsedAsyncAPI
-        .channel(pathname)
-        .binding('ws')
+        .channels().get(pathname)
+        .bindings().get('ws')
 
       if (wsChannelBinding) {
         const correctBindings = await this.checkBindings(socket, {

src/index.ts

@@ -59,7 +59,7 @@ export default async function GleeAppInitializer() {
   await registerAuth(GLEE_AUTH_DIR)
 
   const parsedAsyncAPI = await getParsedAsyncAPI()
-  const channelNames = parsedAsyncAPI.channelNames()
+  const channelNames = parsedAsyncAPI.channels().all().map(e => e.address())
 
   const app = new Glee(config)
 
@@ -78,35 +78,34 @@ export default async function GleeAppInitializer() {
   await generateDocs(parsedAsyncAPI, config, null)
 
   channelNames.forEach((channelName) => {
-    const channel = parsedAsyncAPI.channel(channelName)
-    if (channel.hasPublish()) {
-      const operationId = channel.publish().json('operationId')
-      if (operationId) {
-        const schema = {
-          oneOf: channel
-            .publish()
-            .messages()
-            .map((message) => message.payload().json()),
-        } as any
-        app.use(channelName, validate(schema), (event, next) => {
-          triggerFunction({
-            app,
-            operationId,
-            message: event,
+    const channel = parsedAsyncAPI.channels().get(channelName)
+    if (channel.operations().filterByReceive().length !==0) {
+
+      channel.operations().filterByReceive().forEach(operation => {
+        const receiveOperation = operation
+        const operationId = operation.operationId()
+        if (operationId) {
+          const schema = {
+            onOf: receiveOperation.messages().filterByReceive().map(m => m.payload())
+          } as any
+          app.use(channelName, validate(schema), (event, next) => {
+            triggerFunction({
+              app,
+              operationId,
+              message: event
+            }).then(next).catch(next)
           })
-            .then(next)
-            .catch(next)
-        })
-      }
+        }
+      })
     }
-    if (channel.hasSubscribe()) {
-      const schema = {
-        oneOf: channel
-          .subscribe()
-          .messages()
-          .map((message) => message.payload().json()),
-      } as any
-      app.useOutbound(channelName, validate(schema), json2string)
+    if (channel.operations().filterBySend().length !== 0) {
+      channel.operations().filterBySend().forEach(operation => {
+        const sendOperation = operation
+        const schema = {
+          onOf: sendOperation.messages().filterBySend().map(m => m.payload())
+        } as any
+        app.useOutbound(channelName, validate(schema), json2string)
+      })
     }
   })
 

src/lib/adapter.ts

@@ -1,5 +1,5 @@
 /* eslint-disable security/detect-object-injection */
-import { AsyncAPIDocument, Server } from '@asyncapi/parser'
+import { AsyncAPIDocumentInterface as AsyncAPIDocument, ServerInterface as Server } from '@asyncapi/parser'
 import EventEmitter from 'events'
 import uriTemplates from 'uri-templates'
 import GleeConnection from './connection.js'
@@ -27,6 +27,7 @@ class GleeAdapter extends EventEmitter {
   private _AsyncAPIServer: Server
   private _parsedAsyncAPI: AsyncAPIDocument
   private _channelNames: string[]
+  private _channelAddresses: string[]
   private _connections: GleeConnection[]
   private _serverUrlExpanded: string
 
@@ -41,7 +42,7 @@ class GleeAdapter extends EventEmitter {
   constructor(
     glee: Glee,
     serverName: string,
-    server: Server,
+    server: Server | undefined,
     parsedAsyncAPI: AsyncAPIDocument
   ) {
     super()
@@ -51,7 +52,8 @@ class GleeAdapter extends EventEmitter {
     this._AsyncAPIServer = server
 
     this._parsedAsyncAPI = parsedAsyncAPI
-    this._channelNames = this._parsedAsyncAPI.channelNames()
+    this._channelNames = this._parsedAsyncAPI.channels().all().map(e => e.id())
+    this._channelAddresses = this._parsedAsyncAPI.channels().all().map(c => c.address())
     this._connections = []
 
     const uriTemplateValues = new Map()
@@ -194,6 +196,10 @@ class GleeAdapter extends EventEmitter {
     return this._channelNames
   }
 
+  get channelAddresses(): string[] {
+    return this._channelAddresses
+  }
+
   get connections(): GleeConnection[] {
     return this._connections
   }
@@ -229,12 +235,12 @@ class GleeAdapter extends EventEmitter {
    */
   getSubscribedChannels(): string[] {
     return this._channelNames.filter((channelName) => {
-      const channel = this._parsedAsyncAPI.channel(channelName)
-      if (!channel.hasPublish()) return false
+      const channel = this._parsedAsyncAPI.channels().get(channelName)
+      if (channel.operations().filterBySend().length == 0) return true
 
-      const channelServers = channel.hasServers()
+      const channelServers = channel.servers()
         ? channel.servers()
-        : channel.ext('x-servers') || this._parsedAsyncAPI.serverNames()
+        : channel.extensions().get('x-servers')?.value() || this._parsedAsyncAPI.allServers()
       return channelServers.includes(this._serverName)
     })
   }

src/lib/asyncapiFile.ts

@@ -1,9 +1,11 @@
 import { readFile } from 'fs/promises'
-import asyncapi, { AsyncAPIDocument } from '@asyncapi/parser'
+import { AsyncAPIDocumentInterface as AsyncAPIDocument, Parser, toAsyncAPIDocument} from '@asyncapi/parser'
 import { getConfigs } from './configs.js'
 
 export async function getParsedAsyncAPI(): Promise<AsyncAPIDocument> {
   const { ASYNCAPI_FILE_PATH } = getConfigs()
   const asyncapiFileContent = await readFile(ASYNCAPI_FILE_PATH, 'utf-8')
-  return asyncapi.parse(asyncapiFileContent)
+  const parser = new Parser()
+  const {document} = await parser.parse(asyncapiFileContent)
+  return toAsyncAPIDocument(document)
 }

src/lib/connection.ts

@@ -1,10 +1,10 @@
-import { Server as AsyncAPIServer, AsyncAPIDocument } from '@asyncapi/parser'
+import { ServerInterface as AsyncAPIServer, AsyncAPIDocumentInterface as AsyncAPIDocument } from '@asyncapi/parser'
 
 interface IGleeConnectionConstructor {
   connection: any
   channels: string[]
   serverName: string
-  server: AsyncAPIServer
+  server?: AsyncAPIServer
   parsedAsyncAPI: AsyncAPIDocument
 }
 

src/lib/functions.ts

@@ -54,7 +54,7 @@
 
 export async function register(dir: string) {
   try {
     const statsDir = await stat(dir)
     if (!statsDir.isDirectory()) return
   } catch (e) {
     if (e.code === 'ENOENT') return
@@ -118,10 +118,7 @@
 
     res?.send?.forEach((msg) => {
       const localServerProtocols = ['ws', 'wss', 'http', 'https']
-      const serverProtocol = parsedAsyncAPI
-        .server(msg.server || message.serverName)
-        .protocol()
-        .toLowerCase()
+      const serverProtocol = parsedAsyncAPI.servers().get(msg.server || message.serverName).protocol().toLocaleLowerCase()
       const isBroadcast =
         localServerProtocols.includes(serverProtocol) &&
         !isRemoteServer(parsedAsyncAPI, msg.server)

src/lib/glee.ts

@@ -2,7 +2,7 @@
 import EventEmitter from 'events'
 import async from 'async'
 import Debug from 'debug'
-import { AsyncAPIDocument, Server } from '@asyncapi/parser'
+import { AsyncAPIDocumentInterface as AsyncAPIDocument, ServerInterface as Server } from '@asyncapi/parser'
 import GleeAdapter from './adapter.js'
 import GleeClusterAdapter from './cluster.js'
 import GleeRouter, {
@@ -78,7 +78,7 @@ export default class Glee extends EventEmitter {
       serverName,
       server,
       parsedAsyncAPI,
-    }: { serverName: string; server: Server; parsedAsyncAPI: AsyncAPIDocument }
+    }: { serverName: string; server: Server | undefined; parsedAsyncAPI: AsyncAPIDocument }
   ) {
     this._adapters.push({ Adapter, serverName, server, parsedAsyncAPI })
   }

src/lib/index.d.ts

@@ -1,4 +1,4 @@
-import { AsyncAPIDocument } from '@asyncapi/parser'
+import { AsyncAPIDocumentInterface as AsyncAPIDocument } from '@asyncapi/parser'
 import GleeAdapter from './adapter.js'
 import GleeClusterAdapter from './cluster.js'
 import GleeConnection from './connection.js'