@alagoni97/cli 0.72.1

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

@@ -0,0 +1,99 @@
+"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 = `publishTo${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 headersHandling = channelHeaders
+        ? `// Set up user properties (headers) if provided
+      let publishOptions: Mqtt.IClientPublishOptions = {};
+      if (headers) {
+        const headerData = headers.marshal();
+        const parsedHeaders = typeof headerData === 'string' ? JSON.parse(headerData) : headerData;
+        const userProperties: Record<string, string> = {};
+        for (const [key, value] of Object.entries(parsedHeaders)) {
+          if (value !== undefined) {
+            userProperties[key] = String(value);
+          }
+        }
+        publishOptions.properties = { userProperties };
+      }`
+        : `let publishOptions: Mqtt.IClientPublishOptions = {};`;
+    const publishOperation = messageType === 'null'
+        ? `${headersHandling}
+      mqtt.publish(${addressToUse}, '', publishOptions);`
+        : `let dataToSend: any = ${messageMarshalling};
+      ${headersHandling}
+      mqtt.publish(${addressToUse}, dataToSend, publishOptions);`;
+    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 as MQTT user properties'
+                }
+            ]
+            : []),
+        {
+            parameter: 'mqtt',
+            parameterType: 'mqtt: Mqtt.MqttClient',
+            jsDoc: ' * @param mqtt the MQTT client to publish from'
+        }
+    ];
+    const jsDoc = (0, utils_2.renderChannelJSDoc)({
+        description,
+        deprecated,
+        fallbackDescription: `MQTT 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<void> {
+  return new Promise<void>(async (resolve, reject) => {
+    try {
+      ${publishOperation}
+      resolve();
+    } catch (e: any) {
+      reject(e);
+    }
+  });
+}`;
+    return {
+        messageType,
+        code,
+        functionName,
+        dependencies: [`import * as Mqtt from 'mqtt';`],
+        functionType: __1.ChannelFunctionTypes.MQTT_PUBLISH
+    };
+}
+exports.renderPublish = renderPublish;

package/dist/codegen/generators/typescript/channels/protocols/mqtt/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/mqtt/subscribe.js

@@ -0,0 +1,186 @@
+"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");
+/* eslint-disable sonarjs/cognitive-complexity */
+function renderSubscribe({ topic, messageType, messageModule, channelParameters, channelHeaders, subName = (0, utils_1.pascalCase)(topic), functionName = `subscribeTo${subName}`, payloadGenerator, description, deprecated }) {
+    const includeValidation = payloadGenerator.generator.includeValidation;
+    const addressToUse = channelParameters
+        ? `parameters.getChannelWithParameters('${topic}')`
+        : `'${topic}'`;
+    let messageUnmarshalling = `${messageType}.unmarshal(receivedData)`;
+    if (messageModule) {
+        messageUnmarshalling = `${messageModule}.unmarshal(receivedData)`;
+    }
+    // Constants for error messages and parameters
+    const PARSE_MESSAGE_ERROR = 'Failed to parse message: ${err.message}';
+    const PARSE_HEADERS_ERROR = 'Failed to parse headers: ${headerError}';
+    const PARAMETERS_PARAM = ', parameters';
+    const HEADERS_UNDEFINED_PARAM = ', headers: undefined';
+    const HEADERS_EXTRACTED_PARAM = ', headers: extractedHeaders';
+    const getValidationFailCallback = () => {
+        const baseError = `new Error(\`Invalid message payload received; $\{JSON.stringify({cause: errors})}\`)`;
+        const baseParams = `err: ${baseError}, msg: undefined`;
+        if (channelParameters && channelHeaders) {
+            return `onDataCallback({${baseParams}${PARAMETERS_PARAM}${HEADERS_EXTRACTED_PARAM}, mqttMsg: packet}); return;`;
+        }
+        if (channelParameters) {
+            return `onDataCallback({${baseParams}${PARAMETERS_PARAM}, mqttMsg: packet}); return;`;
+        }
+        if (channelHeaders) {
+            return `onDataCallback({${baseParams}${HEADERS_EXTRACTED_PARAM}, mqttMsg: packet}); return;`;
+        }
+        return `onDataCallback({${baseParams}, mqttMsg: packet}); return;`;
+    };
+    const { potentialValidatorCreation, potentialValidationFunction } = (0, utils_2.getValidationFunctions)({
+        includeValidation,
+        messageModule,
+        messageType,
+        onValidationFail: getValidationFailCallback()
+    });
+    messageType = messageModule ? `${messageModule}.${messageType}` : messageType;
+    const callbackFunctionParameters = [
+        {
+            parameter: 'err?: Error',
+            jsDoc: ' * @param err if any error occurred this will be set'
+        },
+        {
+            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 as MQTT user properties'
+                }
+            ]
+            : []),
+        {
+            parameter: `mqttMsg?: Mqtt.IPublishPacket`,
+            jsDoc: ' * @param mqttMsg the raw MQTT message packet'
+        }
+    ];
+    const functionParameters = [
+        {
+            parameter: `onDataCallback`,
+            parameterType: `onDataCallback: (params: {${callbackFunctionParameters.map((param) => param.parameter).join(', ')}}) => void`,
+            jsDoc: ` * @param onDataCallback to call when messages are received`
+        },
+        ...(channelParameters
+            ? [
+                {
+                    parameter: `parameters`,
+                    parameterType: `parameters: ${channelParameters.type}`,
+                    jsDoc: ' * @param parameters for topic substitution'
+                }
+            ]
+            : []),
+        {
+            parameter: 'mqtt',
+            parameterType: 'mqtt: Mqtt.MqttClient',
+            jsDoc: ' * @param mqtt the MQTT client to subscribe with'
+        },
+        {
+            parameter: 'skipMessageValidation = false',
+            parameterType: 'skipMessageValidation?: boolean',
+            jsDoc: ' * @param skipMessageValidation turn off runtime validation of incoming messages'
+        }
+    ];
+    // Generate message receiving code
+    const topicRegex = (0, utils_1.findRegexFromChannel)(topic);
+    const whenReceivingMessage = `
+    // Check if the received topic matches this subscription's pattern
+    const topicPattern = ${topicRegex};
+    if (!topicPattern.test(topic)) {
+      return; // Ignore messages not matching this subscription's topic pattern
+    }
+    
+    const receivedData = message.toString();
+    ${channelParameters ? `const parameters = ${channelParameters.type}.createFromChannel(topic, '${topic}', ${topicRegex});` : ''}
+    ${channelHeaders
+        ? `
+    // Extract headers from MQTT v5 user properties
+    let extractedHeaders: ${channelHeaders.type} | undefined;
+    if (packet.properties && packet.properties.userProperties) {
+      try {
+        extractedHeaders = ${channelHeaders.type}.unmarshal(packet.properties.userProperties);
+      } catch (headerError) {
+        onDataCallback({err: new Error(\`${PARSE_HEADERS_ERROR}\`), msg: undefined${channelParameters ? PARAMETERS_PARAM : ''}${channelHeaders ? HEADERS_UNDEFINED_PARAM : ''}, mqttMsg: packet});
+        return;
+      }
+    }`
+        : ''}
+    
+    try {
+      const parsedMessage = ${messageUnmarshalling};
+      ${potentialValidationFunction}
+      onDataCallback({err: undefined, msg: parsedMessage${channelParameters ? PARAMETERS_PARAM : ''}${channelHeaders ? HEADERS_EXTRACTED_PARAM : ''}, mqttMsg: packet});
+    } catch (err: any) {
+      onDataCallback({err: new Error(\`${PARSE_MESSAGE_ERROR}\`), msg: undefined${channelParameters ? PARAMETERS_PARAM : ''}${channelHeaders ? HEADERS_EXTRACTED_PARAM : ''}, mqttMsg: packet});
+    }`;
+    const callbackJsDocParameters = callbackFunctionParameters
+        .map((param) => param.jsDoc)
+        .join('\n');
+    const mainJsDoc = (0, utils_2.renderChannelJSDoc)({
+        description,
+        deprecated,
+        fallbackDescription: `MQTT 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<void> {
+  return new Promise<void>(async (resolve, reject) => {
+    try {
+      ${potentialValidatorCreation}
+
+      // Set up message listener
+      const messageHandler = (topic: string, message: Buffer, packet: Mqtt.IPublishPacket) => {
+        ${whenReceivingMessage}
+      };
+
+      mqtt.on('message', messageHandler);
+
+      // Subscribe to the topic
+      await mqtt.subscribeAsync(${addressToUse});
+
+      resolve();
+    } catch (e: any) {
+      reject(e);
+    }
+  });
+}`;
+    return {
+        messageType,
+        code,
+        functionName,
+        dependencies: [`import * as Mqtt from 'mqtt';`],
+        functionType: __1.ChannelFunctionTypes.MQTT_SUBSCRIBE
+    };
+}
+exports.renderSubscribe = renderSubscribe;

package/dist/codegen/generators/typescript/channels/protocols/nats/corePublish.d.ts

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

package/dist/codegen/generators/typescript/channels/protocols/nats/corePublish.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCorePublish = void 0;
+/* eslint-disable sonarjs/no-nested-template-literals */
+const __1 = require("../..");
+const utils_1 = require("../../../utils");
+const utils_2 = require("./utils");
+const utils_3 = require("../../utils");
+function renderCorePublish({ topic, messageType, messageModule, channelParameters, channelHeaders, subName = (0, utils_1.pascalCase)(topic), functionName = `publishTo${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 headerSetup = (0, utils_2.generateHeaderSetupCode)(channelHeaders);
+    const publishOperation = messageType === 'null'
+        ? `${headerSetup}
+      await nc.publish(${addressToUse}, Nats.Empty, options);`
+        : `let dataToSend: any = ${messageMarshalling};
+      ${headerSetup}
+dataToSend = codec.encode(dataToSend);
+nc.publish(${addressToUse}, dataToSend, options);`;
+    const headerParam = (0, utils_2.generateHeaderParameter)(channelHeaders);
+    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'
+                }
+            ]
+            : []),
+        ...(headerParam ? [headerParam] : []),
+        {
+            parameter: 'nc',
+            parameterType: 'nc: Nats.NatsConnection',
+            jsDoc: ' * @param nc the NATS client to publish from'
+        },
+        {
+            parameter: 'codec = Nats.JSONCodec()',
+            parameterType: 'codec?: Nats.Codec<any>',
+            jsDoc: ' * @param codec the serialization codec to use while transmitting the message'
+        },
+        {
+            parameter: 'options',
+            parameterType: 'options?: Nats.PublishOptions',
+            jsDoc: ' * @param options to use while publishing the message'
+        }
+    ];
+    const jsDoc = (0, utils_3.renderChannelJSDoc)({
+        description,
+        deprecated,
+        fallbackDescription: `NATS 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<void> {
+  return new Promise<void>(async (resolve, reject) => {
+    try {
+      ${publishOperation}
+      resolve();
+    } catch (e: any) {
+      reject(e);
+    }
+  });
+}`;
+    return {
+        messageType,
+        code,
+        functionName,
+        dependencies: [`import * as Nats from 'nats';`],
+        functionType: __1.ChannelFunctionTypes.NATS_PUBLISH
+    };
+}
+exports.renderCorePublish = renderCorePublish;

package/dist/codegen/generators/typescript/channels/protocols/nats/coreReply.d.ts

@@ -0,0 +1,3 @@
+import { RenderRequestReplyParameters } from '../../types';
+import { SingleFunctionRenderType } from '../../../../../types';
+export declare function renderCoreReply({ requestTopic, requestMessageType, requestMessageModule, replyMessageType, replyMessageModule, channelParameters, subName, payloadGenerator, functionName, description, deprecated }: RenderRequestReplyParameters): SingleFunctionRenderType;

package/dist/codegen/generators/typescript/channels/protocols/nats/coreReply.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCoreReply = void 0;
+/* eslint-disable sonarjs/no-nested-template-literals */
+/* eslint-disable no-nested-ternary */
+const types_1 = require("../../types");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../../utils");
+function renderCoreReply({ requestTopic, requestMessageType, requestMessageModule, replyMessageType, replyMessageModule, channelParameters, subName = (0, utils_1.pascalCase)(requestTopic), payloadGenerator, functionName = `replyTo${subName}`, description, deprecated }) {
+    const includeValidation = payloadGenerator.generator.includeValidation;
+    const addressToUse = channelParameters
+        ? `parameters.getChannelWithParameters('${requestTopic}')`
+        : `'${requestTopic}'`;
+    const messageType = requestMessageModule
+        ? `${requestMessageModule}.${requestMessageType}`
+        : requestMessageType;
+    const replyType = replyMessageModule ?? replyMessageType;
+    const { potentialValidatorCreation, potentialValidationFunction } = (0, utils_2.getValidationFunctions)({
+        includeValidation,
+        messageModule: requestMessageModule,
+        messageType: requestMessageType,
+        onValidationFail: channelParameters
+            ? `onDataCallback(new Error('Invalid request payload received', JSON.stringify({cause: errors})), undefined, parameters); continue;`
+            : `onDataCallback(new Error('Invalid request payload received', JSON.stringify({cause: errors})), undefined); continue;`
+    });
+    const callbackFunctionParameters = [
+        {
+            parameter: 'err?: Error',
+            jsDoc: ' * @param err if any error occurred this will be sat'
+        },
+        {
+            parameter: `requestMessage?: ${messageType}`,
+            jsDoc: ' * @param requestMessage that was received from the request'
+        },
+        ...(channelParameters
+            ? [
+                {
+                    parameter: `parameters?: ${channelParameters.type}`,
+                    jsDoc: ' * @param parameters that was received in the topic'
+                }
+            ]
+            : [])
+    ];
+    const functionParameters = [
+        {
+            parameter: `onDataCallback`,
+            parameterType: `onDataCallback: (${callbackFunctionParameters.map((param) => param.parameter).join(', ')}) => ${replyType} | Promise<${replyType}>`,
+            jsDoc: ` * @param {${functionName}Callback} onDataCallback to call when the request is received`
+        },
+        ...(channelParameters
+            ? [
+                {
+                    parameter: `parameters`,
+                    parameterType: `parameters: ${channelParameters.type}`,
+                    jsDoc: ' * @param parameters for topic substitution'
+                }
+            ]
+            : []),
+        {
+            parameter: 'nc',
+            parameterType: 'nc: Nats.NatsConnection',
+            jsDoc: ' * @param nc the nats client to setup the reply for'
+        },
+        {
+            parameter: 'codec = Nats.JSONCodec()',
+            parameterType: 'codec?: Nats.Codec<any>',
+            jsDoc: ' * @param codec the serialization codec to use when receiving request and transmitting reply'
+        },
+        {
+            parameter: 'options',
+            parameterType: 'options?: Nats.SubscriptionOptions',
+            jsDoc: ' * @param options when setting up the reply'
+        },
+        {
+            parameter: 'skipMessageValidation = false',
+            parameterType: 'skipMessageValidation?: boolean',
+            jsDoc: ' * @param skipMessageValidation turn off runtime validation of incoming messages'
+        }
+    ];
+    const receivingOperation = `let receivedData : any = codec.decode(msg.data);
+${potentialValidationFunction}
+const replyMessage = await onDataCallback(undefined, ${requestMessageModule ?? requestMessageType}.unmarshal(receivedData) ${channelParameters ? ', parameters ?? undefined' : ''});`;
+    const replyOperation = `let dataToSend : any = replyMessage.marshal();
+dataToSend = codec.encode(dataToSend);
+msg.respond(dataToSend);`;
+    const callbackJsDocParameters = callbackFunctionParameters
+        .map((param) => param.jsDoc)
+        .join('\n');
+    const jsDoc = (0, utils_2.renderChannelJSDoc)({
+        description,
+        deprecated,
+        fallbackDescription: `NATS reply operation for \`${requestTopic}\``,
+        parameters: functionParameters.map((param) => ({
+            jsDoc: param.jsDoc
+        }))
+    });
+    const code = `/**
+ * Callback for when receiving the request
+ *
+ * @callback ${functionName}Callback
+ ${callbackJsDocParameters}
+ */
+
+${jsDoc}
+function ${functionName}({
+  ${functionParameters.map((param) => param.parameter).join(', \n  ')}
+}: {
+  ${functionParameters.map((param) => param.parameterType).join(', \n  ')}
+}): Promise<Nats.Subscription> {
+  return new Promise(async (resolve, reject) => {
+    try {
+      let subscription = nc.subscribe(${addressToUse}, options);
+      ${potentialValidatorCreation}
+      (async () => {
+        for await (const msg of subscription) {
+          ${channelParameters ? `const parameters = ${channelParameters.type}.createFromChannel(msg.subject, '${requestTopic}', ${(0, utils_1.findRegexFromChannel)(requestTopic)})` : ''}
+
+          ${receivingOperation}
+
+          if (msg.reply) {
+            ${replyOperation}
+          } else {
+            onDataCallback(new Error('Expected request to need a reply, did not..'))
+          }
+        }
+      })();
+      resolve(subscription);
+    } catch (e: any) {
+      reject(e);
+    }
+  });
+}`;
+    return {
+        messageType,
+        replyType,
+        code,
+        functionName,
+        dependencies: [`import * as Nats from 'nats';`],
+        functionType: types_1.ChannelFunctionTypes.NATS_REPLY
+    };
+}
+exports.renderCoreReply = renderCoreReply;

package/dist/codegen/generators/typescript/channels/protocols/nats/coreRequest.d.ts

@@ -0,0 +1,3 @@
+import { RenderRequestReplyParameters } from '../../types';
+import { SingleFunctionRenderType } from '../../../../../types';
+export declare function renderCoreRequest({ requestTopic, requestMessageType, requestMessageModule, replyMessageType, replyMessageModule, channelParameters, subName, payloadGenerator, functionName, description, deprecated }: RenderRequestReplyParameters): SingleFunctionRenderType;

package/dist/codegen/generators/typescript/channels/protocols/nats/coreRequest.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCoreRequest = void 0;
+/* eslint-disable sonarjs/no-nested-template-literals */
+/* eslint-disable no-nested-ternary */
+const types_1 = require("../../types");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../../utils");
+function renderCoreRequest({ requestTopic, requestMessageType, requestMessageModule, replyMessageType, replyMessageModule, channelParameters, subName = (0, utils_1.pascalCase)(requestTopic), payloadGenerator, functionName = `requestTo${subName}`, description, deprecated }) {
+    const includeValidation = payloadGenerator.generator.includeValidation;
+    const addressToUse = channelParameters
+        ? `parameters.getChannelWithParameters('${requestTopic}')`
+        : `'${requestTopic}'`;
+    const requestType = requestMessageModule
+        ? `${requestMessageModule}.${requestMessageType}`
+        : requestMessageType;
+    const replyType = replyMessageModule
+        ? `${replyMessageModule}.${replyMessageType}`
+        : replyMessageType;
+    const { potentialValidatorCreation, potentialValidationFunction } = (0, utils_2.getValidationFunctions)({
+        includeValidation,
+        messageModule: replyMessageModule,
+        messageType: replyMessageType,
+        onValidationFail: `return reject(new Error(\`Invalid message payload received; $\{JSON.stringify({cause: errors})}\`));`
+    });
+    const functionParameters = [
+        {
+            parameter: `requestMessage`,
+            parameterType: `requestMessage: ${requestType}`,
+            jsDoc: ` * @param requestMessage the message to send`
+        },
+        ...(channelParameters
+            ? [
+                {
+                    parameter: `parameters`,
+                    parameterType: `parameters: ${channelParameters.type}`,
+                    jsDoc: ' * @param parameters for topic substitution'
+                }
+            ]
+            : []),
+        {
+            parameter: 'nc',
+            parameterType: 'nc: Nats.NatsConnection',
+            jsDoc: ' * @param nc the nats client to setup the request for'
+        },
+        {
+            parameter: 'codec = Nats.JSONCodec()',
+            parameterType: 'codec?: Nats.Codec<any>',
+            jsDoc: ' * @param codec the serialization codec to use when transmitting request and receiving reply'
+        },
+        {
+            parameter: 'options',
+            parameterType: 'options?: Nats.RequestOptions',
+            jsDoc: ' * @param options when sending the request'
+        },
+        {
+            parameter: 'skipMessageValidation = false',
+            parameterType: 'skipMessageValidation?: boolean',
+            jsDoc: ' * @param skipMessageValidation turn off runtime validation of incoming messages'
+        }
+    ];
+    const jsDoc = (0, utils_2.renderChannelJSDoc)({
+        description,
+        deprecated,
+        fallbackDescription: `NATS request operation for \`${requestTopic}\``,
+        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<${replyType}> {
+  return new Promise(async (resolve, reject) => {
+    try {
+      ${potentialValidatorCreation}
+      let dataToSend: any = requestMessage.marshal();
+      dataToSend = codec.encode(dataToSend);
+
+      const msg = await nc.request(${addressToUse}, dataToSend, options);
+      const receivedData: any = codec.decode(msg.data);
+      ${potentialValidationFunction}
+      resolve(${replyMessageModule ? `${replyMessageModule}.unmarshal(receivedData)` : `${replyMessageType}.unmarshal(receivedData)`});
+    } catch (e: any) {
+      reject(e);
+    }
+  });
+}`;
+    return {
+        messageType: requestType,
+        replyType,
+        code,
+        functionName,
+        dependencies: [`import * as Nats from 'nats';`],
+        functionType: types_1.ChannelFunctionTypes.NATS_REQUEST
+    };
+}
+exports.renderCoreRequest = renderCoreRequest;

package/dist/codegen/generators/typescript/channels/protocols/nats/coreSubscribe.d.ts

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