AsyncAPI Parser

The project uses npm workspaces to manage dependencies between local packages. Instead of publishing a package to npm to test it in another package, npm workspaces creates symlinks in the root node_modules folder. This allows one package to import another directly from the local filesystem.

To enable workspaces, the root package.json defines the workspace directories:

{
  "workspaces": [
    "apps/*",
    "packages/*"
  ]
}

After running npm install at the root, you can verify that a package is symlinked by checking its location in node_modules. For example, @asyncapi/openapi-schema-parser will point to ../../packages/openapi-schema-parser.

Note on Jest Configuration: Because dependencies are hoisted to the root node_modules, Jest configurations within individual packages may need to reference dependencies using relative paths from the package root to the root node_modules (e.g., <rootDir>/../../node_modules/...).

ls -la node_modules/@asyncapi/openapi-schema-parser
# → this is a symlink pointing to ../../packages/openapi-schema-parser

The parser can be extended to support non-standard schema formats (like Avro or OpenAPI) by registering a custom schema parser.

A custom parser module must export an object with three functions:

1. validate(input): Validates the syntax of the used schema.
2. parse(input): Parses the schema into the AsyncAPI Schema Format.
3. getMimeTypes(): Returns an array of MIME types that will be used as the schemaFormat property to identify the schema.

To use it, call parser.registerSchemaParser(yourCustomParser) before calling parse() or validate().

// 1. Define the custom parser
export default {
  validate(input) { ... },
  parse(input) { ... },
  getMimeTypes() {
    return [
      'application/vnd.custom.type;version=1.0.0',
      'application/vnd.custom.type+json;version=1.0.0',
    ]
  }
}

// 2. Register it
import { Parser } from "@asyncapi/parser";
import myCustomSchemaParser from "./my-custom-schema-parser";

const parser = new Parser();
parser.registerSchemaParser(myCustomSchemaParser);

The parser-js repository is organized as a monorepo using npm workspaces. It contains several distinct packages, each with its own package.json.

• Root package.json: Acts as the orchestrator. It is marked as "private": true and is not published to npm. It uses Turborepo to manage builds and tests across all workspace members.
• @asyncapi/parser (packages/parser): The main parser package. It is published to npm.
• @asyncapi/multi-parser (packages/multi-parser): Supports multiple Parser-API versions. It depends on the other workspace packages using the "*" version range, which tells npm to resolve the dependency to the local workspace member instead of fetching from the npm registry.
• @asyncapi/openapi-schema-parser (packages/openapi-schema-parser): A specialized package for OpenAPI schemas, published to npm.

To run tasks for a specific package using Turborepo from the root, use the --filter flag.

# Example: Run tests only for the openapi-schema-parser package
npm run openapi-parser:test

# Under the hood, this uses Turborepo filtering:
turbo run test --filter=@asyncapi/openapi-schema-parser

The parser-js repository is organized as a monorepo, meaning it contains multiple distinct, independently publishable packages within a single Git repository. This structure allows for shared tooling, unified CI/CD, and easier cross-package development.

Key packages in the repository include:

• @asyncapi/parser: The core library for reading and validating AsyncAPI documents.
• @asyncapi/multi-parser: A package that consumes other parsers.
• @asyncapi/openapi-schema-parser: A plugin for understanding OpenAPI schemas within AsyncAPI documents.

Each package resides in the packages/ directory and maintains its own package.json and configuration.

parser-js/                          ← the single Git repository
├── packages/
│   ├── parser/                     ← @asyncapi/parser
│   ├── multi-parser/               ← @asyncapi/multi-parser
│   └── openapi-schema-parser/      ← @asyncapi/openapi-schema-parser
├── package.json                    ← root config (NOT published to npm)
├── turbo.json                      ← Turborepo pipeline config
└── .github/workflows/              ← shared CI for all packages