@alagoni97/cli 0.72.1

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

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCoreSubscribe = 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 renderCoreSubscribe({ topic, messageType, messageModule, channelParameters, channelHeaders, subName = (0, utils_1.pascalCase)(topic), payloadGenerator, functionName = `subscribeTo${subName}`, 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)`;
+    }
+    const { potentialValidatorCreation, potentialValidationFunction } = (0, utils_2.getValidationFunctions)({
+        includeValidation,
+        messageModule,
+        messageType,
+        onValidationFail: `onDataCallback(new Error(\`Invalid message payload received; $\{JSON.stringify({cause: errors})}\`), undefined,${channelParameters ? 'parameters, ' : ''}${channelHeaders ? 'extractedHeaders, ' : ''} msg); continue;`
+    });
+    messageType = messageModule ? `${messageModule}.${messageType}` : messageType;
+    const headerCallbackParam = (0, utils_3.generateHeaderCallbackParameter)(channelHeaders);
+    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'
+                }
+            ]
+            : []),
+        ...(headerCallbackParam ? [headerCallbackParam] : []),
+        {
+            parameter: `natsMsg?: Nats.Msg`,
+            jsDoc: ' * @param natsMsg'
+        }
+    ];
+    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: 'nc',
+            parameterType: 'nc: Nats.NatsConnection',
+            jsDoc: ' * @param nc the nats client to setup the subscribe for'
+        },
+        {
+            parameter: 'codec = Nats.JSONCodec()',
+            parameterType: 'codec?: Nats.Codec<any>',
+            jsDoc: ' * @param codec the serialization codec to use while receiving the message'
+        },
+        {
+            parameter: 'options',
+            parameterType: 'options?: Nats.SubscriptionOptions',
+            jsDoc: ' * @param options when setting up the subscription'
+        },
+        {
+            parameter: 'skipMessageValidation = false',
+            parameterType: 'skipMessageValidation?: boolean',
+            jsDoc: ' * @param skipMessageValidation turn off runtime validation of incoming messages'
+        }
+    ];
+    const headerExtraction = (0, utils_3.generateHeaderExtractionCode)(channelHeaders);
+    const whenReceivingMessage = (0, utils_3.generateMessageReceivingCode)({
+        channelParameters,
+        channelHeaders,
+        messageType,
+        messageUnmarshalling,
+        headerExtraction,
+        potentialValidationFunction
+    });
+    const callbackJsDocParameters = callbackFunctionParameters
+        .map((param) => param.jsDoc)
+        .join('\n');
+    const mainJsDoc = (0, utils_2.renderChannelJSDoc)({
+        description,
+        deprecated,
+        fallbackDescription: `Core 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<Nats.Subscription> {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const subscription = nc.subscribe(${addressToUse}, options);
+      ${potentialValidatorCreation}
+      (async () => {
+        for await (const msg of subscription) {
+          ${channelParameters ? `const parameters = ${channelParameters.type}.createFromChannel(msg.subject, '${topic}', ${(0, utils_1.findRegexFromChannel)(topic)})` : ''}
+          ${whenReceivingMessage}
+        }
+      })();
+      resolve(subscription);
+    } catch (e: any) {
+      reject(e);
+    }
+  });
+}`;
+    return {
+        messageType,
+        code,
+        functionName,
+        dependencies: [`import * as Nats from 'nats';`],
+        functionType: __1.ChannelFunctionTypes.NATS_SUBSCRIBE
+    };
+}
+exports.renderCoreSubscribe = renderCoreSubscribe;

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

@@ -0,0 +1,11 @@
+import { TypeScriptChannelsGeneratorContext, TypeScriptChannelRenderedFunctionType } from '../../types';
+import { renderCoreRequest } from './coreRequest';
+import { renderCoreReply } from './coreReply';
+import { renderCorePublish } from './corePublish';
+import { renderCoreSubscribe } from './coreSubscribe';
+import { renderJetstreamPullSubscribe } from './jetstreamPullSubscribe';
+import { renderJetstreamPushSubscription } from './jetstreamPushSubscription';
+import { renderJetstreamPublish } from './jetstreamPublish';
+import { ChannelInterface } from '@asyncapi/parser';
+export { renderCoreRequest, renderCoreReply, renderCorePublish, renderCoreSubscribe, renderJetstreamPullSubscribe, renderJetstreamPushSubscription, renderJetstreamPublish };
+export declare function generateNatsChannels(context: TypeScriptChannelsGeneratorContext, channel: ChannelInterface, protocolCodeFunctions: Record<string, string[]>, externalProtocolFunctionInformation: Record<string, TypeScriptChannelRenderedFunctionType[]>, dependencies: string[]): Promise<void>;

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

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNatsChannels = exports.renderJetstreamPublish = exports.renderJetstreamPushSubscription = exports.renderJetstreamPullSubscribe = exports.renderCoreSubscribe = exports.renderCorePublish = exports.renderCoreReply = exports.renderCoreRequest = 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 coreRequest_1 = require("./coreRequest");
+Object.defineProperty(exports, "renderCoreRequest", { enumerable: true, get: function () { return coreRequest_1.renderCoreRequest; } });
+const coreReply_1 = require("./coreReply");
+Object.defineProperty(exports, "renderCoreReply", { enumerable: true, get: function () { return coreReply_1.renderCoreReply; } });
+const corePublish_1 = require("./corePublish");
+Object.defineProperty(exports, "renderCorePublish", { enumerable: true, get: function () { return corePublish_1.renderCorePublish; } });
+const coreSubscribe_1 = require("./coreSubscribe");
+Object.defineProperty(exports, "renderCoreSubscribe", { enumerable: true, get: function () { return coreSubscribe_1.renderCoreSubscribe; } });
+const jetstreamPullSubscribe_1 = require("./jetstreamPullSubscribe");
+Object.defineProperty(exports, "renderJetstreamPullSubscribe", { enumerable: true, get: function () { return jetstreamPullSubscribe_1.renderJetstreamPullSubscribe; } });
+const jetstreamPushSubscription_1 = require("./jetstreamPushSubscription");
+Object.defineProperty(exports, "renderJetstreamPushSubscription", { enumerable: true, get: function () { return jetstreamPushSubscription_1.renderJetstreamPushSubscription; } });
+const jetstreamPublish_1 = require("./jetstreamPublish");
+Object.defineProperty(exports, "renderJetstreamPublish", { enumerable: true, get: function () { return jetstreamPublish_1.renderJetstreamPublish; } });
+const errors_1 = require("../../../../../errors");
+async function generateNatsChannels(context, channel, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies) {
+    const { parameter, headers, topic, payloads } = context;
+    const ignoreOperation = !context.generator.asyncapiGenerateForOperations;
+    let natsTopic = topic.startsWith('/') ? topic.slice(1) : topic;
+    natsTopic = natsTopic.replace(/\//g, '.');
+    const natsContext = {
+        channelParameters: parameter,
+        channelHeaders: headers,
+        topic: natsTopic,
+        messageType: '',
+        subName: context.subName,
+        payloadGenerator: payloads
+    };
+    const operations = channel.operations().all();
+    const renders = operations.length > 0 && !ignoreOperation
+        ? await generateForOperations(context, channel, natsContext)
+        : await generateForChannels(context, channel, natsContext);
+    addRendersToExternal(renders, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies, parameter);
+}
+exports.generateNatsChannels = generateNatsChannels;
+function addRendersToExternal(renders, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies, parameter) {
+    protocolCodeFunctions['nats'].push(...renders.map((value) => value.code));
+    externalProtocolFunctionInformation['nats'].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, natsContext) {
+    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;
+        if (updatedFunctionTypeMapping !== undefined &&
+            !updatedFunctionTypeMapping?.some((f) => [
+                types_1.ChannelFunctionTypes.NATS_REQUEST,
+                types_1.ChannelFunctionTypes.NATS_REPLY,
+                types_1.ChannelFunctionTypes.NATS_PUBLISH,
+                types_1.ChannelFunctionTypes.NATS_SUBSCRIBE,
+                types_1.ChannelFunctionTypes.NATS_JETSTREAM_PULL_SUBSCRIBE,
+                types_1.ChannelFunctionTypes.NATS_JETSTREAM_PUSH_SUBSCRIBE,
+                types_1.ChannelFunctionTypes.NATS_JETSTREAM_PUBLISH
+            ].includes(f))) {
+            continue;
+        }
+        const payload = payloads.operationModels[(0, utils_1.findOperationId)(operation, channel)];
+        if (!payload) {
+            throw (0, errors_1.createMissingPayloadError)({
+                channelOrOperation: (0, utils_1.findOperationId)(operation, channel),
+                protocol: 'NATS'
+            });
+        }
+        const { messageModule, messageType } = (0, utils_2.getMessageTypeAndModule)(payload);
+        if (messageType === undefined) {
+            throw new Error(`Could not find message type for channel typescript generator for NATS`);
+        }
+        // Extract operation metadata for JSDoc
+        const { description, deprecated } = (0, utils_1.getOperationMetadata)(operation);
+        const updatedContext = {
+            ...natsContext,
+            messageType,
+            messageModule,
+            subName: (0, utils_1.findNameFromOperation)(operation, channel),
+            description,
+            deprecated
+        };
+        renders.push(...(await generateOperationRenders(operation, updatedContext, updatedFunctionTypeMapping, generator, payloads, channel)));
+    }
+    return renders;
+}
+async function generateOperationRenders(operation, natsContext, functionTypeMapping, generator, payloads, channel) {
+    const renders = [];
+    const reply = operation.reply();
+    if (reply) {
+        renders.push(...(await handleReplyOperation(operation, reply, channel, natsContext, functionTypeMapping, generator, payloads)));
+    }
+    else {
+        renders.push(...(await handleNonReplyOperation(operation, natsContext, functionTypeMapping, generator)));
+    }
+    return renders;
+}
+async function handleReplyOperation(operation, reply, channel, natsContext, functionTypeMapping, generator, payloads) {
+    const renders = [];
+    const replyId = (0, utils_1.findReplyId)(operation, reply, channel);
+    const replyMessageModel = payloads.operationModels[replyId];
+    if (!replyMessageModel) {
+        return renders;
+    }
+    const { messageModule: replyMessageModule, messageType: replyMessageType } = (0, utils_2.getMessageTypeAndModule)(replyMessageModel);
+    if (replyMessageType === undefined) {
+        throw new Error(`Could not find reply message type for channel typescript generator for NATS`);
+    }
+    if ((0, asyncapi_1.shouldRenderFunctionType)(functionTypeMapping, types_1.ChannelFunctionTypes.NATS_REQUEST, operation.action(), generator.asyncapiReverseOperations)) {
+        renders.push((0, coreRequest_1.renderCoreRequest)({
+            ...natsContext,
+            requestMessageModule: natsContext.messageModule,
+            requestMessageType: natsContext.messageType,
+            replyMessageModule,
+            replyMessageType,
+            requestTopic: natsContext.topic,
+            payloadGenerator: payloads
+        }));
+    }
+    else if ((0, asyncapi_1.shouldRenderFunctionType)(functionTypeMapping, types_1.ChannelFunctionTypes.NATS_REPLY, operation.action(), generator.asyncapiReverseOperations)) {
+        renders.push((0, coreReply_1.renderCoreReply)({
+            ...natsContext,
+            requestMessageModule: replyMessageModule,
+            requestMessageType: replyMessageType,
+            replyMessageModule: natsContext.messageModule,
+            replyMessageType: natsContext.messageType,
+            requestTopic: natsContext.topic,
+            payloadGenerator: payloads
+        }));
+    }
+    return renders;
+}
+async function handleNonReplyOperation(operation, natsContext, functionTypeMapping, generator) {
+    const renders = [];
+    const action = operation.action();
+    const renderChecks = [
+        { check: types_1.ChannelFunctionTypes.NATS_PUBLISH, render: corePublish_1.renderCorePublish },
+        { check: types_1.ChannelFunctionTypes.NATS_SUBSCRIBE, render: coreSubscribe_1.renderCoreSubscribe },
+        {
+            check: types_1.ChannelFunctionTypes.NATS_JETSTREAM_PULL_SUBSCRIBE,
+            render: jetstreamPullSubscribe_1.renderJetstreamPullSubscribe
+        },
+        {
+            check: types_1.ChannelFunctionTypes.NATS_JETSTREAM_PUSH_SUBSCRIBE,
+            render: jetstreamPushSubscription_1.renderJetstreamPushSubscription
+        },
+        {
+            check: types_1.ChannelFunctionTypes.NATS_JETSTREAM_PUBLISH,
+            render: jetstreamPublish_1.renderJetstreamPublish
+        }
+    ];
+    for (const { check, render } of renderChecks) {
+        if ((0, asyncapi_1.shouldRenderFunctionType)(functionTypeMapping, check, action, generator.asyncapiReverseOperations)) {
+            renders.push(render(natsContext));
+        }
+    }
+    return renders;
+}
+async function generateForChannels(context, channel, natsContext) {
+    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: 'NATS'
+        });
+    }
+    const { messageModule, messageType } = (0, utils_2.getMessageTypeAndModule)(payload);
+    if (messageType === undefined) {
+        throw new Error(`Could not find message type for channel typescript generator for NATS`);
+    }
+    const updatedContext = { ...natsContext, messageType, messageModule };
+    const renderChecks = [
+        {
+            check: types_1.ChannelFunctionTypes.NATS_PUBLISH,
+            render: corePublish_1.renderCorePublish,
+            action: 'send'
+        },
+        {
+            check: types_1.ChannelFunctionTypes.NATS_SUBSCRIBE,
+            render: coreSubscribe_1.renderCoreSubscribe,
+            action: 'receive'
+        },
+        {
+            check: types_1.ChannelFunctionTypes.NATS_JETSTREAM_PULL_SUBSCRIBE,
+            render: jetstreamPullSubscribe_1.renderJetstreamPullSubscribe,
+            action: 'receive'
+        },
+        {
+            check: types_1.ChannelFunctionTypes.NATS_JETSTREAM_PUSH_SUBSCRIBE,
+            render: jetstreamPushSubscription_1.renderJetstreamPushSubscription,
+            action: 'receive'
+        },
+        {
+            check: types_1.ChannelFunctionTypes.NATS_JETSTREAM_PUBLISH,
+            render: jetstreamPublish_1.renderJetstreamPublish,
+            action: 'send'
+        }
+    ];
+    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/nats/jetstreamPublish.d.ts

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

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

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderJetstreamPublish = void 0;
+const utils_1 = require("../../../utils");
+const index_1 = require("../../index");
+const utils_2 = require("./utils");
+const utils_3 = require("../../utils");
+function renderJetstreamPublish({ topic, messageType, messageModule, channelParameters, channelHeaders, subName = (0, utils_1.pascalCase)(topic), functionName = `jetStreamPublishTo${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 js.publish(${addressToUse}, Nats.Empty, options);`
+        : `let dataToSend: any = ${messageMarshalling};
+      ${headerSetup}
+dataToSend = codec.encode(dataToSend);
+await js.publish(${addressToUse}, dataToSend, options);`;
+    const headerParam = (0, utils_2.generateHeaderParameter)(channelHeaders);
+    const functionParameters = [
+        {
+            parameter: `message`,
+            parameterType: `message: ${messageType}`,
+            jsDoc: ' * @param message to publish over jetstream'
+        },
+        ...(channelParameters
+            ? [
+                {
+                    parameter: `parameters`,
+                    parameterType: `parameters: ${channelParameters.type}`,
+                    jsDoc: ' * @param parameters for topic substitution'
+                }
+            ]
+            : []),
+        ...(headerParam ? [headerParam] : []),
+        {
+            parameter: 'js',
+            parameterType: 'js: Nats.JetStreamClient',
+            jsDoc: ' * @param js the JetStream 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?: Partial<Nats.JetStreamPublishOptions>',
+            jsDoc: ' * @param options to use while publishing the message'
+        }
+    ];
+    const jsDoc = (0, utils_3.renderChannelJSDoc)({
+        description,
+        deprecated,
+        fallbackDescription: `JetStream 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: index_1.ChannelFunctionTypes.NATS_JETSTREAM_PUBLISH
+    };
+}
+exports.renderJetstreamPublish = renderJetstreamPublish;

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

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

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

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderJetstreamPullSubscribe = 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 renderJetstreamPullSubscribe({ topic, messageType, messageModule, channelParameters, channelHeaders, subName = (0, utils_1.pascalCase)(topic), payloadGenerator, functionName = `jetStreamPullSubscribeTo${subName}`, 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)`;
+    }
+    messageType = messageModule ? `${messageModule}.${messageType}` : messageType;
+    const { potentialValidatorCreation, potentialValidationFunction } = (0, utils_2.getValidationFunctions)({
+        includeValidation,
+        messageModule,
+        messageType,
+        onValidationFail: `onDataCallback(new Error(\`Invalid message payload received; $\{JSON.stringify({cause: errors})}\`), undefined,${channelParameters ? 'parameters, ' : ''}${channelHeaders ? 'extractedHeaders, ' : ''} msg); continue;`
+    });
+    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: 'jetstreamMsg?: Nats.JsMsg', jsDoc: ' * @param jetstreamMsg' }
+    ];
+    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: 'js',
+            parameterType: 'js: Nats.JetStreamClient',
+            jsDoc: ' * @param js the JetStream client to pull subscribe through'
+        },
+        {
+            parameter: 'options',
+            parameterType: 'options: Nats.ConsumerOptsBuilder | Partial<Nats.ConsumerOpts>',
+            jsDoc: ' * @param options when setting up the subscription'
+        },
+        {
+            parameter: 'codec = Nats.JSONCodec()',
+            parameterType: 'codec?: Nats.Codec<any>',
+            jsDoc: ' * @param codec the serialization codec to use while transmitting the message'
+        },
+        {
+            parameter: 'skipMessageValidation = false',
+            parameterType: 'skipMessageValidation?: boolean',
+            jsDoc: ' * @param skipMessageValidation turn off runtime validation of incoming messages'
+        }
+    ];
+    const headerExtraction = (0, utils_3.generateHeaderExtractionCode)(channelHeaders);
+    const whenReceivingMessage = (0, utils_3.generateMessageReceivingCode)({
+        channelParameters,
+        channelHeaders,
+        messageType,
+        messageUnmarshalling,
+        headerExtraction,
+        potentialValidationFunction
+    });
+    const callbackJsDocParameters = callbackFunctionParameters
+        .map((param) => param.jsDoc)
+        .join('\n');
+    const jsDoc = (0, utils_2.renderChannelJSDoc)({
+        description,
+        deprecated,
+        fallbackDescription: `JetStream pull subscription for \`${topic}\``,
+        parameters: functionParameters.map((param) => ({
+            jsDoc: param.jsDoc
+        }))
+    });
+    const code = `/**
+ * Callback for when receiving messages
+ *
+ * @callback ${functionName}Callback
+ ${callbackJsDocParameters}
+ */
+
+${jsDoc}
+function ${functionName}({
+  ${functionParameters.map((param) => param.parameter).join(', \n  ')}
+}: {
+  ${functionParameters.map((param) => param.parameterType).join(', \n  ')}
+}): Promise<Nats.JetStreamPullSubscription> {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const subscription = await js.pullSubscribe(${addressToUse}, options);
+      ${potentialValidatorCreation}
+      (async () => {
+        for await (const msg of subscription) {
+          ${channelParameters ? `const parameters = ${channelParameters.type}.createFromChannel(msg.subject, '${topic}', ${(0, utils_1.findRegexFromChannel)(topic)})` : ''}
+          ${whenReceivingMessage}
+        }
+      })();
+      resolve(subscription);
+    } catch (e: any) {
+      reject(e);
+    }
+  });
+}`;
+    return {
+        messageType,
+        code,
+        functionName,
+        dependencies: [`import * as Nats from 'nats';`],
+        functionType: __1.ChannelFunctionTypes.NATS_JETSTREAM_PULL_SUBSCRIBE
+    };
+}
+exports.renderJetstreamPullSubscribe = renderJetstreamPullSubscribe;

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

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