@alagoni97/cli 0.72.1

package/dist/codegen/inputs/asyncapi/generators/types.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAsyncAPITypes = void 0;
+async function generateAsyncAPITypes(asyncapiDocument, generator) {
+    const allChannels = asyncapiDocument.allChannels().all();
+    const channelAddressUnion = allChannels
+        .map((channel) => {
+        return `'${channel.address()}'`;
+    })
+        .join(' | ');
+    let result = `export type Topics = ${channelAddressUnion};\n`;
+    // For version 3.x+ we generate additional topic ID types and helper functions
+    if (!asyncapiDocument.version().startsWith('2.')) {
+        const channelIdUnion = allChannels
+            .map((channel) => {
+            return `'${channel.id()}'`;
+        })
+            .join(' | ');
+        const channelIdSwitch = allChannels
+            .map((channel) => {
+            return `case '${channel.id()}':
+    return '${channel.address()}';`;
+        })
+            .join('\n  ');
+        const channelAddressSwitch = allChannels
+            .map((channel) => {
+            return `case '${channel.address()}':
+    return '${channel.id()}';`;
+        })
+            .join('\n  ');
+        const topicIdsPart = `export type TopicIds = ${channelIdUnion};\n`;
+        const toTopicIdsPart = `export function ToTopicIds(topic: Topics): TopicIds {
+  switch (topic) {
+    ${channelAddressSwitch}
+    default:
+      throw new Error('Unknown topic: ' + topic);
+  }
+}\n`;
+        const toTopicsPart = `export function ToTopics(topicId: TopicIds): Topics {
+  switch (topicId) {
+    ${channelIdSwitch}
+    default:
+      throw new Error('Unknown topic ID: ' + topicId);
+  }
+}\n`;
+        const topicsMap = `export const TopicsMap: Record<TopicIds, Topics> = {
+${allChannels
+            .map((channel) => {
+            return `  '${channel.id()}': '${channel.address()}'`;
+        })
+            .join(', \n')}
+};\n`;
+        result += topicIdsPart + toTopicIdsPart + toTopicsPart + topicsMap;
+    }
+    const filePath = `${generator.outputPath}/Types.ts`;
+    return {
+        result,
+        files: [{ path: filePath, content: result }]
+    };
+}
+exports.generateAsyncAPITypes = generateAsyncAPITypes;

package/dist/codegen/inputs/asyncapi/index.d.ts

@@ -0,0 +1 @@
+export { loadAsyncapi, loadAsyncapiDocument, loadAsyncapiFromMemory } from './parser';

package/dist/codegen/inputs/asyncapi/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAsyncapiFromMemory = exports.loadAsyncapiDocument = exports.loadAsyncapi = void 0;
+var parser_1 = require("./parser");
+Object.defineProperty(exports, "loadAsyncapi", { enumerable: true, get: function () { return parser_1.loadAsyncapi; } });
+Object.defineProperty(exports, "loadAsyncapiDocument", { enumerable: true, get: function () { return parser_1.loadAsyncapiDocument; } });
+Object.defineProperty(exports, "loadAsyncapiFromMemory", { enumerable: true, get: function () { return parser_1.loadAsyncapiFromMemory; } });

package/dist/codegen/inputs/asyncapi/parser.d.ts

@@ -0,0 +1,4 @@
+import { InputAuthConfig, RunGeneratorContext } from '../../types';
+export declare function loadAsyncapi(context: RunGeneratorContext): Promise<import("@asyncapi/parser").AsyncAPIDocumentInterface | undefined>;
+export declare function loadAsyncapiDocument(documentPath: string, auth?: InputAuthConfig): Promise<import("@asyncapi/parser").AsyncAPIDocumentInterface | undefined>;
+export declare function loadAsyncapiFromMemory(input: string): Promise<import("@asyncapi/parser").AsyncAPIDocumentInterface | undefined>;

package/dist/codegen/inputs/asyncapi/parser.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAsyncapiFromMemory = exports.loadAsyncapiDocument = exports.loadAsyncapi = void 0;
+const parser_1 = require("@asyncapi/parser");
+const avro_schema_parser_1 = require("@asyncapi/avro-schema-parser");
+const openapi_schema_parser_1 = require("@asyncapi/openapi-schema-parser");
+const raml_dt_schema_parser_1 = require("@asyncapi/raml-dt-schema-parser");
+const protobuf_schema_parser_1 = require("@asyncapi/protobuf-schema-parser");
+const fs_1 = require("fs");
+const LoggingInterface_1 = require("../../../LoggingInterface");
+const errors_1 = require("../../errors");
+const inputSource_1 = require("../../../utils/inputSource");
+const remoteFetch_1 = require("../../../utils/remoteFetch");
+const refResolvers_1 = require("../../../utils/refResolvers");
+const SHARED_PARSER_OPTIONS = {
+    ruleset: {
+        core: false,
+        recommended: false
+    },
+    schemaParsers: [
+        (0, avro_schema_parser_1.AvroSchemaParser)(),
+        (0, openapi_schema_parser_1.OpenAPISchemaParser)(),
+        (0, raml_dt_schema_parser_1.RamlDTSchemaParser)(),
+        (0, protobuf_schema_parser_1.ProtoBuffSchemaParser)()
+    ]
+};
+const sharedParser = new parser_1.Parser({ ...SHARED_PARSER_OPTIONS });
+function buildParserWithAuth(auth, rootUrl) {
+    return new parser_1.Parser({
+        ...SHARED_PARSER_OPTIONS,
+        __unstable: {
+            resolver: {
+                // The resolver shape comes from `@stoplight/spectral-ref-resolver`
+                // and accepts `string | undefined | Promise<string | undefined>`.
+                // Our resolver factory always returns a string.
+                resolvers: (0, refResolvers_1.createAsyncapiResolvers)(auth, { rootUrl })
+            }
+        }
+    });
+}
+async function loadAsyncapi(context) {
+    return loadAsyncapiDocument(context.documentPath, context.inputAuth);
+}
+exports.loadAsyncapi = loadAsyncapi;
+async function loadAsyncapiDocument(documentPath, auth) {
+    LoggingInterface_1.Logger.verbose(`Loading AsyncAPI document from ${documentPath}`);
+    let content;
+    if ((0, inputSource_1.isRemoteUrl)(documentPath)) {
+        const fetched = await (0, remoteFetch_1.fetchRemoteDocument)(documentPath, auth);
+        content = fetched.content;
+    }
+    else {
+        try {
+            content = (0, fs_1.readFileSync)(documentPath, 'utf-8');
+        }
+        catch (error) {
+            throw (0, errors_1.createInputDocumentError)({
+                inputPath: documentPath,
+                inputType: 'asyncapi',
+                errorMessage: `Could not read file: ${error}`
+            });
+        }
+    }
+    const parser = (0, inputSource_1.isRemoteUrl)(documentPath) && auth
+        ? buildParserWithAuth(auth, documentPath)
+        : sharedParser;
+    const document = await parser.parse(content, { source: documentPath });
+    if (document.diagnostics.length > 0) {
+        throw (0, errors_1.createInputDocumentError)({
+            inputPath: documentPath,
+            inputType: 'asyncapi',
+            errorMessage: JSON.stringify(document.diagnostics, null, 2)
+        });
+    }
+    LoggingInterface_1.Logger.debug(`AsyncAPI document loaded successfully`);
+    return document.document;
+}
+exports.loadAsyncapiDocument = loadAsyncapiDocument;
+async function loadAsyncapiFromMemory(input) {
+    const document = await sharedParser.parse(input);
+    if (document.diagnostics.length > 0) {
+        throw (0, errors_1.createInputDocumentError)({
+            inputPath: 'memory',
+            inputType: 'asyncapi',
+            errorMessage: JSON.stringify(document.diagnostics, null, 2)
+        });
+    }
+    return document.document;
+}
+exports.loadAsyncapiFromMemory = loadAsyncapiFromMemory;

package/dist/codegen/inputs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './asyncapi';
+export * from './openapi';
+export * from './jsonschema';

package/dist/codegen/inputs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./asyncapi"), exports);
+__exportStar(require("./openapi"), exports);
+__exportStar(require("./jsonschema"), exports);

package/dist/codegen/inputs/jsonschema/generators/index.d.ts

@@ -0,0 +1 @@
+export { processJsonSchemaModels } from './models';

package/dist/codegen/inputs/jsonschema/generators/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processJsonSchemaModels = void 0;
+var models_1 = require("./models");
+Object.defineProperty(exports, "processJsonSchemaModels", { enumerable: true, get: function () { return models_1.processJsonSchemaModels; } });

package/dist/codegen/inputs/jsonschema/generators/models.d.ts

@@ -0,0 +1,7 @@
+import { JsonSchemaDocument } from '../parser';
+/**
+ * Process JSON Schema document for models generation
+ * Since the models generator works directly with the raw document,
+ * we simply return the document as-is after validation.
+ */
+export declare function processJsonSchemaModels(jsonSchemaDocument: JsonSchemaDocument): JsonSchemaDocument;

package/dist/codegen/inputs/jsonschema/generators/models.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processJsonSchemaModels = void 0;
+const LoggingInterface_1 = require("../../../../LoggingInterface");
+/**
+ * Process JSON Schema document for models generation
+ * Since the models generator works directly with the raw document,
+ * we simply return the document as-is after validation.
+ */
+function processJsonSchemaModels(jsonSchemaDocument) {
+    if (!jsonSchemaDocument) {
+        throw new Error('Expected JSON Schema input, was not given');
+    }
+    LoggingInterface_1.Logger.info('Processing JSON Schema document for models generation');
+    // Validate that the document has content that can be used for model generation
+    const hasType = jsonSchemaDocument.type !== undefined;
+    const hasProperties = jsonSchemaDocument.properties !== undefined;
+    const hasDefinitions = jsonSchemaDocument.definitions !== undefined ||
+        jsonSchemaDocument.$defs !== undefined;
+    if (!hasType && !hasProperties && !hasDefinitions) {
+        LoggingInterface_1.Logger.warn('JSON Schema document appears to have no definitions or type information for model generation');
+    }
+    // For models generator, we return the document as-is since Modelina can work with raw JSON Schema
+    return jsonSchemaDocument;
+}
+exports.processJsonSchemaModels = processJsonSchemaModels;

package/dist/codegen/inputs/jsonschema/index.d.ts

@@ -0,0 +1 @@
+export { loadJsonSchema, loadJsonSchemaDocument, loadJsonSchemaFromMemory, JsonSchemaDocument } from './parser';

package/dist/codegen/inputs/jsonschema/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadJsonSchemaFromMemory = exports.loadJsonSchemaDocument = exports.loadJsonSchema = void 0;
+var parser_1 = require("./parser");
+Object.defineProperty(exports, "loadJsonSchema", { enumerable: true, get: function () { return parser_1.loadJsonSchema; } });
+Object.defineProperty(exports, "loadJsonSchemaDocument", { enumerable: true, get: function () { return parser_1.loadJsonSchemaDocument; } });
+Object.defineProperty(exports, "loadJsonSchemaFromMemory", { enumerable: true, get: function () { return parser_1.loadJsonSchemaFromMemory; } });

package/dist/codegen/inputs/jsonschema/parser.d.ts

@@ -0,0 +1,31 @@
+import { InputAuthConfig, RunGeneratorContext } from '../../types';
+export interface JsonSchemaDocument {
+    [key: string]: any;
+    $schema?: string;
+    type?: string;
+    properties?: {
+        [key: string]: any;
+    };
+    definitions?: {
+        [key: string]: any;
+    };
+    $defs?: {
+        [key: string]: any;
+    };
+}
+/**
+ * Load JSON Schema document from file path or remote URL in context.
+ */
+export declare function loadJsonSchema(context: RunGeneratorContext): Promise<JsonSchemaDocument>;
+/**
+ * Load JSON Schema document from a file path or http(s) URL.
+ *
+ * URL format detection: prefers `Content-Type` (`application/json` →
+ * JSON, `*yaml*` → YAML), falls back to URL extension, then to
+ * JSON-first-then-YAML for ambiguous cases.
+ */
+export declare function loadJsonSchemaDocument(filePath: string, auth?: InputAuthConfig): Promise<JsonSchemaDocument>;
+/**
+ * Load JSON Schema document from memory.
+ */
+export declare function loadJsonSchemaFromMemory(document: JsonSchemaDocument, documentPath?: string): JsonSchemaDocument;

package/dist/codegen/inputs/jsonschema/parser.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadJsonSchemaFromMemory = exports.loadJsonSchemaDocument = exports.loadJsonSchema = void 0;
+const LoggingInterface_1 = require("../../../LoggingInterface");
+const fs_1 = __importDefault(require("fs"));
+const yaml_1 = require("yaml");
+const errors_1 = require("../../errors");
+const inputSource_1 = require("../../../utils/inputSource");
+const remoteFetch_1 = require("../../../utils/remoteFetch");
+/**
+ * Load JSON Schema document from file path or remote URL in context.
+ */
+async function loadJsonSchema(context) {
+    return loadJsonSchemaDocument(context.documentPath, context.inputAuth);
+}
+exports.loadJsonSchema = loadJsonSchema;
+/**
+ * Load JSON Schema document from a file path or http(s) URL.
+ *
+ * URL format detection: prefers `Content-Type` (`application/json` →
+ * JSON, `*yaml*` → YAML), falls back to URL extension, then to
+ * JSON-first-then-YAML for ambiguous cases.
+ */
+async function loadJsonSchemaDocument(filePath, auth) {
+    LoggingInterface_1.Logger.verbose(`Loading JSON Schema document from ${filePath}`);
+    try {
+        let content;
+        let contentType = null;
+        if ((0, inputSource_1.isRemoteUrl)(filePath)) {
+            const fetched = await (0, remoteFetch_1.fetchRemoteDocument)(filePath, auth);
+            content = fetched.content;
+            contentType = fetched.contentType;
+        }
+        else {
+            if (!filePath.endsWith('.json') &&
+                !filePath.endsWith('.yaml') &&
+                !filePath.endsWith('.yml')) {
+                throw (0, errors_1.createInputDocumentError)({
+                    inputPath: filePath,
+                    inputType: 'jsonschema',
+                    errorMessage: `Unsupported file format. Use .json, .yaml, or .yml`
+                });
+            }
+            content = fs_1.default.readFileSync(filePath, 'utf8');
+        }
+        const document = parseDocument(content, filePath, contentType);
+        validateJsonSchemaDocument(document, filePath);
+        return document;
+    }
+    catch (error) {
+        if (error?.type) {
+            throw error;
+        }
+        if (error instanceof Error) {
+            throw (0, errors_1.createInputDocumentError)({
+                inputPath: filePath,
+                inputType: 'jsonschema',
+                errorMessage: error.message
+            });
+        }
+        throw (0, errors_1.createInputDocumentError)({
+            inputPath: filePath,
+            inputType: 'jsonschema',
+            errorMessage: 'Unknown error'
+        });
+    }
+}
+exports.loadJsonSchemaDocument = loadJsonSchemaDocument;
+function parseDocument(content, source, contentType) {
+    const ct = contentType?.toLowerCase() ?? '';
+    const isYaml = ct.includes('yaml') || source.endsWith('.yaml') || source.endsWith('.yml');
+    const isJson = ct.includes('json') || source.endsWith('.json');
+    if (isJson && !isYaml) {
+        return JSON.parse(content);
+    }
+    if (isYaml && !isJson) {
+        return (0, yaml_1.parse)(content);
+    }
+    // Ambiguous → JSON-first-then-YAML.
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        return (0, yaml_1.parse)(content);
+    }
+}
+/**
+ * Load JSON Schema document from memory.
+ */
+function loadJsonSchemaFromMemory(document, documentPath) {
+    const path = documentPath || 'memory';
+    LoggingInterface_1.Logger.verbose(`Loading JSON Schema document from ${path}`);
+    validateJsonSchemaDocument(document, path);
+    return document;
+}
+exports.loadJsonSchemaFromMemory = loadJsonSchemaFromMemory;
+/**
+ * Basic validation for JSON Schema document.
+ */
+function validateJsonSchemaDocument(document, source) {
+    if (!document || typeof document !== 'object') {
+        throw (0, errors_1.createInputDocumentError)({
+            inputPath: source,
+            inputType: 'jsonschema',
+            errorMessage: 'Document must be an object'
+        });
+    }
+    if (document.$schema && typeof document.$schema !== 'string') {
+        throw (0, errors_1.createInputDocumentError)({
+            inputPath: source,
+            inputType: 'jsonschema',
+            errorMessage: '$schema must be a string'
+        });
+    }
+    if (!document.$schema) {
+        LoggingInterface_1.Logger.warn(`JSON Schema document from ${source} does not specify a $schema version. Consider adding one for better validation.`);
+    }
+    const hasType = document.type !== undefined;
+    const hasProperties = document.properties !== undefined;
+    const hasDefinitions = document.definitions !== undefined || document.$defs !== undefined;
+    if (!hasType && !hasProperties && !hasDefinitions) {
+        LoggingInterface_1.Logger.warn(`JSON Schema document from ${source} appears to be empty or incomplete. It should have 'type', 'properties', 'definitions', or '$defs' for code generation.`);
+    }
+    LoggingInterface_1.Logger.debug(`Successfully validated JSON Schema document from ${source}`);
+}

package/dist/codegen/inputs/openapi/generators/headers.d.ts

@@ -0,0 +1,3 @@
+import { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
+import { ProcessedHeadersData } from '../../../generators/typescript/headers';
+export declare function processOpenAPIHeaders(openapiDocument: OpenAPIV3.Document | OpenAPIV2.Document | OpenAPIV3_1.Document): ProcessedHeadersData;

package/dist/codegen/inputs/openapi/generators/headers.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processOpenAPIHeaders = void 0;
+const utils_1 = require("../../../generators/typescript/utils");
+// Helper function to convert OpenAPI header schema to JSON Schema
+function convertHeaderSchemaToJsonSchema(header) {
+    let schema;
+    if (header.schema) {
+        // OpenAPI 3.x format
+        schema = { ...header.schema };
+    }
+    else if (header.type) {
+        // OpenAPI 2.x format
+        schema = {
+            type: header.type,
+            ...(header.format && { format: header.format }),
+            ...(header.enum && { enum: header.enum }),
+            ...(header.minimum !== undefined && { minimum: header.minimum }),
+            ...(header.maximum !== undefined && { maximum: header.maximum }),
+            ...(header.minLength !== undefined && {
+                minLength: header.minLength
+            }),
+            ...(header.maxLength !== undefined && {
+                maxLength: header.maxLength
+            }),
+            ...(header.pattern && { pattern: header.pattern })
+        };
+    }
+    else {
+        // Fallback to string type
+        schema = { type: 'string' };
+    }
+    return schema;
+}
+// Extract header parameters from OpenAPI operations
+function extractHeadersFromOperations(paths) {
+    const operationHeaders = {};
+    for (const [pathKey, pathItem] of Object.entries(paths)) {
+        for (const [method, operation] of Object.entries(pathItem)) {
+            const operationObj = operation;
+            // Collect header parameters from operation and path-level
+            const allParameters = operationObj.parameters ?? [];
+            const headerParams = allParameters.filter((param) => {
+                return param.in === 'header';
+            });
+            if (allParameters.length > 0) {
+                const operationId = operationObj.operationId ??
+                    `${method}${pathKey.replace(/[^a-zA-Z0-9]/g, '')}`;
+                operationHeaders[operationId] = headerParams;
+            }
+        }
+    }
+    return operationHeaders;
+}
+// OpenAPI input processor
+function processOpenAPIHeaders(openapiDocument) {
+    const channelHeaders = {};
+    // Extract header parameters from all operations
+    const operationHeaders = extractHeadersFromOperations(openapiDocument.paths ?? {});
+    // Process each operation that has header parameters
+    for (const [operationId, headerParams] of Object.entries(operationHeaders)) {
+        if (headerParams.length === 0) {
+            channelHeaders[operationId] = undefined;
+            continue;
+        }
+        // Create a JSON Schema object for the headers
+        const properties = {};
+        const required = [];
+        for (const param of headerParams) {
+            const paramName = param.name;
+            const paramSchema = convertHeaderSchemaToJsonSchema(param);
+            // Add description if available
+            if (param.description) {
+                paramSchema.description = param.description;
+            }
+            properties[paramName] = paramSchema;
+            // Check if header is required
+            if (param.required === true) {
+                required.push(paramName);
+            }
+        }
+        // Create the complete schema object
+        const schemaObj = {
+            type: 'object',
+            additionalProperties: false,
+            properties,
+            $id: (0, utils_1.pascalCase)(`${operationId}_headers`),
+            $schema: 'http://json-schema.org/draft-07/schema'
+        };
+        // Add required array if there are required parameters
+        if (required.length > 0) {
+            schemaObj.required = required;
+        }
+        channelHeaders[operationId] = {
+            schema: schemaObj,
+            schemaId: (0, utils_1.pascalCase)(`${operationId}_headers`)
+        };
+    }
+    return { channelHeaders };
+}
+exports.processOpenAPIHeaders = processOpenAPIHeaders;

package/dist/codegen/inputs/openapi/generators/parameters.d.ts

@@ -0,0 +1,10 @@
+import { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
+import { ProcessedParameterSchemaData } from '../../asyncapi/generators/parameters';
+import { TypeScriptFileGenerator } from '@asyncapi/modelina';
+export declare function processOpenAPIParameters(openapiDocument: OpenAPIV3.Document | OpenAPIV2.Document | OpenAPIV3_1.Document): ProcessedParameterSchemaData;
+export declare function convertParameterSchemaToJsonSchema(parameter: any): any;
+export declare function createParameterSchema(operationId: string, parameters: any[], schemaIdSuffix: string, path?: string): {
+    schema: any;
+    schemaId: string;
+};
+export declare function createOpenAPIGenerator(): TypeScriptFileGenerator;