@rvct/asyncapi 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function runCli(args?: string[]): Promise<void>;

package/dist/cli.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { generate } from "./generate.js";
+const HELP = `
+Usage: asyncapi-codegen [--config <path-to-config>] [--input <path-to-asyncapi.{yaml|json}>] [--out <output-dir>]
+
+Options:
+  -c, --config <path> Path to config file. If omitted, asyncapi-codegen.config.{mjs,js,cjs} is resolved from cwd.
+  -i, --input <path>  Override config.input.path.
+  -o, --out <dir>     Override config.output.path.
+  -h, --help          Show this help message.
+
+Examples:
+  asyncapi-codegen
+  asyncapi-codegen --config ./asyncapi-codegen.config.mjs
+  asyncapi-codegen --config ./asyncapi-codegen.config.mjs --input ./specs/asyncapi.yaml --out ./generated
+`;
+function printDiagnostics(diagnostics) {
+    for (const diagnostic of diagnostics) {
+        if (!diagnostic || typeof diagnostic !== "object") {
+            console.log(`[asyncapi] ${String(diagnostic)}`);
+            continue;
+        }
+        const value = diagnostic;
+        const path = Array.isArray(value.path) && value.path.length > 0
+            ? value.path.join(".")
+            : "<root>";
+        const severity = typeof value.severity === "string" || typeof value.severity === "number"
+            ? String(value.severity)
+            : "info";
+        const message = typeof value.message === "string" ? value.message : String(diagnostic);
+        console.log(`[asyncapi:${severity}] ${path}: ${message}`);
+    }
+}
+export async function runCli(args = process.argv.slice(2)) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            options: {
+                config: { type: "string", short: "c" },
+                input: { type: "string", short: "i" },
+                out: { type: "string", short: "o" },
+                help: { type: "boolean", short: "h" },
+            },
+            strict: true,
+            allowPositionals: false,
+        }));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`${message}\n\n${HELP}`);
+    }
+    if (values.help) {
+        console.log(HELP);
+        return;
+    }
+    const result = await generate({
+        config: values.config,
+        input: values.input,
+        out: values.out,
+    });
+    printDiagnostics(result.diagnostics);
+    console.log(`Generated ${result.total} artifacts -> ${result.outDir}`);
+}
+runCli().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/config.d.ts

@@ -0,0 +1,8 @@
+import type { UserConfig } from "./types.js";
+export declare function defineConfig<T extends UserConfig>(config: T): T;
+export declare function loadConfig({ cwd, configPath, input, out, }: {
+    cwd: string;
+    configPath?: string;
+    input?: string;
+    out?: string;
+}): Promise<UserConfig>;

package/dist/config.js

@@ -0,0 +1,66 @@
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+const CONFIG_FILE_NAMES = [
+    "asyncapi.config.mjs",
+    "asyncapi.config.js",
+    "asyncapi.config.cjs",
+];
+export function defineConfig(config) {
+    return config;
+}
+function assertConfigShape(value) {
+    if (!value || typeof value !== "object") {
+        throw new Error("Config must export an object.");
+    }
+    const config = value;
+    if (!config.input ||
+        typeof config.input.path !== "string" ||
+        !config.input.path) {
+        throw new Error("Config must define input.path.");
+    }
+    if (!config.output ||
+        typeof config.output.path !== "string" ||
+        !config.output.path) {
+        throw new Error("Config must define output.path.");
+    }
+    if (config.plugins !== undefined && !Array.isArray(config.plugins)) {
+        throw new Error("Config plugins must be an array when provided.");
+    }
+}
+async function resolveConfigPath({ cwd, configPath, }) {
+    if (configPath) {
+        return resolve(cwd, configPath);
+    }
+    for (const candidate of CONFIG_FILE_NAMES) {
+        const resolved = resolve(cwd, candidate);
+        try {
+            await access(resolved, constants.R_OK);
+            return resolved;
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error("Config not found. Create asyncapi.config.mjs or pass one with --config.");
+}
+export async function loadConfig({ cwd, configPath, input, out, }) {
+    const resolvedConfigPath = await resolveConfigPath({ cwd, configPath });
+    const moduleUrl = pathToFileURL(resolvedConfigPath).href;
+    const imported = (await import(moduleUrl));
+    const loaded = imported.default ?? imported;
+    assertConfigShape(loaded);
+    return {
+        ...loaded,
+        input: {
+            ...loaded.input,
+            path: input ?? loaded.input.path,
+        },
+        output: {
+            ...loaded.output,
+            path: out ?? loaded.output.path,
+        },
+        plugins: Array.isArray(loaded.plugins) ? loaded.plugins : [],
+    };
+}

package/dist/core/AsyncApiDocument.d.ts

@@ -0,0 +1,13 @@
+import type { AsyncAPIDocumentInterface, ChannelInterface, Diagnostic, OperationInterface, SchemaInterface } from "@asyncapi/parser";
+import type { AsyncApiEntitySeed } from "../types.js";
+export declare class AsyncApiDocument {
+    document: AsyncAPIDocumentInterface;
+    diagnostics: Diagnostic[];
+    constructor(document: AsyncAPIDocumentInterface, { diagnostics }?: {
+        diagnostics?: Diagnostic[];
+    });
+    getComponentSchemas(): SchemaInterface[];
+    getOperations(): OperationInterface[];
+    getChannels(): ChannelInterface[];
+    resolveNames(entities: AsyncApiEntitySeed[]): AsyncApiEntitySeed[];
+}

package/dist/core/AsyncApiDocument.js

@@ -0,0 +1,21 @@
+import { resolveEntityNames } from "../core/naming.js";
+export class AsyncApiDocument {
+    document;
+    diagnostics;
+    constructor(document, { diagnostics = [] } = {}) {
+        this.document = document;
+        this.diagnostics = diagnostics;
+    }
+    getComponentSchemas() {
+        return [...(this.document.components?.()?.schemas?.() ?? [])];
+    }
+    getOperations() {
+        return [...(this.document.operations?.() ?? [])];
+    }
+    getChannels() {
+        return [...(this.document.channels?.() ?? [])];
+    }
+    resolveNames(entities) {
+        return resolveEntityNames(entities);
+    }
+}

package/dist/core/entityGraph.d.ts

@@ -0,0 +1,2 @@
+import type { AsyncApiEntity, AsyncApiEntityGraph } from "../types.js";
+export declare function createEntityGraph(entities: AsyncApiEntity[]): AsyncApiEntityGraph;

package/dist/core/entityGraph.js

@@ -0,0 +1,13 @@
+export function createEntityGraph(entities) {
+    const byId = new Map();
+    for (const entity of entities) {
+        if (byId.has(entity.id)) {
+            throw new Error(`Duplicate entity id detected: ${entity.id}`);
+        }
+        byId.set(entity.id, entity);
+    }
+    return {
+        entities,
+        byId,
+    };
+}

package/dist/core/generators/OperationGenerator.d.ts

@@ -0,0 +1,7 @@
+import type { AsyncApiDocument } from "../../core/AsyncApiDocument.js";
+import type { AsyncApiEntity } from "../../types.js";
+export declare class OperationGenerator {
+    asyncapi: AsyncApiDocument;
+    constructor(asyncapi: AsyncApiDocument);
+    build(): Promise<AsyncApiEntity[]>;
+}

package/dist/core/generators/OperationGenerator.js

@@ -0,0 +1,145 @@
+import { pascalCase } from "../../core/naming.js";
+import { normalizeSchema } from "../../core/normalizeSchema.js";
+function getMessageVariant(operationId, messageId) {
+    const operationName = pascalCase(operationId);
+    const messageName = pascalCase(messageId);
+    if (messageName.startsWith(operationName) &&
+        messageName.length > operationName.length) {
+        return messageName.slice(operationName.length);
+    }
+    return messageName;
+}
+function getPayloadBaseName(operationId, messageId, totalMessages) {
+    if (totalMessages === 1) {
+        return `${operationId}Payload`;
+    }
+    return `${operationId}${getMessageVariant(operationId, messageId)}Payload`;
+}
+function getReplyBaseName(operationId, messageId, totalMessages) {
+    if (totalMessages === 1) {
+        return `${operationId}ReplyPayload`;
+    }
+    let variant = getMessageVariant(operationId, messageId);
+    if (variant.startsWith("Reply") && variant.length > "Reply".length) {
+        variant = variant.slice("Reply".length);
+    }
+    return `${operationId}${variant || "Reply"}ReplyPayload`;
+}
+function getHeadersBaseName(operationId, messageId, totalMessages, role) {
+    if (role === "reply" && totalMessages === 1) {
+        return `${operationId}ReplyHeaders`;
+    }
+    if (role === "message" && totalMessages === 1) {
+        return `${operationId}Headers`;
+    }
+    const variant = getMessageVariant(operationId, messageId);
+    return `${operationId}${variant}Headers`;
+}
+export class OperationGenerator {
+    asyncapi;
+    constructor(asyncapi) {
+        this.asyncapi = asyncapi;
+    }
+    async build() {
+        const entities = [];
+        for (const [index, operation] of this.asyncapi.getOperations().entries()) {
+            const operationId = operation.id?.() ?? `operation${index + 1}`;
+            const messages = [
+                ...(operation.messages?.() ?? []),
+            ];
+            for (const [messageIndex, message] of messages.entries()) {
+                const messageId = message.id?.() ?? `${operationId}Message${messageIndex + 1}`;
+                const payload = message.payload?.();
+                const headers = message.headers?.();
+                if (payload) {
+                    entities.push({
+                        id: `operations.${operationId}.messages.${messageId}.payload`,
+                        kind: "message-payload",
+                        baseName: getPayloadBaseName(operationId, messageId, messages.length),
+                        name: getPayloadBaseName(operationId, messageId, messages.length),
+                        schema: await normalizeSchema({
+                            schemaModel: payload,
+                            schemaFormat: message.schemaFormat?.(),
+                            name: `${operationId}.${messageId}.payload`,
+                        }),
+                        sourcePath: `#/operations/${operationId}/messages/${messageId}/payload`,
+                    });
+                }
+                if (headers) {
+                    entities.push({
+                        id: `operations.${operationId}.messages.${messageId}.headers`,
+                        kind: "message-header",
+                        baseName: getHeadersBaseName(operationId, messageId, messages.length, "message"),
+                        name: getHeadersBaseName(operationId, messageId, messages.length, "message"),
+                        schema: await normalizeSchema({
+                            schemaModel: headers,
+                            name: `${operationId}.${messageId}.headers`,
+                        }),
+                        sourcePath: `#/operations/${operationId}/messages/${messageId}/headers`,
+                    });
+                }
+            }
+            const reply = operation.reply?.();
+            const replyMessages = reply
+                ? [...(reply.messages?.() ?? [])]
+                : [];
+            for (const [replyIndex, message] of replyMessages.entries()) {
+                const messageId = message.id?.() ?? `${operationId}Reply${replyIndex + 1}`;
+                const payload = message.payload?.();
+                const headers = message.headers?.();
+                if (payload) {
+                    entities.push({
+                        id: `operations.${operationId}.reply.messages.${messageId}.payload`,
+                        kind: "reply-payload",
+                        baseName: getReplyBaseName(operationId, messageId, replyMessages.length),
+                        name: getReplyBaseName(operationId, messageId, replyMessages.length),
+                        schema: await normalizeSchema({
+                            schemaModel: payload,
+                            schemaFormat: message.schemaFormat?.(),
+                            name: `${operationId}.${messageId}.reply.payload`,
+                        }),
+                        sourcePath: `#/operations/${operationId}/reply/messages/${messageId}/payload`,
+                    });
+                }
+                if (headers) {
+                    entities.push({
+                        id: `operations.${operationId}.reply.messages.${messageId}.headers`,
+                        kind: "message-header",
+                        baseName: getHeadersBaseName(operationId, messageId, replyMessages.length, "reply"),
+                        name: getHeadersBaseName(operationId, messageId, replyMessages.length, "reply"),
+                        schema: await normalizeSchema({
+                            schemaModel: headers,
+                            name: `${operationId}.${messageId}.reply.headers`,
+                        }),
+                        sourcePath: `#/operations/${operationId}/reply/messages/${messageId}/headers`,
+                    });
+                }
+            }
+        }
+        for (const [channelIndex, channel] of this.asyncapi.getChannels().entries()) {
+            const channelId = channel.id?.() ?? `channel${channelIndex + 1}`;
+            const parameters = [
+                ...(channel.parameters?.() ?? []),
+            ];
+            for (const [parameterIndex, parameter] of parameters.entries()) {
+                const parameterId = parameter.id?.() ?? `parameter${parameterIndex + 1}`;
+                const schema = parameter.schema?.();
+                if (!schema) {
+                    continue;
+                }
+                entities.push({
+                    id: `channels.${channelId}.parameters.${parameterId}`,
+                    kind: "channel-parameter",
+                    baseName: `${channelId} ${parameterId} Parameter`,
+                    name: `${channelId} ${parameterId} Parameter`,
+                    schema: await normalizeSchema({
+                        schemaModel: schema,
+                        name: `${channelId}.${parameterId}.parameter`,
+                    }),
+                    sourcePath: `#/channels/${channelId}/parameters/${parameterId}`,
+                });
+            }
+        }
+        return entities;
+    }
+}

package/dist/core/generators/SchemaGenerator.d.ts

@@ -0,0 +1,7 @@
+import type { AsyncApiDocument } from "../../core/AsyncApiDocument.js";
+import type { AsyncApiEntity } from "../../types.js";
+export declare class SchemaGenerator {
+    asyncapi: AsyncApiDocument;
+    constructor(asyncapi: AsyncApiDocument);
+    build(): Promise<AsyncApiEntity[]>;
+}

package/dist/core/generators/SchemaGenerator.js

@@ -0,0 +1,26 @@
+import { normalizeSchema } from "../../core/normalizeSchema.js";
+export class SchemaGenerator {
+    asyncapi;
+    constructor(asyncapi) {
+        this.asyncapi = asyncapi;
+    }
+    async build() {
+        const entities = [];
+        for (const schemaModel of this.asyncapi.getComponentSchemas()) {
+            const schemaId = schemaModel.id?.() ?? "Schema";
+            entities.push({
+                id: `components.schemas.${schemaId}`,
+                kind: "component-schema",
+                baseName: schemaId,
+                name: schemaId,
+                schema: await normalizeSchema({
+                    schemaModel,
+                    schemaFormat: schemaModel.schemaFormat?.(),
+                    name: schemaId,
+                }),
+                sourcePath: `#/components/schemas/${schemaId}`,
+            });
+        }
+        return entities;
+    }
+}

package/dist/core/loadFromConfig.d.ts

@@ -0,0 +1,6 @@
+import type { UserConfig } from "../types.js";
+import { AsyncApiDocument } from "../core/AsyncApiDocument.js";
+export declare function loadFromConfig({ cwd, input, }: {
+    cwd: string;
+    input: UserConfig["input"];
+}): Promise<AsyncApiDocument>;

package/dist/core/loadFromConfig.js

@@ -0,0 +1,14 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { DiagnosticSeverity, Parser } from "@asyncapi/parser";
+import { AsyncApiDocument } from "../core/AsyncApiDocument.js";
+export async function loadFromConfig({ cwd, input, }) {
+    const parser = new Parser();
+    const source = readFileSync(resolve(cwd, input.path), "utf8");
+    const { document, diagnostics } = await parser.parse(source);
+    const fatalDiagnostics = diagnostics.filter((diagnostic) => diagnostic.severity === DiagnosticSeverity.Error);
+    if (!document || fatalDiagnostics.length > 0) {
+        throw new Error(`AsyncAPI parse failed with ${fatalDiagnostics.length} error(s).`);
+    }
+    return new AsyncApiDocument(document, { diagnostics });
+}

package/dist/core/naming.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+export declare function pascalCase(value: any): string;
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+export declare function camelCase(value: any): string;
+/**
+ * @param {Array<{ id: string, kind: keyof typeof KIND_SUFFIX, baseName?: string, name?: string }>} entities
+ * @returns {Array<{ id: string, kind: keyof typeof KIND_SUFFIX, baseName?: string, name: string }>}
+ */
+export declare function resolveEntityNames(entities: any): any;

package/dist/core/naming.js

@@ -0,0 +1,81 @@
+// @ts-check
+const KIND_SUFFIX = {
+    "component-schema": "Schema",
+    "message-payload": "Payload",
+    "reply-payload": "ReplyPayload",
+    "channel-parameter": "Parameter",
+    "message-header": "Headers",
+};
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+export function pascalCase(value) {
+    return String(value)
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[^a-zA-Z0-9]+/g, " ")
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((part) => part[0].toUpperCase() + part.slice(1))
+        .join("");
+}
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+export function camelCase(value) {
+    const normalized = pascalCase(value);
+    if (!normalized) {
+        return normalized;
+    }
+    return normalized[0].toLowerCase() + normalized.slice(1);
+}
+/**
+ * @param {Array<{ id: string, kind: keyof typeof KIND_SUFFIX, baseName?: string, name?: string }>} entities
+ * @returns {Array<{ id: string, kind: keyof typeof KIND_SUFFIX, baseName?: string, name: string }>}
+ */
+export function resolveEntityNames(entities) {
+    const initial = entities.map((entity) => ({
+        ...entity,
+        name: pascalCase(entity.baseName ?? entity.name ?? entity.id) || "Entity",
+    }));
+    const initialCounts = countByName(initial);
+    const withSemanticSuffix = initial.map((entity) => {
+        if ((initialCounts.get(entity.name) ?? 0) < 2) {
+            return entity;
+        }
+        return {
+            ...entity,
+            name: `${entity.name}${KIND_SUFFIX[entity.kind]}`,
+        };
+    });
+    const finalCounts = countByName(withSemanticSuffix);
+    /** @type {Map<string, number>} */
+    const seen = new Map();
+    return withSemanticSuffix.map((entity) => {
+        if ((finalCounts.get(entity.name) ?? 0) < 2) {
+            return entity;
+        }
+        const nextIndex = (seen.get(entity.name) ?? 0) + 1;
+        seen.set(entity.name, nextIndex);
+        return nextIndex === 1
+            ? entity
+            : {
+                ...entity,
+                name: `${entity.name}${nextIndex}`,
+            };
+    });
+}
+/**
+ * @param {Array<{ name: string }>} entities
+ * @returns {Map<string, number>}
+ */
+function countByName(entities) {
+    /** @type {Map<string, number>} */
+    const counts = new Map();
+    for (const entity of entities) {
+        counts.set(entity.name, (counts.get(entity.name) ?? 0) + 1);
+    }
+    return counts;
+}

package/dist/core/normalizeSchema.d.ts

@@ -0,0 +1,8 @@
+export declare function normalizeSchema({ schemaModel, schemaFormat, name, }: {
+    schemaModel: {
+        json(): unknown;
+        schemaFormat?(): string | undefined;
+    };
+    schemaFormat?: string;
+    name: string;
+}): Promise<unknown>;

package/dist/core/normalizeSchema.js

@@ -0,0 +1,28 @@
+const PARSER_PRIVATE_KEYS = new Set([
+    "x-parser-schema-id",
+    "x-parser-unique-object-id",
+]);
+function stripParserMetadata(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => stripParserMetadata(item));
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .filter(([key, nested]) => !PARSER_PRIVATE_KEYS.has(key) && nested !== undefined)
+            .map(([key, nested]) => [key, stripParserMetadata(nested)]));
+    }
+    return value;
+}
+export async function normalizeSchema({ schemaModel, schemaFormat, name, }) {
+    const resolvedSchemaFormat = schemaFormat ??
+        (typeof schemaModel.schemaFormat === "function"
+            ? schemaModel.schemaFormat()
+            : undefined);
+    if (resolvedSchemaFormat &&
+        !resolvedSchemaFormat.startsWith("application/vnd.aai.asyncapi") &&
+        !resolvedSchemaFormat.startsWith("application/schema+json") &&
+        !resolvedSchemaFormat.startsWith("application/json")) {
+        throw new Error(`Unsupported schemaFormat for ${name}: ${resolvedSchemaFormat}. v1 only supports AsyncAPI and JSON Schema compatible payloads.`);
+    }
+    return stripParserMetadata(schemaModel.json());
+}

package/dist/emitters/json-schema.d.ts

@@ -0,0 +1,6 @@
+import type { AsyncApiEntityGraph, EntityKind, GeneratedArtifact } from "../types.js";
+export declare function emitJsonSchemaArtifacts({ graph, outputPath, include, }: {
+    graph: AsyncApiEntityGraph;
+    outputPath: string;
+    include?: EntityKind[];
+}): GeneratedArtifact[];

package/dist/emitters/json-schema.js

@@ -0,0 +1,9 @@
+export function emitJsonSchemaArtifacts({ graph, outputPath, include, }) {
+    return graph.entities
+        .filter((entity) => Array.isArray(include) ? include.includes(entity.kind) : true)
+        .map((entity) => ({
+        kind: "json-schema",
+        filePath: `${outputPath}/${entity.name}.schema.json`,
+        code: `${JSON.stringify(entity.schema, null, 2)}\n`,
+    }));
+}

package/dist/emitters/typescript.d.ts

@@ -0,0 +1,6 @@
+import type { AsyncApiEntityGraph, EntityKind, GeneratedArtifact } from "../types.js";
+export declare function emitTypescriptArtifacts({ graph, outputPath, include, }: {
+    graph: AsyncApiEntityGraph;
+    outputPath: string;
+    include?: EntityKind[];
+}): Promise<GeneratedArtifact[]>;

package/dist/emitters/typescript.js

@@ -0,0 +1,42 @@
+import { compile } from "json-schema-to-typescript";
+const BANNER = `/**
+ * Generated from AsyncAPI spec.
+ * Do not edit manually.
+ */`;
+function applyBinaryTsType(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => applyBinaryTsType(item));
+    }
+    if (value && typeof value === "object") {
+        const node = value;
+        const transformed = Object.fromEntries(Object.entries(node).map(([key, nested]) => [
+            key,
+            applyBinaryTsType(nested),
+        ]));
+        if (transformed.type === "string" && transformed.format === "binary") {
+            return {
+                ...transformed,
+                tsType: "ArrayBuffer",
+            };
+        }
+        return transformed;
+    }
+    return value;
+}
+export async function emitTypescriptArtifacts({ graph, outputPath, include, }) {
+    return Promise.all(graph.entities
+        .filter((entity) => Array.isArray(include) ? include.includes(entity.kind) : true)
+        .map(async (entity) => ({
+        kind: "types",
+        filePath: `${outputPath}/${entity.name}.ts`,
+        code: await compile(applyBinaryTsType(entity.schema), entity.name, {
+            additionalProperties: false,
+            bannerComment: BANNER,
+            format: false,
+        }),
+        export: {
+            name: entity.name,
+            kind: "type",
+        },
+    })));
+}

package/dist/emitters/zod.d.ts

@@ -0,0 +1,6 @@
+import type { AsyncApiEntityGraph, EntityKind, GeneratedArtifact } from "../types.js";
+export declare function emitZodArtifacts({ graph, outputPath, include, }: {
+    graph: AsyncApiEntityGraph;
+    outputPath: string;
+    include?: EntityKind[];
+}): GeneratedArtifact[];

package/dist/emitters/zod.js

@@ -0,0 +1,63 @@
+import { jsonSchemaToZod } from "json-schema-to-zod";
+import { camelCase } from "../core/naming.js";
+const BANNER = `/**
+ * Generated from AsyncAPI spec.
+ * Do not edit manually.
+ */`;
+function normalizeZodSchema(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeZodSchema(item));
+    }
+    if (value && typeof value === "object") {
+        const node = value;
+        const transformed = Object.fromEntries(Object.entries(node).map(([key, nested]) => [
+            key,
+            normalizeZodSchema(nested),
+        ]));
+        if (Array.isArray(transformed.oneOf) && transformed.anyOf === undefined) {
+            return {
+                ...transformed,
+                anyOf: transformed.oneOf,
+                oneOf: undefined,
+            };
+        }
+        return transformed;
+    }
+    return value;
+}
+function withBinaryArrayBufferZodParser(node) {
+    if (node.type === "string" && node.format === "binary") {
+        return "z.instanceof(ArrayBuffer)";
+    }
+    return undefined;
+}
+function emitZodExpression(schema) {
+    return jsonSchemaToZod(normalizeZodSchema(schema), {
+        parserOverride: withBinaryArrayBufferZodParser,
+    })
+        .replace(/z\.record\((?!z\.string\(\),\s)/g, "z.record(z.string(), ")
+        .replaceAll("z.any()", "z.unknown()")
+        .trim()
+        .replace(/;$/, "");
+}
+export function emitZodArtifacts({ graph, outputPath, include, }) {
+    return graph.entities
+        .filter((entity) => Array.isArray(include) ? include.includes(entity.kind) : true)
+        .map((entity) => {
+        const exportName = `${camelCase(entity.name)}Schema`;
+        return {
+            kind: "zod",
+            filePath: `${outputPath}/${entity.name}Schema.ts`,
+            code: `${BANNER}
+
+import { z } from "zod/v4";
+
+export const ${exportName} = ${emitZodExpression(entity.schema)};
+`,
+            export: {
+                name: exportName,
+                kind: "value",
+            },
+        };
+    });
+}

package/dist/generate.d.ts

@@ -0,0 +1,2 @@
+import type { GenerateOptions, GenerateResult } from "./types.js";
+export declare function generate(options?: GenerateOptions): Promise<GenerateResult>;

package/dist/generate.js

@@ -0,0 +1,33 @@
+import { loadConfig } from "./config.js";
+import { PluginManager } from "./runtime/PluginManager.js";
+import { writeArtifacts } from "./runtime/writeArtifacts.js";
+export async function generate(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const config = await loadConfig({
+        cwd,
+        configPath: options.config,
+        input: options.input,
+        out: options.out,
+    });
+    const pluginManager = new PluginManager(config);
+    const context = {
+        cwd,
+        config,
+        asyncapi: null,
+        graph: null,
+        diagnostics: [],
+        artifacts: [],
+    };
+    await pluginManager.run(context);
+    const outDir = await writeArtifacts({
+        cwd,
+        outDir: config.output.path,
+        artifacts: context.artifacts,
+    });
+    return {
+        total: context.artifacts.length,
+        outDir,
+        diagnostics: context.diagnostics,
+        artifacts: context.artifacts,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { defineConfig } from "./config.js";
+export { generate } from "./generate.js";
+export { asyncapi } from "./plugins/asyncapi.js";
+export { typescript } from "./plugins/typescript.js";
+export { zod } from "./plugins/zod.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export { defineConfig } from "./config.js";
+export { generate } from "./generate.js";
+export { asyncapi } from "./plugins/asyncapi.js";
+export { typescript } from "./plugins/typescript.js";
+export { zod } from "./plugins/zod.js";

package/dist/plugins/asyncapi.d.ts

@@ -0,0 +1,13 @@
+import type { EntityKind, PluginInstance } from "../types.js";
+interface AsyncApiPluginOptions {
+    output?: {
+        path?: string;
+    } | false;
+    include?: EntityKind[];
+}
+export declare const asyncapi: (options?: Record<string, unknown>) => PluginInstance<Required<Pick<AsyncApiPluginOptions, "include">> & {
+    output: {
+        path: string;
+    } | null;
+}>;
+export {};

package/dist/plugins/asyncapi.js

@@ -0,0 +1,56 @@
+import { createEntityGraph } from "../core/entityGraph.js";
+import { OperationGenerator } from "../core/generators/OperationGenerator.js";
+import { SchemaGenerator } from "../core/generators/SchemaGenerator.js";
+import { loadFromConfig } from "../core/loadFromConfig.js";
+import { definePlugin } from "../plugins/definePlugin.js";
+import { emitJsonSchemaArtifacts } from "../emitters/json-schema.js";
+function normalizeOutput(output, defaultPath) {
+    if (output === false) {
+        return null;
+    }
+    return {
+        path: output?.path ?? defaultPath,
+    };
+}
+export const asyncapi = definePlugin((options = {}) => {
+    const output = normalizeOutput(options.output, "schemas");
+    return {
+        name: "asyncapi",
+        options: {
+            output,
+            include: options.include ?? [],
+        },
+        inject() {
+            return {
+                getAsyncApi: async () => this.asyncapi,
+                getEntityGraph: async () => this.graph,
+            };
+        },
+        async install() {
+            const asyncapi = await loadFromConfig({
+                cwd: this.cwd,
+                input: this.config.input,
+            });
+            const schemaGenerator = new SchemaGenerator(asyncapi);
+            const operationGenerator = new OperationGenerator(asyncapi);
+            const graph = createEntityGraph(asyncapi.resolveNames([
+                ...(await schemaGenerator.build()),
+                ...(await operationGenerator.build()),
+            ]));
+            this.asyncapi = asyncapi;
+            this.graph = graph;
+            this.diagnostics = asyncapi.diagnostics;
+            if (!output) {
+                return;
+            }
+            const artifacts = emitJsonSchemaArtifacts({
+                graph,
+                outputPath: output.path,
+                include: options.include,
+            });
+            for (const artifact of artifacts) {
+                this.addArtifact(artifact);
+            }
+        },
+    };
+});

package/dist/plugins/definePlugin.d.ts

@@ -0,0 +1,2 @@
+import type { PluginInstance } from "../types.js";
+export declare function definePlugin<TOptions extends Record<string, unknown> | undefined, TPlugin extends PluginInstance>(build: (options?: TOptions) => TPlugin): (options?: TOptions) => TPlugin;

package/dist/plugins/definePlugin.js

@@ -0,0 +1,3 @@
+export function definePlugin(build) {
+    return (options) => build(options);
+}

package/dist/plugins/typescript.d.ts

@@ -0,0 +1,2 @@
+import type { PluginInstance } from "../types.js";
+export declare const typescript: (options?: Record<string, unknown>) => PluginInstance<Record<string, unknown>>;

package/dist/plugins/typescript.js

@@ -0,0 +1,26 @@
+import { definePlugin } from "../plugins/definePlugin.js";
+import { emitTypescriptArtifacts } from "../emitters/typescript.js";
+export const typescript = definePlugin((options = {}) => ({
+    name: "typescript",
+    pre: ["asyncapi"],
+    options: {
+        output: {
+            path: options.output?.path ?? "types",
+        },
+        include: options.include ?? [],
+    },
+    async install() {
+        const graph = await this.getEntityGraph?.();
+        if (!graph) {
+            throw new Error("typescript requires asyncapi to initialize the entity graph.");
+        }
+        const artifacts = await emitTypescriptArtifacts({
+            graph,
+            outputPath: options.output?.path ?? "types",
+            include: options.include,
+        });
+        for (const artifact of artifacts) {
+            this.addArtifact(artifact);
+        }
+    },
+}));

package/dist/plugins/zod.d.ts

@@ -0,0 +1,2 @@
+import type { PluginInstance } from "../types.js";
+export declare const zod: (options?: Record<string, unknown>) => PluginInstance<Record<string, unknown>>;

package/dist/plugins/zod.js

@@ -0,0 +1,26 @@
+import { definePlugin } from "../plugins/definePlugin.js";
+import { emitZodArtifacts } from "../emitters/zod.js";
+export const zod = definePlugin((options = {}) => ({
+    name: "zod",
+    pre: ["asyncapi"],
+    options: {
+        output: {
+            path: options.output?.path ?? "zod",
+        },
+        include: options.include ?? [],
+    },
+    async install() {
+        const graph = await this.getEntityGraph?.();
+        if (!graph) {
+            throw new Error("zod requires asyncapi to initialize the entity graph.");
+        }
+        const artifacts = emitZodArtifacts({
+            graph,
+            outputPath: options.output?.path ?? "zod",
+            include: options.include,
+        });
+        for (const artifact of artifacts) {
+            this.addArtifact(artifact);
+        }
+    },
+}));

package/dist/runtime/PluginManager.d.ts

@@ -0,0 +1,13 @@
+import type { GenerationContext, PluginContext, PluginInstance, UserConfig } from "../types.js";
+export declare class PluginManager {
+    config: UserConfig;
+    plugins: PluginInstance[];
+    constructor(config: UserConfig);
+    run(context: GenerationContext): Promise<GenerationContext>;
+    sortByDependencies(plugins: PluginInstance[]): PluginInstance[];
+    createPluginContext({ context, plugin, injections, }: {
+        context: GenerationContext;
+        plugin: PluginInstance;
+        injections: Record<string, unknown>;
+    }): PluginContext;
+}

package/dist/runtime/PluginManager.js

@@ -0,0 +1,90 @@
+export class PluginManager {
+    config;
+    plugins;
+    constructor(config) {
+        this.config = config;
+        this.plugins = Array.isArray(config.plugins) ? [...config.plugins] : [];
+    }
+    async run(context) {
+        const ordered = this.sortByDependencies(this.plugins);
+        const injections = {};
+        for (const plugin of ordered) {
+            const pluginContext = this.createPluginContext({
+                context,
+                plugin,
+                injections,
+            });
+            await plugin.install.call(pluginContext, pluginContext);
+            if (typeof plugin.inject === "function") {
+                Object.assign(injections, plugin.inject.call(pluginContext, pluginContext) ?? {});
+            }
+        }
+        return context;
+    }
+    sortByDependencies(plugins) {
+        const availableNames = new Set(plugins.map((plugin) => plugin.name));
+        for (const plugin of plugins) {
+            const dependencies = [...(plugin.pre ?? []), ...(plugin.post ?? [])];
+            const missing = dependencies.filter((name) => !availableNames.has(name));
+            if (missing.length > 0) {
+                throw new Error(`Plugin "${plugin.name}" requires missing dependencies: ${missing.join(", ")}`);
+            }
+        }
+        const ordered = [];
+        const pending = [...plugins];
+        const resolvedNames = new Set();
+        while (pending.length > 0) {
+            const readyIndex = pending.findIndex((plugin) => {
+                const dependencies = [...(plugin.pre ?? []), ...(plugin.post ?? [])];
+                return dependencies.every((name) => resolvedNames.has(name));
+            });
+            if (readyIndex === -1) {
+                throw new Error(`Cannot resolve plugin order for: ${pending
+                    .map((plugin) => plugin.name)
+                    .join(", ")}`);
+            }
+            const [plugin] = pending.splice(readyIndex, 1);
+            ordered.push(plugin);
+            resolvedNames.add(plugin.name);
+        }
+        return ordered;
+    }
+    createPluginContext({ context, plugin, injections, }) {
+        const pluginContext = {
+            cwd: context.cwd,
+            config: context.config,
+            plugin,
+            pluginManager: this,
+            artifacts: context.artifacts,
+            get asyncapi() {
+                return context.asyncapi;
+            },
+            set asyncapi(value) {
+                context.asyncapi = value;
+            },
+            get graph() {
+                return context.graph;
+            },
+            set graph(value) {
+                context.graph = value;
+            },
+            get diagnostics() {
+                return context.diagnostics;
+            },
+            set diagnostics(value) {
+                context.diagnostics = Array.isArray(value) ? value : [value];
+            },
+            addArtifact(artifact) {
+                context.artifacts.push(artifact);
+            },
+            resolveName(name, type = "type") {
+                return plugin.resolveName?.call(pluginContext, name, type) ?? name;
+            },
+            resolvePath(baseName, mode = "split") {
+                return (plugin.resolvePath?.call(pluginContext, baseName, mode) ?? baseName);
+            },
+            ...injections,
+        };
+        return pluginContext;
+    }
+}

package/dist/runtime/writeArtifacts.d.ts

@@ -0,0 +1,6 @@
+import type { GeneratedArtifact } from "../types.js";
+export declare function writeArtifacts({ cwd, outDir, artifacts, }: {
+    cwd: string;
+    outDir: string;
+    artifacts: GeneratedArtifact[];
+}): Promise<string>;

package/dist/runtime/writeArtifacts.js

@@ -0,0 +1,73 @@
+import { dirname, join, resolve } from "node:path";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import prettier from "prettier";
+function toPosixPath(value) {
+    return value.replaceAll("\\", "/");
+}
+function assertSafeOutputRoot(root, cwd) {
+    if (root === cwd) {
+        throw new Error("Refusing to clean the current working directory. Use a dedicated output.path.");
+    }
+    const parent = dirname(root);
+    if (root === parent) {
+        throw new Error(`Refusing to clean filesystem root: ${root}`);
+    }
+}
+function createBarrelFiles(artifacts) {
+    const groups = new Map();
+    for (const artifact of artifacts) {
+        if (!artifact.export) {
+            continue;
+        }
+        const directory = dirname(artifact.filePath);
+        const items = groups.get(directory) ?? [];
+        items.push({
+            filePath: artifact.filePath,
+            export: artifact.export,
+        });
+        groups.set(directory, items);
+    }
+    const generated = new Map();
+    for (const [directory, items] of [...groups.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+        const lines = items
+            .sort((left, right) => left.filePath.localeCompare(right.filePath))
+            .map((item) => {
+            const fileName = item.filePath
+                .slice(directory.length + 1)
+                .replace(/\.ts$/, ".js");
+            const path = `./${toPosixPath(fileName)}`;
+            return item.export.kind === "type"
+                ? `export type { ${item.export.name} } from "${path}";`
+                : `export { ${item.export.name} } from "${path}";`;
+        });
+        generated.set(join(directory, "index.ts"), `${lines.join("\n")}\n`);
+    }
+    const rootLines = [...groups.keys()]
+        .sort((left, right) => left.localeCompare(right))
+        .map((directory) => `export * from "./${toPosixPath(join(directory, "index.js"))}";`);
+    if (rootLines.length > 0) {
+        generated.set("index.ts", `${rootLines.join("\n")}\n`);
+    }
+    return generated;
+}
+export async function writeArtifacts({ cwd, outDir, artifacts, }) {
+    const resolvedOutDir = resolve(cwd, outDir);
+    assertSafeOutputRoot(resolvedOutDir, cwd);
+    rmSync(resolvedOutDir, { recursive: true, force: true });
+    mkdirSync(resolvedOutDir, { recursive: true });
+    const prettierConfig = await prettier.resolveConfig(cwd);
+    const files = new Map(createBarrelFiles(artifacts));
+    for (const artifact of artifacts) {
+        files.set(artifact.filePath, artifact.code);
+    }
+    for (const [relativePath, code] of [...files.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+        const absolutePath = resolve(resolvedOutDir, relativePath);
+        mkdirSync(dirname(absolutePath), { recursive: true });
+        const formatted = await prettier.format(code, {
+            ...(prettierConfig ?? {}),
+            filepath: absolutePath,
+        });
+        writeFileSync(absolutePath, formatted);
+    }
+    return resolvedOutDir;
+}

package/dist/types.d.ts

@@ -0,0 +1,78 @@
+import type { Diagnostic } from "@asyncapi/parser";
+import type { AsyncApiDocument } from "./core/AsyncApiDocument.js";
+export type EntityKind = "component-schema" | "message-payload" | "reply-payload" | "channel-parameter" | "message-header";
+export interface AsyncApiEntity {
+    id: string;
+    kind: EntityKind;
+    baseName?: string;
+    name: string;
+    schema: unknown;
+    sourcePath: string;
+}
+export interface AsyncApiEntitySeed {
+    id: string;
+    kind: EntityKind;
+    baseName?: string;
+    name?: string;
+}
+export interface AsyncApiEntityGraph {
+    entities: AsyncApiEntity[];
+    byId: Map<string, AsyncApiEntity>;
+}
+export interface GeneratedArtifact {
+    kind: "json-schema" | "types" | "zod";
+    filePath: string;
+    code: string;
+    export?: {
+        name: string;
+        kind: "type" | "value";
+    };
+}
+export interface UserConfig {
+    input: {
+        path: string;
+    };
+    output: {
+        path: string;
+    };
+    plugins?: PluginInstance[];
+}
+export interface GenerateOptions {
+    cwd?: string;
+    config?: string;
+    input?: string;
+    out?: string;
+}
+export interface GenerateResult {
+    total: number;
+    outDir: string;
+    diagnostics: Diagnostic[];
+    artifacts: GeneratedArtifact[];
+}
+export interface GenerationContext {
+    cwd: string;
+    config: UserConfig;
+    asyncapi: AsyncApiDocument | null;
+    graph: AsyncApiEntityGraph | null;
+    diagnostics: Diagnostic[];
+    artifacts: GeneratedArtifact[];
+}
+export interface PluginContext extends GenerationContext {
+    plugin: PluginInstance;
+    pluginManager: unknown;
+    addArtifact(artifact: GeneratedArtifact): void;
+    resolveName(name: string, type?: "file" | "type"): string;
+    resolvePath(baseName: string, mode?: "single" | "split"): string;
+    getAsyncApi?(): Promise<AsyncApiDocument | null>;
+    getEntityGraph?(): Promise<AsyncApiEntityGraph | null>;
+}
+export interface PluginInstance<TOptions extends Record<string, unknown> = Record<string, unknown>> {
+    name: string;
+    options: TOptions;
+    pre?: string[];
+    post?: string[];
+    resolveName?(this: PluginContext, name: string, type?: "file" | "type"): string | undefined;
+    resolvePath?(this: PluginContext, baseName: string, mode?: "single" | "split"): string | undefined;
+    inject?(this: PluginContext, context: PluginContext): Record<string, unknown> | void;
+    install(this: PluginContext, context: PluginContext): Promise<void> | void;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@rvct/asyncapi",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json && tsc-alias -p tsconfig.json -f",
+    "lint": "eslint . && tsc --noEmit -p tsconfig.json",
+    "format": "eslint --fix . && prettier --write .",
+    "format.check": "eslint . && prettier --check .",
+    "test": "npm run test:unit && npm run test:smoke",
+    "test:unit": "vitest run --config vitest.config.ts",
+    "test:smoke": "npm run build && vitest run --config vitest.smoke.config.ts"
+  },
+  "description": "Config-driven AsyncAPI to JSON Schema, TypeScript, and Zod generator",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ravecat/asyncapi.git"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./cli": "./dist/cli.js",
+    "./config": "./dist/config.js",
+    "./plugins/asyncapi": "./dist/plugins/asyncapi.js",
+    "./plugins/typescript": "./dist/plugins/typescript.js",
+    "./plugins/zod": "./dist/plugins/zod.js"
+  },
+  "bin": {
+    "asyncapi-codegen": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "asyncapi",
+    "codegen",
+    "typescript",
+    "zod"
+  ],
+  "dependencies": {
+    "@asyncapi/parser": "^3.6.0",
+    "json-schema-to-typescript": "^15.0.4",
+    "json-schema-to-zod": "^2.7.0",
+    "prettier": "^3.6.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@types/node": "^25.6.0",
+    "eslint": "^9.39.1",
+    "semantic-release": "25.0.3",
+    "tsc-alias": "^1.8.16",
+    "typescript": "^6.0.2",
+    "typescript-eslint": "^8.58.1",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.2.4"
+  }
+}