@alagoni97/cli 0.72.1

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

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateKafkaChannels = exports.renderSubscribe = exports.renderPublish = 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 publish_1 = require("./publish");
+Object.defineProperty(exports, "renderPublish", { enumerable: true, get: function () { return publish_1.renderPublish; } });
+const subscribe_1 = require("./subscribe");
+Object.defineProperty(exports, "renderSubscribe", { enumerable: true, get: function () { return subscribe_1.renderSubscribe; } });
+const errors_1 = require("../../../../../errors");
+async function generateKafkaChannels(context, channel, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies) {
+    const { parameter, topic } = context;
+    const ignoreOperation = !context.generator.asyncapiGenerateForOperations;
+    let kafkaTopic = topic.startsWith('/') ? topic.slice(1) : topic;
+    kafkaTopic = kafkaTopic.replace(/\//g, context.generator.kafkaTopicSeparator);
+    const kafkaContext = {
+        channelParameters: parameter,
+        channelHeaders: context.headers, // Kafka supports headers
+        topic: kafkaTopic,
+        messageType: '',
+        subName: context.subName,
+        payloadGenerator: context.payloads
+    };
+    const operations = channel.operations().all();
+    const renders = operations.length > 0 && !ignoreOperation
+        ? await generateForOperations(context, channel, kafkaContext)
+        : await generateForChannels(context, channel, kafkaContext);
+    addRendersToExternal(renders, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies, parameter);
+}
+exports.generateKafkaChannels = generateKafkaChannels;
+function addRendersToExternal(renders, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies, parameter) {
+    protocolCodeFunctions['kafka'].push(...renders.map((value) => value.code));
+    externalProtocolFunctionInformation['kafka'].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, kafkaContext) {
+    const renders = [];
+    const { generator, payloads } = context;
+    const functionTypeMapping = generator.functionTypeMapping?.[channel.id()];
+    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: 'Kafka'
+            });
+        }
+        const { messageModule, messageType } = (0, utils_2.getMessageTypeAndModule)(payload);
+        if (messageType === undefined) {
+            throw new Error(`Could not find message type for channel typescript generator for Kafka`);
+        }
+        // Extract operation metadata for JSDoc
+        const { description, deprecated } = (0, utils_1.getOperationMetadata)(operation);
+        const updatedContext = {
+            ...kafkaContext,
+            messageType,
+            messageModule,
+            subName: (0, utils_1.findNameFromOperation)(operation, channel),
+            description,
+            deprecated
+        };
+        renders.push(...generateOperationRenders(operation, updatedContext, updatedFunctionTypeMapping, generator));
+    }
+    return renders;
+}
+function generateOperationRenders(operation, kafkaContext, functionTypeMapping, generator) {
+    const renders = [];
+    const action = operation.action();
+    if ((0, asyncapi_1.shouldRenderFunctionType)(functionTypeMapping, types_1.ChannelFunctionTypes.KAFKA_PUBLISH, action, generator.asyncapiReverseOperations)) {
+        renders.push((0, publish_1.renderPublish)(kafkaContext));
+    }
+    if ((0, asyncapi_1.shouldRenderFunctionType)(functionTypeMapping, types_1.ChannelFunctionTypes.KAFKA_SUBSCRIBE, action, generator.asyncapiReverseOperations)) {
+        renders.push((0, subscribe_1.renderSubscribe)(kafkaContext));
+    }
+    return renders;
+}
+async function generateForChannels(context, channel, kafkaContext) {
+    const renders = [];
+    const { generator, payloads } = context;
+    const functionTypeMapping = (0, asyncapi_1.getFunctionTypeMappingFromAsyncAPI)(channel) ??
+        generator.functionTypeMapping?.[channel.id()];
+    const payload = payloads.channelModels[channel.id()];
+    if (!payload) {
+        throw (0, errors_1.createMissingPayloadError)({
+            channelOrOperation: channel.id(),
+            protocol: 'Kafka'
+        });
+    }
+    const { messageModule, messageType } = (0, utils_2.getMessageTypeAndModule)(payload);
+    if (messageType === undefined) {
+        throw new Error(`Could not find message type for channel typescript generator for Kafka`);
+    }
+    const updatedContext = { ...kafkaContext, messageType, messageModule };
+    const renderChecks = [
+        {
+            check: types_1.ChannelFunctionTypes.KAFKA_PUBLISH,
+            render: publish_1.renderPublish,
+            action: 'send'
+        },
+        {
+            check: types_1.ChannelFunctionTypes.KAFKA_SUBSCRIBE,
+            render: subscribe_1.renderSubscribe,
+            action: 'receive'
+        }
+    ];
+    for (const { check, render, action } of renderChecks) {
+        if ((0, asyncapi_1.shouldRenderFunctionType)(functionTypeMapping, check, action, generator.asyncapiReverseOperations)) {
+            renders.push(render(updatedContext));
+        }
+    }
+    return renders;
+}

package/dist/codegen/generators/typescript/channels/protocols/kafka/publish.d.ts

@@ -0,0 +1,3 @@
+import { SingleFunctionRenderType } from '../../../../../types';
+import { RenderRegularParameters } from '../../types';
+export declare function renderPublish({ topic, messageType, messageModule, channelParameters, channelHeaders, subName, functionName, description, deprecated }: RenderRegularParameters): SingleFunctionRenderType;

package/dist/codegen/generators/typescript/channels/protocols/kafka/publish.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderPublish = void 0;
+/* eslint-disable sonarjs/no-nested-template-literals */
+const __1 = require("../..");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../../utils");
+function renderPublish({ topic, messageType, messageModule, channelParameters, channelHeaders, subName = (0, utils_1.pascalCase)(topic), functionName = `produceTo${subName}`, description, deprecated }) {
+    const addressToUse = channelParameters
+        ? `parameters.getChannelWithParameters('${topic}')`
+        : `'${topic}'`;
+    let messageMarshalling = 'message.marshal()';
+    if (messageModule) {
+        messageMarshalling = `${messageModule}.marshal(message)`;
+    }
+    messageType = messageModule ? `${messageModule}.${messageType}` : messageType;
+    const publishOperation = messageType === 'null'
+        ? `let dataToSend: any = null;`
+        : `let dataToSend: any = ${messageMarshalling};`;
+    const functionParameters = [
+        {
+            parameter: `message`,
+            parameterType: `message: ${messageType}`,
+            jsDoc: ' * @param message to publish'
+        },
+        ...(channelParameters
+            ? [
+                {
+                    parameter: `parameters`,
+                    parameterType: `parameters: ${channelParameters.type}`,
+                    jsDoc: ' * @param parameters for topic substitution'
+                }
+            ]
+            : []),
+        ...(channelHeaders
+            ? [
+                {
+                    parameter: `headers`,
+                    parameterType: `headers?: ${channelHeaders.type}`,
+                    jsDoc: ' * @param headers optional headers to include with the message'
+                }
+            ]
+            : []),
+        {
+            parameter: 'kafka',
+            parameterType: 'kafka: Kafka.Kafka',
+            jsDoc: ' * @param kafka the KafkaJS client to publish from'
+        }
+    ];
+    const headersHandling = channelHeaders
+        ? `// Set up headers if provided
+      let messageHeaders: Record<string, string> | undefined = undefined;
+      if (headers) {
+        const headerData = headers.marshal();
+        const parsedHeaders = typeof headerData === 'string' ? JSON.parse(headerData) : headerData;
+        messageHeaders = {};
+        for (const [key, value] of Object.entries(parsedHeaders)) {
+          if (value !== undefined) {
+            messageHeaders[key] = String(value);
+          }
+        }
+      }`
+        : '';
+    const headersInMessage = channelHeaders ? 'headers: messageHeaders' : '';
+    const jsDoc = (0, utils_2.renderChannelJSDoc)({
+        description,
+        deprecated,
+        fallbackDescription: `Kafka publish operation for \`${topic}\``,
+        parameters: functionParameters.map((param) => ({
+            jsDoc: param.jsDoc
+        }))
+    });
+    const code = `${jsDoc}
+function ${functionName}({
+  ${functionParameters.map((param) => param.parameter).join(', \n  ')}
+}: {
+  ${functionParameters.map((param) => param.parameterType).join(', \n  ')}
+}): Promise<Kafka.Producer> {
+  return new Promise(async (resolve, reject) => {
+    try {
+      ${publishOperation}
+      const producer = kafka.producer();
+      await producer.connect();
+      ${headersHandling}
+
+      await producer.send({
+        topic: ${addressToUse},
+        messages: [
+          {
+            value: dataToSend${channelHeaders ? `,\n            ${headersInMessage}` : ''}
+          },
+        ],
+      });
+      resolve(producer);
+    } catch (e: any) {
+      reject(e);
+    }
+  });
+}`;
+    return {
+        messageType,
+        code,
+        functionName,
+        dependencies: [`import * as Kafka from 'kafkajs';`],
+        functionType: __1.ChannelFunctionTypes.KAFKA_PUBLISH
+    };
+}
+exports.renderPublish = renderPublish;

package/dist/codegen/generators/typescript/channels/protocols/kafka/subscribe.d.ts

@@ -0,0 +1,3 @@
+import { SingleFunctionRenderType } from '../../../../../types';
+import { RenderRegularParameters } from '../../types';
+export declare function renderSubscribe({ topic, messageType, messageModule, channelParameters, channelHeaders, subName, functionName, payloadGenerator, description, deprecated }: RenderRegularParameters): SingleFunctionRenderType;

package/dist/codegen/generators/typescript/channels/protocols/kafka/subscribe.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderSubscribe = void 0;
+/* eslint-disable sonarjs/no-nested-template-literals */
+/* eslint-disable no-nested-ternary */
+const __1 = require("../..");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../../utils");
+const utils_3 = require("./utils");
+function renderSubscribe({ topic, messageType, messageModule, channelParameters, channelHeaders, subName = (0, utils_1.pascalCase)(topic), functionName = `consumeFrom${subName}`, payloadGenerator, description, deprecated }) {
+    const includeValidation = payloadGenerator.generator.includeValidation;
+    const addressToUse = channelParameters
+        ? `parameters.getChannelWithParameters('${topic}')`
+        : `'${topic}'`;
+    const messageUnmarshalling = `${messageModule ?? messageType}.unmarshal(receivedData)`;
+    messageType = messageModule ? `${messageModule}.${messageType}` : messageType;
+    const { potentialValidatorCreation, potentialValidationFunction } = (0, utils_2.getValidationFunctions)({
+        includeValidation,
+        messageModule,
+        messageType,
+        onValidationFail: channelParameters && channelHeaders
+            ? `return onDataCallback(new Error(\`Invalid message payload received; $\{JSON.stringify({cause: errors})}\`), undefined, parameters, extractedHeaders, kafkaMessage);`
+            : channelParameters
+                ? `return onDataCallback(new Error(\`Invalid message payload received; $\{JSON.stringify({cause: errors})}\`), undefined, parameters, kafkaMessage);`
+                : channelHeaders
+                    ? `return onDataCallback(new Error(\`Invalid message payload received; $\{JSON.stringify({cause: errors})}\`), undefined, extractedHeaders, kafkaMessage);`
+                    : `return onDataCallback(new Error(\`Invalid message payload received; $\{JSON.stringify({cause: errors})}\`), undefined, kafkaMessage);`
+    });
+    const callbackFunctionParameters = [
+        {
+            parameter: 'err?: Error',
+            jsDoc: ' * @param err if any error occurred this will be sat'
+        },
+        {
+            parameter: `msg?: ${messageType}`,
+            jsDoc: ' * @param msg that was received'
+        },
+        ...(channelParameters
+            ? [
+                {
+                    parameter: `parameters?: ${channelParameters.type}`,
+                    jsDoc: ' * @param parameters that was received in the topic'
+                }
+            ]
+            : []),
+        ...(channelHeaders
+            ? [
+                {
+                    parameter: `headers?: ${channelHeaders.type}`,
+                    jsDoc: ' * @param headers that was received with the message'
+                }
+            ]
+            : []),
+        {
+            parameter: `kafkaMsg?: Kafka.EachMessagePayload`,
+            jsDoc: ' * @param kafkaMsg'
+        }
+    ];
+    const functionParameters = [
+        {
+            parameter: `onDataCallback`,
+            parameterType: `onDataCallback: (${callbackFunctionParameters.map((param) => param.parameter).join(', ')}) => void`,
+            jsDoc: ` * @param {${functionName}Callback} onDataCallback to call when messages are received`
+        },
+        ...(channelParameters
+            ? [
+                {
+                    parameter: `parameters`,
+                    parameterType: `parameters: ${channelParameters.type}`,
+                    jsDoc: ' * @param parameters for topic substitution'
+                }
+            ]
+            : []),
+        {
+            parameter: 'kafka',
+            parameterType: 'kafka: Kafka.Kafka',
+            jsDoc: ' * @param kafka the KafkaJS client to subscribe through'
+        },
+        {
+            parameter: `options = {fromBeginning: true, groupId: ''}`,
+            parameterType: `options: {fromBeginning: boolean, groupId: string}`,
+            jsDoc: ' * @param options when setting up the subscription'
+        },
+        {
+            parameter: 'skipMessageValidation = false',
+            parameterType: 'skipMessageValidation?: boolean',
+            jsDoc: ' * @param skipMessageValidation turn off runtime validation of incoming messages'
+        }
+    ];
+    // Generate message receiving code using utility function
+    const whenReceivingMessage = (0, utils_3.generateKafkaMessageReceivingCode)({
+        channelParameters,
+        channelHeaders,
+        messageType,
+        messageUnmarshalling,
+        potentialValidationFunction
+    });
+    const callbackJsDocParameters = callbackFunctionParameters
+        .map((param) => param.jsDoc)
+        .join('\n');
+    const mainJsDoc = (0, utils_2.renderChannelJSDoc)({
+        description,
+        deprecated,
+        fallbackDescription: `Kafka subscription for \`${topic}\``,
+        parameters: functionParameters.map((param) => ({
+            jsDoc: param.jsDoc
+        }))
+    });
+    const code = `/**
+ * Callback for when receiving messages
+ *
+ * @callback ${functionName}Callback
+${callbackJsDocParameters}
+ */
+
+${mainJsDoc}
+function ${functionName}({
+  ${functionParameters.map((param) => param.parameter).join(', \n  ')}
+}: {
+  ${functionParameters.map((param) => param.parameterType).join(', \n  ')}
+}): Promise<Kafka.Consumer> {
+  return new Promise(async (resolve, reject) => {
+    try {
+      if(!options.groupId) {
+        return reject('No group ID provided');
+      }
+      const consumer = kafka.consumer({ groupId: options.groupId });
+
+      ${potentialValidatorCreation}
+      await consumer.connect();
+      await consumer.subscribe({ topic: ${addressToUse}, fromBeginning: options.fromBeginning });
+      await consumer.run({
+        eachMessage: async (kafkaMessage: Kafka.EachMessagePayload) => {
+          const { topic, message } = kafkaMessage;
+          const receivedData = message.value?.toString()!;
+          ${channelParameters ? `const parameters = ${channelParameters.type}.createFromChannel(topic, '${topic}', ${(0, utils_1.findRegexFromChannel)(topic)});` : ''}
+          ${whenReceivingMessage}
+        }
+      });
+      resolve(consumer);
+    } catch (e: any) {
+      reject(e);
+    }
+  });
+}`;
+    return {
+        messageType,
+        code,
+        functionName,
+        dependencies: [`import * as Kafka from 'kafkajs';`],
+        functionType: __1.ChannelFunctionTypes.KAFKA_SUBSCRIBE
+    };
+}
+exports.renderSubscribe = renderSubscribe;

package/dist/codegen/generators/typescript/channels/protocols/kafka/utils.d.ts

@@ -0,0 +1,11 @@
+import { ConstrainedObjectModel } from '@asyncapi/modelina';
+/**
+ * Generates the message receiving code for Kafka subscribe functions
+ */
+export declare function generateKafkaMessageReceivingCode({ channelParameters, channelHeaders, messageType, messageUnmarshalling, potentialValidationFunction }: {
+    channelParameters?: ConstrainedObjectModel;
+    channelHeaders?: ConstrainedObjectModel;
+    messageType: string;
+    messageUnmarshalling: string;
+    potentialValidationFunction: string;
+}): string;

package/dist/codegen/generators/typescript/channels/protocols/kafka/utils.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateKafkaMessageReceivingCode = void 0;
+/**
+ * Generates the message receiving code for Kafka subscribe functions
+ */
+function generateKafkaMessageReceivingCode({ channelParameters, channelHeaders, messageType, messageUnmarshalling, potentialValidationFunction }) {
+    // Generate header extraction code
+    const headerExtraction = channelHeaders
+        ? `
+          // Extract headers if present
+          let extractedHeaders: ${channelHeaders.type} | undefined = undefined;
+          if (message.headers) {
+            const headerObj: Record<string, any> = {};
+            for (const [key, value] of Object.entries(message.headers)) {
+              if (value !== undefined) {
+                headerObj[key] = value.toString();
+              }
+            }
+            extractedHeaders = ${channelHeaders.type}.unmarshal(headerObj);
+          }`
+        : '';
+    if (channelParameters && channelHeaders) {
+        if (messageType === 'null') {
+            return `${headerExtraction}
+          onDataCallback(undefined, null, parameters, extractedHeaders, kafkaMessage);`;
+        }
+        return `${headerExtraction}
+${potentialValidationFunction}
+const callbackData = ${messageUnmarshalling};
+onDataCallback(undefined, callbackData, parameters, extractedHeaders, kafkaMessage);`;
+    }
+    else if (channelParameters) {
+        if (messageType === 'null') {
+            return `onDataCallback(undefined, null, parameters, kafkaMessage);`;
+        }
+        return `${potentialValidationFunction}
+const callbackData = ${messageUnmarshalling};
+onDataCallback(undefined, callbackData, parameters, kafkaMessage);`;
+    }
+    else if (channelHeaders) {
+        if (messageType === 'null') {
+            return `${headerExtraction}
+          onDataCallback(undefined, null, extractedHeaders, kafkaMessage);`;
+        }
+        return `${headerExtraction}
+${potentialValidationFunction}
+const callbackData = ${messageUnmarshalling};
+onDataCallback(undefined, callbackData, extractedHeaders, kafkaMessage);`;
+    }
+    else if (messageType === 'null') {
+        return `onDataCallback(undefined, null, kafkaMessage);`;
+    }
+    return `${potentialValidationFunction}
+const callbackData = ${messageUnmarshalling};
+onDataCallback(undefined, callbackData, kafkaMessage);`;
+}
+exports.generateKafkaMessageReceivingCode = generateKafkaMessageReceivingCode;

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

@@ -0,0 +1,6 @@
+import { TypeScriptChannelRenderedFunctionType, TypeScriptChannelsGeneratorContext } from '../../types';
+import { renderPublish } from './publish';
+import { renderSubscribe } from './subscribe';
+import { ChannelInterface } from '@asyncapi/parser';
+export { renderPublish, renderSubscribe };
+export declare function generateMqttChannels(context: TypeScriptChannelsGeneratorContext, channel: ChannelInterface, protocolCodeFunctions: Record<string, string[]>, externalProtocolFunctionInformation: Record<string, TypeScriptChannelRenderedFunctionType[]>, dependencies: string[]): Promise<void>;

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMqttChannels = exports.renderSubscribe = exports.renderPublish = 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 publish_1 = require("./publish");
+Object.defineProperty(exports, "renderPublish", { enumerable: true, get: function () { return publish_1.renderPublish; } });
+const subscribe_1 = require("./subscribe");
+Object.defineProperty(exports, "renderSubscribe", { enumerable: true, get: function () { return subscribe_1.renderSubscribe; } });
+const asyncapi_1 = require("../../asyncapi");
+const errors_1 = require("../../../../../errors");
+async function generateMqttChannels(context, channel, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies) {
+    const { generator, parameter, topic } = context;
+    const ignoreOperation = !generator.asyncapiGenerateForOperations;
+    const mqttContext = {
+        channelParameters: parameter,
+        channelHeaders: context.headers, // MQTT v5 supports user properties as headers
+        topic,
+        subName: context.subName,
+        messageType: '',
+        payloadGenerator: context.payloads
+    };
+    let renders = [];
+    const operations = channel.operations().all();
+    if (operations.length > 0 && !ignoreOperation) {
+        renders = generateForOperations(context, channel, mqttContext);
+    }
+    else {
+        renders = generateForChannels(context, channel, mqttContext);
+    }
+    addRendersToExternal(renders, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies, parameter);
+}
+exports.generateMqttChannels = generateMqttChannels;
+function addRendersToExternal(renders, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies, parameter) {
+    protocolCodeFunctions['mqtt'].push(...renders.map((value) => value.code));
+    externalProtocolFunctionInformation['mqtt'].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));
+}
+function generateForOperations(context, channel, mqttContext) {
+    const renders = [];
+    const { generator, payloads } = context;
+    const functionTypeMapping = generator.functionTypeMapping?.[channel.id()];
+    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 === undefined) {
+            throw (0, errors_1.createMissingPayloadError)({
+                channelOrOperation: payloadId,
+                protocol: 'MQTT'
+            });
+        }
+        const { messageModule, messageType } = (0, utils_2.getMessageTypeAndModule)(payload);
+        if (messageType === undefined) {
+            throw new Error(`Could not find message type for ${payloadId} for mqtt channel typescript generator`);
+        }
+        // Extract operation metadata for JSDoc
+        const { description, deprecated } = (0, utils_1.getOperationMetadata)(operation);
+        const updatedContext = {
+            ...mqttContext,
+            messageType,
+            messageModule,
+            subName: (0, utils_1.findNameFromOperation)(operation, channel),
+            description,
+            deprecated
+        };
+        const action = operation.action();
+        if ((0, asyncapi_1.shouldRenderFunctionType)(updatedFunctionTypeMapping, types_1.ChannelFunctionTypes.MQTT_PUBLISH, action, generator.asyncapiReverseOperations)) {
+            renders.push((0, publish_1.renderPublish)(updatedContext));
+        }
+        if ((0, asyncapi_1.shouldRenderFunctionType)(updatedFunctionTypeMapping, types_1.ChannelFunctionTypes.MQTT_SUBSCRIBE, action, generator.asyncapiReverseOperations)) {
+            renders.push((0, subscribe_1.renderSubscribe)(updatedContext));
+        }
+    }
+    return renders;
+}
+function generateForChannels(context, channel, mqttContext) {
+    const renders = [];
+    const { generator, payloads } = context;
+    const functionTypeMapping = generator.functionTypeMapping?.[channel.id()];
+    const updatedFunctionTypeMapping = (0, asyncapi_1.getFunctionTypeMappingFromAsyncAPI)(channel) ?? functionTypeMapping;
+    const payload = payloads.channelModels[channel.id()];
+    if (payload === undefined) {
+        throw (0, errors_1.createMissingPayloadError)({
+            channelOrOperation: channel.id(),
+            protocol: 'MQTT'
+        });
+    }
+    const { messageModule, messageType } = (0, utils_2.getMessageTypeAndModule)(payload);
+    if (messageType === undefined) {
+        throw new Error(`Could not find message type for ${channel.id()} for mqtt channel typescript generator`);
+    }
+    const updatedContext = { ...mqttContext, messageType, messageModule };
+    if ((0, asyncapi_1.shouldRenderFunctionType)(updatedFunctionTypeMapping, types_1.ChannelFunctionTypes.MQTT_PUBLISH, 'send', generator.asyncapiReverseOperations)) {
+        renders.push((0, publish_1.renderPublish)(updatedContext));
+    }
+    if ((0, asyncapi_1.shouldRenderFunctionType)(updatedFunctionTypeMapping, types_1.ChannelFunctionTypes.MQTT_SUBSCRIBE, 'receive', generator.asyncapiReverseOperations)) {
+        renders.push((0, subscribe_1.renderSubscribe)(updatedContext));
+    }
+    return renders;
+}

package/dist/codegen/generators/typescript/channels/protocols/mqtt/publish.d.ts

@@ -0,0 +1,3 @@
+import { SingleFunctionRenderType } from '../../../../../types';
+import { RenderRegularParameters } from '../../types';
+export declare function renderPublish({ topic, messageType, messageModule, channelParameters, channelHeaders, subName, functionName, description, deprecated }: RenderRegularParameters): SingleFunctionRenderType;