@alagoni97/cli 0.72.1

package/dist/browser/adapters/output.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserOutput = void 0;
+class BrowserOutput {
+    files = new Map();
+    /**
+     * Write a file to memory.
+     * @param path - The file path (e.g., 'src/models/User.ts')
+     * @param content - The file content
+     */
+    async write(path, content) {
+        this.files.set(path, content);
+    }
+    /**
+     * No-op for browser - directories are virtual.
+     */
+    async mkdir(_dirPath, _options) {
+        // No-op - directories are virtual in memory
+    }
+    /**
+     * Get all file paths that were written.
+     * Implements OutputAdapter interface.
+     */
+    getWrittenFiles() {
+        return Array.from(this.files.keys());
+    }
+    /**
+     * Get all files with their content.
+     * Implements OutputAdapter interface.
+     */
+    getAllFiles() {
+        const result = {};
+        for (const [path, content] of this.files) {
+            result[path] = content;
+        }
+        return result;
+    }
+    /**
+     * Read a file from memory.
+     * @param path - The file path
+     * @returns The file content, or undefined if not found
+     */
+    read(path) {
+        return this.files.get(path);
+    }
+    /**
+     * Get all files as a Record.
+     * @deprecated Use getAllFiles() instead for OutputAdapter compatibility
+     * @returns A copy of all files as Record<path, content>
+     */
+    getAll() {
+        return this.getAllFiles();
+    }
+    /**
+     * Clear all files from memory.
+     */
+    clear() {
+        this.files.clear();
+    }
+    /**
+     * Check if a file exists.
+     * @param path - The file path
+     * @returns True if the file exists
+     */
+    has(path) {
+        return this.files.has(path);
+    }
+    /**
+     * Delete a specific file.
+     * @param path - The file path
+     * @returns True if the file was deleted, false if it didn't exist
+     */
+    delete(path) {
+        return this.files.delete(path);
+    }
+    /**
+     * Get all file paths.
+     * @deprecated Use getWrittenFiles() instead for OutputAdapter compatibility
+     * @returns Array of file paths
+     */
+    getPaths() {
+        return this.getWrittenFiles();
+    }
+    /**
+     * Get the number of files.
+     */
+    get size() {
+        return this.files.size;
+    }
+}
+exports.BrowserOutput = BrowserOutput;

package/dist/browser/config.d.ts

@@ -0,0 +1,18 @@
+import { TheCodegenConfiguration } from '../codegen/types';
+/**
+ * Parse a configuration string into a validated configuration object.
+ *
+ * @param configString - The configuration as a string (JSON or YAML)
+ * @param format - The format of the string ('json' or 'yaml')
+ * @returns The validated configuration object
+ * @throws Error if parsing or validation fails
+ */
+export declare function parseConfig(configString: string, format: 'json' | 'yaml'): TheCodegenConfiguration;
+/**
+ * Serialize a configuration object to a string.
+ *
+ * @param config - The configuration object
+ * @param format - The output format ('json' or 'yaml')
+ * @returns The configuration as a string
+ */
+export declare function serializeConfig(config: TheCodegenConfiguration, format: 'json' | 'yaml'): string;

package/dist/browser/config.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeConfig = exports.parseConfig = void 0;
+/**
+ * Parse configuration from string for browser environments.
+ * Replaces cosmiconfig filesystem search with direct string parsing.
+ */
+const yaml_1 = require("yaml");
+const types_1 = require("../codegen/types");
+/**
+ * Parse a configuration string into a validated configuration object.
+ *
+ * @param configString - The configuration as a string (JSON or YAML)
+ * @param format - The format of the string ('json' or 'yaml')
+ * @returns The validated configuration object
+ * @throws Error if parsing or validation fails
+ */
+function parseConfig(configString, format) {
+    let rawConfig;
+    // Parse the string based on format
+    try {
+        if (format === 'json') {
+            rawConfig = JSON.parse(configString);
+        }
+        else {
+            rawConfig = (0, yaml_1.parse)(configString);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown parse error';
+        throw new Error(`Failed to parse ${format} configuration: ${message}`);
+    }
+    // Validate with Zod schema
+    const result = types_1.zodTheCodegenConfiguration.safeParse(rawConfig);
+    if (!result.success) {
+        const errors = result.error.issues
+            .map((issue) => `  - ${issue.path.join('.')}: ${issue.message}`)
+            .join('\n');
+        throw new Error(`Invalid configuration:\n${errors}`);
+    }
+    return result.data;
+}
+exports.parseConfig = parseConfig;
+/**
+ * Serialize a configuration object to a string.
+ *
+ * @param config - The configuration object
+ * @param format - The output format ('json' or 'yaml')
+ * @returns The configuration as a string
+ */
+function serializeConfig(config, format) {
+    if (format === 'json') {
+        return JSON.stringify(config, null, 2);
+    }
+    // For YAML, we'd need to import stringify from yaml
+    // For now, default to JSON
+    return JSON.stringify(config, null, 2);
+}
+exports.serializeConfig = serializeConfig;

package/dist/browser/generate.d.ts

@@ -0,0 +1,20 @@
+import { TheCodegenConfiguration } from '../codegen/types';
+export interface BrowserGenerateInput {
+    /** The API specification as a string (YAML or JSON) */
+    spec: string;
+    /** The format of the specification */
+    specFormat: 'asyncapi' | 'openapi' | 'jsonschema';
+    /** The codegen configuration */
+    config: TheCodegenConfiguration;
+}
+export interface BrowserGenerateOutput {
+    /** Generated files as Record<path, content> */
+    files: Record<string, string>;
+    /** Any errors that occurred during generation */
+    errors: string[];
+}
+/**
+ * Generate code from an API specification in the browser.
+ * This is the main entry point for browser-based code generation.
+ */
+export declare function generate(input: BrowserGenerateInput): Promise<BrowserGenerateOutput>;

package/dist/browser/generate.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = void 0;
+/**
+ * Main browser generation function.
+ * Uses the shared rendering pipeline for in-memory code generation.
+ * No filesystem I/O - returns generated files as data.
+ */
+const yaml_1 = require("yaml");
+const openapi_parser_1 = require("@readme/openapi-parser");
+const errors_1 = require("../codegen/errors");
+const parser_1 = require("./parser");
+const jsonschema_1 = require("../codegen/inputs/jsonschema");
+const types_1 = require("../codegen/types");
+const configurations_1 = require("../codegen/configurations");
+const renderer_1 = require("../codegen/renderer");
+/**
+ * Generate code from an API specification in the browser.
+ * This is the main entry point for browser-based code generation.
+ */
+// eslint-disable-next-line sonarjs/cognitive-complexity
+async function generate(input) {
+    const errors = [];
+    const files = {};
+    try {
+        // Validate and realize configuration (adds default generators for dependencies)
+        const configResult = types_1.zodTheCodegenConfiguration.safeParse(input.config);
+        if (!configResult.success) {
+            errors.push(`Invalid configuration: ${configResult.error.issues.map((i) => i.message).join(', ')}`);
+            return { files, errors };
+        }
+        // Realize configuration to add dependency generators and merge with defaults
+        const config = (0, configurations_1.realizeConfiguration)(configResult.data);
+        // Parse the specification
+        let asyncapiDocument;
+        let openapiDocument;
+        let jsonSchemaDocument;
+        // Validate spec is not empty
+        if (!input.spec || input.spec.trim() === '') {
+            errors.push('Empty specification provided');
+            return { files, errors };
+        }
+        switch (input.specFormat) {
+            case 'asyncapi':
+                try {
+                    asyncapiDocument = await (0, parser_1.loadAsyncapiFromMemoryBrowser)(input.spec);
+                }
+                catch (error) {
+                    // Include details from CodegenError if available
+                    let errorMsg = error instanceof Error ? error.message : String(error);
+                    if (error instanceof errors_1.CodegenError && error.details) {
+                        errorMsg += `\n${error.details}`;
+                    }
+                    errors.push(`Failed to parse AsyncAPI spec: ${errorMsg}`);
+                    return { files, errors };
+                }
+                break;
+            case 'openapi':
+                try {
+                    openapiDocument = await parseOpenAPIFromMemory(input.spec);
+                }
+                catch (error) {
+                    errors.push(`Failed to parse OpenAPI spec: ${error instanceof Error ? error.message : String(error)}`);
+                    return { files, errors };
+                }
+                break;
+            case 'jsonschema':
+                try {
+                    const parsed = parseSpecString(input.spec);
+                    jsonSchemaDocument = (0, jsonschema_1.loadJsonSchemaFromMemory)(parsed);
+                }
+                catch (error) {
+                    errors.push(`Failed to parse JSON Schema: ${error instanceof Error ? error.message : String(error)}`);
+                    return { files, errors };
+                }
+                break;
+            default:
+                errors.push(`Unknown spec format: ${input.specFormat}`);
+                return { files, errors };
+        }
+        // Cast the browser shim's AsyncAPIDocumentInterface to the Node.js version
+        // At runtime, the objects are compatible - this is just for TypeScript
+        const nodeAsyncapiDocument = asyncapiDocument;
+        // Build the context for the shared rendering pipeline
+        // Use root-level virtual path so output paths don't get 'browser/' prefix
+        const context = {
+            configuration: config,
+            configFilePath: '/virtual-config.mjs', // Virtual path for browser (root level)
+            documentPath: '/virtual-spec',
+            asyncapiDocument: nodeAsyncapiDocument,
+            openapiDocument,
+            jsonSchemaDocument
+        };
+        // Use the shared rendering pipeline
+        const graph = (0, renderer_1.determineRenderGraph)(context);
+        const result = await (0, renderer_1.renderGraph)(context, graph);
+        // Convert GeneratedFile[] to Record<string, string>
+        for (const file of result.files) {
+            files[file.path] = file.content;
+        }
+    }
+    catch (error) {
+        errors.push(`Generation failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return { files, errors };
+}
+exports.generate = generate;
+/**
+ * Parse an OpenAPI spec from a string.
+ */
+async function parseOpenAPIFromMemory(specString) {
+    const document = parseSpecString(specString);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const parsedDocument = await (0, openapi_parser_1.parse)(document);
+    return await (0, openapi_parser_1.dereference)(parsedDocument);
+}
+/**
+ * Parse a spec string (YAML or JSON) into an object.
+ */
+function parseSpecString(specString) {
+    // Try JSON first
+    try {
+        return JSON.parse(specString);
+    }
+    catch {
+        // Fall back to YAML
+        return (0, yaml_1.parse)(specString);
+    }
+}

package/dist/browser/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Browser bundle entry point.
+ * Exports browser-compatible generation functions for use in web applications.
+ *
+ * This module provides:
+ * - generate() - Main function to generate code from API specs
+ * - parseConfig() - Parse configuration from JSON/YAML strings
+ * - BrowserOutput - In-memory file storage
+ * - MemoryAdapter - Shared in-memory output adapter
+ */
+export { generate } from './generate';
+export type { BrowserGenerateInput, BrowserGenerateOutput } from './generate';
+export { parseConfig, serializeConfig } from './config';
+export { BrowserOutput } from './adapters/output';
+export { MemoryAdapter } from '../codegen/output';
+export type { OutputAdapter } from '../codegen/output';
+export type { TheCodegenConfiguration } from '../codegen/types';

package/dist/browser/index.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Browser bundle entry point.
+ * Exports browser-compatible generation functions for use in web applications.
+ *
+ * This module provides:
+ * - generate() - Main function to generate code from API specs
+ * - parseConfig() - Parse configuration from JSON/YAML strings
+ * - BrowserOutput - In-memory file storage
+ * - MemoryAdapter - Shared in-memory output adapter
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryAdapter = exports.BrowserOutput = exports.serializeConfig = exports.parseConfig = exports.generate = void 0;
+// Main generation function
+var generate_1 = require("./generate");
+Object.defineProperty(exports, "generate", { enumerable: true, get: function () { return generate_1.generate; } });
+// Configuration parsing
+var config_1 = require("./config");
+Object.defineProperty(exports, "parseConfig", { enumerable: true, get: function () { return config_1.parseConfig; } });
+Object.defineProperty(exports, "serializeConfig", { enumerable: true, get: function () { return config_1.serializeConfig; } });
+// Adapters for direct usage
+var output_1 = require("./adapters/output");
+Object.defineProperty(exports, "BrowserOutput", { enumerable: true, get: function () { return output_1.BrowserOutput; } });
+// Re-export shared MemoryAdapter for direct usage
+var output_2 = require("../codegen/output");
+Object.defineProperty(exports, "MemoryAdapter", { enumerable: true, get: function () { return output_2.MemoryAdapter; } });

package/dist/browser/parser.d.ts

@@ -0,0 +1,9 @@
+import { AsyncAPIDocumentInterface } from './shims/asyncapi-parser';
+/**
+ * Load an AsyncAPI document from a string in the browser environment.
+ * Uses the browser-specific parser that properly handles $ref resolution.
+ *
+ * @param input - The AsyncAPI document as a YAML or JSON string
+ * @returns The parsed AsyncAPI document
+ */
+export declare function loadAsyncapiFromMemoryBrowser(input: string): Promise<AsyncAPIDocumentInterface>;

package/dist/browser/parser.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAsyncapiFromMemoryBrowser = void 0;
+/**
+ * Browser-specific AsyncAPI parser.
+ *
+ * This module provides the same interface as the Node.js parser but is designed
+ * to work correctly when bundled for browser environments.
+ *
+ * When bundled with esbuild for browser:
+ * - Uses the shim which loads @asyncapi/parser/browser with proper $ref resolution
+ *
+ * When running in Node.js (tests):
+ * - Uses the regular @asyncapi/parser which works correctly
+ *
+ * Reference: https://github.com/asyncapi/parser-js#using-in-the-browserspa-applications
+ */
+const errors_1 = require("../codegen/errors");
+const asyncapi_parser_1 = require("./shims/asyncapi-parser");
+/**
+ * Browser parser instance.
+ * Configured without linting rules for faster parsing.
+ * The Parser is loaded from our shim which handles browser vs Node.js environments.
+ */
+const parser = new asyncapi_parser_1.Parser({
+    ruleset: {
+        core: false,
+        recommended: false
+    }
+});
+/**
+ * Load an AsyncAPI document from a string in the browser environment.
+ * Uses the browser-specific parser that properly handles $ref resolution.
+ *
+ * @param input - The AsyncAPI document as a YAML or JSON string
+ * @returns The parsed AsyncAPI document
+ */
+async function loadAsyncapiFromMemoryBrowser(input) {
+    const result = await parser.parse(input);
+    // Check for errors (severity 0 = error)
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const errors = result.diagnostics?.filter((d) => d.severity === 0);
+    if (errors && errors.length > 0) {
+        throw (0, errors_1.createInputDocumentError)({
+            inputPath: 'memory',
+            inputType: 'asyncapi',
+            errorMessage: JSON.stringify(errors, null, 2)
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (!result.document) {
+        throw (0, errors_1.createInputDocumentError)({
+            inputPath: 'memory',
+            inputType: 'asyncapi',
+            errorMessage: 'Failed to parse AsyncAPI document'
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return result.document;
+}
+exports.loadAsyncapiFromMemoryBrowser = loadAsyncapiFromMemoryBrowser;

package/dist/browser/shims/asyncapi-parser.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Shim for @asyncapi/parser that works in both Node.js and browser environments.
+ *
+ * - In Node.js (tests): Uses the regular @asyncapi/parser package
+ * - In browser (bundled): Uses @asyncapi/parser/browser which has proper $ref resolution
+ *
+ * The esbuild plugin (asyncapiParserBrowserPlugin) transforms the browser bundle
+ * to properly export the Parser class.
+ */
+export interface AsyncAPIDocumentInterface {
+    version(): string;
+    info(): unknown;
+    servers(): unknown;
+    channels(): unknown;
+    operations(): unknown;
+    messages(): unknown;
+    schemas(): unknown;
+    securitySchemes(): unknown;
+    components(): unknown;
+    allServers(): unknown;
+    allChannels(): unknown;
+    allOperations(): unknown;
+    allMessages(): unknown;
+    allSchemas(): unknown;
+    extensions(): unknown;
+    json<T = any>(): T;
+}
+declare let ParserClass: any;
+export declare const Parser: any;
+export default ParserClass;

package/dist/browser/shims/asyncapi-parser.js

@@ -0,0 +1,52 @@
+"use strict";
+/* eslint-disable no-undef, no-console */
+/**
+ * Shim for @asyncapi/parser that works in both Node.js and browser environments.
+ *
+ * - In Node.js (tests): Uses the regular @asyncapi/parser package
+ * - In browser (bundled): Uses @asyncapi/parser/browser which has proper $ref resolution
+ *
+ * The esbuild plugin (asyncapiParserBrowserPlugin) transforms the browser bundle
+ * to properly export the Parser class.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+// Detect environment - if we have window/document, we're in browser
+const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let ParserClass;
+if (isBrowser) {
+    // In browser: use the browser bundle
+    // The esbuild plugin transforms this to properly export Parser
+    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+    const browserBundle = require('@asyncapi/parser/browser');
+    // Debug: log the bundle structure to help diagnose issues
+    if (typeof console !== 'undefined' && console.debug) {
+        console.debug('[AsyncAPI Parser Shim] Bundle keys:', Object.keys(browserBundle));
+        console.debug('[AsyncAPI Parser Shim] Parser type:', typeof browserBundle.Parser);
+        console.debug('[AsyncAPI Parser Shim] default type:', typeof browserBundle.default);
+        if (browserBundle.default) {
+            console.debug('[AsyncAPI Parser Shim] default.Parser type:', typeof browserBundle.default?.Parser);
+        }
+    }
+    ParserClass =
+        browserBundle.Parser ||
+            browserBundle.default?.Parser ||
+            browserBundle.default;
+    if (!ParserClass || typeof ParserClass !== 'function') {
+        console.error('AsyncAPI Parser browser bundle structure:', Object.keys(browserBundle));
+        console.error('Parser value:', browserBundle.Parser);
+        console.error('default value:', browserBundle.default);
+        throw new Error(`Could not find Parser constructor in @asyncapi/parser/browser bundle. ` +
+            `Parser type: ${typeof ParserClass}`);
+    }
+}
+else {
+    // In Node.js: use the regular parser
+    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
+    const parserModule = require('@asyncapi/parser');
+    ParserClass = parserModule.Parser;
+}
+// Export Parser as both named and default export
+exports.Parser = ParserClass;
+exports.default = ParserClass;