@alagoni97/cli 0.72.1 → 0.72.3

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

@@ -8,6 +8,7 @@ const utils_3 = require("../utils");
 const errors_1 = require("../../../errors");
 const utils_4 = require("../../../utils");
 const security_1 = require("../../../inputs/openapi/security");
+const utils_5 = require("../../../inputs/openapi/utils");
 const HTTP_METHODS = [
     'get',
     'post',
@@ -83,7 +84,11 @@ function processOperation(pathItem, method, path, payloads, parameters) {
     if (!operation) {
         return undefined;
     }
-    const operationId = getOperationId(operation, method, path);
+    const operationId = (0, utils_5.deriveOperationId)({
+        operationId: operation.operationId,
+        method,
+        path
+    });
     const hasBody = METHODS_WITH_BODY.includes(method);
     // Look up payloads
     const requestPayload = hasBody
@@ -120,9 +125,12 @@ function processOperation(pathItem, method, path, payloads, parameters) {
     // Extract operation metadata for JSDoc
     const description = operation.description ?? operation.summary;
     const deprecated = operation.deprecated === true;
-    // Generate the HTTP client function
+    // Generate the HTTP client function.
+    // Use the operationId directly as the function name; the HTTP method is
+    // already encoded in synthesized ids (and meaningful in spec-provided ones),
+    // so prepending the method here would double the verb (e.g. getGetUser).
     return (0, http_1.renderHttpFetchClient)({
-        subName: (0, utils_3.pascalCase)(operationId),
+        functionName: (0, utils_3.camelCase)(operationId),
         requestMessageModule: hasBody ? requestMessageModule : undefined,
         requestMessageType: hasBody ? requestMessageType : undefined,
         replyMessageModule,
@@ -154,15 +162,3 @@ function validateOpenAPIContext(context) {
     }
     return { openapiDocument };
 }
-/**
- * Gets the operation ID from an OpenAPI operation.
- * Falls back to generating one from method+path if not present.
- */
-function getOperationId(operation, method, path) {
-    if (operation.operationId) {
-        return operation.operationId;
-    }
-    // Generate from method + path
-    const sanitizedPath = path.replace(/[^a-zA-Z0-9]/g, '');
-    return `${method}${sanitizedPath}`;
-}

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processOpenAPIHeaders = void 0;
 const utils_1 = require("../../../generators/typescript/utils");
+const utils_2 = require("../utils");
 // Helper function to convert OpenAPI header schema to JSON Schema
 function convertHeaderSchemaToJsonSchema(header) {
     let schema;
@@ -44,8 +45,11 @@ function extractHeadersFromOperations(paths) {
                 return param.in === 'header';
             });
             if (allParameters.length > 0) {
-                const operationId = operationObj.operationId ??
-                    `${method}${pathKey.replace(/[^a-zA-Z0-9]/g, '')}`;
+                const operationId = (0, utils_2.deriveOperationId)({
+                    operationId: operationObj.operationId,
+                    method,
+                    path: pathKey
+                });
                 operationHeaders[operationId] = headerParams;
             }
         }

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOpenAPIGenerator = exports.createParameterSchema = exports.convertParameterSchemaToJsonSchema = exports.processOpenAPIParameters = void 0;
 const utils_1 = require("../../../generators/typescript/utils");
+const utils_2 = require("../utils");
 const modelina_1 = require("@asyncapi/modelina");
 // Constants for OpenAPI parameter metadata keys
 const X_PARAMETER_LOCATION = 'x-parameter-location';
@@ -9,6 +10,15 @@ const X_PARAMETER_STYLE = 'x-parameter-style';
 const X_PARAMETER_EXPLODE = 'x-parameter-explode';
 const X_PARAMETER_ALLOW_RESERVED = 'x-parameter-allowReserved';
 const X_PARAMETER_COLLECTION_FORMAT = 'x-parameter-collectionFormat';
+/**
+ * Map the raw OpenAPI parameter name to the constrained TypeScript property
+ * name rendered by Modelina, falling back to the raw name when the model does
+ * not expose the property.
+ */
+function getConstrainedPropertyName({ model, parameterName }) {
+    const constrainedProperty = Object.values(model.properties).find((property) => property.unconstrainedPropertyName === parameterName);
+    return constrainedProperty?.propertyName ?? parameterName;
+}
 // OpenAPI parameter processor
 function processOpenAPIParameters(openapiDocument) {
     const channelParameters = {};
@@ -21,8 +31,11 @@ function processOpenAPIParameters(openapiDocument) {
                 return ['path', 'query'].includes(param.in);
             });
             if (filteredParams.length > 0) {
-                const operationId = operationObj.operationId ??
-                    `${method}${pathKey.replace(/[^a-zA-Z0-9]/g, '')}`;
+                const operationId = (0, utils_2.deriveOperationId)({
+                    operationId: operationObj.operationId,
+                    method,
+                    path: pathKey
+                });
                 // Create schema for the parameters
                 const parameterSchema = createParameterSchema(operationId, filteredParams, 'Parameters', pathKey);
                 channelParameters[operationId] = {
@@ -134,11 +147,21 @@ function generateOpenAPIParameterMethods(model) {
     for (const [propName, propSchema] of Object.entries(properties)) {
         const paramConfig = processParameterSchema(propName, propSchema);
         if (paramConfig) {
+            const parameterConfig = {
+                name: paramConfig.name,
+                propertyName: getConstrainedPropertyName({
+                    model,
+                    parameterName: propName
+                }),
+                style: paramConfig.style,
+                explode: paramConfig.explode,
+                allowReserved: paramConfig.allowReserved
+            };
             if (paramConfig.location === 'path') {
-                pathParams.push(paramConfig);
+                pathParams.push(parameterConfig);
             }
             else if (paramConfig.location === 'query') {
-                queryParams.push(paramConfig);
+                queryParams.push(parameterConfig);
             }
         }
     }
@@ -292,11 +315,11 @@ getChannelWithParameters(basePath: string): string {
  * Generate serialization code for a single path parameter
  */
 function generatePathParameterSerialization(param) {
-    const { name, style, explode, allowReserved } = param;
+    const { name, propertyName, style, explode, allowReserved } = param;
     const encoding = allowReserved ? '' : 'encodeURIComponent';
     return `    // Serialize path parameter: ${name} (style: ${style}, explode: ${explode})
-  if (this.${name} !== undefined && this.${name} !== null) {
-    const value = this.${name};
+  if (this.${propertyName} !== undefined && this.${propertyName} !== null) {
+    const value = this.${propertyName};
     ${generatePathSerializationLogic(name, style, explode, encoding)}
   }`;
 }
@@ -304,11 +327,11 @@ function generatePathParameterSerialization(param) {
  * Generate serialization code for a single query parameter
  */
 function generateQueryParameterSerialization(param) {
-    const { name, style, explode, allowReserved } = param;
+    const { name, propertyName, style, explode, allowReserved } = param;
     const encoding = allowReserved ? '' : 'encodeURIComponent';
     return `  // Serialize query parameter: ${name} (style: ${style}, explode: ${explode})
-  if (this.${name} !== undefined && this.${name} !== null) {
-    const value = this.${name};
+  if (this.${propertyName} !== undefined && this.${propertyName} !== null) {
+    const value = this.${propertyName};
     ${generateQuerySerializationLogic(name, style, explode, encoding)}
   }`;
 }
@@ -486,7 +509,11 @@ function generateDeserializationMethods(pathParams, queryParams, model) {
         methods += generateUrlDeserializationMethod(queryParams, model);
     }
     // Generate static fromUrl method
-    methods += generateFromUrlStaticMethod(pathParams, model);
+    methods += generateFromUrlStaticMethod({
+        pathParams,
+        hasQueryParams: queryParams.length > 0,
+        model
+    });
     return methods;
 }
 /**
@@ -523,7 +550,7 @@ ${paramDeserializations}
 /**
  * Generate static fromUrl method
  */
-function generateFromUrlStaticMethod(pathParams, model) {
+function generateFromUrlStaticMethod({ pathParams, hasQueryParams, model }) {
     const properties = model.originalInput?.properties ?? {};
     const requiredParams = [];
     // Find required parameters to determine constructor defaults
@@ -537,11 +564,11 @@ function generateFromUrlStaticMethod(pathParams, model) {
     const pathParamExtraction = pathParams.length > 0 ? generatePathParameterExtraction(pathParams) : '';
     // Generate constructor arguments with path parameters first, then required non-path parameters
     const pathParamArgs = pathParams
-        .map((param) => `${param.name}: pathParams.${param.name}`)
+        .map((param) => `${param.propertyName}: pathParams.${param.propertyName}`)
         .join(', ');
     const requiredNonPathParams = requiredParams.filter((param) => !pathParams.some((pathParam) => pathParam.name === param));
     const requiredParamArgs = requiredNonPathParams
-        .map((param) => `${param}: default${(0, utils_1.pascalCase)(param)}`)
+        .map((param) => `${getConstrainedPropertyName({ model, parameterName: param })}: default${(0, utils_1.pascalCase)(param)}`)
         .join(', ');
     let constructorArgs = '';
     if (pathParamArgs && requiredParamArgs) {
@@ -565,6 +592,11 @@ function generateFromUrlStaticMethod(pathParams, model) {
             .map((param) => `, default${(0, utils_1.pascalCase)(param)}: ${getParameterType(properties[param])} = ${generateDefaultValue(properties[param], param)}`)
             .join('')
         : '';
+    // deserializeUrl only exists on the class when there are query parameters
+    const deserializeUrlCall = hasQueryParams
+        ? `
+  instance.deserializeUrl(url);`
+        : '';
     return `
 
 /**
@@ -576,8 +608,7 @@ ${paramDocs}
  */
 static fromUrl(url: string, basePath: string${functionParams}): ${model.type} {
   ${pathParamExtraction}
-  const instance = new ${model.type}({ ${constructorArgs} });
-  instance.deserializeUrl(url);
+  const instance = new ${model.type}({ ${constructorArgs} });${deserializeUrlCall}
   return instance;
 }`;
 }
@@ -598,7 +629,7 @@ function generateQueryParameterDeserialization(param, model) {
     const { name, style, explode } = param;
     const properties = model.originalInput?.properties ?? {};
     const propSchema = properties[name];
-    const logicCode = generateQueryDeserializationLogic(name, style, explode, propSchema);
+    const logicCode = generateQueryDeserializationLogic({ param, propSchema });
     return `  // Deserialize query parameter: ${name} (style: ${style}, explode: ${explode})
   if (params.has('${name}')) {
     const value = params.get('${name}');
@@ -608,36 +639,60 @@ function generateQueryParameterDeserialization(param, model) {
 /**
  * Generate query parameter deserialization logic
  */
-function generateQueryDeserializationLogic(name, style, explode, propSchema) {
+function generateQueryDeserializationLogic({ param, propSchema }) {
     const isArray = propSchema?.type === 'array' || propSchema?.items;
     const isBoolean = propSchema?.type === 'boolean';
     const isNumber = propSchema?.type === 'integer' || propSchema?.type === 'number';
     const paramType = getParameterType(propSchema);
-    switch (style) {
+    switch (param.style) {
         case 'form':
-            return generateFormStyleDeserializationLogic(name, explode, isArray, isBoolean, isNumber, paramType);
+            return generateFormStyleDeserializationLogic({
+                param,
+                isArray,
+                isBoolean,
+                isNumber,
+                paramType
+            });
         case 'spaceDelimited':
-            return generateSpaceDelimitedDeserializationLogic(name, explode, isArray, isBoolean, isNumber, paramType);
+            return generateSpaceDelimitedDeserializationLogic({
+                param,
+                isArray,
+                isBoolean,
+                isNumber,
+                paramType
+            });
         case 'pipeDelimited':
-            return generatePipeDelimitedDeserializationLogic(name, explode, isArray, isBoolean, isNumber, paramType);
+            return generatePipeDelimitedDeserializationLogic({
+                param,
+                isArray,
+                isBoolean,
+                isNumber,
+                paramType
+            });
         case 'deepObject':
-            return generateDeepObjectDeserializationLogic(name, isBoolean, isNumber, paramType);
+            return generateDeepObjectDeserializationLogic({
+                param,
+                isBoolean,
+                isNumber,
+                paramType
+            });
         default:
-            throw new Error(`Unsupported style: ${style}`);
+            throw new Error(`Unsupported style: ${param.style}`);
     }
 }
 /**
  * Generate deserialization logic for form style
  */
-function generateFormStyleDeserializationLogic(name, explode, isArray, isBoolean, isNumber, paramType) {
+function generateFormStyleDeserializationLogic({ param, isArray, isBoolean, isNumber, paramType }) {
+    const { name, propertyName, explode } = param;
     if (isArray && !explode) {
         const typecast = paramType.includes('[]') ? ` as ${paramType}` : '';
         return `if (value === '') {
-      this.${name} = [];
+      this.${propertyName} = [];
     } else if (value) {
       // Split by comma and decode
       const decodedValues = value.split(',').map(val => decodeURIComponent(val.trim()));
-      this.${name} = decodedValues${typecast};
+      this.${propertyName} = decodedValues${typecast};
     }`;
     }
     else if (isArray && explode) {
@@ -645,13 +700,13 @@ function generateFormStyleDeserializationLogic(name, explode, isArray, isBoolean
         return `const allValues = params.getAll('${name}');
     if (allValues.length > 0) {
       const decodedValues = allValues.map(val => decodeURIComponent(val));
-      this.${name} = decodedValues${typecast};
+      this.${propertyName} = decodedValues${typecast};
     }`;
     }
     else if (isBoolean) {
         return `if (value) {
       const decodedValue = decodeURIComponent(value);
-      this.${name} = decodedValue.toLowerCase() === 'true';
+      this.${propertyName} = decodedValue.toLowerCase() === 'true';
     }`;
     }
     else if (isNumber) {
@@ -659,7 +714,7 @@ function generateFormStyleDeserializationLogic(name, explode, isArray, isBoolean
       const decodedValue = decodeURIComponent(value);
       const numValue = Number(decodedValue);
       if (!isNaN(numValue)) {
-        this.${name} = numValue;
+        this.${propertyName} = numValue;
       }
     }`;
     }
@@ -668,45 +723,58 @@ function generateFormStyleDeserializationLogic(name, explode, isArray, isBoolean
         : '';
     return `if (value) {
       const decodedValue = decodeURIComponent(value);
-      this.${name} = decodedValue${typecast};
+      this.${propertyName} = decodedValue${typecast};
     }`;
 }
 /**
  * Generate deserialization logic for space delimited style
  */
-function generateSpaceDelimitedDeserializationLogic(name, explode, isArray, isBoolean, isNumber, paramType) {
-    if (isArray && !explode) {
+function generateSpaceDelimitedDeserializationLogic({ param, isArray, isBoolean, isNumber, paramType }) {
+    if (isArray && !param.explode) {
         const typecast = paramType.includes('[]') ? ` as ${paramType}` : '';
         return `if (value === '') {
-      this.${name} = [];
+      this.${param.propertyName} = [];
     } else if (value) {
       // Split by space and decode
       const decodedValues = value.split(' ').map(val => decodeURIComponent(val.trim()));
-      this.${name} = decodedValues${typecast};
+      this.${param.propertyName} = decodedValues${typecast};
     }`;
     }
-    return generateFormStyleDeserializationLogic(name, explode, isArray, isBoolean, isNumber, paramType);
+    return generateFormStyleDeserializationLogic({
+        param,
+        isArray,
+        isBoolean,
+        isNumber,
+        paramType
+    });
 }
 /**
  * Generate deserialization logic for pipe delimited style
  */
-function generatePipeDelimitedDeserializationLogic(name, explode, isArray, isBoolean, isNumber, paramType) {
-    if (isArray && !explode) {
+function generatePipeDelimitedDeserializationLogic({ param, isArray, isBoolean, isNumber, paramType }) {
+    if (isArray && !param.explode) {
         const typecast = paramType.includes('[]') ? ` as ${paramType}` : '';
         return `if (value === '') {
-      this.${name} = [];
+      this.${param.propertyName} = [];
     } else if (value) {
       // Split by pipe and decode
       const decodedValues = value.split('|').map(val => decodeURIComponent(val.trim()));
-      this.${name} = decodedValues${typecast};
+      this.${param.propertyName} = decodedValues${typecast};
     }`;
     }
-    return generateFormStyleDeserializationLogic(name, explode, isArray, isBoolean, isNumber, paramType);
+    return generateFormStyleDeserializationLogic({
+        param,
+        isArray,
+        isBoolean,
+        isNumber,
+        paramType
+    });
 }
 /**
  * Generate deserialization logic for deep object style
  */
-function generateDeepObjectDeserializationLogic(name, isBoolean, isNumber, paramType) {
+function generateDeepObjectDeserializationLogic({ param, paramType }) {
+    const { name, propertyName } = param;
     const nameLength = name.length + 1;
     const typecast = paramType !== 'any' && paramType !== 'any | undefined'
         ? ` as ${paramType.replace(' | undefined', '')}`
@@ -720,7 +788,7 @@ function generateDeepObjectDeserializationLogic(name, isBoolean, isNumber, param
       }
     }
     if (Object.keys(deepObjectParams).length > 0) {
-      this.${name} = deepObjectParams${typecast};
+      this.${propertyName} = deepObjectParams${typecast};
     }`;
 }
 /**
@@ -787,7 +855,7 @@ function generateExtractPathParametersMethod(pathParams, model) {
         const paramType = getParameterType(propSchema);
         const typecast = paramType !== 'string' ? ` as ${paramType}` : '';
         return `      case '${param.name}':
-          result.${param.name} = ${conversion}${typecast};
+          result.${param.propertyName} = ${conversion}${typecast};
           break;`;
     })
         .join('\n');
@@ -799,7 +867,7 @@ function generateExtractPathParametersMethod(pathParams, model) {
  * @param basePath The base path template (e.g., '/pet/findByStatus/{status}/{categoryId}')
  * @returns Object containing extracted path parameter values
  */
-private static extractPathParameters(url: string, basePath: string): { ${pathParams.map((p) => `${p.name}: ${getParameterType(properties[p.name])}`).join(', ')} } {
+private static extractPathParameters(url: string, basePath: string): { ${pathParams.map((p) => `${p.propertyName}: ${getParameterType(properties[p.name])}`).join(', ')} } {
   // Remove query string from URL for path matching
   const urlPath = url.split('?')[0];
   

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.processOpenAPIPayloads = void 0;
 const utils_1 = require("../../../generators/typescript/utils");
 const utils_2 = require("../../../utils");
+const utils_3 = require("../utils");
 // Constants
 const JSON_SCHEMA_DRAFT_07 = 'http://json-schema.org/draft-07/schema';
 // Helper function to extract schema from OpenAPI 2.0 response
@@ -98,8 +99,11 @@ function extractPayloadsFromOperations(paths) {
                 continue;
             }
             const operationObj = operation;
-            const operationId = operationObj.operationId ??
-                `${method}${pathKey.replace(/[^a-zA-Z0-9]/g, '')}`;
+            const operationId = (0, utils_3.deriveOperationId)({
+                operationId: operationObj.operationId,
+                method,
+                path: pathKey
+            });
             // Extract request payload schema
             let requestSchema = null;
             // Check if this is OpenAPI 2.0 vs 3.x based on the structure

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateOpenAPITypes = void 0;
+const utils_1 = require("../utils");
 async function generateOpenAPITypes(openapiDocument, generator) {
     const paths = openapiDocument.paths ?? {};
     const allPaths = Object.keys(paths);
@@ -22,8 +23,11 @@ async function generateOpenAPITypes(openapiDocument, generator) {
             if (operationObj &&
                 typeof operationObj === 'object' &&
                 method !== 'parameters') {
-                const operationId = operationObj.operationId ??
-                    `${method}${pathStr.replace(/[^a-zA-Z0-9]/g, '')}`;
+                const operationId = (0, utils_1.deriveOperationId)({
+                    operationId: operationObj.operationId,
+                    method,
+                    path: pathStr
+                });
                 operationIds.push(operationId);
                 operationIdToPathMap[operationId] = pathStr;
                 pathOperationIds.push(operationId);

package/dist/codegen/inputs/openapi/utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Derive the operation identifier used to correlate payloads, parameters,
+ * headers and channel functions for a single OpenAPI operation.
+ *
+ * When the spec provides an `operationId` it is used verbatim so generated
+ * names stay predictable. Otherwise a name is synthesized from the HTTP method
+ * and path segments, preserving word boundaries so it can be cased cleanly
+ * (e.g. `GET /v2/connect/{referenceId}` -> `getV2ConnectReferenceId`) instead
+ * of collapsing into an uncasable blob (`getv2connectreferenceId`).
+ */
+export declare function deriveOperationId({ operationId, method, path }: {
+    operationId?: string;
+    method: string;
+    path: string;
+}): string;

package/dist/codegen/inputs/openapi/utils.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveOperationId = void 0;
+/**
+ * Shared helpers for deriving stable identifiers from OpenAPI operations.
+ */
+const modelina_1 = require("@asyncapi/modelina");
+/**
+ * Derive the operation identifier used to correlate payloads, parameters,
+ * headers and channel functions for a single OpenAPI operation.
+ *
+ * When the spec provides an `operationId` it is used verbatim so generated
+ * names stay predictable. Otherwise a name is synthesized from the HTTP method
+ * and path segments, preserving word boundaries so it can be cased cleanly
+ * (e.g. `GET /v2/connect/{referenceId}` -> `getV2ConnectReferenceId`) instead
+ * of collapsing into an uncasable blob (`getv2connectreferenceId`).
+ */
+function deriveOperationId({ operationId, method, path }) {
+    if (operationId) {
+        return operationId;
+    }
+    const segments = path
+        .split('/')
+        .map((segment) => segment.replace(/[{}]/g, ''))
+        .filter((segment) => segment.length > 0);
+    return modelina_1.FormatHelpers.toCamelCase([method, ...segments].join(' '));
+}
+exports.deriveOperationId = deriveOperationId;

package/oclif.manifest.json

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

package/package.json

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