@alagoni97/cli 0.72.1

package/dist/codegen/generators/typescript/channels/protocols/amqp/publishExchange.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderPublishExchange = void 0;
+/* eslint-disable sonarjs/no-nested-template-literals */
+const __1 = require("../..");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../../utils");
+function renderPublishExchange({ topic, messageType, messageModule, channelParameters, channelHeaders, subName = (0, utils_1.pascalCase)(topic), functionName = `publishTo${subName}Exchange`, additionalProperties, 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 message properties (headers) if provided
+let publishOptions = { ...options };
+if (headers) {
+  const headerData = headers.marshal();
+  const parsedHeaders = typeof headerData === 'string' ? JSON.parse(headerData) : headerData;
+  publishOptions.headers = {};
+  for (const [key, value] of Object.entries(parsedHeaders)) {
+    if (value !== undefined) {
+      publishOptions.headers[key] = value;
+    }
+  }
+}`
+        : `let publishOptions = { ...options };`;
+    const publishOperation = `let dataToSend: any = ${messageType === 'null' ? 'null' : messageMarshalling};
+const channel = await amqp.createChannel();
+const routingKey = ${addressToUse};
+${headersHandling}
+channel.publish(exchange, routingKey, Buffer.from(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'
+                }
+            ]
+            : []),
+        {
+            parameter: 'amqp',
+            parameterType: 'amqp: Amqp.Connection',
+            jsDoc: ' * @param amqp the AMQP connection to send over'
+        },
+        {
+            parameter: `options`,
+            parameterType: `options?: {exchange: string | undefined} & Amqp.Options.Publish`,
+            jsDoc: ' * @param options for the AMQP publish exchange operation'
+        }
+    ];
+    const jsDoc = (0, utils_2.renderChannelJSDoc)({
+        description,
+        deprecated,
+        fallbackDescription: `AMQP publish operation for exchange \`${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) => {
+    const exchange = options?.exchange ?? '${additionalProperties?.exchange}';
+    if(!exchange) {
+      return reject('No exchange value found, please provide one')
+    }
+    try {
+      ${publishOperation}
+      resolve();
+    } catch (e: any) {
+      reject(e);
+    }
+  });
+}`;
+    return {
+        messageType,
+        code,
+        functionName,
+        dependencies: [`import * as Amqp from 'amqplib';`],
+        functionType: __1.ChannelFunctionTypes.AMQP_EXCHANGE_PUBLISH
+    };
+}
+exports.renderPublishExchange = renderPublishExchange;

package/dist/codegen/generators/typescript/channels/protocols/amqp/publishQueue.d.ts

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

package/dist/codegen/generators/typescript/channels/protocols/amqp/publishQueue.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderPublishQueue = void 0;
+/* eslint-disable sonarjs/no-nested-template-literals */
+const __1 = require("../..");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../../utils");
+function renderPublishQueue({ topic, messageType, messageModule, channelParameters, channelHeaders, subName = (0, utils_1.pascalCase)(topic), functionName = `publishTo${subName}Queue`, 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 message properties (headers) if provided
+let publishOptions = { ...options };
+if (headers) {
+  const headerData = headers.marshal();
+  const parsedHeaders = typeof headerData === 'string' ? JSON.parse(headerData) : headerData;
+  publishOptions.headers = {};
+  for (const [key, value] of Object.entries(parsedHeaders)) {
+    if (value !== undefined) {
+      publishOptions.headers[key] = value;
+    }
+  }
+}`
+        : `let publishOptions = { ...options };`;
+    const publishOperation = `let dataToSend: any = ${messageType === 'null' ? 'null' : messageMarshalling};
+const channel = await amqp.createChannel();
+const queue = ${addressToUse};
+${headersHandling}
+channel.sendToQueue(queue, Buffer.from(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'
+                }
+            ]
+            : []),
+        {
+            parameter: 'amqp',
+            parameterType: 'amqp: Amqp.Connection',
+            jsDoc: ' * @param amqp the AMQP connection to send over'
+        },
+        {
+            parameter: `options`,
+            parameterType: `options?: Amqp.Options.Publish`,
+            jsDoc: ' * @param options for the AMQP publish queue operation'
+        }
+    ];
+    const jsDoc = (0, utils_2.renderChannelJSDoc)({
+        description,
+        deprecated,
+        fallbackDescription: `AMQP publish operation for queue \`${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 Amqp from 'amqplib';`],
+        functionType: __1.ChannelFunctionTypes.AMQP_QUEUE_PUBLISH
+    };
+}
+exports.renderPublishQueue = renderPublishQueue;

package/dist/codegen/generators/typescript/channels/protocols/amqp/subscribeQueue.d.ts

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

package/dist/codegen/generators/typescript/channels/protocols/amqp/subscribeQueue.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderSubscribeQueue = void 0;
+const __1 = require("../..");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../../utils");
+function renderSubscribeQueue({ topic, messageType, messageModule, channelParameters, channelHeaders, subName = (0, utils_1.pascalCase)(topic), functionName = `subscribeTo${subName}Queue`, payloadGenerator, description, deprecated }) {
+    const includeValidation = payloadGenerator.generator.includeValidation;
+    const addressToUse = channelParameters
+        ? `parameters.getChannelWithParameters('${topic}')`
+        : `'${topic}'`;
+    const messageUnmarshalling = `${messageModule ?? messageType}.unmarshal(receivedData)`;
+    messageType = messageModule ? `${messageModule}.${messageType}` : messageType;
+    const { potentialValidatorCreation, potentialValidationFunction } = (0, utils_2.getValidationFunctions)({
+        includeValidation,
+        messageModule,
+        messageType,
+        onValidationFail: `onDataCallback({err: new Error(\`Invalid message payload received $\{JSON.stringify({cause: errors})}\`), msg: undefined${channelHeaders ? ', headers: extractedHeaders' : ''}, amqpMsg: msg}); return;`
+    });
+    const subscribeOperation = `const channel = await amqp.createChannel();
+const queue = ${addressToUse};
+await channel.assertQueue(queue, { durable: true });
+${potentialValidatorCreation}
+channel.consume(queue, (msg) => {
+  if (msg !== null) {
+    const receivedData = msg.content.toString()
+    ${channelHeaders
+        ? `// Extract headers if present
+    let extractedHeaders: ${channelHeaders.type} | undefined = undefined;
+    if (msg.properties && msg.properties.headers) {
+      const headerObj: Record<string, any> = {};
+      for (const [key, value] of Object.entries(msg.properties.headers)) {
+        if (value !== undefined) {
+          headerObj[key] = value;
+        }
+      }
+      extractedHeaders = ${channelHeaders.type}.unmarshal(headerObj);
+    }`
+        : ''}
+    ${potentialValidationFunction}
+    const message = ${messageUnmarshalling};
+    onDataCallback({err: undefined, msg: message${channelHeaders ? ', headers: extractedHeaders' : ''}, amqpMsg: msg});
+  }
+}, options);`;
+    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'
+        },
+        ...(channelHeaders
+            ? [
+                {
+                    parameter: `headers?: ${channelHeaders.type}`,
+                    jsDoc: ' * @param headers that was received with the message'
+                }
+            ]
+            : []),
+        {
+            parameter: `amqpMsg?: Amqp.ConsumeMessage`,
+            jsDoc: ' * @param amqpMsg'
+        }
+    ];
+    const callbackObjectType = `{${callbackFunctionParameters.map((param) => param.parameter).join(', ')}}`;
+    const callbackParameterNames = callbackFunctionParameters
+        .map((param) => param.parameter.split('?')[0])
+        .join(', ');
+    const functionParameters = [
+        {
+            parameter: `onDataCallback`,
+            parameterType: `onDataCallback: (params: ${callbackObjectType}) => 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: 'amqp',
+            parameterType: 'amqp: Amqp.Connection',
+            jsDoc: ' * @param amqp the AMQP connection to receive from'
+        },
+        {
+            parameter: `options`,
+            parameterType: `options?: Amqp.Options.Consume`,
+            jsDoc: ' * @param options for the AMQP subscribe queue operation'
+        },
+        {
+            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: `AMQP subscribe operation for queue \`${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<Amqp.Channel> {
+  return new Promise(async (resolve, reject) => {
+    try {
+      ${subscribeOperation}
+      resolve(channel);
+    } catch (e: any) {
+      reject(e);
+    }
+  });
+}`;
+    return {
+        messageType,
+        code,
+        functionName,
+        dependencies: [`import * as Amqp from 'amqplib';`],
+        functionType: __1.ChannelFunctionTypes.AMQP_QUEUE_SUBSCRIBE
+    };
+}
+exports.renderSubscribeQueue = renderSubscribeQueue;

package/dist/codegen/generators/typescript/channels/protocols/eventsource/express.d.ts

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

package/dist/codegen/generators/typescript/channels/protocols/eventsource/express.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderExpress = void 0;
+/* eslint-disable sonarjs/no-nested-template-literals */
+const __1 = require("../..");
+const utils_1 = require("../../../utils");
+const utils_2 = require("../../utils");
+function renderExpress({ topic, messageType, messageModule, channelParameters, channelHeaders, subName = (0, utils_1.pascalCase)(topic), functionName = `register${subName}`, description, deprecated }) {
+    let addressToUse = topic.replace(/{([^}]+)}/g, ':$1');
+    addressToUse = addressToUse.startsWith('/')
+        ? addressToUse
+        : `/${addressToUse}`;
+    let messageMarshalling = 'message.marshal()';
+    if (messageModule) {
+        messageMarshalling = `${messageModule}.marshal(message)`;
+    }
+    messageType = messageModule ? `${messageModule}.${messageType}` : messageType;
+    const callbackFunctionParameters = [
+        {
+            parameter: 'req: Request',
+            jsDoc: ' * @param req from the request'
+        },
+        {
+            parameter: 'res: Response',
+            jsDoc: ' * @param res from the request'
+        },
+        {
+            parameter: 'next: NextFunction',
+            jsDoc: ' * @param next attached to the request'
+        },
+        ...(channelParameters
+            ? [
+                {
+                    parameter: `parameters: ${channelParameters.type}`,
+                    jsDoc: ' * @param parameters that was received when client made the connection'
+                }
+            ]
+            : []),
+        {
+            parameter: `sendEvent: (message: ${messageType}) => void`,
+            jsDoc: ' * @param sendEvent callback you can use to send message to the client'
+        }
+    ];
+    const functionParameters = [
+        {
+            parameter: 'router',
+            parameterType: 'router: Router',
+            jsDoc: ' * @param router to attach the event source to'
+        },
+        {
+            parameter: `callback`,
+            parameterType: `callback: ((${callbackFunctionParameters.map((param) => param.parameter).join(', ')}) => void) | ((${callbackFunctionParameters.map((param) => param.parameter).join(', ')}) => Promise<void>)`,
+            jsDoc: ' * @param callback to call when receiving events'
+        }
+    ];
+    const jsDoc = (0, utils_2.renderChannelJSDoc)({
+        description,
+        deprecated,
+        fallbackDescription: `Register EventSource endpoint 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 event = '${addressToUse}';
+  router.get(event, async (req, res, next) => {
+    ${channelParameters ? `const listenParameters = ${channelParameters.type}.createFromChannel(req.originalUrl.startsWith('/') ? req.originalUrl.slice(1) : req.originalUrl, '${topic}', ${(0, utils_1.findRegexFromChannel)(topic)});` : ''}
+    res.writeHead(200, {
+      'Cache-Control': 'no-cache, no-transform',
+      'Content-Type': 'text/event-stream',
+      Connection: 'keep-alive',
+      'Access-Control-Allow-Origin': '*',
+    })
+    const sendEventCallback = (message: ${messageType}) => {
+      if (res.closed) {
+        return
+      }
+      res.write(\`event: \${event}\\n\`)
+      res.write(\`data: \${${messageMarshalling}}\\n\\n\`)
+    }
+    await callback(req, res, next, ${channelParameters ? 'listenParameters, ' : ' '}sendEventCallback)
+  })
+}
+`;
+    return {
+        messageType,
+        code,
+        functionName,
+        dependencies: [
+            `import { NextFunction, Request, Response, Router } from 'express';`
+        ],
+        functionType: __1.ChannelFunctionTypes.EVENT_SOURCE_EXPRESS
+    };
+}
+exports.renderExpress = renderExpress;

package/dist/codegen/generators/typescript/channels/protocols/eventsource/fetch.d.ts

@@ -0,0 +1,5 @@
+import { SingleFunctionRenderType } from '../../../../../types';
+import { RenderRegularParameters } from '../../types';
+export declare function renderFetch({ topic, messageType, messageModule, channelParameters, channelHeaders, subName, functionName, additionalProperties, payloadGenerator, description, deprecated }: RenderRegularParameters<{
+    fetchDependency: string;
+}>): SingleFunctionRenderType;

package/dist/codegen/generators/typescript/channels/protocols/eventsource/fetch.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderFetch = void 0;
+/* eslint-disable sonarjs/no-nested-template-literals */
+const __1 = require("../..");
+const utils_1 = require("../../../utils");
+const types_1 = require("../../types");
+const utils_2 = require("../../utils");
+function renderFetch({ topic, messageType, messageModule, channelParameters, channelHeaders, subName = (0, utils_1.pascalCase)(topic), functionName = `listenFor${subName}`, additionalProperties = {
+    fetchDependency: types_1.defaultTypeScriptChannelsGenerator.eventSourceDependency
+}, payloadGenerator, description, deprecated }) {
+    const includeValidation = payloadGenerator.generator.includeValidation;
+    const addressToUse = channelParameters
+        ? `parameters.getChannelWithParameters('${topic}')`
+        : `'${topic}'`;
+    const messageUnmarshalling = `${messageModule ?? messageType}.unmarshal(receivedData)`;
+    messageType = messageModule ? `${messageModule}.${messageType}` : messageType;
+    const { potentialValidatorCreation, potentialValidationFunction } = (0, utils_2.getValidationFunctions)({
+        includeValidation,
+        messageModule,
+        messageType,
+        onValidationFail: `return callback({error: new Error(\`Invalid message payload received; $\{JSON.stringify({cause: errors})}\`), messageEvent: undefined});`
+    });
+    const functionParameters = [
+        {
+            parameter: `callback`,
+            parameterType: `callback: (params: {error?: Error, messageEvent?: ${messageType}}) => void`,
+            jsDoc: ' * @param callback to call when receiving events'
+        },
+        ...(channelParameters
+            ? [
+                {
+                    parameter: `parameters`,
+                    parameterType: `parameters: ${channelParameters.type}`,
+                    jsDoc: ' * @param parameters for listening'
+                }
+            ]
+            : []),
+        ...(channelHeaders
+            ? [
+                {
+                    parameter: `headers`,
+                    parameterType: `headers?: ${channelHeaders.type}`,
+                    jsDoc: ' * @param headers optional headers to include with the EventSource connection'
+                }
+            ]
+            : []),
+        {
+            parameter: 'options',
+            parameterType: `options: {authorization?: string, onClose?: (err?: string) => void, baseUrl: string, headers?: Record<string, string>}`,
+            jsDoc: ' * @param options additionally used to handle the event source'
+        },
+        {
+            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: `Event source fetch for \`${topic}\``,
+        parameters: [
+            ...functionParameters.map((param) => ({
+                jsDoc: param.jsDoc
+            })),
+            {
+                jsDoc: ' * @returns A cleanup function to abort the connection'
+            }
+        ]
+    });
+    const code = `${jsDoc}
+function ${functionName}({
+  ${functionParameters.map((param) => param.parameter).join(', \n  ')}
+}: {
+  ${functionParameters.map((param) => param.parameterType).join(', \n  ')}
+}): (() => void) {
+	const controller = new AbortController();
+	let eventsUrl: string = ${addressToUse};
+	const url = \`\${options.baseUrl}/\${eventsUrl}\`
+  const requestHeaders: Record<string, string> = {
+	  ...options.headers ?? {},
+    Accept: 'text/event-stream'
+  }
+  if(options.authorization) {
+    requestHeaders['authorization'] = \`Bearer \${options?.authorization}\`;
+  }
+  ${channelHeaders
+        ? `// Add headers from AsyncAPI specification if provided
+  if (headers) {
+    const asyncApiHeaderData = headers.marshal();
+    const parsedAsyncApiHeaders = typeof asyncApiHeaderData === 'string' ? JSON.parse(asyncApiHeaderData) : asyncApiHeaderData;
+    for (const [key, value] of Object.entries(parsedAsyncApiHeaders)) {
+      if (value !== undefined) {
+        requestHeaders[key] = String(value);
+      }
+    }
+  }`
+        : ''}
+  ${potentialValidatorCreation}
+	fetchEventSource(\`\${url}\`, {
+		method: 'GET',
+		headers: requestHeaders,
+		signal: controller.signal,
+		onmessage: (ev: EventSourceMessage) => {
+      const receivedData = ev.data;
+      ${potentialValidationFunction}
+      const callbackData = ${messageUnmarshalling};
+			callback({error: undefined, messageEvent: callbackData});
+		},
+		onerror: (err) => {
+			options.onClose?.(err);
+		},
+		onclose: () => {
+			options.onClose?.();
+		},
+		async onopen(response: { ok: any; headers: any; status: number }) {
+			if (response.ok && response.headers.get('content-type') === EventStreamContentType) {
+				return // everything's good
+			} else if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+				// client-side errors are usually non-retriable:
+				callback({error: new Error('Client side error, could not open event connection'), messageEvent: undefined})
+			} else {
+				callback({error: new Error('Unknown error, could not open event connection'), messageEvent: undefined});
+			}
+		},
+	});
+	
+	return () => {
+		controller.abort();
+	};
+}
+`;
+    return {
+        messageType,
+        code,
+        functionName,
+        dependencies: [
+            `import { fetchEventSource, EventStreamContentType, EventSourceMessage } from '${additionalProperties.fetchDependency}';`
+        ],
+        functionType: __1.ChannelFunctionTypes.EVENT_SOURCE_FETCH
+    };
+}
+exports.renderFetch = renderFetch;

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

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