@alagoni97/cli 0.72.1

package/dist/codegen/generators/typescript/channels/asyncapi.d.ts

@@ -0,0 +1,10 @@
+import { ChannelInterface, OperationInterface } from '@asyncapi/parser';
+import { TypeScriptParameterRenderType } from '../parameters';
+import { TypeScriptPayloadRenderType } from '../payloads';
+import { TypeScriptHeadersRenderType } from '../headers';
+import { ChannelFunctionTypes, TypeScriptChannelRenderedFunctionType, SupportedProtocols, TypeScriptChannelsContext } from './types';
+type Action = 'send' | 'receive' | 'subscribe' | 'publish';
+export declare function shouldRenderFunctionType(givenFunctionTypes: ChannelFunctionTypes[] | undefined, functionTypesToCheckFor: ChannelFunctionTypes | ChannelFunctionTypes[], action: Action, reverseOperation: boolean): boolean;
+export declare function generateTypeScriptChannelsForAsyncAPI(context: TypeScriptChannelsContext, parameters: TypeScriptParameterRenderType, payloads: TypeScriptPayloadRenderType, headers: TypeScriptHeadersRenderType, protocolsToUse: SupportedProtocols[], protocolCodeFunctions: Record<string, string[]>, externalProtocolFunctionInformation: Record<string, TypeScriptChannelRenderedFunctionType[]>, protocolDependencies: Record<string, string[]>): Promise<void>;
+export declare function getFunctionTypeMappingFromAsyncAPI(object: OperationInterface | ChannelInterface): ChannelFunctionTypes[] | undefined;
+export {};

package/dist/codegen/generators/typescript/channels/asyncapi.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFunctionTypeMappingFromAsyncAPI = exports.generateTypeScriptChannelsForAsyncAPI = exports.shouldRenderFunctionType = void 0;
+const types_1 = require("./types");
+const utils_1 = require("../../../utils");
+const utils_2 = require("./utils");
+const nats_1 = require("./protocols/nats");
+const kafka_1 = require("./protocols/kafka");
+const mqtt_1 = require("./protocols/mqtt");
+const amqp_1 = require("./protocols/amqp");
+const eventsource_1 = require("./protocols/eventsource");
+const http_1 = require("./protocols/http");
+const websocket_1 = require("./protocols/websocket");
+const errors_1 = require("../../../errors");
+// eslint-disable-next-line sonarjs/cognitive-complexity
+function shouldRenderFunctionType(givenFunctionTypes, functionTypesToCheckFor, action, reverseOperation) {
+    const listToCheck = [
+        ...(Array.isArray(functionTypesToCheckFor)
+            ? functionTypesToCheckFor
+            : [functionTypesToCheckFor])
+    ];
+    const hasSendingOperation = action === 'send' || action === 'subscribe';
+    const hasReceivingOperation = action === 'receive' || action === 'publish';
+    const hasFunctionMappingConfig = givenFunctionTypes !== undefined;
+    const checkForSending = listToCheck.some((item) => types_1.sendingFunctionTypes.includes(item));
+    const checkForReceiving = listToCheck.some((item) => types_1.receivingFunctionTypes.includes(item));
+    const hasFunctionType = (givenFunctionTypes ?? []).some((item) => listToCheck.includes(item));
+    if (hasFunctionMappingConfig) {
+        if (hasFunctionType) {
+            const renderForSending = checkForSending && hasSendingOperation;
+            const renderForReceiving = checkForReceiving && hasReceivingOperation;
+            return renderForSending || renderForReceiving;
+        }
+        return false;
+    }
+    if (reverseOperation) {
+        const renderForSending = hasSendingOperation && checkForReceiving;
+        const renderForReceiving = hasReceivingOperation && checkForSending;
+        return renderForSending || renderForReceiving;
+    }
+    const renderForSending = checkForSending && hasSendingOperation;
+    const renderForReceiving = checkForReceiving && hasReceivingOperation;
+    return renderForSending || renderForReceiving;
+}
+exports.shouldRenderFunctionType = shouldRenderFunctionType;
+async function generateTypeScriptChannelsForAsyncAPI(context, parameters, payloads, headers, protocolsToUse, protocolCodeFunctions, externalProtocolFunctionInformation, protocolDependencies) {
+    const { asyncapiDocument } = validateAsyncapiContext(context);
+    const channels = asyncapiDocument
+        .allChannels()
+        .all()
+        .filter((channel) => channel.address() && channel.messages().length > 0);
+    // Collect payload/parameter/header imports for each protocol
+    const importExtension = (0, utils_1.resolveImportExtension)(context.generator, context.config);
+    for (const protocol of protocolsToUse) {
+        // eslint-disable-next-line security/detect-object-injection
+        const deps = protocolDependencies[protocol];
+        (0, utils_2.collectProtocolDependencies)(payloads, parameters, headers, context, deps, importExtension);
+    }
+    for (const channel of channels) {
+        const subName = (0, utils_1.findNameFromChannel)(channel);
+        let parameter = undefined;
+        if (channel.parameters().length > 0) {
+            parameter = parameters.channelModels[channel.id()];
+            if (parameter === undefined) {
+                throw (0, errors_1.createMissingParameterError)({
+                    channelOrOperation: channel.id(),
+                    protocol: 'channels'
+                });
+            }
+        }
+        // Headers are now always available, but the specific channel may not have headers defined
+        const headerModel = headers.channelModels[channel.id()];
+        for (const protocol of protocolsToUse) {
+            const protocolContext = {
+                ...context,
+                subName,
+                topic: channel.address(),
+                parameter: parameter?.model,
+                headers: headerModel?.model,
+                payloads
+            };
+            switch (protocol) {
+                case 'nats':
+                    await (0, nats_1.generateNatsChannels)(protocolContext, channel, protocolCodeFunctions, externalProtocolFunctionInformation, protocolDependencies['nats']);
+                    break;
+                case 'kafka':
+                    await (0, kafka_1.generateKafkaChannels)(protocolContext, channel, protocolCodeFunctions, externalProtocolFunctionInformation, protocolDependencies['kafka']);
+                    break;
+                case 'mqtt':
+                    await (0, mqtt_1.generateMqttChannels)(protocolContext, channel, protocolCodeFunctions, externalProtocolFunctionInformation, protocolDependencies['mqtt']);
+                    break;
+                case 'amqp':
+                    await (0, amqp_1.generateAmqpChannels)(protocolContext, channel, protocolCodeFunctions, externalProtocolFunctionInformation, protocolDependencies['amqp']);
+                    break;
+                case 'http_client':
+                    await (0, http_1.generatehttpChannels)(protocolContext, channel, protocolCodeFunctions, externalProtocolFunctionInformation, protocolDependencies['http_client']);
+                    break;
+                case 'event_source':
+                    await (0, eventsource_1.generateEventSourceChannels)(protocolContext, channel, protocolCodeFunctions, externalProtocolFunctionInformation, protocolDependencies['event_source']);
+                    break;
+                case 'websocket':
+                    await (0, websocket_1.generateWebSocketChannels)(protocolContext, channel, protocolCodeFunctions, externalProtocolFunctionInformation, protocolDependencies['websocket']);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+}
+exports.generateTypeScriptChannelsForAsyncAPI = generateTypeScriptChannelsForAsyncAPI;
+function validateAsyncapiContext(context) {
+    const { asyncapiDocument, inputType } = context;
+    if (inputType !== 'asyncapi') {
+        throw (0, errors_1.createMissingInputDocumentError)({
+            expectedType: 'asyncapi',
+            generatorPreset: 'channels'
+        });
+    }
+    if (asyncapiDocument === undefined) {
+        throw (0, errors_1.createMissingInputDocumentError)({
+            expectedType: 'asyncapi',
+            generatorPreset: 'channels'
+        });
+    }
+    return { asyncapiDocument };
+}
+function getFunctionTypeMappingFromAsyncAPI(object) {
+    return (object.extensions().get('x-the-codegen-project')?.value()
+        ?.functionTypeMapping ?? undefined);
+}
+exports.getFunctionTypeMappingFromAsyncAPI = getFunctionTypeMappingFromAsyncAPI;

package/dist/codegen/generators/typescript/channels/index.d.ts

@@ -0,0 +1,8 @@
+import { TheCodegenConfiguration } from '../../../types';
+import { TypeScriptChannelRenderedFunctionType, TypeScriptChannelRenderType, TypeScriptChannelsContext, TypeScriptChannelsGenerator, defaultTypeScriptChannelsGenerator, TypeScriptChannelsGeneratorInternal, zodTypescriptChannelsGenerator, ChannelFunctionTypes } from './types';
+export { TypeScriptChannelRenderedFunctionType, TypeScriptChannelRenderType, TypeScriptChannelsContext, defaultTypeScriptChannelsGenerator, TypeScriptChannelsGenerator, TypeScriptChannelsGeneratorInternal, zodTypescriptChannelsGenerator, ChannelFunctionTypes };
+export declare function generateTypeScriptChannels(context: TypeScriptChannelsContext): Promise<TypeScriptChannelRenderType>;
+/**
+ * Make sure we include all dependencies, if not added manually, is added to the generators.
+ */
+export declare function includeTypeScriptChannelDependencies(config: TheCodegenConfiguration, generator: TypeScriptChannelsGenerator): unknown[];

package/dist/codegen/generators/typescript/channels/index.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.includeTypeScriptChannelDependencies = exports.generateTypeScriptChannels = exports.ChannelFunctionTypes = exports.zodTypescriptChannelsGenerator = exports.defaultTypeScriptChannelsGenerator = void 0;
+const utils_1 = require("../../../utils");
+const parameters_1 = require("../parameters");
+const payloads_1 = require("../payloads");
+const headers_1 = require("../headers");
+const types_1 = require("./types");
+Object.defineProperty(exports, "defaultTypeScriptChannelsGenerator", { enumerable: true, get: function () { return types_1.defaultTypeScriptChannelsGenerator; } });
+Object.defineProperty(exports, "zodTypescriptChannelsGenerator", { enumerable: true, get: function () { return types_1.zodTypescriptChannelsGenerator; } });
+Object.defineProperty(exports, "ChannelFunctionTypes", { enumerable: true, get: function () { return types_1.ChannelFunctionTypes; } });
+const asyncapi_1 = require("./asyncapi");
+const openapi_1 = require("./openapi");
+// eslint-disable-next-line sonarjs/cognitive-complexity
+async function generateTypeScriptChannels(context) {
+    const protocolCodeFunctions = {};
+    const externalProtocolFunctionInformation = {};
+    const { parameters, payloads, headers } = validateContext(context);
+    const generator = context.generator;
+    const protocolsToUse = generator.protocols;
+    const protocolDependencies = {};
+    for (const protocol of protocolsToUse) {
+        protocolCodeFunctions[protocol] = [];
+        externalProtocolFunctionInformation[protocol] = [];
+        protocolDependencies[protocol] = [];
+    }
+    if (context.inputType === 'asyncapi') {
+        await (0, asyncapi_1.generateTypeScriptChannelsForAsyncAPI)(context, parameters, payloads, headers, protocolsToUse, protocolCodeFunctions, externalProtocolFunctionInformation, protocolDependencies);
+    }
+    else if (context.inputType === 'openapi') {
+        await (0, openapi_1.generateTypeScriptChannelsForOpenAPI)(context, parameters, payloads, headers, protocolsToUse, protocolCodeFunctions, externalProtocolFunctionInformation, protocolDependencies);
+    }
+    return await finalizeGeneration(context, protocolDependencies, protocolCodeFunctions, externalProtocolFunctionInformation, parameters, payloads);
+}
+exports.generateTypeScriptChannels = generateTypeScriptChannels;
+async function finalizeGeneration(context, protocolDependencies, protocolCodeFunctions, externalProtocolFunctionInformation, parameters, payloads) {
+    const files = [];
+    const generatedProtocols = [];
+    const protocolFiles = {};
+    // Generate one file per protocol
+    for (const [protocol, functions] of Object.entries(protocolCodeFunctions)) {
+        if (functions.length === 0) {
+            continue;
+        }
+        const deps = [...new Set(protocolDependencies[protocol] || [])];
+        // Get function names for the export statement
+        const functionNames = (externalProtocolFunctionInformation[protocol] || []).map((fn) => fn.functionName);
+        // Functions are defined first, then exported by name at the end
+        const depsSection = deps.join('\n');
+        const depsNewline = deps.length > 0 ? '\n\n' : '';
+        const functionsSection = functions.join('\n\n');
+        const exportSection = functionNames.length > 0
+            ? `\n\nexport { ${functionNames.join(', ')} };`
+            : '';
+        const fileContent = `${depsSection}${depsNewline}${functionsSection}${exportSection}\n`;
+        const protocolFilePath = (0, utils_1.joinPath)(context.generator.outputPath, `${protocol}.ts`);
+        files.push({ path: protocolFilePath, content: fileContent });
+        generatedProtocols.push(protocol);
+        protocolFiles[protocol] = fileContent;
+    }
+    // Generate index.ts with namespace re-exports
+    let indexContent;
+    if (generatedProtocols.length > 0) {
+        const ext = (0, utils_1.resolveImportExtension)(context.generator, context.config);
+        const imports = generatedProtocols
+            .map((p) => {
+            const importPath = (0, utils_1.appendImportExtension)(`./${p}`, ext);
+            return `import * as ${p} from '${importPath}';`;
+        })
+            .join('\n');
+        const exports = generatedProtocols.join(', ');
+        indexContent = `${imports}\n\nexport {${exports}};\n`;
+    }
+    else {
+        indexContent = '// No protocols generated\n';
+    }
+    const indexFilePath = (0, utils_1.joinPath)(context.generator.outputPath, 'index.ts');
+    files.push({ path: indexFilePath, content: indexContent });
+    return {
+        parameterRender: parameters,
+        payloadRender: payloads,
+        generator: context.generator,
+        renderedFunctions: externalProtocolFunctionInformation,
+        result: indexContent,
+        protocolFiles,
+        files
+    };
+}
+function validateContext(context) {
+    const { generator } = context;
+    if (!context.dependencyOutputs) {
+        throw new Error('Internal error, could not determine previous rendered outputs that is required for channel typescript generator');
+    }
+    const payloads = context.dependencyOutputs[generator.payloadGeneratorId];
+    const parameters = context.dependencyOutputs[generator.parameterGeneratorId];
+    const headers = context.dependencyOutputs[generator.headerGeneratorId];
+    if (!payloads) {
+        throw new Error('Internal error, could not determine previous rendered payloads generator that is required for channel TypeScript generator');
+    }
+    if (!parameters) {
+        throw new Error('Internal error, could not determine previous rendered parameters generator that is required for channel TypeScript generator');
+    }
+    if (!headers) {
+        throw new Error('Internal error, could not determine previous rendered headers generator that is required for channel TypeScript generator');
+    }
+    return { payloads, parameters, headers };
+}
+/**
+ * Make sure we include all dependencies, if not added manually, is added to the generators.
+ */
+function includeTypeScriptChannelDependencies(config, generator) {
+    const newGenerators = [];
+    const parameterGeneratorId = generator.parameterGeneratorId;
+    const payloadGeneratorId = generator.payloadGeneratorId;
+    const headerGeneratorId = generator.headerGeneratorId;
+    const hasParameterGenerator = config.generators.find((generatorSearch) => generatorSearch.id === parameterGeneratorId) !== undefined;
+    const hasPayloadGenerator = config.generators.find((generatorSearch) => generatorSearch.id === payloadGeneratorId) !== undefined;
+    const hasHeaderGenerator = config.generators.find((generatorSearch) => generatorSearch.id === headerGeneratorId) !== undefined;
+    if (!hasParameterGenerator) {
+        const defaultChannelParameterGenerator = {
+            ...parameters_1.defaultTypeScriptParametersOptions,
+            outputPath: (0, utils_1.joinPath)(generator.outputPath ?? '', './parameter')
+        };
+        newGenerators.push(defaultChannelParameterGenerator);
+    }
+    if (!hasPayloadGenerator) {
+        const defaultChannelPayloadGenerator = {
+            ...payloads_1.defaultTypeScriptPayloadGenerator,
+            outputPath: (0, utils_1.joinPath)(generator.outputPath ?? '', './payload')
+        };
+        newGenerators.push(defaultChannelPayloadGenerator);
+    }
+    if (!hasHeaderGenerator) {
+        const defaultChannelHeaderGenerator = {
+            ...headers_1.defaultTypeScriptHeadersOptions,
+            outputPath: (0, utils_1.joinPath)(generator.outputPath ?? '', './headers')
+        };
+        newGenerators.push(defaultChannelHeaderGenerator);
+    }
+    return newGenerators;
+}
+exports.includeTypeScriptChannelDependencies = includeTypeScriptChannelDependencies;

package/dist/codegen/generators/typescript/channels/openapi.d.ts

@@ -0,0 +1,9 @@
+import { TypeScriptParameterRenderType } from '../parameters';
+import { TypeScriptPayloadRenderType } from '../payloads';
+import { TypeScriptHeadersRenderType } from '../headers';
+import { TypeScriptChannelRenderedFunctionType, SupportedProtocols, TypeScriptChannelsContext } from './types';
+/**
+ * Generates TypeScript HTTP client channels from an OpenAPI document.
+ * Only supports http_client protocol - other protocols are ignored for OpenAPI input.
+ */
+export declare function generateTypeScriptChannelsForOpenAPI(context: TypeScriptChannelsContext, parameters: TypeScriptParameterRenderType, payloads: TypeScriptPayloadRenderType, headers: TypeScriptHeadersRenderType, protocolsToUse: SupportedProtocols[], protocolCodeFunctions: Record<string, string[]>, externalProtocolFunctionInformation: Record<string, TypeScriptChannelRenderedFunctionType[]>, protocolDependencies: Record<string, string[]>): Promise<void>;

package/dist/codegen/generators/typescript/channels/openapi.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypeScriptChannelsForOpenAPI = void 0;
+const utils_1 = require("./utils");
+const http_1 = require("./protocols/http");
+const utils_2 = require("./utils");
+const utils_3 = require("../utils");
+const errors_1 = require("../../../errors");
+const utils_4 = require("../../../utils");
+const security_1 = require("../../../inputs/openapi/security");
+const HTTP_METHODS = [
+    'get',
+    'post',
+    'put',
+    'patch',
+    'delete',
+    'options',
+    'head'
+];
+const METHODS_WITH_BODY = ['post', 'put', 'patch'];
+/**
+ * Generates TypeScript HTTP client channels from an OpenAPI document.
+ * Only supports http_client protocol - other protocols are ignored for OpenAPI input.
+ */
+async function generateTypeScriptChannelsForOpenAPI(context, parameters, payloads, headers, protocolsToUse, protocolCodeFunctions, externalProtocolFunctionInformation, protocolDependencies) {
+    // Only http_client is supported for OpenAPI
+    if (!protocolsToUse.includes('http_client')) {
+        return;
+    }
+    const { openapiDocument } = validateOpenAPIContext(context);
+    // Extract security schemes from the OpenAPI document
+    const securitySchemes = (0, security_1.extractSecuritySchemes)(openapiDocument);
+    // Collect dependencies
+    const deps = protocolDependencies['http_client'];
+    const importExtension = (0, utils_4.resolveImportExtension)(context.generator, context.config);
+    (0, utils_1.collectProtocolDependencies)(payloads, parameters, headers, context, deps, importExtension);
+    // Process all operations and collect renders
+    const renders = processOpenAPIOperations(openapiDocument, payloads, parameters);
+    // Generate common types once (stateless check)
+    // Pass security schemes to generate only relevant auth types
+    if (protocolCodeFunctions['http_client'].length === 0 && renders.length > 0) {
+        const commonTypesCode = (0, http_1.renderHttpCommonTypes)(securitySchemes);
+        protocolCodeFunctions['http_client'].unshift(commonTypesCode);
+    }
+    // Add renders to output
+    protocolCodeFunctions['http_client'].push(...renders.map((r) => r.code));
+    externalProtocolFunctionInformation['http_client'].push(...renders.map((r) => ({
+        functionType: r.functionType,
+        functionName: r.functionName,
+        messageType: r.messageType ?? '',
+        replyType: r.replyType,
+        parameterType: undefined
+    })));
+    // Add dependencies
+    const renderedDeps = renders.flatMap((r) => r.dependencies);
+    deps.push(...new Set(renderedDeps));
+}
+exports.generateTypeScriptChannelsForOpenAPI = generateTypeScriptChannelsForOpenAPI;
+/**
+ * Process all OpenAPI operations and generate HTTP client functions.
+ */
+function processOpenAPIOperations(openapiDocument, payloads, parameters) {
+    const renders = [];
+    for (const [path, pathItem] of Object.entries(openapiDocument.paths ?? {})) {
+        if (!pathItem) {
+            continue;
+        }
+        for (const method of HTTP_METHODS) {
+            const render = processOperation(pathItem, method, path, payloads, parameters);
+            if (render) {
+                renders.push(render);
+            }
+        }
+    }
+    return renders;
+}
+/**
+ * Process a single OpenAPI operation and generate an HTTP client function.
+ */
+function processOperation(pathItem, method, path, payloads, parameters) {
+    // eslint-disable-next-line security/detect-object-injection
+    const operation = pathItem[method];
+    if (!operation) {
+        return undefined;
+    }
+    const operationId = getOperationId(operation, method, path);
+    const hasBody = METHODS_WITH_BODY.includes(method);
+    // Look up payloads
+    const requestPayload = hasBody
+        ? // eslint-disable-next-line security/detect-object-injection
+            payloads.operationModels[operationId]
+        : undefined;
+    const responsePayloadKey = `${operationId}_Response`;
+    // eslint-disable-next-line security/detect-object-injection
+    const responsePayload = payloads.operationModels[responsePayloadKey];
+    // Look up parameters
+    // eslint-disable-next-line security/detect-object-injection
+    const parameterModel = parameters.channelModels[operationId];
+    // Get message types - handle undefined payloads
+    const requestMessageInfo = requestPayload
+        ? (0, utils_2.getMessageTypeAndModule)(requestPayload)
+        : {
+            messageModule: undefined,
+            messageType: undefined,
+            includesStatusCodes: false
+        };
+    const responseMessageInfo = responsePayload
+        ? (0, utils_2.getMessageTypeAndModule)(responsePayload)
+        : {
+            messageModule: undefined,
+            messageType: undefined,
+            includesStatusCodes: false
+        };
+    const { messageModule: requestMessageModule, messageType: requestMessageType } = requestMessageInfo;
+    const { messageModule: replyMessageModule, messageType: replyMessageType, includesStatusCodes: replyIncludesStatusCodes } = responseMessageInfo;
+    // Skip if no response type (nothing to generate)
+    if (!replyMessageType) {
+        return undefined;
+    }
+    // Extract operation metadata for JSDoc
+    const description = operation.description ?? operation.summary;
+    const deprecated = operation.deprecated === true;
+    // Generate the HTTP client function
+    return (0, http_1.renderHttpFetchClient)({
+        subName: (0, utils_3.pascalCase)(operationId),
+        requestMessageModule: hasBody ? requestMessageModule : undefined,
+        requestMessageType: hasBody ? requestMessageType : undefined,
+        replyMessageModule,
+        replyMessageType,
+        requestTopic: path,
+        method: method.toUpperCase(),
+        channelParameters: parameterModel?.model,
+        includesStatusCodes: replyIncludesStatusCodes,
+        description,
+        deprecated
+    });
+}
+/**
+ * Validates the context is for OpenAPI input and has a parsed document.
+ */
+function validateOpenAPIContext(context) {
+    const { openapiDocument, inputType } = context;
+    if (inputType !== 'openapi') {
+        throw (0, errors_1.createMissingInputDocumentError)({
+            expectedType: 'openapi',
+            generatorPreset: 'channels'
+        });
+    }
+    if (!openapiDocument) {
+        throw (0, errors_1.createMissingInputDocumentError)({
+            expectedType: 'openapi',
+            generatorPreset: 'channels'
+        });
+    }
+    return { openapiDocument };
+}
+/**
+ * Gets the operation ID from an OpenAPI operation.
+ * Falls back to generating one from method+path if not present.
+ */
+function getOperationId(operation, method, path) {
+    if (operation.operationId) {
+        return operation.operationId;
+    }
+    // Generate from method + path
+    const sanitizedPath = path.replace(/[^a-zA-Z0-9]/g, '');
+    return `${method}${sanitizedPath}`;
+}

package/dist/codegen/generators/typescript/channels/protocols/amqp/index.d.ts

@@ -0,0 +1,7 @@
+import { TypeScriptChannelRenderedFunctionType, TypeScriptChannelsGeneratorContext } from '../../types';
+import { renderPublishExchange } from './publishExchange';
+import { renderPublishQueue } from './publishQueue';
+import { renderSubscribeQueue } from './subscribeQueue';
+import { ChannelInterface } from '@asyncapi/parser';
+export { renderPublishExchange, renderPublishQueue, renderSubscribeQueue };
+export declare function generateAmqpChannels(context: TypeScriptChannelsGeneratorContext, channel: ChannelInterface, protocolCodeFunctions: Record<string, string[]>, externalProtocolFunctionInformation: Record<string, TypeScriptChannelRenderedFunctionType[]>, dependencies: string[]): Promise<void>;

package/dist/codegen/generators/typescript/channels/protocols/amqp/index.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAmqpChannels = exports.renderSubscribeQueue = exports.renderPublishQueue = exports.renderPublishExchange = void 0;
+/* eslint-disable sonarjs/cognitive-complexity */
+/* eslint-disable security/detect-object-injection */
+const types_1 = require("../../types");
+const utils_1 = require("../../../../../utils");
+const utils_2 = require("../../utils");
+const asyncapi_1 = require("../../asyncapi");
+const publishExchange_1 = require("./publishExchange");
+Object.defineProperty(exports, "renderPublishExchange", { enumerable: true, get: function () { return publishExchange_1.renderPublishExchange; } });
+const publishQueue_1 = require("./publishQueue");
+Object.defineProperty(exports, "renderPublishQueue", { enumerable: true, get: function () { return publishQueue_1.renderPublishQueue; } });
+const subscribeQueue_1 = require("./subscribeQueue");
+Object.defineProperty(exports, "renderSubscribeQueue", { enumerable: true, get: function () { return subscribeQueue_1.renderSubscribeQueue; } });
+const errors_1 = require("../../../../../errors");
+async function generateAmqpChannels(context, channel, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies) {
+    const { parameter, topic } = context;
+    const ignoreOperation = !context.generator.asyncapiGenerateForOperations;
+    const amqpContext = {
+        channelParameters: parameter,
+        channelHeaders: context.headers, // AMQP supports message properties as headers
+        topic,
+        messageType: '',
+        subName: context.subName,
+        payloadGenerator: context.payloads
+    };
+    const operations = channel.operations().all();
+    const renders = operations.length > 0 && !ignoreOperation
+        ? await generateForOperations(context, channel, amqpContext)
+        : await generateForChannels(context, channel, amqpContext);
+    addRendersToExternal(renders, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies, parameter);
+}
+exports.generateAmqpChannels = generateAmqpChannels;
+function addRendersToExternal(renders, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies, parameter) {
+    protocolCodeFunctions['amqp'].push(...renders.map((value) => value.code));
+    externalProtocolFunctionInformation['amqp'].push(...renders.map((value) => ({
+        functionType: value.functionType,
+        functionName: value.functionName,
+        messageType: value.messageType,
+        replyType: value.replyType,
+        parameterType: parameter?.type
+    })));
+    const renderedDependencies = renders
+        .map((value) => value.dependencies)
+        .flat(Infinity);
+    dependencies.push(...new Set(renderedDependencies));
+}
+async function generateForOperations(context, channel, amqpContext) {
+    const renders = [];
+    const { generator, payloads } = context;
+    const functionTypeMapping = generator.functionTypeMapping?.[channel.id()];
+    const exchangeName = channel.bindings().get('amqp')?.value()?.exchange?.name;
+    for (const operation of channel.operations().all()) {
+        const updatedFunctionTypeMapping = (0, asyncapi_1.getFunctionTypeMappingFromAsyncAPI)(operation) ?? functionTypeMapping;
+        const payloadId = (0, utils_1.findOperationId)(operation, channel);
+        const payload = payloads.operationModels[payloadId];
+        if (!payload) {
+            throw (0, errors_1.createMissingPayloadError)({
+                channelOrOperation: payloadId,
+                protocol: 'AMQP'
+            });
+        }
+        const { messageModule, messageType } = (0, utils_2.getMessageTypeAndModule)(payload);
+        if (messageType === undefined) {
+            throw new Error(`Could not find message type for channel typescript generator for AMQP`);
+        }
+        // Extract operation metadata for JSDoc
+        const { description, deprecated } = (0, utils_1.getOperationMetadata)(operation);
+        const updatedContext = {
+            ...amqpContext,
+            messageType,
+            messageModule,
+            subName: (0, utils_1.findNameFromOperation)(operation, channel),
+            description,
+            deprecated
+        };
+        renders.push(...generateOperationRenders(operation, updatedContext, updatedFunctionTypeMapping, generator, exchangeName));
+    }
+    return renders;
+}
+function generateOperationRenders(operation, amqpContext, functionTypeMapping, generator, exchangeName) {
+    const renders = [];
+    const action = operation.action();
+    const renderChecks = [
+        {
+            check: types_1.ChannelFunctionTypes.AMQP_EXCHANGE_PUBLISH,
+            render: publishExchange_1.renderPublishExchange,
+            additionalProperties: { exchange: exchangeName }
+        },
+        {
+            check: types_1.ChannelFunctionTypes.AMQP_QUEUE_PUBLISH,
+            render: publishQueue_1.renderPublishQueue
+        },
+        {
+            check: types_1.ChannelFunctionTypes.AMQP_QUEUE_SUBSCRIBE,
+            render: subscribeQueue_1.renderSubscribeQueue
+        }
+    ];
+    for (const { check, render, additionalProperties } of renderChecks) {
+        if ((0, asyncapi_1.shouldRenderFunctionType)(functionTypeMapping, check, action, generator.asyncapiReverseOperations)) {
+            renders.push(render({ ...amqpContext, additionalProperties }));
+        }
+    }
+    return renders;
+}
+async function generateForChannels(context, channel, amqpContext) {
+    const renders = [];
+    const { generator, payloads } = context;
+    const functionTypeMapping = (0, asyncapi_1.getFunctionTypeMappingFromAsyncAPI)(channel) ??
+        generator.functionTypeMapping?.[channel.id()];
+    const exchangeName = channel.bindings().get('amqp')?.value()?.exchange?.name;
+    const payload = payloads.channelModels[channel.id()];
+    if (!payload) {
+        throw (0, errors_1.createMissingPayloadError)({
+            channelOrOperation: channel.id(),
+            protocol: 'AMQP'
+        });
+    }
+    const { messageModule, messageType } = (0, utils_2.getMessageTypeAndModule)(payload);
+    if (messageType === undefined) {
+        throw new Error(`Could not find message type for channel typescript generator for AMQP`);
+    }
+    const updatedContext = { ...amqpContext, messageType, messageModule };
+    const renderChecks = [
+        {
+            check: types_1.ChannelFunctionTypes.AMQP_EXCHANGE_PUBLISH,
+            render: publishExchange_1.renderPublishExchange,
+            action: 'send',
+            additionalProperties: { exchange: exchangeName }
+        },
+        {
+            check: types_1.ChannelFunctionTypes.AMQP_QUEUE_PUBLISH,
+            render: publishQueue_1.renderPublishQueue,
+            action: 'send'
+        },
+        {
+            check: types_1.ChannelFunctionTypes.AMQP_QUEUE_SUBSCRIBE,
+            render: subscribeQueue_1.renderSubscribeQueue,
+            action: 'receive'
+        }
+    ];
+    for (const { check, render, action, additionalProperties } of renderChecks) {
+        if ((0, asyncapi_1.shouldRenderFunctionType)(functionTypeMapping, check, action, generator.asyncapiReverseOperations)) {
+            renders.push(render({ ...updatedContext, additionalProperties }));
+        }
+    }
+    return renders;
+}

package/dist/codegen/generators/typescript/channels/protocols/amqp/publishExchange.d.ts

@@ -0,0 +1,5 @@
+import { SingleFunctionRenderType } from '../../../../../types';
+import { RenderRegularParameters } from '../../types';
+export declare function renderPublishExchange({ topic, messageType, messageModule, channelParameters, channelHeaders, subName, functionName, additionalProperties, description, deprecated }: RenderRegularParameters<{
+    exchange: string | undefined;
+}>): SingleFunctionRenderType;