@alagoni97/cli 0.72.1

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

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderChannelJSDoc = exports.escapeJSDocDescription = exports.collectProtocolDependencies = exports.getValidationFunctions = exports.getMessageTypeAndModule = exports.addHeadersToDependencies = exports.addParametersToExports = exports.addParametersToDependencies = exports.addPayloadsToExports = exports.addPayloadsToDependencies = void 0;
+const modelina_1 = require("@asyncapi/modelina");
+const utils_1 = require("../../../utils");
+function addPayloadsToDependencies(models, payloadGenerator, currentGenerator, dependencies, importExtension = 'none') {
+    models
+        .filter((payload) => payload)
+        .forEach((payload) => {
+        const payloadImportPath = (0, utils_1.relativePath)(currentGenerator.outputPath, (0, utils_1.joinPath)(payloadGenerator.outputPath, payload.messageModel.modelName));
+        const importPath = (0, utils_1.appendImportExtension)(`./${(0, utils_1.ensureRelativePath)(payloadImportPath)}`, importExtension);
+        if (payload.messageModel.model instanceof modelina_1.ConstrainedObjectModel ||
+            payload.messageModel.model instanceof modelina_1.ConstrainedEnumModel) {
+            dependencies.push(`import {${payload.messageModel.modelName}} from '${importPath}';`);
+        }
+        else {
+            dependencies.push(`import * as ${payload.messageModel.modelName}Module from '${importPath}';`);
+        }
+    });
+}
+exports.addPayloadsToDependencies = addPayloadsToDependencies;
+function addPayloadsToExports(models, dependencies) {
+    models
+        .filter((payload) => payload)
+        .forEach((payload) => {
+        if (payload.messageModel.model instanceof modelina_1.ConstrainedObjectModel ||
+            payload.messageModel.model instanceof modelina_1.ConstrainedEnumModel) {
+            dependencies.push(`export {${payload.messageModel.modelName}};`);
+        }
+        else {
+            dependencies.push(`export {${payload.messageModel.modelName}Module};`);
+        }
+    });
+}
+exports.addPayloadsToExports = addPayloadsToExports;
+function addParametersToDependencies(parameters, parameterGenerator, currentGenerator, dependencies, importExtension = 'none') {
+    Object.values(parameters)
+        .filter((model) => model !== undefined)
+        .forEach((parameter) => {
+        if (parameter === undefined) {
+            return;
+        }
+        const parameterImportPath = (0, utils_1.relativePath)(currentGenerator.outputPath, (0, utils_1.joinPath)(parameterGenerator.outputPath, parameter.modelName));
+        const importPath = (0, utils_1.appendImportExtension)(`./${(0, utils_1.ensureRelativePath)(parameterImportPath)}`, importExtension);
+        dependencies.push(`import {${parameter.modelName}} from '${importPath}';`);
+    });
+}
+exports.addParametersToDependencies = addParametersToDependencies;
+function addParametersToExports(parameters, dependencies) {
+    Object.values(parameters)
+        .filter((model) => model !== undefined)
+        .forEach((parameter) => {
+        if (parameter === undefined) {
+            return;
+        }
+        dependencies.push(`export {${parameter.modelName}};`);
+    });
+}
+exports.addParametersToExports = addParametersToExports;
+function addHeadersToDependencies(headers, headerGenerator, currentGenerator, dependencies, importExtension = 'none') {
+    Object.values(headers)
+        .filter((model) => model !== undefined)
+        .forEach((header) => {
+        if (header === undefined) {
+            return;
+        }
+        const headerImportPath = (0, utils_1.relativePath)(currentGenerator.outputPath, (0, utils_1.joinPath)(headerGenerator.outputPath, header.modelName));
+        const importPath = (0, utils_1.appendImportExtension)(`./${(0, utils_1.ensureRelativePath)(headerImportPath)}`, importExtension);
+        dependencies.push(`import {${header.modelName}} from '${importPath}';`);
+    });
+}
+exports.addHeadersToDependencies = addHeadersToDependencies;
+function getMessageTypeAndModule(payload) {
+    if (payload === undefined) {
+        return {
+            messageType: undefined,
+            messageModule: undefined,
+            includesStatusCodes: false
+        };
+    }
+    let messageModule;
+    if (!(payload.messageModel.model instanceof modelina_1.ConstrainedObjectModel)) {
+        // Use modelName for module name since messageType may contain invalid identifier characters
+        // (e.g., 'Pet[]' for array types). The import is generated using modelName, so we need to match.
+        messageModule = `${payload.messageModel.modelName}Module`;
+    }
+    // Check if this payload has unmarshalByStatusCode support
+    // This is set explicitly on the payload, or detected from the model's originalInput
+    const includesStatusCodes = payload.includesStatusCodes ??
+        payload.messageModel.model.originalInput?.['x-modelina-has-status-codes'] === true;
+    return { messageType: payload.messageType, messageModule, includesStatusCodes };
+}
+exports.getMessageTypeAndModule = getMessageTypeAndModule;
+function getValidationFunctions({ includeValidation, messageModule, messageType, onValidationFail }) {
+    let validatorCreation = '';
+    let validationFunction = '';
+    if (includeValidation) {
+        validatorCreation = `const validator = ${messageModule ?? messageType}.createValidator();`;
+        validationFunction = `if(!skipMessageValidation) {
+    const {valid, errors} = ${messageModule ?? messageType}.validate({data: receivedData, ajvValidatorFunction: validator});
+    if(!valid) {
+      ${onValidationFail}
+    }
+  }`;
+    }
+    return {
+        potentialValidatorCreation: validatorCreation,
+        potentialValidationFunction: validationFunction
+    };
+}
+exports.getValidationFunctions = getValidationFunctions;
+/**
+ * Collects all payload, parameter, and header imports for a specific protocol's dependencies.
+ * This should be called once per protocol to add the necessary imports.
+ */
+function collectProtocolDependencies(payloads, parameters, headers, context, protocolDeps, importExtension = 'none') {
+    // Add payload imports
+    addPayloadsToDependencies(Object.values(payloads.operationModels), payloads.generator, context.generator, protocolDeps, importExtension);
+    addPayloadsToDependencies(Object.values(payloads.channelModels), payloads.generator, context.generator, protocolDeps, importExtension);
+    addPayloadsToDependencies(Object.values(payloads.otherModels), payloads.generator, context.generator, protocolDeps, importExtension);
+    // Add parameter imports
+    addParametersToDependencies(parameters.channelModels, parameters.generator, context.generator, protocolDeps, importExtension);
+    // Add header imports
+    if (headers) {
+        addHeadersToDependencies(headers.channelModels, headers.generator, context.generator, protocolDeps, importExtension);
+    }
+}
+exports.collectProtocolDependencies = collectProtocolDependencies;
+/**
+ * Escapes special characters in description for JSDoc.
+ * Handles closing comment markers and formats multi-line descriptions.
+ */
+function escapeJSDocDescription(description) {
+    if (!description) {
+        return '';
+    }
+    return description
+        .replace(/\*\//g, '*\u2215') // Escape closing comment (use division slash)
+        .replace(/\n/g, '\n * '); // Format multi-line with JSDoc prefix
+}
+exports.escapeJSDocDescription = escapeJSDocDescription;
+/**
+ * Renders JSDoc block for channel functions.
+ * Uses operation description from API spec when available, falls back to generic text.
+ */
+function renderChannelJSDoc(params) {
+    const { description, deprecated, fallbackDescription, parameters = [] } = params;
+    const desc = description
+        ? escapeJSDocDescription(description)
+        : escapeJSDocDescription(fallbackDescription);
+    const parts = ['/**', ` * ${desc}`];
+    if (deprecated) {
+        parts.push(' *');
+        parts.push(' * @deprecated');
+    }
+    if (parameters.length > 0) {
+        parts.push(' *');
+        parameters.forEach((p) => parts.push(p.jsDoc));
+    }
+    parts.push(' */');
+    return parts.join('\n');
+}
+exports.renderChannelJSDoc = renderChannelJSDoc;

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

@@ -0,0 +1,8 @@
+import { TheCodegenConfiguration } from '../../../types';
+import { SupportedProtocols, TypeScriptClientContext, TypeScriptClientGenerator, TypeScriptClientRenderType, defaultTypeScriptClientGenerator, zodTypescriptClientGenerator, TypeScriptClientGeneratorInternal } from './types';
+export { SupportedProtocols, TypeScriptClientContext, TypeScriptClientGenerator, TypeScriptClientRenderType, defaultTypeScriptClientGenerator, zodTypescriptClientGenerator, TypeScriptClientGeneratorInternal };
+export declare function generateTypeScriptClient(context: TypeScriptClientContext): Promise<TypeScriptClientRenderType>;
+/**
+ * Make sure we include all dependencies, if not added manually, is added to the generators.
+ */
+export declare function includeTypeScriptClientDependencies(config: TheCodegenConfiguration, generator: TypeScriptClientGenerator): unknown[];

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.includeTypeScriptClientDependencies = exports.generateTypeScriptClient = exports.zodTypescriptClientGenerator = exports.defaultTypeScriptClientGenerator = void 0;
+/* eslint-disable security/detect-object-injection */
+/* eslint-disable sonarjs/no-duplicate-string */
+const channels_1 = require("../channels");
+const nats_1 = require("./protocols/nats");
+const utils_1 = require("../../../utils");
+const types_1 = require("./types");
+Object.defineProperty(exports, "defaultTypeScriptClientGenerator", { enumerable: true, get: function () { return types_1.defaultTypeScriptClientGenerator; } });
+Object.defineProperty(exports, "zodTypescriptClientGenerator", { enumerable: true, get: function () { return types_1.zodTypescriptClientGenerator; } });
+const errors_1 = require("../../../errors");
+async function generateTypeScriptClient(context) {
+    const { asyncapiDocument, generator, inputType } = context;
+    if (inputType === 'asyncapi' && asyncapiDocument === undefined) {
+        throw (0, errors_1.createMissingInputDocumentError)({
+            expectedType: 'asyncapi',
+            generatorPreset: 'client'
+        });
+    }
+    const renderedProtocols = {
+        nats: ''
+    };
+    const files = [];
+    for (const protocol of generator.protocols) {
+        switch (protocol) {
+            case 'nats': {
+                const renderedResult = await (0, nats_1.generateNatsClient)(context);
+                const filePath = (0, utils_1.joinPath)(context.generator.outputPath, 'NatsClient.ts');
+                files.push({ path: filePath, content: renderedResult });
+                renderedProtocols[protocol] = renderedResult;
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return {
+        protocolResult: renderedProtocols,
+        files
+    };
+}
+exports.generateTypeScriptClient = generateTypeScriptClient;
+/**
+ * Make sure we include all dependencies, if not added manually, is added to the generators.
+ */
+function includeTypeScriptClientDependencies(config, generator) {
+    const newGenerators = [];
+    const channelsGeneratorId = generator.channelsGeneratorId;
+    const hasChannelsGenerator = config.generators.find((generatorSearch) => generatorSearch.id === channelsGeneratorId) !== undefined;
+    if (!hasChannelsGenerator) {
+        const defaultChannelPayloadGenerator = {
+            ...channels_1.defaultTypeScriptChannelsGenerator,
+            protocols: generator.protocols,
+            outputPath: (0, utils_1.joinPath)(generator.outputPath ?? '', './channels')
+        };
+        newGenerators.push(defaultChannelPayloadGenerator);
+    }
+    return newGenerators;
+}
+exports.includeTypeScriptClientDependencies = includeTypeScriptClientDependencies;

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

@@ -0,0 +1,6 @@
+export declare function renderCorePublish({ description, messageType, channelParameterType, channelName }: {
+    description: string;
+    messageType: string;
+    channelParameterType?: string;
+    channelName: string;
+}): string;

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCorePublish = void 0;
+function renderCorePublish({ description, messageType, channelParameterType, channelName }) {
+    const functionParameters = [
+        {
+            parameter: `message`,
+            parameterType: `message: ${messageType}`,
+            jsDoc: ' * @param message to publish'
+        },
+        ...(channelParameterType
+            ? [
+                {
+                    parameter: `parameters`,
+                    parameterType: `parameters: ${channelParameterType}`,
+                    jsDoc: ' * @param parameters for topic substitution'
+                }
+            ]
+            : []),
+        {
+            parameter: 'options',
+            parameterType: 'options?: Nats.PublishOptions',
+            jsDoc: ' * @param options to use while publishing the message'
+        }
+    ];
+    const functionCallParameters = [
+        'message',
+        ...(channelParameterType ? ['parameters'] : []),
+        'nc: this.nc',
+        'codec: this.codec',
+        'options'
+    ];
+    return `
+  /**
+   * ${description}
+   * 
+  ${functionParameters.map((param) => param.jsDoc).join('\n  ')}
+   */
+  public async ${channelName}({
+    ${functionParameters.map((param) => param.parameter).join(', \n    ')}
+  }: {
+    ${functionParameters.map((param) => param.parameterType).join(', \n    ')}
+  }): Promise<void> {
+    if (!this.isClosed() && this.nc !== undefined && this.codec !== undefined) {
+      await nats.${channelName}({
+        ${functionCallParameters.join(', \n        ')}
+      });
+    } else {
+      Promise.reject('Nats client not available yet, please connect or set the client');
+    }
+  }`;
+}
+exports.renderCorePublish = renderCorePublish;

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

@@ -0,0 +1,6 @@
+export declare function renderCoreSubscribe({ description, messageType, channelParameterType, channelName }: {
+    description: string;
+    messageType: string;
+    channelParameterType?: string;
+    channelName: string;
+}): string;

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCoreSubscribe = void 0;
+function renderCoreSubscribe({ description, messageType, channelParameterType, channelName }) {
+    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'
+        },
+        ...(channelParameterType
+            ? [
+                {
+                    parameter: `parameters?: ${channelParameterType}`,
+                    jsDoc: ' * @param parameters that was received in the topic'
+                }
+            ]
+            : []),
+        {
+            parameter: `natsMsg?: Nats.Msg`,
+            jsDoc: ' * @param natsMsg'
+        }
+    ];
+    const functionParameters = [
+        {
+            parameter: `onDataCallback`,
+            parameterType: `onDataCallback: (${callbackFunctionParameters.map((param) => param.parameter).join(', ')}) => void`,
+            jsDoc: ` * @param {${channelName}Callback} onDataCallback to call when messages are received`
+        },
+        ...(channelParameterType
+            ? [
+                {
+                    parameter: `parameters`,
+                    parameterType: `parameters: ${channelParameterType}`,
+                    jsDoc: ' * @param parameters for topic substitution'
+                }
+            ]
+            : []),
+        {
+            parameter: 'options',
+            parameterType: 'options?: Nats.SubscriptionOptions',
+            jsDoc: ' * @param options when setting up the subscription'
+        },
+        {
+            parameter: 'flush',
+            parameterType: 'flush?: boolean',
+            jsDoc: ' * @param options when setting up the subscription'
+        }
+    ];
+    const functionCallParameters = [
+        'onDataCallback',
+        ...(channelParameterType ? ['parameters'] : []),
+        'nc: this.nc',
+        'codec: this.codec',
+        'options'
+    ];
+    return `
+  /** 
+   * ${description}
+   * 
+   ${functionParameters.map((param) => param.jsDoc).join('\n   ')}
+   */
+  public ${channelName}({
+    ${functionParameters.map((param) => param.parameter).join(', \n    ')}
+  }: {
+    ${functionParameters.map((param) => param.parameterType).join(', \n    ')}
+  }): Promise<Nats.Subscription> {
+  return new Promise(async (resolve, reject) => {
+    if(!this.isClosed() && this.nc !== undefined && this.codec !== undefined){
+      try {
+        const sub = await nats.${channelName}({
+          ${functionCallParameters.join(', \n          ')}
+        });
+        if(flush){
+          await this.nc.flush();
+        }
+        resolve(sub);
+      }catch(e: any){
+        reject(e);
+      }
+    } else {
+      Promise.reject('Nats client not available yet, please connect or set the client');
+    }
+  });
+}`;
+}
+exports.renderCoreSubscribe = renderCoreSubscribe;

package/dist/codegen/generators/typescript/client/protocols/nats/jetStreamPullSubscription.d.ts

@@ -0,0 +1,6 @@
+export declare function renderJetStreamPullSubscription({ description, messageType, channelParameterType, channelName }: {
+    description: string;
+    messageType: string;
+    channelParameterType?: string;
+    channelName: string;
+}): string;

package/dist/codegen/generators/typescript/client/protocols/nats/jetStreamPullSubscription.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderJetStreamPullSubscription = void 0;
+function renderJetStreamPullSubscription({ description, messageType, channelParameterType, channelName }) {
+    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'
+        },
+        ...(channelParameterType
+            ? [
+                {
+                    parameter: `parameters?: ${channelParameterType}`,
+                    jsDoc: ' * @param parameters that was received in the topic'
+                }
+            ]
+            : []),
+        {
+            parameter: `jetstreamMsg?: Nats.JsMsg`,
+            jsDoc: ' * @param jetstreamMsg'
+        }
+    ];
+    const functionParameters = [
+        {
+            parameter: `onDataCallback`,
+            parameterType: `onDataCallback: (${callbackFunctionParameters.map((param) => param.parameter).join(', ')}) => void`,
+            jsDoc: ` * @param {${channelName}Callback} onDataCallback to call when messages are received`
+        },
+        ...(channelParameterType
+            ? [
+                {
+                    parameter: `parameters`,
+                    parameterType: `parameters: ${channelParameterType}`,
+                    jsDoc: ' * @param parameters for topic substitution'
+                }
+            ]
+            : []),
+        {
+            parameter: 'options = {}',
+            parameterType: 'options: Nats.ConsumerOptsBuilder | Partial<Nats.ConsumerOpts>',
+            jsDoc: ' * @param options when setting up the subscription'
+        }
+    ];
+    const functionCallParameters = [
+        'onDataCallback',
+        ...(channelParameterType ? ['parameters'] : []),
+        'js: this.js',
+        'codec: this.codec',
+        'options'
+    ];
+    return `
+  /**
+  * ${description}
+  * 
+  ${functionParameters.map((param) => param.jsDoc).join('\n  ')}
+  */
+  public ${channelName}({
+    ${functionParameters.map((param) => param.parameter).join(', \n    ')}
+  }: {
+    ${functionParameters.map((param) => param.parameterType).join(', \n    ')}
+  }): Promise<Nats.JetStreamPullSubscription> {
+      return new Promise(async (resolve, reject) => {
+        if (!this.isClosed() && this.nc !== undefined && this.codec !== undefined && this.js !== undefined) {
+          try {
+            const sub = await nats.${channelName}({
+              ${functionCallParameters.join(', \n              ')}
+            });
+            resolve(sub);
+          } catch (e: any) {
+            reject(e);
+          }
+        } else {
+          Promise.reject('Nats client not available yet, please connect or set the client');
+        }
+      });
+    }
+  `;
+}
+exports.renderJetStreamPullSubscription = renderJetStreamPullSubscription;

package/dist/codegen/generators/typescript/client/protocols/nats/jetstreamPublish.d.ts

@@ -0,0 +1,6 @@
+export declare function renderJetStreamPublish({ description, messageType, channelParameterType, channelName }: {
+    description: string;
+    messageType: string;
+    channelParameterType?: string;
+    channelName: string;
+}): string;

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderJetStreamPublish = void 0;
+function renderJetStreamPublish({ description, messageType, channelParameterType, channelName }) {
+    const functionParameters = [
+        {
+            parameter: `message`,
+            parameterType: `message: ${messageType}`,
+            jsDoc: ' * @param message to publish'
+        },
+        ...(channelParameterType
+            ? [
+                {
+                    parameter: `parameters`,
+                    parameterType: `parameters: ${channelParameterType}`,
+                    jsDoc: ' * @param parameters for topic substitution'
+                }
+            ]
+            : []),
+        {
+            parameter: 'options = {}',
+            parameterType: 'options?: Partial<Nats.JetStreamPublishOptions>',
+            jsDoc: ' * @param options to use while publishing the message'
+        }
+    ];
+    const functionCallParameters = [
+        'message',
+        ...(channelParameterType ? ['parameters'] : []),
+        'js: this.js',
+        'codec: this.codec',
+        'options'
+    ];
+    return `
+  /**
+   * ${description}
+   * 
+  ${functionParameters.map((param) => param.jsDoc).join('\n')}
+   */
+  public async ${channelName}({
+    ${functionParameters.map((param) => param.parameter).join(', \n    ')}
+  }: {
+    ${functionParameters.map((param) => param.parameterType).join(', \n    ')}
+  }): Promise<void> {
+    if (!this.isClosed() && this.nc !== undefined && this.codec !== undefined && this.js !== undefined) {
+      return nats.${channelName}({
+        ${functionCallParameters.join(', \n        ')}
+      });
+    } else {
+      Promise.reject('Nats client not available yet, please connect or set the client');
+    }
+  }
+  `;
+}
+exports.renderJetStreamPublish = renderJetStreamPublish;

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

@@ -0,0 +1,6 @@
+export declare function renderJetStreamPushSubscription({ description, messageType, channelParameterType, channelName }: {
+    description: string;
+    messageType: string;
+    channelParameterType?: string;
+    channelName: string;
+}): string;

package/dist/codegen/generators/typescript/client/protocols/nats/jetstreamPushSubscription.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderJetStreamPushSubscription = void 0;
+function renderJetStreamPushSubscription({ description, messageType, channelParameterType, channelName }) {
+    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'
+        },
+        ...(channelParameterType
+            ? [
+                {
+                    parameter: `parameters?: ${channelParameterType}`,
+                    jsDoc: ' * @param parameters that was received in the topic'
+                }
+            ]
+            : []),
+        {
+            parameter: `jetstreamMsg?: Nats.JsMsg`,
+            jsDoc: ' * @param jetstreamMsg'
+        }
+    ];
+    const functionParameters = [
+        {
+            parameter: `onDataCallback`,
+            parameterType: `onDataCallback: (${callbackFunctionParameters.map((param) => param.parameter).join(', ')}) => void`,
+            jsDoc: ` * @param {${channelName}Callback} onDataCallback to call when messages are received`
+        },
+        ...(channelParameterType
+            ? [
+                {
+                    parameter: `parameters`,
+                    parameterType: `parameters: ${channelParameterType}`,
+                    jsDoc: ' * @param parameters for topic substitution'
+                }
+            ]
+            : []),
+        {
+            parameter: 'options = {}',
+            parameterType: 'options: Nats.ConsumerOptsBuilder | Partial<Nats.ConsumerOpts>',
+            jsDoc: ' * @param options when setting up the subscription'
+        }
+    ];
+    const functionCallParameters = [
+        'onDataCallback',
+        ...(channelParameterType ? ['parameters'] : []),
+        'js: this.js',
+        'codec: this.codec',
+        'options'
+    ];
+    return `
+  /**
+  * ${description}
+  * 
+  ${functionParameters.map((param) => param.jsDoc).join('\n  ')}
+  */
+  public ${channelName}({
+    ${functionParameters.map((param) => param.parameter).join(', \n    ')}
+  }: {
+    ${functionParameters.map((param) => param.parameterType).join(', \n    ')}
+  }): Promise<Nats.JetStreamSubscription> {
+    return new Promise(async (resolve, reject) => {
+      if (!this.isClosed() && this.nc !== undefined && this.codec !== undefined && this.js !== undefined) {
+        try {
+          const sub = await nats.${channelName}({
+            ${functionCallParameters.join(', \n            ')}
+          });
+          resolve(sub);
+        } catch (e: any) {
+          reject(e);
+        }
+      } else {
+        Promise.reject('Nats client not available yet, please connect or set the client');
+      }
+    });
+  }`;
+}
+exports.renderJetStreamPushSubscription = renderJetStreamPushSubscription;

package/dist/codegen/generators/typescript/client/protocols/nats.d.ts

@@ -0,0 +1,2 @@
+import { TypeScriptClientContext } from '..';
+export declare function generateNatsClient(context: TypeScriptClientContext): Promise<string>;