@alagoni97/cli 0.72.1

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderJetstreamPushSubscription = 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 renderJetstreamPushSubscription({ topic, messageType, messageModule, channelParameters, channelHeaders, subName = (0, utils_1.pascalCase)(topic), payloadGenerator, functionName = `jetStreamPushSubscriptionFrom${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 push 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.JetStreamSubscription> {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const subscription = await js.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_JETSTREAM_PUSH_SUBSCRIBE
+    };
+}
+exports.renderJetstreamPushSubscription = renderJetstreamPushSubscription;

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

@@ -0,0 +1,35 @@
+import { ConstrainedObjectModel } from '@asyncapi/modelina';
+/**
+ * Generates the header setup code for NATS publish operations
+ */
+export declare function generateHeaderSetupCode(channelHeaders: ConstrainedObjectModel | undefined): string;
+/**
+ * Generates the header extraction code for NATS subscribe operations
+ */
+export declare function generateHeaderExtractionCode(channelHeaders: ConstrainedObjectModel | undefined): string;
+/**
+ * Generates the function parameter for headers
+ */
+export declare function generateHeaderParameter(channelHeaders: ConstrainedObjectModel | undefined): {
+    parameter: string;
+    parameterType: string;
+    jsDoc: string;
+} | null;
+/**
+ * Generates the callback parameter for headers in subscribe functions
+ */
+export declare function generateHeaderCallbackParameter(channelHeaders: ConstrainedObjectModel | undefined): {
+    parameter: string;
+    jsDoc: string;
+} | null;
+/**
+ * Generates the message receiving code for NATS subscribe operations
+ */
+export declare function generateMessageReceivingCode({ channelParameters, channelHeaders, messageType, messageUnmarshalling, headerExtraction, potentialValidationFunction }: {
+    channelParameters: ConstrainedObjectModel | undefined;
+    channelHeaders: ConstrainedObjectModel | undefined;
+    messageType: string;
+    messageUnmarshalling: string;
+    headerExtraction: string;
+    potentialValidationFunction: string;
+}): string;

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMessageReceivingCode = exports.generateHeaderCallbackParameter = exports.generateHeaderParameter = exports.generateHeaderExtractionCode = exports.generateHeaderSetupCode = void 0;
+/**
+ * Generates the header setup code for NATS publish operations
+ */
+function generateHeaderSetupCode(channelHeaders) {
+    if (!channelHeaders) {
+        return '';
+    }
+    return `// Set up headers if provided
+      if (headers) {
+        const natsHeaders = Nats.headers();
+        const headerData = headers.marshal();
+        const parsedHeaders = typeof headerData === 'string' ? JSON.parse(headerData) : headerData;
+        for (const [key, value] of Object.entries(parsedHeaders)) {
+          if (value !== undefined) {
+            natsHeaders.append(key, String(value));
+          }
+        }
+        options = { ...options, headers: natsHeaders };
+      }`;
+}
+exports.generateHeaderSetupCode = generateHeaderSetupCode;
+/**
+ * Generates the header extraction code for NATS subscribe operations
+ */
+function generateHeaderExtractionCode(channelHeaders) {
+    if (!channelHeaders) {
+        return '';
+    }
+    return `// Extract headers if present
+          let extractedHeaders: ${channelHeaders.type} | undefined = undefined;
+          if (msg.headers) {
+            const headerObj: Record<string, any> = {};
+            // NATS headers support both iteration and get() method
+            if (typeof msg.headers.keys === 'function') {
+              // Use keys() method if available (NATS MsgHdrs)
+              for (const key of msg.headers.keys()) {
+                headerObj[key] = msg.headers.get(key);
+              }
+            } else {
+              // Fallback to Object.entries for plain objects
+              for (const [key, value] of Object.entries(msg.headers)) {
+                headerObj[key] = value;
+              }
+            }
+            extractedHeaders = ${channelHeaders.type}.unmarshal(headerObj);
+          }`;
+}
+exports.generateHeaderExtractionCode = generateHeaderExtractionCode;
+/**
+ * Generates the function parameter for headers
+ */
+function generateHeaderParameter(channelHeaders) {
+    if (!channelHeaders) {
+        return null;
+    }
+    return {
+        parameter: 'headers',
+        parameterType: `headers?: ${channelHeaders.type}`,
+        jsDoc: ' * @param headers optional headers to include with the message'
+    };
+}
+exports.generateHeaderParameter = generateHeaderParameter;
+/**
+ * Generates the callback parameter for headers in subscribe functions
+ */
+function generateHeaderCallbackParameter(channelHeaders) {
+    if (!channelHeaders) {
+        return null;
+    }
+    return {
+        parameter: `headers?: ${channelHeaders.type}`,
+        jsDoc: ' * @param headers that were received with the message'
+    };
+}
+exports.generateHeaderCallbackParameter = generateHeaderCallbackParameter;
+/**
+ * Generates the message receiving code for NATS subscribe operations
+ */
+function generateMessageReceivingCode({ channelParameters, channelHeaders, messageType, messageUnmarshalling, headerExtraction, potentialValidationFunction }) {
+    const hasParameters = !!channelParameters;
+    const hasHeaders = !!channelHeaders;
+    const isNullMessage = messageType === 'null';
+    // Build callback parameters
+    const callbackParams = ['undefined'];
+    if (isNullMessage) {
+        callbackParams.push('null');
+    }
+    else {
+        callbackParams.push(messageUnmarshalling);
+    }
+    if (hasParameters) {
+        callbackParams.push('parameters');
+    }
+    if (hasHeaders) {
+        callbackParams.push('extractedHeaders');
+    }
+    callbackParams.push('msg');
+    const callbackInvocation = `onDataCallback(${callbackParams.join(', ')});`;
+    // Generate message processing code
+    if (isNullMessage) {
+        return hasHeaders
+            ? `${headerExtraction}\n          ${callbackInvocation}`
+            : callbackInvocation;
+    }
+    // Non-null message processing
+    const messageDecoding = 'let receivedData: any = codec.decode(msg.data);';
+    const parts = [messageDecoding];
+    if (hasHeaders) {
+        parts.push(headerExtraction);
+    }
+    if (potentialValidationFunction) {
+        parts.push(potentialValidationFunction);
+    }
+    parts.push(callbackInvocation);
+    return parts.join('\n');
+}
+exports.generateMessageReceivingCode = generateMessageReceivingCode;

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

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

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

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateWebSocketChannels = exports.renderWebSocketRegister = exports.renderWebSocketSubscribe = exports.renderWebSocketPublish = 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, "renderWebSocketPublish", { enumerable: true, get: function () { return publish_1.renderWebSocketPublish; } });
+const subscribe_1 = require("./subscribe");
+Object.defineProperty(exports, "renderWebSocketSubscribe", { enumerable: true, get: function () { return subscribe_1.renderWebSocketSubscribe; } });
+const register_1 = require("./register");
+Object.defineProperty(exports, "renderWebSocketRegister", { enumerable: true, get: function () { return register_1.renderWebSocketRegister; } });
+const errors_1 = require("../../../../../errors");
+async function generateWebSocketChannels(context, channel, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies) {
+    const { parameter, topic, payloads } = context;
+    const ignoreOperation = !context.generator.asyncapiGenerateForOperations;
+    // Convert AsyncAPI topic format to WebSocket path format
+    const websocketTopic = topic.startsWith('/') ? topic : `/${topic}`;
+    // Keep the topic as is for WebSocket paths
+    const websocketContext = {
+        channelParameters: parameter,
+        channelHeaders: undefined, // WebSocket doesn't use headers in the same way
+        topic: websocketTopic,
+        messageType: '',
+        subName: context.subName,
+        payloadGenerator: payloads
+    };
+    const operations = channel.operations().all();
+    const renders = operations.length > 0 && !ignoreOperation
+        ? await generateForOperations(context, channel, websocketContext)
+        : await generateForChannels(context, channel, websocketContext);
+    addRendersToExternal(renders, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies, parameter);
+}
+exports.generateWebSocketChannels = generateWebSocketChannels;
+function addRendersToExternal(renders, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies, parameter) {
+    protocolCodeFunctions['websocket'].push(...renders.map((value) => value.code));
+    externalProtocolFunctionInformation['websocket'].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, websocketContext) {
+    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.WEBSOCKET_PUBLISH,
+                types_1.ChannelFunctionTypes.WEBSOCKET_SUBSCRIBE,
+                types_1.ChannelFunctionTypes.WEBSOCKET_REGISTER
+            ].includes(f))) {
+            continue;
+        }
+        const payload = payloads.operationModels[(0, utils_1.findOperationId)(operation, channel)];
+        if (!payload) {
+            throw new Error(`Could not find payload for operation in channel typescript generator for WebSocket`);
+        }
+        const { messageModule, messageType } = (0, utils_2.getMessageTypeAndModule)(payload);
+        if (messageType === undefined) {
+            throw new Error(`Could not find message type for channel typescript generator for WebSocket`);
+        }
+        // Extract operation metadata for JSDoc
+        const { description, deprecated } = (0, utils_1.getOperationMetadata)(operation);
+        const updatedContext = {
+            ...websocketContext,
+            messageType,
+            messageModule,
+            subName: (0, utils_1.findNameFromOperation)(operation, channel),
+            description,
+            deprecated
+        };
+        renders.push(...(await generateOperationRenders(operation, updatedContext, updatedFunctionTypeMapping, generator)));
+    }
+    return renders;
+}
+async function generateOperationRenders(operation, websocketContext, functionTypeMapping, generator) {
+    const renders = [];
+    const action = operation.action();
+    const renderChecks = [
+        {
+            check: types_1.ChannelFunctionTypes.WEBSOCKET_PUBLISH,
+            render: publish_1.renderWebSocketPublish
+        },
+        {
+            check: types_1.ChannelFunctionTypes.WEBSOCKET_SUBSCRIBE,
+            render: subscribe_1.renderWebSocketSubscribe
+        },
+        {
+            check: types_1.ChannelFunctionTypes.WEBSOCKET_REGISTER,
+            render: register_1.renderWebSocketRegister
+        }
+    ];
+    for (const { check, render } of renderChecks) {
+        if ((0, asyncapi_1.shouldRenderFunctionType)(functionTypeMapping, check, action, generator.asyncapiReverseOperations)) {
+            renders.push(render(websocketContext));
+        }
+    }
+    return renders;
+}
+async function generateForChannels(context, channel, websocketContext) {
+    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: 'WebSocket'
+        });
+    }
+    const { messageModule, messageType } = (0, utils_2.getMessageTypeAndModule)(payload);
+    if (messageType === undefined) {
+        throw new Error(`Could not find message type for channel typescript generator for WebSocket`);
+    }
+    const updatedContext = { ...websocketContext, messageType, messageModule };
+    const renderChecks = [
+        {
+            check: types_1.ChannelFunctionTypes.WEBSOCKET_PUBLISH,
+            render: publish_1.renderWebSocketPublish,
+            action: 'send'
+        },
+        {
+            check: types_1.ChannelFunctionTypes.WEBSOCKET_SUBSCRIBE,
+            render: subscribe_1.renderWebSocketSubscribe,
+            action: 'receive'
+        },
+        {
+            check: types_1.ChannelFunctionTypes.WEBSOCKET_REGISTER,
+            render: register_1.renderWebSocketRegister,
+            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/websocket/publish.d.ts

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

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderWebSocketPublish = void 0;
+/* eslint-disable sonarjs/no-nested-template-literals */
+const __1 = require("../..");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../../utils");
+function renderWebSocketPublish({ topic, messageType, messageModule, subName = (0, utils_1.pascalCase)(topic), functionName = `publishTo${subName}`, description, deprecated }) {
+    let messageMarshalling = 'message.marshal()';
+    if (messageModule) {
+        messageMarshalling = `${messageModule}.marshal(message)`;
+    }
+    messageType = messageModule ? `${messageModule}.${messageType}` : messageType;
+    const functionParameters = [
+        {
+            parameter: `message`,
+            parameterType: `message: ${messageType}`,
+            jsDoc: ' * @param message to publish'
+        },
+        {
+            parameter: 'ws',
+            parameterType: 'ws: WebSocket.WebSocket',
+            jsDoc: ' * @param ws the WebSocket connection (assumed to be already connected)'
+        }
+    ];
+    const jsDoc = (0, utils_2.renderChannelJSDoc)({
+        description,
+        deprecated,
+        fallbackDescription: `WebSocket client-side function to publish messages to \`${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((resolve, reject) => {
+    // Check if WebSocket is open
+    if (ws.readyState !== WebSocket.WebSocket.OPEN) {
+      reject(new Error('WebSocket is not open'));
+      return;
+    }
+
+    // Send message directly
+    ws.send(${messageMarshalling}, (err) => {
+      if (err) {
+        reject(new Error(\`Failed to send message: \${err.message}\`));
+      }
+      resolve();
+    });
+  });
+}`;
+    return {
+        messageType,
+        code,
+        functionName,
+        dependencies: [`import * as WebSocket from 'ws';`],
+        functionType: __1.ChannelFunctionTypes.WEBSOCKET_PUBLISH
+    };
+}
+exports.renderWebSocketPublish = renderWebSocketPublish;

package/dist/codegen/generators/typescript/channels/protocols/websocket/register.d.ts

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

package/dist/codegen/generators/typescript/channels/protocols/websocket/register.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderWebSocketRegister = void 0;
+/* eslint-disable sonarjs/no-nested-template-literals */
+const __1 = require("../..");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../../utils");
+function renderWebSocketRegister({ topic, messageType, messageModule, channelParameters, subName = (0, utils_1.pascalCase)(topic), functionName = `register${subName}`, description, deprecated }) {
+    let messageUnmarshalling = `${messageType}.unmarshal(receivedData)`;
+    if (messageModule) {
+        messageUnmarshalling = `${messageModule}.unmarshal(receivedData)`;
+    }
+    messageType = messageModule ? `${messageModule}.${messageType}` : messageType;
+    // Create channel pattern based on topic
+    const channelPattern = topic.replace(/\{[^}]+\}/g, '([^\\/]*)');
+    const escapedChannelPattern = channelPattern.replace(/\//g, '\\/');
+    const regexPattern = `/^${escapedChannelPattern}(?:\\?.*)?$/`;
+    // Create parameter extraction logic
+    const topicWithoutLeadingSlash = topic.startsWith('/')
+        ? topic.slice(1)
+        : topic;
+    const channelPatternWithoutLeadingSlash = topicWithoutLeadingSlash.replace(/\{[^}]+\}/g, '([^\\/]*)');
+    const parameterExtraction = channelParameters
+        ? `const channelPath = url.startsWith('/') ? url.slice(1) : url;
+              const parameters = ${channelParameters.type}.createFromChannel(channelPath, '${topicWithoutLeadingSlash}', /^${channelPatternWithoutLeadingSlash.replace(/\//g, '\\/')}$/);`
+        : '';
+    const onConnectionParameters = [
+        ...(channelParameters ? [`parameters: ${channelParameters.type}`] : []),
+        'ws: WebSocket.WebSocket',
+        'request: IncomingMessage'
+    ];
+    const onMessageParameters = [
+        `message: ${messageType}`,
+        'ws: WebSocket.WebSocket'
+    ];
+    const functionParameters = [
+        {
+            parameter: `wss`,
+            parameterType: `wss: WebSocket.WebSocketServer`,
+            jsDoc: ' * @param wss the WebSocket server instance'
+        },
+        {
+            parameter: `onConnection`,
+            parameterType: `onConnection: (params: {${onConnectionParameters.join(', ')}}) => void`,
+            jsDoc: ' * @param onConnection callback when a client connects to this channel'
+        },
+        {
+            parameter: `onMessage`,
+            parameterType: `onMessage: (params: {${onMessageParameters.join(', ')}}) => void`,
+            jsDoc: ' * @param onMessage callback when a message is received on this channel'
+        }
+    ];
+    const jsDoc = (0, utils_2.renderChannelJSDoc)({
+        description,
+        deprecated,
+        fallbackDescription: `WebSocket server-side function to handle messages 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  ')}
+}): void {
+  const channelPattern = ${regexPattern};
+  
+  wss.on('connection', (ws: WebSocket.WebSocket, request: IncomingMessage) => {
+    try {
+      const url = request.url || '';
+      const match = url.match(channelPattern);
+      if (match) {
+        try {
+          ${parameterExtraction}
+          onConnection({${channelParameters ? '\n            parameters,' : ''}
+            ws,
+            request
+          });
+        } catch (connectionError) {
+          console.error('Error in onConnection callback:', connectionError);
+          ws.close(1011, 'Connection error');
+          return;
+        }
+        
+        ws.on('message', (data: WebSocket.RawData) => {
+          try {
+            const receivedData = data.toString();
+            const parsedMessage = ${messageUnmarshalling};
+            onMessage({
+              message: parsedMessage,
+              ws
+            });
+          } catch (error: any) {
+            // Ignore parsing errors
+          }
+        });
+      }
+    } catch (error: any) {
+      ws.close(1011, 'Server error');
+    }
+  });
+}`;
+    return {
+        messageType,
+        code,
+        functionName,
+        dependencies: [
+            `import * as WebSocket from 'ws';`,
+            `import { IncomingMessage } from 'http';`
+        ],
+        functionType: __1.ChannelFunctionTypes.WEBSOCKET_REGISTER
+    };
+}
+exports.renderWebSocketRegister = renderWebSocketRegister;

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

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