@alagoni97/cli 0.72.1

package/dist/codegen/output/memory.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryAdapter = void 0;
+/**
+ * MemoryAdapter stores files in memory using a Map.
+ * Used in browser context for in-memory code generation.
+ */
+class MemoryAdapter {
+    files = new Map();
+    basePath;
+    constructor(options) {
+        // Normalize basePath - remove trailing slashes
+        this.basePath = (options?.basePath ?? '').replace(/\/+$/, '');
+    }
+    /**
+     * Write content to memory.
+     */
+    async write(filePath, content) {
+        const resolvedPath = this.resolvePath(filePath);
+        this.files.set(resolvedPath, content);
+    }
+    /**
+     * No-op for memory adapter - directories are virtual.
+     */
+    async mkdir(_dirPath, _options) {
+        // No-op - directories are virtual in memory
+    }
+    /**
+     * Get all file paths that were written.
+     */
+    getWrittenFiles() {
+        return [...this.files.keys()];
+    }
+    /**
+     * Get all files with their content.
+     */
+    getAllFiles() {
+        const result = {};
+        for (const [filePath, content] of this.files) {
+            result[filePath] = content;
+        }
+        return result;
+    }
+    /**
+     * Read a file from memory.
+     * @param filePath - The file path
+     * @returns The file content, or undefined if not found
+     */
+    read(filePath) {
+        return this.files.get(this.resolvePath(filePath));
+    }
+    /**
+     * Clear all files from memory.
+     */
+    clear() {
+        this.files.clear();
+    }
+    /**
+     * Check if a file exists.
+     */
+    has(filePath) {
+        return this.files.has(this.resolvePath(filePath));
+    }
+    /**
+     * Get the number of files.
+     */
+    get size() {
+        return this.files.size;
+    }
+    /**
+     * Resolve a file path with the base path.
+     */
+    resolvePath(filePath) {
+        if (!this.basePath) {
+            return filePath;
+        }
+        // Normalize to avoid double slashes
+        return `${this.basePath}/${filePath}`.replace(/\/+/g, '/');
+    }
+}
+exports.MemoryAdapter = MemoryAdapter;

package/dist/codegen/output/modelina.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Modelina integration for pure-core code generation.
+ * Generates models in-memory and returns them as GeneratedFile[].
+ * No I/O is performed - writing files is handled by the CLI layer.
+ */
+import { TypeScriptFileGenerator, TypeScriptRenderCompleteModelOptions, OutputModel } from '@asyncapi/modelina';
+import { GeneratedFile } from '../types';
+export interface GenerateModelsArgs {
+    /** The Modelina generator instance */
+    generator: TypeScriptFileGenerator;
+    /** The input schema (JSON Schema or any format Modelina accepts) */
+    input: unknown;
+    /** The output path to use for file names (e.g., 'src/models') */
+    outputPath: string;
+    /** Optional render options */
+    options?: Partial<TypeScriptRenderCompleteModelOptions>;
+}
+export interface GenerateModelsResult {
+    /** The generated models */
+    models: OutputModel[];
+    /** Generated files with path and content */
+    files: GeneratedFile[];
+}
+/**
+ * Generate models using Modelina.
+ * Returns files as data - no I/O is performed.
+ *
+ * @returns The generated models and files
+ */
+export declare function generateModels({ generator, input, outputPath, options }: GenerateModelsArgs): Promise<GenerateModelsResult>;

package/dist/codegen/output/modelina.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModels = void 0;
+/**
+ * Generate models using Modelina.
+ * Returns files as data - no I/O is performed.
+ *
+ * @returns The generated models and files
+ */
+async function generateModels({ generator, input, outputPath, options = {} }) {
+    const files = [];
+    // Use Modelina's generateCompleteModels() which returns OutputModel[] with rendered content
+    // This is the same method used by generateToFiles() internally, but without writing to disk
+    const models = await generator.generateCompleteModels(input, {
+        exportType: options.exportType ?? 'named'
+    });
+    // Filter out any models that weren't successfully generated
+    const validModels = models.filter((model) => model.modelName !== '');
+    // Collect files as data (no I/O)
+    for (const model of validModels) {
+        const fileName = `${model.modelName}.ts`;
+        const filePath = `${outputPath}/${fileName}`;
+        files.push({ path: filePath, content: model.result });
+    }
+    return {
+        models: validModels,
+        files
+    };
+}
+exports.generateModels = generateModels;

package/dist/codegen/output/types.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Output adapter types for abstracting file output operations.
+ * Allows generators to work in both CLI (filesystem) and browser (memory) environments.
+ */
+/**
+ * Abstract interface for file output operations.
+ * Allows generators to work in both CLI (filesystem) and browser (memory) environments.
+ */
+export interface OutputAdapter {
+    /**
+     * Write content to a file path.
+     * @param filePath - The file path to write to (relative or absolute)
+     * @param content - The content to write
+     */
+    write(filePath: string, content: string): Promise<void>;
+    /**
+     * Create a directory.
+     * @param dirPath - The directory path to create
+     * @param options - Options (e.g., recursive)
+     */
+    mkdir(dirPath: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    /**
+     * Get all written files (for tracking/reporting).
+     * @returns Array of file paths that were written
+     */
+    getWrittenFiles(): string[];
+    /**
+     * Get all files with their content.
+     * For FileSystemAdapter, this returns an empty object (use getWrittenFiles() for paths).
+     * For MemoryAdapter, this returns all files with their content.
+     * @returns Record of path to content
+     */
+    getAllFiles(): Record<string, string>;
+}
+/**
+ * Options for OutputAdapter implementations.
+ */
+export interface OutputAdapterOptions {
+    /**
+     * Base path for resolving relative paths.
+     * For FileSystemAdapter: directory on disk
+     * For MemoryAdapter: prefix for virtual paths
+     */
+    basePath?: string;
+}

package/dist/codegen/output/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Output adapter types for abstracting file output operations.
+ * Allows generators to work in both CLI (filesystem) and browser (memory) environments.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/codegen/renderer.d.ts

@@ -0,0 +1,13 @@
+import { GenerationResult, Generators, GeneratorsInternal, RenderTypes, RunGeneratorContext } from './types';
+import Graph from 'graphology';
+export type Node = {
+    generator: Generators;
+};
+type GraphType = Graph<Node>;
+export declare function renderGenerator(generator: GeneratorsInternal, context: RunGeneratorContext, renderedContext: Record<string, unknown>): Promise<RenderTypes>;
+export declare function determineRenderGraph(context: RunGeneratorContext): GraphType;
+/**
+ * Recursively go over all nodes and render those that are ready to be rendered (no dependencies that have not been rendered) and recursively do it until no nodes are left
+ */
+export declare function renderGraph(context: RunGeneratorContext, graph: GraphType): Promise<GenerationResult>;
+export {};

package/dist/codegen/renderer.js

@@ -0,0 +1,309 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderGraph = exports.determineRenderGraph = exports.renderGenerator = void 0;
+const LoggingInterface_1 = require("../LoggingInterface");
+const generators_1 = require("./generators");
+const path_1 = __importDefault(require("path"));
+const graphology_1 = __importDefault(require("graphology"));
+const utils_1 = require("./utils");
+const models_1 = require("./generators/typescript/models");
+const errors_1 = require("./errors");
+//eslint-disable-next-line sonarjs/cognitive-complexity
+async function renderGenerator(generator, context, renderedContext) {
+    const { configuration, asyncapiDocument, openapiDocument, jsonSchemaDocument, configFilePath } = context;
+    const outputPath = path_1.default.resolve(path_1.default.dirname(configFilePath), generator.outputPath ?? '');
+    const language = generator.language
+        ? generator.language
+        : configuration.language;
+    LoggingInterface_1.Logger.debug(`Generator ${generator.id}: outputPath=${outputPath}, language=${language}, preset=${generator.preset}`);
+    // Check if this generator is compatible with the input type
+    if (configuration.inputType === 'jsonschema' &&
+        generator.preset !== 'models' &&
+        generator.preset !== 'custom') {
+        throw (0, errors_1.createUnsupportedPresetForInputError)({
+            preset: generator.preset,
+            inputType: 'jsonschema',
+            supportedPresets: ['models', 'custom']
+        });
+    }
+    switch (generator.preset) {
+        case 'payloads': {
+            switch (language) {
+                case 'typescript': {
+                    return (0, generators_1.generateTypescriptPayload)({
+                        asyncapiDocument,
+                        openapiDocument,
+                        generator: {
+                            ...generator,
+                            outputPath
+                        },
+                        config: configuration,
+                        inputType: configuration.inputType,
+                        dependencyOutputs: renderedContext
+                    });
+                }
+                default: {
+                    throw (0, errors_1.createUnsupportedLanguageError)({
+                        preset: 'payloads',
+                        language: language ?? 'unknown'
+                    });
+                }
+            }
+        }
+        case 'parameters': {
+            switch (language) {
+                case 'typescript': {
+                    return (0, generators_1.generateTypescriptParameters)({
+                        generator: {
+                            ...generator,
+                            outputPath
+                        },
+                        config: configuration,
+                        inputType: configuration.inputType,
+                        asyncapiDocument,
+                        openapiDocument,
+                        dependencyOutputs: renderedContext
+                    });
+                }
+                default: {
+                    throw (0, errors_1.createUnsupportedLanguageError)({
+                        preset: 'parameters',
+                        language: language ?? 'unknown'
+                    });
+                }
+            }
+        }
+        case 'headers': {
+            switch (language) {
+                case 'typescript': {
+                    return (0, generators_1.generateTypescriptHeaders)({
+                        asyncapiDocument,
+                        openapiDocument,
+                        generator: {
+                            ...generator,
+                            outputPath
+                        },
+                        config: configuration,
+                        inputType: configuration.inputType,
+                        dependencyOutputs: renderedContext
+                    });
+                }
+                default: {
+                    throw (0, errors_1.createUnsupportedLanguageError)({
+                        preset: 'headers',
+                        language: language ?? 'unknown'
+                    });
+                }
+            }
+        }
+        case 'types': {
+            switch (language) {
+                case 'typescript': {
+                    return (0, generators_1.generateTypescriptTypes)({
+                        asyncapiDocument,
+                        openapiDocument,
+                        generator: {
+                            ...generator,
+                            outputPath
+                        },
+                        config: configuration,
+                        inputType: configuration.inputType,
+                        dependencyOutputs: renderedContext
+                    });
+                }
+                default: {
+                    throw (0, errors_1.createUnsupportedLanguageError)({
+                        preset: 'types',
+                        language: language ?? 'unknown'
+                    });
+                }
+            }
+        }
+        case 'channels': {
+            switch (language) {
+                case 'typescript': {
+                    return (0, generators_1.generateTypeScriptChannels)({
+                        asyncapiDocument,
+                        openapiDocument,
+                        generator: {
+                            ...generator,
+                            outputPath
+                        },
+                        config: configuration,
+                        inputType: configuration.inputType,
+                        dependencyOutputs: renderedContext
+                    });
+                }
+                default: {
+                    throw (0, errors_1.createUnsupportedLanguageError)({
+                        preset: 'channels',
+                        language: language ?? 'unknown'
+                    });
+                }
+            }
+        }
+        case 'client': {
+            switch (language) {
+                case 'typescript': {
+                    return (0, generators_1.generateTypeScriptClient)({
+                        asyncapiDocument,
+                        openapiDocument,
+                        generator: {
+                            ...generator,
+                            outputPath
+                        },
+                        config: configuration,
+                        inputType: configuration.inputType,
+                        dependencyOutputs: renderedContext
+                    });
+                }
+                default: {
+                    throw (0, errors_1.createUnsupportedLanguageError)({
+                        preset: 'client',
+                        language: language ?? 'unknown'
+                    });
+                }
+            }
+        }
+        case 'models': {
+            switch (language) {
+                case 'typescript': {
+                    return (0, models_1.generateTypescriptModels)({
+                        asyncapiDocument,
+                        openapiDocument,
+                        jsonSchemaDocument,
+                        generator: {
+                            ...generator,
+                            outputPath
+                        },
+                        config: configuration,
+                        inputType: configuration.inputType,
+                        dependencyOutputs: renderedContext
+                    });
+                }
+                default: {
+                    throw (0, errors_1.createUnsupportedLanguageError)({
+                        preset: 'models',
+                        language: language ?? 'unknown'
+                    });
+                }
+            }
+        }
+        case 'custom': {
+            return generator.renderFunction({
+                asyncapiDocument,
+                openapiDocument,
+                jsonSchemaDocument,
+                inputType: configuration.inputType,
+                dependencyOutputs: renderedContext,
+                generator
+            }, generator.options);
+        }
+        // No default
+    }
+}
+exports.renderGenerator = renderGenerator;
+function determineRenderGraph(context) {
+    const { configuration } = context;
+    const duplicateGenerators = (0, utils_1.findDuplicatesInArray)(context.configuration.generators, 'id');
+    if (duplicateGenerators.length > 0) {
+        throw (0, errors_1.createDuplicateGeneratorIdError)({ duplicateIds: duplicateGenerators });
+    }
+    const graph = new graphology_1.default({ allowSelfLoops: true, type: 'directed' });
+    for (const generator of configuration.generators) {
+        graph.addNode(generator.id, { generator });
+    }
+    for (const generator of configuration.generators) {
+        for (const dependency of generator.dependencies ?? []) {
+            graph.addDirectedEdge(dependency, generator.id);
+        }
+    }
+    if (graph.selfLoopCount !== 0) {
+        throw (0, errors_1.createCircularDependencyError)();
+    }
+    return graph;
+}
+exports.determineRenderGraph = determineRenderGraph;
+/**
+ * Extract files from render result.
+ * Generators now return `files: GeneratedFile[]` instead of `filesWritten: string[]`.
+ */
+function extractFilesFromResult(result) {
+    // Type guard to check for files property
+    if (result &&
+        typeof result === 'object' &&
+        'files' in result &&
+        Array.isArray(result.files)) {
+        return result.files;
+    }
+    return [];
+}
+/**
+ * Recursively go over all nodes and render those that are ready to be rendered (no dependencies that have not been rendered) and recursively do it until no nodes are left
+ */
+// eslint-disable-next-line sonarjs/cognitive-complexity
+async function renderGraph(context, graph) {
+    const startTime = Date.now();
+    const renderedContext = {};
+    const generatorResults = [];
+    const recursivelyRenderGenerators = async (nodesToRender, previousCount) => {
+        const count = nodesToRender.length;
+        if (previousCount === count) {
+            throw (0, errors_1.createCircularDependencyError)();
+        }
+        const nodesToRenderNext = [];
+        const alreadyRenderedNodes = Object.keys(renderedContext);
+        for (const nodeEntry of nodesToRender) {
+            const dependencies = graph.inEdgeEntries(nodeEntry.node);
+            //check if all dependencies have been rendered, if not, wait until later
+            let allRendered = true;
+            for (const dependency of dependencies) {
+                if (!alreadyRenderedNodes.includes(dependency.source)) {
+                    allRendered = false;
+                    break;
+                }
+            }
+            if (allRendered) {
+                const generatorStartTime = Date.now();
+                const generator = nodeEntry.attributes.generator;
+                LoggingInterface_1.Logger.updateSpinner(`Generating ${generator.preset}...`);
+                const result = await renderGenerator(generator, context, renderedContext);
+                renderedContext[nodeEntry.node] = result;
+                // Extract files from result
+                const files = extractFilesFromResult(result);
+                // Record generator result with files
+                generatorResults.push({
+                    id: generator.id,
+                    preset: generator.preset,
+                    files,
+                    duration: Date.now() - generatorStartTime
+                });
+            }
+            else {
+                nodesToRenderNext.push(nodeEntry);
+            }
+        }
+        if (nodesToRenderNext.length > 0) {
+            await recursivelyRenderGenerators(nodesToRenderNext, count);
+        }
+    };
+    await recursivelyRenderGenerators([...graph.nodeEntries()]);
+    // Collect all files (deduplicated by path)
+    const allFilesMap = new Map();
+    for (const result of generatorResults) {
+        for (const file of result.files) {
+            // Later files with same path override earlier ones
+            allFilesMap.set(file.path, file);
+        }
+    }
+    const allFiles = Array.from(allFilesMap.values());
+    return {
+        generators: generatorResults,
+        files: allFiles,
+        totalDuration: Date.now() - startTime
+    };
+}
+exports.renderGraph = renderGraph;

package/dist/codegen/schemaPostProcess.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Post-processors for `zod-to-json-schema`. Splits a single Zod source-of-truth
+ * (markdown-enabled `.describe()` text) into two JSON Schema variants:
+ * a clean one (markdown links stripped) and a markdown one (description
+ * renamed to `markdownDescription` so Monaco renders it as markdown).
+ */
+import type { PostProcessCallback } from 'zod-to-json-schema';
+/**
+ * Replace markdown links of the form `[text](https://...)` with their link
+ * text. Leaves plain bracketed text (e.g. `[string]`) untouched because the
+ * expression requires `(http://` or `(https://` immediately after.
+ */
+export declare function stripMarkdownLinks(text: string): string;
+/**
+ * Strip markdown link wrappers from a JSON Schema node's description.
+ * Used to produce the canonical schema consumed by CLI validation and IDEs
+ * that don't understand markdown.
+ */
+export declare const postProcessClean: PostProcessCallback;
+/**
+ * Rename a JSON Schema node's `description` to `markdownDescription` so
+ * Monaco-based editors render the text as markdown (and links become
+ * clickable) in hover tooltips.
+ */
+export declare const postProcessMarkdown: PostProcessCallback;

package/dist/codegen/schemaPostProcess.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postProcessMarkdown = exports.postProcessClean = exports.stripMarkdownLinks = void 0;
+const MD_LINK_RE = /\[([^\]]+)\]\(https?:\/\/[^)]+\)/g;
+/**
+ * Replace markdown links of the form `[text](https://...)` with their link
+ * text. Leaves plain bracketed text (e.g. `[string]`) untouched because the
+ * expression requires `(http://` or `(https://` immediately after.
+ */
+function stripMarkdownLinks(text) {
+    return text.replace(MD_LINK_RE, '$1');
+}
+exports.stripMarkdownLinks = stripMarkdownLinks;
+/**
+ * Strip markdown link wrappers from a JSON Schema node's description.
+ * Used to produce the canonical schema consumed by CLI validation and IDEs
+ * that don't understand markdown.
+ */
+const postProcessClean = (out) => {
+    if (out && typeof out.description === 'string') {
+        out.description = stripMarkdownLinks(out.description);
+    }
+    return out;
+};
+exports.postProcessClean = postProcessClean;
+/**
+ * Rename a JSON Schema node's `description` to `markdownDescription` so
+ * Monaco-based editors render the text as markdown (and links become
+ * clickable) in hover tooltips.
+ */
+const postProcessMarkdown = (out) => {
+    if (out && typeof out.description === 'string') {
+        out.markdownDescription = out.description;
+        delete out.description;
+    }
+    return out;
+};
+exports.postProcessMarkdown = postProcessMarkdown;