@alagoni97/cli 0.72.1 → 0.72.2

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

@@ -9,6 +9,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 = {};
@@ -134,11 +143,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 +311,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 +323,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 +505,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 +546,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 +560,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 +588,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 +604,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 +625,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 +635,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 +696,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 +710,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 +719,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 +784,7 @@ function generateDeepObjectDeserializationLogic(name, isBoolean, isNumber, param
       }
     }
     if (Object.keys(deepObjectParams).length > 0) {
-      this.${name} = deepObjectParams${typecast};
+      this.${propertyName} = deepObjectParams${typecast};
     }`;
 }
 /**
@@ -787,7 +851,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 +863,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/oclif.manifest.json

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

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.2",
   "bin": {
     "codegen": "./bin/run.mjs"
   },