@alagoni97/cli 0.72.1

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

@@ -0,0 +1,3 @@
+import { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
+import { ProcessedPayloadSchemaData } from '../../asyncapi/generators/payloads';
+export declare function processOpenAPIPayloads(openapiDocument: OpenAPIV3.Document | OpenAPIV2.Document | OpenAPIV3_1.Document): ProcessedPayloadSchemaData;

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

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processOpenAPIPayloads = void 0;
+const utils_1 = require("../../../generators/typescript/utils");
+const utils_2 = require("../../../utils");
+// Constants
+const JSON_SCHEMA_DRAFT_07 = 'http://json-schema.org/draft-07/schema';
+// Helper function to extract schema from OpenAPI 2.0 response
+function extractOpenAPI2ResponseSchema(response) {
+    if (response.schema) {
+        return response.schema;
+    }
+    return null;
+}
+// Helper function to extract schema from OpenAPI 3.x response content
+function extractOpenAPI3ResponseSchema(response) {
+    if (!response.content) {
+        return null;
+    }
+    // Prioritize JSON content types
+    const jsonContentTypes = [
+        'application/json',
+        'application/vnd.api+json',
+        'text/json'
+    ];
+    // Fall back to any content type with a schema
+    for (const [contentType, mediaType] of Object.entries(response.content)) {
+        if (!jsonContentTypes.includes(contentType)) {
+            continue;
+        }
+        if (mediaType.schema) {
+            return mediaType.schema;
+        }
+    }
+    return null;
+}
+// Helper function to extract schema from OpenAPI 2.0 request body parameter
+function extractOpenAPI2RequestSchema(parameters) {
+    const bodyParam = parameters.find((param) => param.in === 'body');
+    return bodyParam?.schema ?? null;
+}
+// Helper function to extract schema from OpenAPI 3.x request body
+function extractOpenAPI3RequestSchema(requestBody) {
+    if (!requestBody?.content) {
+        return null;
+    }
+    // Prioritize JSON content types
+    const jsonContentTypes = [
+        'application/json',
+        'application/vnd.api+json',
+        'text/json'
+    ];
+    // Fall back to any content type with a schema
+    for (const [contentType, mediaType] of Object.entries(requestBody.content)) {
+        if (!jsonContentTypes.includes(contentType)) {
+            continue;
+        }
+        if (mediaType.schema) {
+            return mediaType.schema;
+        }
+    }
+    return null;
+}
+// Helper function to create a union schema from multiple response schemas
+function createUnionSchema(schemas, baseId, hasStatusCodes = false) {
+    if (schemas.length === 0) {
+        return null;
+    }
+    if (schemas.length === 1) {
+        const schema = schemas[0];
+        return {
+            ...schema,
+            $id: schema.$id ?? baseId,
+            $schema: JSON_SCHEMA_DRAFT_07
+        };
+    }
+    const unionSchema = {
+        type: 'object',
+        oneOf: schemas,
+        $id: baseId,
+        $schema: JSON_SCHEMA_DRAFT_07
+    };
+    if (hasStatusCodes) {
+        unionSchema['x-modelina-has-status-codes'] = true;
+    }
+    return unionSchema;
+}
+// Extract payload schemas from OpenAPI operations
+function extractPayloadsFromOperations(paths) {
+    const requestPayloads = {};
+    const responsePayloads = {};
+    for (const [pathKey, pathItem] of Object.entries(paths)) {
+        if (!pathItem) {
+            continue;
+        }
+        for (const [method, operation] of Object.entries(pathItem)) {
+            if (!operation || typeof operation !== 'object') {
+                continue;
+            }
+            const operationObj = operation;
+            const operationId = operationObj.operationId ??
+                `${method}${pathKey.replace(/[^a-zA-Z0-9]/g, '')}`;
+            // Extract request payload schema
+            let requestSchema = null;
+            // Check if this is OpenAPI 2.0 vs 3.x based on the structure
+            if ('parameters' in operationObj && operationObj.parameters) {
+                // OpenAPI 2.0 style
+                requestSchema = extractOpenAPI2RequestSchema(operationObj.parameters);
+            }
+            else if ('requestBody' in operationObj && operationObj.requestBody) {
+                // OpenAPI 3.x style
+                requestSchema = extractOpenAPI3RequestSchema(operationObj.requestBody);
+            }
+            if (requestSchema) {
+                const requestSchemaId = (0, utils_1.pascalCase)(`${operationId}_Request`);
+                requestPayloads[operationId] = {
+                    schema: {
+                        ...requestSchema,
+                        $id: requestSchemaId,
+                        $schema: JSON_SCHEMA_DRAFT_07
+                    },
+                    schemaId: requestSchemaId
+                };
+            }
+            // Extract response payload schemas
+            if (operationObj.responses) {
+                const responseSchemas = [];
+                let hasStatusCodes = false;
+                for (const [statusCode, response] of Object.entries(operationObj.responses)) {
+                    if (!response || typeof response !== 'object') {
+                        continue;
+                    }
+                    let responseSchema = null;
+                    // Determine if this is OpenAPI 2.0 or 3.x response
+                    if ('schema' in response) {
+                        // OpenAPI 2.0 style
+                        responseSchema = extractOpenAPI2ResponseSchema(response);
+                    }
+                    else {
+                        // OpenAPI 3.x style
+                        responseSchema = extractOpenAPI3ResponseSchema(response);
+                    }
+                    if (responseSchema) {
+                        // Add status code information for proper discrimination
+                        if (statusCode !== 'default' && !isNaN(Number(statusCode))) {
+                            hasStatusCodes = true;
+                            responseSchema['x-modelina-status-codes'] = {
+                                code: Number(statusCode)
+                            };
+                        }
+                        responseSchemas.push({
+                            ...responseSchema,
+                            $id: `${operationId}_Response_${statusCode}`
+                        });
+                    }
+                }
+                if (responseSchemas.length > 0) {
+                    const responseSchemaId = (0, utils_1.pascalCase)(`${operationId}_Response`);
+                    const unionSchema = createUnionSchema(responseSchemas, responseSchemaId, hasStatusCodes);
+                    if (unionSchema) {
+                        responsePayloads[`${operationId}_Response`] = {
+                            schema: unionSchema,
+                            schemaId: responseSchemaId
+                        };
+                    }
+                }
+            }
+        }
+    }
+    return { requestPayloads, responsePayloads };
+}
+// Helper function to extract schemas from components/definitions
+function extractComponentSchemas(openapiDocument) {
+    const componentSchemas = [];
+    // OpenAPI 3.x components
+    if ('components' in openapiDocument && openapiDocument.components?.schemas) {
+        for (const [schemaName, schema] of Object.entries(openapiDocument.components.schemas)) {
+            if (schema && typeof schema === 'object') {
+                componentSchemas.push({
+                    schema: {
+                        ...schema,
+                        $id: schemaName,
+                        $schema: JSON_SCHEMA_DRAFT_07
+                    },
+                    schemaId: schemaName
+                });
+            }
+        }
+    }
+    // OpenAPI 2.0 definitions
+    if ('definitions' in openapiDocument && openapiDocument.definitions) {
+        for (const [schemaName, schema] of Object.entries(openapiDocument.definitions)) {
+            if (schema && typeof schema === 'object') {
+                componentSchemas.push({
+                    schema: {
+                        ...schema,
+                        $id: schemaName,
+                        $schema: JSON_SCHEMA_DRAFT_07
+                    },
+                    schemaId: schemaName
+                });
+            }
+        }
+    }
+    return componentSchemas;
+}
+// OpenAPI input processor
+function processOpenAPIPayloads(openapiDocument) {
+    const channelPayloads = {};
+    const operationPayloads = {};
+    const otherPayloads = [];
+    // Extract request and response payloads from operations
+    const { requestPayloads, responsePayloads } = extractPayloadsFromOperations(openapiDocument.paths ?? {});
+    // Map request payloads to operation payloads
+    for (const [operationId, payload] of Object.entries(requestPayloads)) {
+        operationPayloads[operationId] = payload;
+    }
+    // Map response payloads to operation payloads
+    for (const [responseId, payload] of Object.entries(responsePayloads)) {
+        operationPayloads[responseId] = payload;
+    }
+    // Extract component schemas
+    const componentSchemas = extractComponentSchemas(openapiDocument);
+    otherPayloads.push(...componentSchemas);
+    return {
+        channelPayloads,
+        operationPayloads,
+        otherPayloads: (0, utils_2.onlyUnique)(otherPayloads)
+    };
+}
+exports.processOpenAPIPayloads = processOpenAPIPayloads;

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

@@ -0,0 +1,9 @@
+import { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
+import { TypescriptTypesGeneratorInternal } from '../../../generators/typescript/types';
+import { GeneratedFile } from '../../../types';
+export interface TypesGeneratorResult {
+    result: string;
+    /** Generated files with path and content */
+    files: GeneratedFile[];
+}
+export declare function generateOpenAPITypes(openapiDocument: OpenAPIV3.Document | OpenAPIV2.Document | OpenAPIV3_1.Document, generator: TypescriptTypesGeneratorInternal): Promise<TypesGeneratorResult>;

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOpenAPITypes = void 0;
+async function generateOpenAPITypes(openapiDocument, generator) {
+    const paths = openapiDocument.paths ?? {};
+    const allPaths = Object.keys(paths);
+    // Generate union type for all paths
+    const pathsUnion = allPaths
+        .map((pathStr) => {
+        return `'${pathStr}'`;
+    })
+        .join(' | ');
+    let result = `export type Paths = ${pathsUnion};\n`;
+    // Generate operation IDs and their corresponding paths
+    const operationIds = [];
+    const operationIdToPathMap = {};
+    const pathToOperationIdMap = {};
+    for (const [pathStr, pathItem] of Object.entries(paths)) {
+        const pathOperationIds = [];
+        for (const [method, operation] of Object.entries(pathItem)) {
+            const operationObj = operation;
+            if (operationObj &&
+                typeof operationObj === 'object' &&
+                method !== 'parameters') {
+                const operationId = operationObj.operationId ??
+                    `${method}${pathStr.replace(/[^a-zA-Z0-9]/g, '')}`;
+                operationIds.push(operationId);
+                operationIdToPathMap[operationId] = pathStr;
+                pathOperationIds.push(operationId);
+            }
+        }
+        if (pathOperationIds.length > 0) {
+            pathToOperationIdMap[pathStr] = pathOperationIds;
+        }
+    }
+    // Generate operation IDs union type
+    if (operationIds.length > 0) {
+        const operationIdsUnion = operationIds.map((id) => `'${id}'`).join(' | ');
+        result += `export type OperationIds = ${operationIdsUnion};\n`;
+        // Generate helper function to get path from operation ID
+        const operationIdToPathSwitch = Object.entries(operationIdToPathMap)
+            .map(([operationId, pathStr]) => {
+            return `case '${operationId}':
+    return '${pathStr}';`;
+        })
+            .join('\n  ');
+        const toPathPart = `export function ToPath(operationId: OperationIds): Paths {
+  switch (operationId) {
+    ${operationIdToPathSwitch}
+    default:
+      throw new Error('Unknown operation ID: ' + operationId);
+  }
+}\n`;
+        // Generate helper function to get operation IDs from path
+        const pathToOperationIdSwitch = Object.entries(pathToOperationIdMap)
+            .map(([pathStr, operationIds]) => {
+            const operationIdsArray = operationIds
+                .map((id) => `'${id}'`)
+                .join(', ');
+            return `case '${pathStr}':
+    return [${operationIdsArray}];`;
+        })
+            .join('\n  ');
+        const toOperationIdsPart = `export function ToOperationIds(path: Paths): OperationIds[] {
+  switch (path) {
+    ${pathToOperationIdSwitch}
+    default:
+      throw new Error('Unknown path: ' + path);
+  }
+}\n`;
+        const pathsMap = `export const PathsMap: Record<OperationIds, Paths> = {
+${Object.entries(operationIdToPathMap)
+            .map(([operationId, pathStr]) => {
+            return `  '${operationId}': '${pathStr}'`;
+        })
+            .join(',\n')}
+};\n`;
+        result += toPathPart + toOperationIdsPart + pathsMap;
+    }
+    const filePath = `${generator.outputPath}/Types.ts`;
+    return {
+        result,
+        files: [{ path: filePath, content: result }]
+    };
+}
+exports.generateOpenAPITypes = generateOpenAPITypes;

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

@@ -0,0 +1,2 @@
+export { loadOpenapi, loadOpenapiDocument } from './parser';
+export { processOpenAPIPayloads } from './generators/payloads';

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processOpenAPIPayloads = exports.loadOpenapiDocument = exports.loadOpenapi = void 0;
+var parser_1 = require("./parser");
+Object.defineProperty(exports, "loadOpenapi", { enumerable: true, get: function () { return parser_1.loadOpenapi; } });
+Object.defineProperty(exports, "loadOpenapiDocument", { enumerable: true, get: function () { return parser_1.loadOpenapiDocument; } });
+var payloads_1 = require("./generators/payloads");
+Object.defineProperty(exports, "processOpenAPIPayloads", { enumerable: true, get: function () { return payloads_1.processOpenAPIPayloads; } });

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

@@ -0,0 +1,4 @@
+import { InputAuthConfig, RunGeneratorContext } from '../../types';
+import { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
+export declare function loadOpenapi(context: RunGeneratorContext): Promise<OpenAPIV3.Document | OpenAPIV2.Document | OpenAPIV3_1.Document>;
+export declare function loadOpenapiDocument(documentPath: string, auth?: InputAuthConfig): Promise<OpenAPIV3.Document | OpenAPIV2.Document | OpenAPIV3_1.Document>;

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

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadOpenapiDocument = exports.loadOpenapi = void 0;
+const openapi_parser_1 = require("@readme/openapi-parser");
+const json_schema_ref_parser_1 = __importDefault(require("@apidevtools/json-schema-ref-parser"));
+const fs_1 = require("fs");
+const yaml_1 = require("yaml");
+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");
+async function loadOpenapi(context) {
+    return loadOpenapiDocument(context.documentPath, context.inputAuth);
+}
+exports.loadOpenapi = loadOpenapi;
+async function loadOpenapiDocument(documentPath, auth) {
+    LoggingInterface_1.Logger.verbose(`Loading OpenAPI document from ${documentPath}`);
+    try {
+        let documentContent;
+        let contentType = null;
+        if ((0, inputSource_1.isRemoteUrl)(documentPath)) {
+            const fetched = await (0, remoteFetch_1.fetchRemoteDocument)(documentPath, auth);
+            documentContent = fetched.content;
+            contentType = fetched.contentType;
+        }
+        else {
+            try {
+                documentContent = (0, fs_1.readFileSync)(documentPath, 'utf-8');
+            }
+            catch (error) {
+                throw (0, errors_1.createInputDocumentError)({
+                    inputPath: documentPath,
+                    inputType: 'openapi',
+                    errorMessage: `Could not read file: ${error}`
+                });
+            }
+        }
+        const document = parseDocumentContent(documentContent, documentPath, contentType);
+        let dereferenced;
+        if ((0, inputSource_1.isRemoteUrl)(documentPath)) {
+            // Use $RefParser directly so cross-spec $refs go through our
+            // auth-aware http resolver. The root document is already in memory.
+            const refParser = new json_schema_ref_parser_1.default();
+            dereferenced = await refParser.dereference(documentPath, document, {
+                resolve: {
+                    http: (0, refResolvers_1.createOpenapiRefParserResolver)(auth, { rootUrl: documentPath })
+                }
+            });
+        }
+        else {
+            // Local file path: keep the existing @readme/openapi-parser flow
+            // which handles file:// $refs via the built-in resolver.
+            const parsedDocument = await (0, openapi_parser_1.parse)(document);
+            const { dereference } = await import('@readme/openapi-parser');
+            dereferenced = await dereference(parsedDocument);
+        }
+        // Run @readme/openapi-parser validation on the (already-dereferenced)
+        // document so we still get OpenAPI 3.x-spec-aware error messages.
+        if ((0, inputSource_1.isRemoteUrl)(documentPath)) {
+            try {
+                await (0, openapi_parser_1.parse)(JSON.parse(JSON.stringify(dereferenced)));
+            }
+            catch (validationError) {
+                LoggingInterface_1.Logger.debug(`OpenAPI validation warning after dereferencing: ${validationError}`);
+            }
+        }
+        LoggingInterface_1.Logger.debug(`OpenAPI document loaded and dereferenced`);
+        return dereferenced;
+    }
+    catch (error) {
+        if (error?.type) {
+            // Already a CodegenError from a sub-step
+            throw error;
+        }
+        throw (0, errors_1.createInputDocumentError)({
+            inputPath: documentPath,
+            inputType: 'openapi',
+            errorMessage: error instanceof Error ? error.message : String(error)
+        });
+    }
+}
+exports.loadOpenapiDocument = loadOpenapiDocument;
+function parseDocumentContent(content, documentPath, contentType) {
+    const ct = contentType?.toLowerCase() ?? '';
+    const isYaml = ct.includes('yaml') ||
+        documentPath.endsWith('.yaml') ||
+        documentPath.endsWith('.yml');
+    const isJson = ct.includes('json') || documentPath.endsWith('.json');
+    try {
+        if (isYaml && !isJson) {
+            return (0, yaml_1.parse)(content);
+        }
+        if (isJson) {
+            return JSON.parse(content);
+        }
+        // Ambiguous: try JSON first, then YAML.
+        try {
+            return JSON.parse(content);
+        }
+        catch {
+            return (0, yaml_1.parse)(content);
+        }
+    }
+    catch (error) {
+        throw (0, errors_1.createInputDocumentError)({
+            inputPath: documentPath,
+            inputType: 'openapi',
+            errorMessage: `Could not parse document: ${error}`
+        });
+    }
+}

package/dist/codegen/inputs/openapi/security.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Extracts security scheme information from OpenAPI 2.0/3.x documents.
+ * Converts security definitions to a normalized internal format.
+ */
+import { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types';
+/**
+ * Security scheme configuration options.
+ *
+ * Provides a normalized representation of security schemes from OpenAPI documents,
+ * supporting both OpenAPI 3.x securitySchemes and Swagger 2.0 securityDefinitions.
+ * This interface is used by generators to configure authentication in generated code.
+ */
+export interface SecuritySchemeOptions {
+    /** The name/key of the security scheme as defined in the spec */
+    name: string;
+    /** Security scheme type */
+    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+    /** For apiKey type: the name of the key parameter */
+    apiKeyName?: string;
+    /** For apiKey type: where to place the key */
+    apiKeyIn?: 'header' | 'query' | 'cookie';
+    /** For http type: the authentication scheme (bearer, basic, etc.) */
+    httpScheme?: 'bearer' | 'basic' | string;
+    /** For http bearer: the format of the bearer token */
+    bearerFormat?: string;
+    /** For oauth2 type: the available flows */
+    oauth2Flows?: {
+        implicit?: {
+            authorizationUrl: string;
+            scopes: Record<string, string>;
+        };
+        password?: {
+            tokenUrl: string;
+            scopes: Record<string, string>;
+        };
+        clientCredentials?: {
+            tokenUrl: string;
+            scopes: Record<string, string>;
+        };
+        authorizationCode?: {
+            authorizationUrl: string;
+            tokenUrl: string;
+            scopes: Record<string, string>;
+        };
+    };
+    /** For openIdConnect type: the OpenID Connect discovery URL */
+    openIdConnectUrl?: string;
+}
+type OpenAPIDocument = OpenAPIV3.Document | OpenAPIV2.Document | OpenAPIV3_1.Document;
+/**
+ * Extracts security schemes from an OpenAPI document.
+ * Handles both OpenAPI 3.x (components.securitySchemes) and
+ * Swagger 2.0 (securityDefinitions) formats.
+ */
+export declare function extractSecuritySchemes(document: OpenAPIDocument): SecuritySchemeOptions[];
+export {};