@azure-tools/typespec-rust 0.13.3 → 0.14.1

package/dist/src/codegen/clients.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clients.d.ts","sourceRoot":"","sources":["../../../src/codegen/clients.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAGxC,OAAO,KAAK,IAAI,MAAM,uBAAuB,CAAC;AAE9C,yBAAyB;AACzB,MAAM,WAAW,aAAa;IAC5B,iCAAiC;IACjC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAE/B,uCAAuC;IACvC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,GAAG,aAAa,GAAG,SAAS,CAoPxE"}
+{"version":3,"file":"clients.d.ts","sourceRoot":"","sources":["../../../src/codegen/clients.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAGxC,OAAO,KAAK,IAAI,MAAM,uBAAuB,CAAC;AAE9C,yBAAyB;AACzB,MAAM,WAAW,aAAa;IAC5B,iCAAiC;IACjC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAE/B,uCAAuC;IACvC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,GAAG,aAAa,GAAG,SAAS,CAoPxE"}

package/dist/src/codegen/clients.js

@@ -4,6 +4,7 @@
 *--------------------------------------------------------------------------------------------*/
 import * as codegen from '@azure-tools/codegen';
 import { values } from '@azure-tools/linq';
+import { CodegenError } from './errors.js';
 import * as helpers from './helpers.js';
 import queryString from 'query-string';
 import { Use } from './use.js';
@@ -112,7 +113,7 @@ export function emitClients(crate) {
                         continue;
                     }
                     if (!client.fields.find((v) => { return v.name === param.name; })) {
-                        throw new Error(`didn't find field in client ${client.name} for param ${param.name}`);
+                        throw new CodegenError('InternalError', `didn't find field in client ${client.name} for param ${param.name}`);
                     }
                     // by convention, the param field and param name are the
                     // same so we can use shorthand initialization syntax
@@ -124,10 +125,10 @@ export function emitClients(crate) {
                         continue;
                     }
                     if (!client.fields.find((v) => { return v.name === param.name; })) {
-                        throw new Error(`didn't find field in client ${client.name} for param ${param.name}`);
+                        throw new CodegenError('InternalError', `didn't find field in client ${client.name} for param ${param.name}`);
                     }
                     if (!client.constructable.options.type.fields.find((v) => { return v.name === param.name; })) {
-                        throw new Error(`didn't find field in client options ${client.constructable.options.type.name} for optional param ${param.name}`);
+                        throw new CodegenError('InternalError', `didn't find field in client options ${client.constructable.options.type.name} for optional param ${param.name}`);
                     }
                     body += `${indent.get()}${param.name}: options.${param.name},\n`;
                 }
@@ -349,11 +350,7 @@ function getConstructorParamsSig(params, options, use) {
             continue;
         }
         use.addForType(param.type);
-        let ref = '';
-        if (param.kind === 'clientMethod' && param.ref) {
-            ref = '&';
-        }
-        paramsSig.push(`${param.name}: ${ref}${helpers.getTypeDeclaration(param.type)}`);
+        paramsSig.push(`${param.name}: ${helpers.getTypeDeclaration(param.type)}`);
     }
     paramsSig.push(`options: ${helpers.getTypeDeclaration(options)}`);
     return paramsSig.join(', ');
@@ -379,13 +376,14 @@ function getMethodParamsSig(method, use) {
     }
     else {
         for (const param of method.params) {
-            if (param.type.kind === 'literal') {
+            const paramType = helpers.unwrapType(param.type);
+            if (paramType.kind === 'literal') {
                 // literal params are embedded directly in the code (e.g. accept header param)
                 continue;
             }
-            else if (param.type.kind === 'enumValue') {
+            else if (paramType.kind === 'enumValue') {
                 // enum values are treated like literals, we just need to use their type
-                use.addForType(param.type.type);
+                use.addForType(paramType.type);
                 continue;
             }
             // don't add client or optional params to the method param sig
@@ -428,7 +426,7 @@ function getAuthPolicy(ctor, use) {
  */
 function formatParamTypeName(param) {
     let format = '';
-    if (param.ref) {
+    if (param.ref === true) {
         format = '&';
     }
     if (param.mut) {
@@ -462,13 +460,13 @@ function getEndpointFieldName(client) {
     for (const field of client.fields) {
         if (field.type.kind === 'Url') {
             if (endpointFieldName) {
-                throw new Error(`found multiple URL fields in client ${client.name} which is unexpected`);
+                throw new CodegenError('InternalError', `found multiple URL fields in client ${client.name} which is unexpected`);
             }
             endpointFieldName = field.name;
         }
     }
     if (!endpointFieldName) {
-        throw new Error(`didn't find URI field for client ${client.name}`);
+        throw new CodegenError('InternalError', `didn't find URI field for client ${client.name}`);
     }
     return endpointFieldName;
 }
@@ -533,7 +531,7 @@ function getMethodParamGroup(method) {
                 queryParams.push(param);
                 break;
         }
-        if (param.kind === 'query' && param.isApiVersion) {
+        if ((param.kind === 'header' || param.kind === 'query') && param.isApiVersion) {
             apiVersionParam = param;
         }
     }
@@ -544,7 +542,7 @@ function getMethodParamGroup(method) {
     for (const param of method.params) {
         if (param.kind === 'body') {
             if (bodyParam) {
-                throw new Error(`method ${method.name} has multiple body parameters`);
+                throw new CodegenError('InternalError', `method ${method.name} has multiple body parameters`);
             }
             bodyParam = param;
         }
@@ -568,13 +566,14 @@ function getMethodParamGroup(method) {
  * @param indent the indentation helper currently in scope
  * @param param the parameter to which the contents of setter apply
  * @param setter the callback that emits the code to read from a param var
+ * @param inClosure indicates if the value is being read from within a closure (e.g. pageable methods)
  * @returns
  */
-function getParamValueHelper(indent, param, setter) {
+function getParamValueHelper(indent, param, inClosure, setter) {
     if (param.optional) {
         // optional params are in the unwrapped options local var
         const op = indent.get() + helpers.buildIfBlock(indent, {
-            condition: `let Some(${param.name}) = options.${param.name}`,
+            condition: `let Some(${param.name}) = ${inClosure ? '&' : ''}options.${param.name}`,
             body: setter,
         });
         return op + '\n';
@@ -596,11 +595,14 @@ function constructUrl(indent, use, method, paramGroups, urlVarName = 'url') {
     // including them in the call to set_path() causes the chars to be path-escaped.
     const pathChunks = method.httpPath.split('?');
     if (pathChunks.length > 2) {
-        throw new Error('too many HTTP path chunks');
+        throw new CodegenError('InternalError', 'too many HTTP path chunks');
     }
     /** returns & if the param needs to be borrowed (which is the majority of cases), else the empty string */
     const borrowOrNot = function (param) {
-        return param.ref ? '' : '&';
+        if (param.type.kind !== 'ref' || param.type.type.kind === 'encodedBytes' || param.type.type.kind === 'slice') {
+            return '&';
+        }
+        return '';
     };
     let body = '';
     // if path is just "/" no need to set it again, we're already there
@@ -649,7 +651,7 @@ function constructUrl(indent, use, method, paramGroups, urlVarName = 'url') {
     }
     for (const queryParam of paramGroups.query) {
         if (queryParam.kind === 'queryCollection' && queryParam.format === 'multi') {
-            body += getParamValueHelper(indent, queryParam, () => {
+            body += getParamValueHelper(indent, queryParam, false, () => {
                 const valueVar = queryParam.name[0];
                 let text = `${indent.get()}for ${valueVar} in ${queryParam.name}.iter() {\n`;
                 text += `${indent.push().get()}${urlVarName}.query_pairs_mut().append_pair("${queryParam.key}", ${valueVar});\n`;
@@ -658,7 +660,7 @@ function constructUrl(indent, use, method, paramGroups, urlVarName = 'url') {
             });
         }
         else {
-            body += getParamValueHelper(indent, queryParam, () => {
+            body += getParamValueHelper(indent, queryParam, false, () => {
                 // for enums we call .as_ref() which elides the need to borrow
                 const borrow = queryParam.type.kind === 'enum' ? '' : borrowOrNot(queryParam);
                 return `${indent.get()}${urlVarName}.query_pairs_mut().append_pair("${queryParam.key}", ${borrow}${getHeaderPathQueryParamValue(use, queryParam, !queryParam.optional)});\n`;
@@ -676,28 +678,40 @@ function constructUrl(indent, use, method, paramGroups, urlVarName = 'url') {
  * @param use the use statement builder currently in scope
  * @param method the method for which we're building the body
  * @param paramGroups the param groups for the provided method
- * @param fromSelf applicable for client params. when true, the prefix "self." is included
+ * @param inClosure indicates if the request is being constructed within a closure (e.g. pageable methods)
  * @returns the request construction code
  */
-function constructRequest(indent, use, method, paramGroups, fromSelf = true) {
+function constructRequest(indent, use, method, paramGroups, inClosure) {
+    var _a, _b, _c;
     let body = `${indent.get()}let mut request = Request::new(url, Method::${codegen.capitalize(method.httpMethod)});\n`;
     for (const headerParam of paramGroups.header) {
-        body += getParamValueHelper(indent, headerParam, () => {
+        if (method.kind === 'pageable' && ((_a = method.strategy) === null || _a === void 0 ? void 0 : _a.kind) === 'continuationToken' && ((_b = method.strategy) === null || _b === void 0 ? void 0 : _b.requestToken.kind) === 'header' && ((_c = method.strategy) === null || _c === void 0 ? void 0 : _c.requestToken) === headerParam) {
+            // we have some special handling for the header continuation token.
+            // if we have a token value, i.e. from the next page, then use that value.
+            // if not, then check if an optional token value was provided.
+            body += indent.get() + helpers.buildIfBlock(indent, {
+                condition: `let Some(${headerParam.name}) = ${headerParam.name}.or_else(|| options.${headerParam.name}.clone())`,
+                body: (indent) => `${indent.get()}request.insert_header("${headerParam.header}", ${headerParam.name});\n`,
+            });
+            continue;
+        }
+        body += getParamValueHelper(indent, headerParam, inClosure, () => {
             if (headerParam.kind === 'headerHashMap') {
                 let setter = `for (k, v) in &${headerParam.name} {\n`;
                 setter += `${indent.push().get()}request.insert_header(format!("${headerParam.header}-{}", k), v);\n`;
                 setter += `${indent.pop().get()}}\n`;
                 return setter;
             }
-            const borrow = headerParam.location === 'client' && nonCopyableType(headerParam.type) ? '&' : '';
-            const toOwned = headerParam.ref ? '.to_owned()' : '';
-            return `${indent.get()}request.insert_header("${headerParam.header.toLowerCase()}", ${borrow}${getHeaderPathQueryParamValue(use, headerParam, fromSelf)}${toOwned});\n`;
+            // for non-copyable params (e.g. String), we need to borrow them if they're on the
+            // client or we're in a closure and the param is required (header params are always owned)
+            const borrow = nonCopyableType(headerParam.type) && (headerParam.location === 'client' || (inClosure && !headerParam.optional)) ? '&' : '';
+            return `${indent.get()}request.insert_header("${headerParam.header.toLowerCase()}", ${borrow}${getHeaderPathQueryParamValue(use, headerParam, !inClosure)});\n`;
         });
     }
     const bodyParam = paramGroups.body;
     if (bodyParam) {
-        body += getParamValueHelper(indent, bodyParam, () => {
-            return `${indent.get()}request.set_body(${bodyParam.name});\n`;
+        body += getParamValueHelper(indent, bodyParam, inClosure, () => {
+            return `${indent.get()}request.set_body(${bodyParam.name}${inClosure ? '.clone()' : ''});\n`;
         });
     }
     else if (paramGroups.partialBody.length > 0) {
@@ -708,16 +722,13 @@ function constructRequest(indent, use, method, paramGroups, fromSelf = true) {
         indent.push();
         for (const partialBodyParam of paramGroups.partialBody) {
             if (partialBodyParam.type.content.type !== requestContentType.content.type) {
-                throw new Error(`spread param ${partialBodyParam.name} has conflicting model type ${partialBodyParam.type.content.type.name}, expected model type ${requestContentType.content.type.name}`);
+                throw new CodegenError('InternalError', `spread param ${partialBodyParam.name} has conflicting model type ${partialBodyParam.type.content.type.name}, expected model type ${requestContentType.content.type.name}`);
             }
             if (partialBodyParam.optional) {
                 body += `${indent.get()}${partialBodyParam.name}: options.${partialBodyParam.name},\n`;
                 continue;
             }
             let initializer = partialBodyParam.name;
-            if (partialBodyParam.ref) {
-                initializer = `${initializer}.to_owned()`;
-            }
             if (requestContentType.content.type.visibility === 'pub') {
                 // spread param maps to a non-internal model, so it must be wrapped in Some()
                 initializer = `Some(${initializer})`;
@@ -761,7 +772,7 @@ function getAsyncMethodBody(indent, use, client, method) {
     body += `${indent.get()}let ctx = Context::with_context(&options.method_options.context);\n`;
     body += `${indent.get()}let ${urlVarNeedsMut(paramGroups, method)}url = self.${getEndpointFieldName(client)}.clone();\n`;
     body += constructUrl(indent, use, method, paramGroups);
-    body += constructRequest(indent, use, method, paramGroups);
+    body += constructRequest(indent, use, method, paramGroups, false);
     body += `${indent.get()}self.pipeline.send(&ctx, &mut request).await\n`;
     return body;
 }
@@ -776,14 +787,10 @@ function getAsyncMethodBody(indent, use, client, method) {
  */
 function getPageableMethodBody(indent, use, client, method) {
     if (!method.strategy) {
-        throw new Error('paged method with no strategy NYI');
-    }
-    else if (method.strategy.kind !== 'nextLink') {
-        throw new Error('paged methods other than nextLink NYI');
+        throw new CodegenError('InternalError', 'paged method with no strategy NYI');
     }
-    const nextLinkName = method.strategy.nextLink.name;
     use.add('azure_core::http', 'Method', 'Pager', 'PagerResult', 'Request', 'Response', 'Url');
-    use.add('azure_core', 'json', 'Result');
+    use.add('azure_core', method.returns.type.type.format, 'Result');
     use.addForType(method.returns.type.type.type);
     const paramGroups = getMethodParamGroup(method);
     const urlVar = 'first_url';
@@ -794,49 +801,114 @@ function getPageableMethodBody(indent, use, client, method) {
     if (paramGroups.apiVersion) {
         body += `${indent.get()}let ${paramGroups.apiVersion.name} = ${getHeaderPathQueryParamValue(use, paramGroups.apiVersion, true)}.clone();\n`;
     }
-    body += `${indent.get()}Ok(Pager::from_callback(move |${nextLinkName}: Option<Url>| {\n`;
-    body += `${indent.push().get()}let url = ` + helpers.buildMatch(indent, nextLinkName, [{
-            pattern: `Some(${nextLinkName})`,
-            body: (indent) => {
-                if (paramGroups.apiVersion) {
-                    const apiVersionKey = `"${paramGroups.apiVersion.key}"`;
-                    // there are no APIs to set/update an existing query parameter.
-                    // so, we filter the existing query params to remove the api-version
-                    // query param. we then add back the filtered set and then add the
-                    // api-version as specified on the client.
-                    let setApiVerBody = `${indent.get()}let qp = ${nextLinkName}.query_pairs().filter(|(name, _)| name.ne(${apiVersionKey}));\n`;
-                    setApiVerBody += `${indent.get()}let mut ${nextLinkName} = ${nextLinkName}.clone();\n`;
-                    setApiVerBody += `${indent.get()}${nextLinkName}.query_pairs_mut().clear().extend_pairs(qp).append_pair(${apiVersionKey}, &${paramGroups.apiVersion.name});\n`;
-                    setApiVerBody += `${indent.get()}${nextLinkName}\n`;
-                    return setApiVerBody;
-                }
-                return `${indent.get()} ${nextLinkName}\n`;
+    switch (method.strategy.kind) {
+        case 'continuationToken': {
+            const reqTokenParam = method.strategy.requestToken.name;
+            body += `${indent.get()}Ok(Pager::from_callback(move |${reqTokenParam}: Option<String>| {\n`;
+            body += `${indent.push().get()}let ${method.strategy.requestToken.kind === 'query' ? 'mut ' : ''}url = first_url.clone();\n`;
+            if (method.strategy.requestToken.kind === 'query') {
+                // if the url already contains the token query param,
+                // e.g. we started on some page, then we need to remove
+                // it before appending the token for the next page.
+                const reqTokenValue = method.strategy.requestToken.key;
+                body += `${indent.get()}${helpers.buildIfBlock(indent, {
+                    condition: `let Some(${reqTokenParam}) = ${reqTokenParam}`,
+                    body: (indent) => {
+                        let body = indent.get() + helpers.buildIfBlock(indent, {
+                            condition: `url.query_pairs().any(|(name, _)| name.eq("${reqTokenValue}"))`,
+                            body: (indent) => {
+                                let body = `${indent.get()}let mut new_url = url.clone();\n`;
+                                body += `${indent.get()}new_url.query_pairs_mut().clear().extend_pairs(url.query_pairs().filter(|(name, _)| name.ne("${reqTokenValue}")));\n`;
+                                body += `${indent.get()}url = new_url;\n`;
+                                return body;
+                            },
+                        });
+                        body += `${indent.get()}url.query_pairs_mut().append_pair("${reqTokenValue}", &${reqTokenParam});\n`;
+                        return body;
+                    }
+                })}`;
             }
-        }, {
-            pattern: 'None',
-            body: (indent) => `${indent.get()}${urlVar}.clone()\n`
-        }]);
-    body += ';\n';
+            break;
+        }
+        case 'nextLink': {
+            const nextLinkName = method.strategy.nextLink.name;
+            body += `${indent.get()}Ok(Pager::from_callback(move |${nextLinkName}: Option<Url>| {\n`;
+            body += `${indent.push().get()}let url = ` + helpers.buildMatch(indent, nextLinkName, [{
+                    pattern: `Some(${nextLinkName})`,
+                    body: (indent) => {
+                        if (paramGroups.apiVersion && paramGroups.apiVersion.kind === 'query') {
+                            const apiVersionKey = `"${paramGroups.apiVersion.key}"`;
+                            // there are no APIs to set/update an existing query parameter.
+                            // so, we filter the existing query params to remove the api-version
+                            // query param. we then add back the filtered set and then add the
+                            // api-version as specified on the client.
+                            let setApiVerBody = `${indent.get()}let qp = ${nextLinkName}.query_pairs().filter(|(name, _)| name.ne(${apiVersionKey}));\n`;
+                            setApiVerBody += `${indent.get()}let mut ${nextLinkName} = ${nextLinkName}.clone();\n`;
+                            setApiVerBody += `${indent.get()}${nextLinkName}.query_pairs_mut().clear().extend_pairs(qp).append_pair(${apiVersionKey}, &${paramGroups.apiVersion.name});\n`;
+                            setApiVerBody += `${indent.get()}${nextLinkName}\n`;
+                            return setApiVerBody;
+                        }
+                        return `${indent.get()} ${nextLinkName}\n`;
+                    }
+                }, {
+                    pattern: 'None',
+                    body: (indent) => `${indent.get()}${urlVar}.clone()\n`
+                }]);
+            body += ';\n';
+            break;
+        }
+    }
     // here we want the T in Pager<T>
     const returnType = helpers.getTypeDeclaration(method.returns.type.type.type);
-    body += constructRequest(indent, use, method, paramGroups, false);
+    body += constructRequest(indent, use, method, paramGroups, true);
     body += `${indent.get()}let ctx = options.method_options.context.clone();\n`;
     body += `${indent.get()}let pipeline = pipeline.clone();\n`;
     body += `${indent.get()}async move {\n`;
     body += `${indent.push().get()}let rsp: Response<${returnType}> = pipeline.send(&ctx, &mut request).await?;\n`;
-    body += `${indent.get()}let (status, headers, body) = rsp.deconstruct();\n`;
-    body += `${indent.get()}let bytes = body.collect().await?;\n`;
-    body += `${indent.get()}let res: ${returnType} = json::from_json(bytes.clone())?;\n`;
-    body += `${indent.get()}let rsp = Response::from_bytes(status, headers, bytes);\n`;
-    body += `${indent.get()}Ok(${helpers.buildMatch(indent, `res.${nextLinkName}`, [{
-            pattern: `Some(${nextLinkName})`,
-            returns: 'PagerResult::Continue',
-            body: (indent) => `${indent.get()}response: rsp,\n${indent.get()}continuation: ${nextLinkName}.parse()?,\n`
-        }, {
-            pattern: 'None',
-            returns: 'PagerResult::Complete',
-            body: () => `${indent.get()}response: rsp,\n`
-        }])}`;
+    // check if we need to extract the next link field from the response model
+    if (method.strategy.kind === 'nextLink' || method.strategy.responseToken.kind === 'modelField') {
+        body += `${indent.get()}let (status, headers, body) = rsp.deconstruct();\n`;
+        body += `${indent.get()}let bytes = body.collect().await?;\n`;
+        const deserialize = method.returns.type.type.format === 'json' ? 'json::from_json' : 'xml::read_xml';
+        body += `${indent.get()}let res: ${returnType} = ${deserialize}(&bytes)?;\n`;
+        body += `${indent.get()}let rsp = Response::from_bytes(status, headers, bytes);\n`;
+    }
+    let srcNextPage;
+    let nextPageValue;
+    let continuation;
+    switch (method.strategy.kind) {
+        case 'continuationToken':
+            nextPageValue = method.strategy.responseToken.name;
+            continuation = nextPageValue;
+            switch (method.strategy.responseToken.kind) {
+                case 'modelField':
+                    srcNextPage = `res.${nextPageValue}`;
+                    break;
+                case 'responseHeaderScalar':
+                    if (!method.responseHeaders) {
+                        throw new CodegenError('InternalError', `missing response headers trait for method ${method.name}`);
+                    }
+                    use.addForType(method.responseHeaders);
+                    srcNextPage = `rsp.${method.strategy.responseToken.name}()?`;
+                    break;
+            }
+            break;
+        case 'nextLink':
+            nextPageValue = method.strategy.nextLink.name;
+            srcNextPage = `res.${nextPageValue}`;
+            continuation = `${nextPageValue}.parse()?`;
+            break;
+    }
+    // we need to handle the case where the next page value is the empty string,
+    // so checking strickly for None(theNextLink) is insufficient.
+    // the most common case for this is XML, e.g. an empty tag like <NextLink />
+    body += `${indent.get()}let ${nextPageValue} = ${srcNextPage}.unwrap_or_default();\n`;
+    body += `${indent.get()}Ok(${helpers.buildIfBlock(indent, {
+        condition: `${nextPageValue}.is_empty()`,
+        body: (indent) => `${indent.get()}PagerResult::Complete { response: rsp }\n`,
+    }, {
+        body: (indent) => `${indent.get()} PagerResult::Continue { response: rsp, continuation: ${continuation} }\n`,
+    })}`;
     body += ')\n'; // end Ok
     body += `${indent.pop().get()}}\n`; // end async move
     body += `${indent.pop().get()}}))`; // end Ok/Pager::from_callback
@@ -862,7 +934,7 @@ function getClientEndpointParamValue(param) {
         case 'scalar':
             return `&${paramName}.to_string()`;
         default:
-            throw new Error(`unhandled ${param.kind} param type kind ${param.type.kind}`);
+            throw new CodegenError('InternalError', `unhandled ${param.kind} param type kind ${param.type.kind}`);
     }
 }
 /**
@@ -913,51 +985,52 @@ function getHeaderPathQueryParamValue(use, param, fromSelf) {
                 return `${param}.unix_timestamp().to_string()`;
         }
     };
+    const paramType = helpers.unwrapType(param.type);
     if (param.kind === 'headerCollection' || param.kind === 'queryCollection') {
         if (param.format === 'multi') {
-            throw new Error('multi should have been handled outside getHeaderPathQueryParamValue');
+            throw new CodegenError('InternalError', 'multi should have been handled outside getHeaderPathQueryParamValue');
         }
-        else if (param.type.type.kind === 'String') {
+        else if (paramType.kind === 'String' || paramType.kind === 'str') {
             return `${paramName}.join("${getCollectionDelimiter(param.format)}")`;
         }
         // convert the items to strings
         let strConv;
-        switch (param.type.type.kind) {
+        switch (paramType.kind) {
             case 'encodedBytes':
-                strConv = encodeBytes(param.type.type);
+                strConv = encodeBytes(paramType);
                 break;
             case 'offsetDateTime':
-                strConv = `|i| ${encodeDateTime(param.type.type, 'i')}`;
+                strConv = `|i| ${encodeDateTime(paramType, 'i')}`;
                 break;
             default:
                 strConv = '|i| i.to_string()';
         }
         return `${param.name}.iter().map(${strConv}).collect::<Vec<String>>().join("${getCollectionDelimiter(param.format)}")`;
     }
-    switch (param.type.kind) {
+    switch (paramType.kind) {
         case 'String':
         case 'str':
             return paramName;
+        case 'decimal':
+            return `${param.name}.to_string()`;
         case 'encodedBytes':
-            return encodeBytes(param.type, paramName);
+            return encodeBytes(paramType, paramName);
         case 'enum':
         case 'scalar':
-            if (param.type.kind === 'enum' && param.kind === 'query') {
+            if (paramType.kind === 'enum' && param.kind === 'query') {
                 // append_pair wants a reference to the string
                 // TODO: https://github.com/Azure/typespec-rust/issues/25
                 return `${paramName}.as_ref()`;
             }
             return `${paramName}.to_string()`;
         case 'enumValue':
-            return `${param.type.type.name}::${param.type.name}.to_string()`;
-        case 'implTrait':
-            return `${paramName}.into()`;
+            return `${paramType.type.name}::${paramType.name}.to_string()`;
         case 'literal':
-            return `"${param.type.value}"`;
+            return `"${paramType.value}"`;
         case 'offsetDateTime':
-            return encodeDateTime(param.type, param.name);
+            return encodeDateTime(paramType, param.name);
         default:
-            throw new Error(`unhandled ${param.kind} param type kind ${param.type.kind}`);
+            throw new CodegenError('InternalError', `unhandled ${param.kind} param type kind ${paramType.kind}`);
     }
 }
 /**