@alagoni97/cli 0.72.3 → 0.72.5

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

@@ -35,8 +35,12 @@ async function generateTypeScriptChannelsForOpenAPI(context, parameters, payload
     const deps = protocolDependencies['http_client'];
     const importExtension = (0, utils_4.resolveImportExtension)(context.generator, context.config);
     (0, utils_1.collectProtocolDependencies)(payloads, parameters, headers, context, deps, importExtension);
+    // OAuth2 request handling is only generated when the spec defines an OAuth2
+    // scheme; otherwise the narrowed AuthConfig union would make that code fail to
+    // type-check.
+    const oauth2Enabled = (0, http_1.analyzeSecuritySchemes)(securitySchemes).oauth2;
     // Process all operations and collect renders
-    const renders = processOpenAPIOperations(openapiDocument, payloads, parameters);
+    const renders = processOpenAPIOperations(openapiDocument, payloads, parameters, oauth2Enabled);
     // Generate common types once (stateless check)
     // Pass security schemes to generate only relevant auth types
     if (protocolCodeFunctions['http_client'].length === 0 && renders.length > 0) {
@@ -60,14 +64,14 @@ exports.generateTypeScriptChannelsForOpenAPI = generateTypeScriptChannelsForOpen
 /**
  * Process all OpenAPI operations and generate HTTP client functions.
  */
-function processOpenAPIOperations(openapiDocument, payloads, parameters) {
+function processOpenAPIOperations(openapiDocument, payloads, parameters, oauth2Enabled) {
     const renders = [];
     for (const [path, pathItem] of Object.entries(openapiDocument.paths ?? {})) {
         if (!pathItem) {
             continue;
         }
         for (const method of HTTP_METHODS) {
-            const render = processOperation(pathItem, method, path, payloads, parameters);
+            const render = processOperation(pathItem, method, path, payloads, parameters, oauth2Enabled);
             if (render) {
                 renders.push(render);
             }
@@ -78,7 +82,7 @@ function processOpenAPIOperations(openapiDocument, payloads, parameters) {
 /**
  * Process a single OpenAPI operation and generate an HTTP client function.
  */
-function processOperation(pathItem, method, path, payloads, parameters) {
+function processOperation(pathItem, method, path, payloads, parameters, oauth2Enabled) {
     // eslint-disable-next-line security/detect-object-injection
     const operation = pathItem[method];
     if (!operation) {
@@ -140,7 +144,8 @@ function processOperation(pathItem, method, path, payloads, parameters) {
         channelParameters: parameterModel?.model,
         includesStatusCodes: replyIncludesStatusCodes,
         description,
-        deprecated
+        deprecated,
+        oauth2Enabled
     });
 }
 /**

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

@@ -7,4 +7,4 @@ 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;
+export declare function renderHttpFetchClient({ requestTopic, requestMessageType, requestMessageModule, replyMessageType, replyMessageModule, channelParameters, method, servers, subName, functionName, includesStatusCodes, description, deprecated, oauth2Enabled }: RenderHttpParameters): HttpRenderType;

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

@@ -7,7 +7,7 @@ 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 }) {
+function renderHttpFetchClient({ requestTopic, requestMessageType, requestMessageModule, replyMessageType, replyMessageModule, channelParameters, method, servers = [], subName = (0, utils_1.pascalCase)(requestTopic), functionName = `${method.toLowerCase()}${subName}`, includesStatusCodes = false, description, deprecated, oauth2Enabled = true }) {
     const messageType = requestMessageModule
         ? `${requestMessageModule}.${requestMessageType}`
         : requestMessageType;
@@ -39,7 +39,8 @@ function renderHttpFetchClient({ requestTopic, requestMessageType, requestMessag
         method,
         servers,
         includesStatusCodes,
-        jsDoc
+        jsDoc,
+        oauth2Enabled
     });
     const code = `${contextInterface}
 
@@ -80,7 +81,7 @@ function generateContextInterface(interfaceName, messageType, hasParameters, met
  * Generate the function implementation
  */
 function generateFunctionImplementation(params) {
-    const { functionName, contextInterfaceName, replyType, replyMessageModule, replyMessageType, messageType, requestTopic, hasParameters, method, servers, includesStatusCodes, jsDoc } = params;
+    const { functionName, contextInterfaceName, replyType, replyMessageModule, replyMessageType, messageType, requestTopic, hasParameters, method, servers, includesStatusCodes, jsDoc, oauth2Enabled } = params;
     const defaultServer = servers[0] ?? "'localhost:3000'";
     const hasBody = messageType && ['POST', 'PUT', 'PATCH'].includes(method.toUpperCase());
     // Generate URL building code
@@ -108,6 +109,40 @@ function generateFunctionImplementation(params) {
     }
     // Generate default context for optional context parameter
     const contextDefault = !hasBody && !hasParameters ? ' = {}' : '';
+    // OAuth2 request handling is only emitted when the API actually defines an
+    // OAuth2 scheme; otherwise these branches reference fields/functions that the
+    // narrowed AuthConfig union no longer carries and would fail to type-check.
+    const oauth2ValidateBlock = oauth2Enabled
+        ? `  // Validate OAuth2 config if present
+  if (config.auth?.type === 'oauth2' && AUTH_FEATURES.oauth2) {
+    validateOAuth2Config(config.auth);
+  }
+
+`
+        : '';
+    const oauth2TokenBlock = oauth2Enabled
+        ? `
+    // 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');
+      }
+    }
+`
+        : '';
     return `${jsDoc}
 async function ${functionName}(context: ${contextInterfaceName}${contextDefault}): Promise<HttpClientResponse<${replyType}>> {
   // Apply defaults
@@ -117,12 +152,7 @@ async function ${functionName}(context: ${contextInterfaceName}${contextDefault}
     ...context,
   };
 
-  // Validate OAuth2 config if present
-  if (config.auth?.type === 'oauth2' && AUTH_FEATURES.oauth2) {
-    validateOAuth2Config(config.auth);
-  }
-
-  // Build headers
+${oauth2ValidateBlock}  // Build headers
   ${headersInit}
 
   // Build URL
@@ -166,27 +196,7 @@ async function ${functionName}(context: ${contextInterfaceName}${contextDefault}
     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');
-      }
-    }
-
+${oauth2TokenBlock}
     // Handle error responses
     if (!response.ok) {
       handleHttpError(response.status, response.statusText);

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

@@ -13,6 +13,33 @@ const security_1 = require("./security");
 function renderHttpCommonTypes(securitySchemes) {
     const requirements = (0, security_1.analyzeSecuritySchemes)(securitySchemes);
     const securityTypes = (0, security_1.renderSecurityTypes)(securitySchemes, requirements);
+    const applyAuthCases = (0, security_1.renderApplyAuthCases)(requirements);
+    // Only emit the AUTH_FEATURES flag when OAuth2 code is generated, and the
+    // API_KEY_DEFAULTS const when an apiKey case is generated - otherwise they
+    // become unused declarations in the output.
+    const authFeaturesBlock = requirements.oauth2
+        ? `
+/**
+ * Feature flags indicating which auth types are available.
+ * Used internally to conditionally call auth-specific helpers.
+ */
+const AUTH_FEATURES = {
+  oauth2: ${requirements.oauth2}
+} as const;
+`
+        : '';
+    const apiKeyDefaultsBlock = requirements.apiKey
+        ? `
+/**
+ * Default values for API key authentication derived from the spec.
+ * These match the defaults documented in the ApiKeyAuth interface.
+ */
+const API_KEY_DEFAULTS = {
+  name: '${(0, security_1.escapeStringForCodeGen)((0, security_1.getApiKeyDefaults)(requirements.apiKeySchemes).name)}',
+  in: '${(0, security_1.escapeStringForCodeGen)((0, security_1.getApiKeyDefaults)(requirements.apiKeySchemes).in)}' as 'header' | 'query' | 'cookie'
+} as const;
+`
+        : '';
     return `// ============================================================================
 // Common Types - Shared across all HTTP client functions
 // ============================================================================
@@ -95,24 +122,7 @@ export interface TokenResponse {
 }
 
 ${securityTypes}
-
-/**
- * Feature flags indicating which auth types are available.
- * Used internally to conditionally call auth-specific helpers.
- */
-const AUTH_FEATURES = {
-  oauth2: ${requirements.oauth2}
-} as const;
-
-/**
- * Default values for API key authentication derived from the spec.
- * These match the defaults documented in the ApiKeyAuth interface.
- */
-const API_KEY_DEFAULTS = {
-  name: '${(0, security_1.escapeStringForCodeGen)((0, security_1.getApiKeyDefaults)(requirements.apiKeySchemes).name)}',
-  in: '${(0, security_1.escapeStringForCodeGen)((0, security_1.getApiKeyDefaults)(requirements.apiKeySchemes).in)}' as 'header' | 'query' | 'cookie'
-} as const;
-
+${authFeaturesBlock}${apiKeyDefaultsBlock}
 // ============================================================================
 // Pagination Types
 // ============================================================================
@@ -294,39 +304,7 @@ function applyAuth(
   if (!auth) return { headers, url };
 
   switch (auth.type) {
-    case 'bearer':
-      headers['Authorization'] = \`Bearer \${auth.token}\`;
-      break;
-
-    case 'basic': {
-      const credentials = Buffer.from(\`\${auth.username}:\${auth.password}\`).toString('base64');
-      headers['Authorization'] = \`Basic \${credentials}\`;
-      break;
-    }
-
-    case 'apiKey': {
-      const keyName = auth.name ?? API_KEY_DEFAULTS.name;
-      const keyIn = auth.in ?? API_KEY_DEFAULTS.in;
-
-      if (keyIn === 'header') {
-        headers[keyName] = auth.key;
-      } else if (keyIn === 'query') {
-        const separator = url.includes('?') ? '&' : '?';
-        url = \`\${url}\${separator}\${keyName}=\${encodeURIComponent(auth.key)}\`;
-      } else if (keyIn === 'cookie') {
-        headers['Cookie'] = \`\${keyName}=\${auth.key}\`;
-      }
-      break;
-    }
-
-    case 'oauth2': {
-      // If we have an access token, use it directly
-      // Token flows (client_credentials, password) are handled separately
-      if (auth.accessToken) {
-        headers['Authorization'] = \`Bearer \${auth.accessToken}\`;
-      }
-      break;
-    }
+${applyAuthCases}
   }
 
   return { headers, url };
@@ -792,7 +770,7 @@ function applyTypedHeaders(
 
   return headers;
 }
-${requirements.oauth2 ? (0, security_1.renderOAuth2Helpers)() : (0, security_1.renderOAuth2Stubs)()}
+${requirements.oauth2 ? (0, security_1.renderOAuth2Helpers)() : ''}
 // ============================================================================
 // Generated HTTP Client Functions
 // ============================================================================`;

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

@@ -3,6 +3,6 @@ import { ChannelInterface } from '@asyncapi/parser';
 import { renderHttpCommonTypes } from './common-types';
 import { renderHttpFetchClient } from './client';
 export { renderHttpCommonTypes, renderHttpFetchClient };
-export { analyzeSecuritySchemes, escapeStringForCodeGen, getApiKeyDefaults, renderOAuth2Helpers, renderOAuth2Stubs, renderSecurityTypes, type AuthTypeRequirements } from './security';
+export { analyzeSecuritySchemes, escapeStringForCodeGen, getApiKeyDefaults, renderOAuth2Helpers, renderSecurityTypes, type AuthTypeRequirements } from './security';
 export type { SecuritySchemeOptions } from '../../types';
 export declare function generatehttpChannels(context: TypeScriptChannelsGeneratorContext, channel: ChannelInterface, protocolCodeFunctions: Record<string, string[]>, externalProtocolFunctionInformation: Record<string, TypeScriptChannelRenderedFunctionType[]>, dependencies: string[]): Promise<void>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generatehttpChannels = exports.renderSecurityTypes = exports.renderOAuth2Stubs = exports.renderOAuth2Helpers = exports.getApiKeyDefaults = exports.escapeStringForCodeGen = exports.analyzeSecuritySchemes = exports.renderHttpFetchClient = exports.renderHttpCommonTypes = void 0;
+exports.generatehttpChannels = exports.renderSecurityTypes = exports.renderOAuth2Helpers = exports.getApiKeyDefaults = exports.escapeStringForCodeGen = exports.analyzeSecuritySchemes = exports.renderHttpFetchClient = exports.renderHttpCommonTypes = void 0;
 /* eslint-disable security/detect-object-injection */
 const types_1 = require("../../types");
 const utils_1 = require("../../../../../utils");
@@ -16,7 +16,6 @@ Object.defineProperty(exports, "analyzeSecuritySchemes", { enumerable: true, get
 Object.defineProperty(exports, "escapeStringForCodeGen", { enumerable: true, get: function () { return security_1.escapeStringForCodeGen; } });
 Object.defineProperty(exports, "getApiKeyDefaults", { enumerable: true, get: function () { return security_1.getApiKeyDefaults; } });
 Object.defineProperty(exports, "renderOAuth2Helpers", { enumerable: true, get: function () { return security_1.renderOAuth2Helpers; } });
-Object.defineProperty(exports, "renderOAuth2Stubs", { enumerable: true, get: function () { return security_1.renderOAuth2Stubs; } });
 Object.defineProperty(exports, "renderSecurityTypes", { enumerable: true, get: function () { return security_1.renderSecurityTypes; } });
 async function generatehttpChannels(context, channel, protocolCodeFunctions, externalProtocolFunctionInformation, dependencies) {
     const { generator, parameter, topic } = context;

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

@@ -36,11 +36,15 @@ export declare function getApiKeyDefaults(apiKeySchemes: SecuritySchemeOptions[]
  */
 export declare function renderSecurityTypes(schemes: SecuritySchemeOptions[] | undefined, requirements?: AuthTypeRequirements): string;
 /**
- * Generate OAuth2 stub functions when OAuth2 is not available.
- * These stubs ensure TypeScript compilation succeeds when generated code
- * references OAuth2 functions, but the runtime guards prevent them from being called.
- */
-export declare function renderOAuth2Stubs(): string;
+ * Renders the `switch (auth.type)` case blocks for the generated `applyAuth`
+ * helper, emitting only the branches whose auth interfaces were generated.
+ *
+ * A case for an auth type absent from the (possibly narrowed) AuthConfig union
+ * would not type-check: the discriminant comparison has no overlap and the
+ * type-specific fields (`token`, `username`, `key`, `accessToken`, ...) don't
+ * exist on the union members that remain.
+ */
+export declare function renderApplyAuthCases(requirements: AuthTypeRequirements): string;
 /**
  * Generates OAuth2-specific helper functions.
  * Only included when OAuth2 auth is needed.

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderOAuth2Helpers = exports.renderOAuth2Stubs = exports.renderSecurityTypes = exports.getApiKeyDefaults = exports.analyzeSecuritySchemes = exports.escapeStringForCodeGen = void 0;
+exports.renderOAuth2Helpers = exports.renderApplyAuthCases = exports.renderSecurityTypes = exports.getApiKeyDefaults = exports.analyzeSecuritySchemes = exports.escapeStringForCodeGen = void 0;
 /**
  * Escapes special characters in strings that will be interpolated into generated code.
  * Prevents syntax errors when OpenAPI spec values contain quotes, backticks, or template expressions.
@@ -310,30 +310,57 @@ ${bearerSection}${basicSection}${apiKeySection}${oauth2Section}${renderAuthConfi
 }
 exports.renderSecurityTypes = renderSecurityTypes;
 /**
- * Generate OAuth2 stub functions when OAuth2 is not available.
- * These stubs ensure TypeScript compilation succeeds when generated code
- * references OAuth2 functions, but the runtime guards prevent them from being called.
+ * Renders the `switch (auth.type)` case blocks for the generated `applyAuth`
+ * helper, emitting only the branches whose auth interfaces were generated.
+ *
+ * A case for an auth type absent from the (possibly narrowed) AuthConfig union
+ * would not type-check: the discriminant comparison has no overlap and the
+ * type-specific fields (`token`, `username`, `key`, `accessToken`, ...) don't
+ * exist on the union members that remain.
  */
-function renderOAuth2Stubs() {
-    return `
-// OAuth2 helpers not needed for this API - provide type-safe stubs
-// These are never called due to AUTH_FEATURES.oauth2 runtime guards
-type OAuth2Auth = never;
-function validateOAuth2Config(_auth: OAuth2Auth): void {}
-async function handleOAuth2TokenFlow(
-  _auth: OAuth2Auth,
-  _originalParams: HttpRequestParams,
-  _makeRequest: (params: HttpRequestParams) => Promise<HttpResponse>,
-  _retryConfig?: RetryConfig
-): Promise<HttpResponse | null> { return null; }
-async function handleTokenRefresh(
-  _auth: OAuth2Auth,
-  _originalParams: HttpRequestParams,
-  _makeRequest: (params: HttpRequestParams) => Promise<HttpResponse>,
-  _retryConfig?: RetryConfig
-): Promise<HttpResponse | null> { return null; }`;
+function renderApplyAuthCases(requirements) {
+    const cases = [];
+    if (requirements.bearer) {
+        cases.push(`    case 'bearer':
+      headers['Authorization'] = \`Bearer \${auth.token}\`;
+      break;`);
+    }
+    if (requirements.basic) {
+        cases.push(`    case 'basic': {
+      const credentials = Buffer.from(\`\${auth.username}:\${auth.password}\`).toString('base64');
+      headers['Authorization'] = \`Basic \${credentials}\`;
+      break;
+    }`);
+    }
+    if (requirements.apiKey) {
+        cases.push(`    case 'apiKey': {
+      const keyName = auth.name ?? API_KEY_DEFAULTS.name;
+      const keyIn = auth.in ?? API_KEY_DEFAULTS.in;
+
+      if (keyIn === 'header') {
+        headers[keyName] = auth.key;
+      } else if (keyIn === 'query') {
+        const separator = url.includes('?') ? '&' : '?';
+        url = \`\${url}\${separator}\${keyName}=\${encodeURIComponent(auth.key)}\`;
+      } else if (keyIn === 'cookie') {
+        headers['Cookie'] = \`\${keyName}=\${auth.key}\`;
+      }
+      break;
+    }`);
+    }
+    if (requirements.oauth2) {
+        cases.push(`    case 'oauth2': {
+      // If we have an access token, use it directly
+      // Token flows (client_credentials, password) are handled separately
+      if (auth.accessToken) {
+        headers['Authorization'] = \`Bearer \${auth.accessToken}\`;
+      }
+      break;
+    }`);
+    }
+    return cases.join('\n\n');
 }
-exports.renderOAuth2Stubs = renderOAuth2Stubs;
+exports.renderApplyAuthCases = renderApplyAuthCases;
 /**
  * Generates OAuth2-specific helper functions.
  * Only included when OAuth2 auth is needed.

package/dist/codegen/generators/typescript/channels/types.d.ts

@@ -177,5 +177,12 @@ export interface RenderHttpParameters {
     description?: string;
     /** Whether the operation is marked as deprecated in the API specification */
     deprecated?: boolean;
+    /**
+     * Whether OAuth2 auth is available for this API. When false, OAuth2-specific
+     * request handling is omitted so the generated function type-checks against an
+     * AuthConfig union that was narrowed to exclude OAuth2. Defaults to true to keep
+     * the AsyncAPI path (which generates all auth types) unchanged.
+     */
+    oauth2Enabled?: boolean;
 }
 export type SupportedProtocols = 'nats' | 'kafka' | 'mqtt' | 'amqp' | 'event_source' | 'http_client' | 'websocket';

package/dist/codegen/inputs/openapi/generators/payloads.js

@@ -104,17 +104,21 @@ function extractPayloadsFromOperations(paths) {
                 method,
                 path: pathKey
             });
-            // Extract request payload schema
+            // Extract request payload schema.
+            // Prefer the 3.x `requestBody`: 3.x operations also carry a `parameters`
+            // array (path/query/header), so presence of `parameters` cannot be used
+            // to detect 2.0 - doing so would drop the body on any 3.x operation that
+            // declares parameters. The 2.0 body lives in a `parameters` entry with
+            // `in: 'body'`, so fall back to that only when there is no `requestBody`.
             let requestSchema = null;
-            // Check if this is OpenAPI 2.0 vs 3.x based on the structure
-            if ('parameters' in operationObj && operationObj.parameters) {
-                // OpenAPI 2.0 style
-                requestSchema = extractOpenAPI2RequestSchema(operationObj.parameters);
-            }
-            else if ('requestBody' in operationObj && operationObj.requestBody) {
+            if ('requestBody' in operationObj && operationObj.requestBody) {
                 // OpenAPI 3.x style
                 requestSchema = extractOpenAPI3RequestSchema(operationObj.requestBody);
             }
+            else if ('parameters' in operationObj && operationObj.parameters) {
+                // OpenAPI 2.0 style (body carried as a `in: 'body'` parameter)
+                requestSchema = extractOpenAPI2RequestSchema(operationObj.parameters);
+            }
             if (requestSchema) {
                 const requestSchemaId = (0, utils_1.pascalCase)(`${operationId}_Request`);
                 requestPayloads[operationId] = {

package/oclif.manifest.json

@@ -506,5 +506,5 @@
       ]
     }
   },
-  "version": "0.72.3"
+  "version": "0.72.5"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alagoni97/cli",
   "description": "CLI to work with code generation in any environment",
-  "version": "0.72.3",
+  "version": "0.72.5",
   "bin": {
     "codegen": "./bin/run.mjs"
   },