@alagoni97/cli 0.72.1

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

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEventSourceChannels = exports.renderExpress = exports.renderFetch = 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 express_1 = require("./express");
+Object.defineProperty(exports, "renderExpress", { enumerable: true, get: function () { return express_1.renderExpress; } });
+const fetch_1 = require("./fetch");
+Object.defineProperty(exports, "renderFetch", { enumerable: true, get: function () { return fetch_1.renderFetch; } });
+const errors_1 = require("../../../../../errors");
+async function generateEventSourceChannels(context, channel, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies) {
+    const { parameter, topic } = context;
+    const ignoreOperation = !context.generator.asyncapiGenerateForOperations;
+    const eventSourceContext = {
+        channelParameters: parameter,
+        channelHeaders: context.headers, // EventSource supports custom headers
+        topic,
+        messageType: '',
+        subName: context.subName,
+        payloadGenerator: context.payloads
+    };
+    const operations = channel.operations().all();
+    const renders = operations.length > 0 && !ignoreOperation
+        ? await generateForOperations(context, channel, eventSourceContext)
+        : await generateForChannels(context, channel, eventSourceContext);
+    addRendersToExternal(renders, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies, parameter);
+}
+exports.generateEventSourceChannels = generateEventSourceChannels;
+function addRendersToExternal(renders, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies, parameter) {
+    protocolCodeFunctions['event_source'].push(...renders.map((value) => value.code));
+    externalProtocolFunctionInformation['event_source'].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, eventSourceContext) {
+    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;
+        const payloadId = (0, utils_1.findOperationId)(operation, channel);
+        const payload = payloads.operationModels[payloadId];
+        if (!payload) {
+            throw new Error(`Could not find payload for operation in channel typescript generator for EventSource`);
+        }
+        const { messageModule, messageType } = (0, utils_2.getMessageTypeAndModule)(payload);
+        if (messageType === undefined) {
+            throw new Error(`Could not find message type for channel typescript generator for EventSource`);
+        }
+        // Extract operation metadata for JSDoc
+        const { description, deprecated } = (0, utils_1.getOperationMetadata)(operation);
+        const updatedContext = {
+            ...eventSourceContext,
+            messageType,
+            messageModule,
+            subName: (0, utils_1.findNameFromOperation)(operation, channel),
+            description,
+            deprecated
+        };
+        renders.push(...generateOperationRenders(operation, updatedContext, updatedFunctionTypeMapping, generator));
+    }
+    return renders;
+}
+function generateOperationRenders(operation, eventSourceContext, functionTypeMapping, generator) {
+    const renders = [];
+    const action = operation.action();
+    if ((0, asyncapi_1.shouldRenderFunctionType)(functionTypeMapping, types_1.ChannelFunctionTypes.EVENT_SOURCE_FETCH, action, generator.asyncapiReverseOperations)) {
+        renders.push((0, fetch_1.renderFetch)({
+            ...eventSourceContext,
+            additionalProperties: {
+                fetchDependency: generator.eventSourceDependency
+            }
+        }));
+    }
+    if ((0, asyncapi_1.shouldRenderFunctionType)(functionTypeMapping, types_1.ChannelFunctionTypes.EVENT_SOURCE_EXPRESS, action, generator.asyncapiReverseOperations)) {
+        renders.push((0, express_1.renderExpress)(eventSourceContext));
+    }
+    return renders;
+}
+async function generateForChannels(context, channel, eventSourceContext) {
+    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: 'EventSource'
+        });
+    }
+    const { messageModule, messageType } = (0, utils_2.getMessageTypeAndModule)(payload);
+    if (messageType === undefined) {
+        throw new Error(`Could not find message type for channel typescript generator for EventSource`);
+    }
+    const updatedContext = { ...eventSourceContext, messageType, messageModule };
+    const renderChecks = [
+        {
+            check: types_1.ChannelFunctionTypes.EVENT_SOURCE_FETCH,
+            render: fetch_1.renderFetch,
+            action: 'receive'
+        },
+        {
+            check: types_1.ChannelFunctionTypes.EVENT_SOURCE_EXPRESS,
+            render: express_1.renderExpress,
+            action: 'send'
+        }
+    ];
+    for (const { check, render, action } of renderChecks) {
+        if ((0, asyncapi_1.shouldRenderFunctionType)(functionTypeMapping, check, action, generator.asyncapiReverseOperations)) {
+            renders.push(render({
+                ...updatedContext,
+                additionalProperties: check === types_1.ChannelFunctionTypes.EVENT_SOURCE_FETCH
+                    ? { fetchDependency: generator.eventSourceDependency }
+                    : undefined
+            }));
+        }
+    }
+    return renders;
+}

package/dist/codegen/generators/typescript/channels/protocols/http/client.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Generates HTTP client functions for individual API operations.
+ * Each operation gets a typed function with request/response handling.
+ */
+import { HttpRenderType } from '../../../../../types';
+import { RenderHttpParameters } from '../../types';
+/**
+ * Renders an HTTP fetch client function for a specific API operation.
+ */
+export declare function renderHttpFetchClient({ requestTopic, requestMessageType, requestMessageModule, replyMessageType, replyMessageModule, channelParameters, method, servers, subName, functionName, includesStatusCodes, description, deprecated }: RenderHttpParameters): HttpRenderType;

package/dist/codegen/generators/typescript/channels/protocols/http/client.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderHttpFetchClient = void 0;
+const utils_1 = require("../../../utils");
+const types_1 = require("../../types");
+const utils_2 = require("../../utils");
+/**
+ * Renders an HTTP fetch client function for a specific API operation.
+ */
+function renderHttpFetchClient({ requestTopic, requestMessageType, requestMessageModule, replyMessageType, replyMessageModule, channelParameters, method, servers = [], subName = (0, utils_1.pascalCase)(requestTopic), functionName = `${method.toLowerCase()}${subName}`, includesStatusCodes = false, description, deprecated }) {
+    const messageType = requestMessageModule
+        ? `${requestMessageModule}.${requestMessageType}`
+        : requestMessageType;
+    const replyType = replyMessageModule
+        ? `${replyMessageModule}.${replyMessageType}`
+        : replyMessageType;
+    // Generate context interface name
+    const contextInterfaceName = `${(0, utils_1.pascalCase)(functionName)}Context`;
+    // Determine if operation has path parameters
+    const hasParameters = channelParameters !== undefined;
+    // Generate the context interface (extends HttpClientContext)
+    const contextInterface = generateContextInterface(contextInterfaceName, messageType, hasParameters, method);
+    // Generate JSDoc for the function
+    const jsDoc = (0, utils_2.renderChannelJSDoc)({
+        description,
+        deprecated,
+        fallbackDescription: `HTTP ${method} request to ${requestTopic}`
+    });
+    // Generate the function implementation
+    const functionCode = generateFunctionImplementation({
+        functionName,
+        contextInterfaceName,
+        replyType,
+        replyMessageModule,
+        replyMessageType,
+        messageType,
+        requestTopic,
+        hasParameters,
+        method,
+        servers,
+        includesStatusCodes,
+        jsDoc
+    });
+    const code = `${contextInterface}
+
+${functionCode}`;
+    return {
+        messageType,
+        replyType,
+        code,
+        functionName,
+        dependencies: [
+            `import { URLSearchParams, URL } from 'url';`,
+            `import * as NodeFetch from 'node-fetch';`
+        ],
+        functionType: types_1.ChannelFunctionTypes.HTTP_CLIENT
+    };
+}
+exports.renderHttpFetchClient = renderHttpFetchClient;
+/**
+ * Generate the context interface for an HTTP operation
+ */
+function generateContextInterface(interfaceName, messageType, hasParameters, method) {
+    const fields = [];
+    // Add payload field for methods that have a body
+    if (messageType && ['POST', 'PUT', 'PATCH'].includes(method.toUpperCase())) {
+        fields.push(`  payload: ${messageType};`);
+    }
+    // Add parameters field if operation has path parameters
+    if (hasParameters) {
+        fields.push(`  parameters: { getChannelWithParameters: (path: string) => string };`);
+    }
+    // Add requestHeaders field (optional) for operations that support typed headers
+    // This is always optional since headers can also be passed via additionalHeaders
+    fields.push(`  requestHeaders?: { marshal: () => string };`);
+    const fieldsStr = fields.length > 0 ? `\n${fields.join('\n')}\n` : '';
+    return `export interface ${interfaceName} extends HttpClientContext {${fieldsStr}}`;
+}
+/**
+ * Generate the function implementation
+ */
+function generateFunctionImplementation(params) {
+    const { functionName, contextInterfaceName, replyType, replyMessageModule, replyMessageType, messageType, requestTopic, hasParameters, method, servers, includesStatusCodes, jsDoc } = params;
+    const defaultServer = servers[0] ?? "'localhost:3000'";
+    const hasBody = messageType && ['POST', 'PUT', 'PATCH'].includes(method.toUpperCase());
+    // Generate URL building code
+    const urlBuildCode = hasParameters
+        ? `let url = buildUrlWithParameters(config.server, '${requestTopic}', context.parameters);`
+        : 'let url = `${config.server}${config.path}`;';
+    // Generate headers initialization
+    const headersInit = `let headers = context.requestHeaders
+    ? applyTypedHeaders(context.requestHeaders, config.additionalHeaders)
+    : { 'Content-Type': 'application/json', ...config.additionalHeaders } as Record<string, string | string[]>;`;
+    // Generate body preparation
+    const bodyPrep = hasBody
+        ? `const body = context.payload?.marshal();`
+        : `const body = undefined;`;
+    // Generate response parsing
+    // Use unmarshalByStatusCode if the payload is a union type with status code support
+    let responseParseCode;
+    if (replyMessageModule) {
+        responseParseCode = includesStatusCodes
+            ? `const responseData = ${replyMessageModule}.unmarshalByStatusCode(rawData, response.status);`
+            : `const responseData = ${replyMessageModule}.unmarshal(rawData);`;
+    }
+    else {
+        responseParseCode = `const responseData = ${replyMessageType}.unmarshal(rawData);`;
+    }
+    // Generate default context for optional context parameter
+    const contextDefault = !hasBody && !hasParameters ? ' = {}' : '';
+    return `${jsDoc}
+async function ${functionName}(context: ${contextInterfaceName}${contextDefault}): Promise<HttpClientResponse<${replyType}>> {
+  // Apply defaults
+  const config = {
+    path: '${requestTopic}',
+    server: ${defaultServer},
+    ...context,
+  };
+
+  // Validate OAuth2 config if present
+  if (config.auth?.type === 'oauth2' && AUTH_FEATURES.oauth2) {
+    validateOAuth2Config(config.auth);
+  }
+
+  // Build headers
+  ${headersInit}
+
+  // Build URL
+  ${urlBuildCode}
+  url = applyQueryParams(config.queryParams, url);
+
+  // Apply pagination (can affect URL and/or headers)
+  const paginationResult = applyPagination(config.pagination, url, headers);
+  url = paginationResult.url;
+  headers = paginationResult.headers;
+
+  // Apply authentication
+  const authResult = applyAuth(config.auth, headers, url);
+  headers = authResult.headers;
+  url = authResult.url;
+
+  // Prepare body
+  ${bodyPrep}
+
+  // Determine request function
+  const makeRequest = config.hooks?.makeRequest ?? defaultMakeRequest;
+
+  // Build request params
+  let requestParams: HttpRequestParams = {
+    url,
+    method: '${method}',
+    headers,
+    body
+  };
+
+  // Apply beforeRequest hook
+  if (config.hooks?.beforeRequest) {
+    requestParams = await config.hooks.beforeRequest(requestParams);
+  }
+
+  try {
+    // Execute request with retry logic
+    let response = await executeWithRetry(requestParams, makeRequest, config.retry);
+
+    // Apply afterResponse hook
+    if (config.hooks?.afterResponse) {
+      response = await config.hooks.afterResponse(response, requestParams);
+    }
+
+    // Handle OAuth2 token flows that require getting a token first
+    if (config.auth?.type === 'oauth2' && !config.auth.accessToken && AUTH_FEATURES.oauth2) {
+      const tokenFlowResponse = await handleOAuth2TokenFlow(config.auth, requestParams, makeRequest, config.retry);
+      if (tokenFlowResponse) {
+        response = tokenFlowResponse;
+      }
+    }
+
+    // Handle 401 with token refresh
+    if (response.status === 401 && config.auth?.type === 'oauth2' && AUTH_FEATURES.oauth2) {
+      try {
+        const refreshResponse = await handleTokenRefresh(config.auth, requestParams, makeRequest, config.retry);
+        if (refreshResponse) {
+          response = refreshResponse;
+        }
+      } catch {
+        throw new Error('Unauthorized');
+      }
+    }
+
+    // Handle error responses
+    if (!response.ok) {
+      handleHttpError(response.status, response.statusText);
+    }
+
+    // Parse response
+    const rawData = await response.json();
+    ${responseParseCode}
+
+    // Extract response metadata
+    const responseHeaders = extractHeaders(response);
+    const paginationInfo = extractPaginationInfo(responseHeaders, config.pagination);
+
+    // Build response wrapper with pagination helpers
+    const result: HttpClientResponse<${replyType}> = {
+      data: responseData,
+      status: response.status,
+      statusText: response.statusText,
+      headers: responseHeaders,
+      rawData,
+      pagination: paginationInfo,
+      ...createPaginationHelpers(config, paginationInfo, ${functionName}),
+    };
+
+    return result;
+
+  } catch (error) {
+    // Apply onError hook if present
+    if (config.hooks?.onError && error instanceof Error) {
+      throw await config.hooks.onError(error, requestParams);
+    }
+    throw error;
+  }
+}`;
+}

package/dist/codegen/generators/typescript/channels/protocols/http/common-types.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Generates common types and helper functions shared across all HTTP client functions.
+ * This module renders the shared infrastructure code that is included once per generation.
+ */
+import { SecuritySchemeOptions } from '../../types';
+/**
+ * Generates common types and helper functions shared across all HTTP client functions.
+ * This should be called once per protocol generation to avoid code duplication.
+ *
+ * @param securitySchemes - Optional security schemes extracted from OpenAPI.
+ *                          When provided, only relevant auth types are generated.
+ *                          When undefined/empty, all auth types are generated for backward compatibility.
+ */
+export declare function renderHttpCommonTypes(securitySchemes?: SecuritySchemeOptions[]): string;