@azure-tools/typespec-go 0.9.0 → 0.9.2

package/dist/codegen.go/src/fake/servers.js

@@ -2,9 +2,8 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import { camelCase, capitalize, uncapitalize } from '@azure-tools/codegen';
-import { values } from '@azure-tools/linq';
 import * as go from '../../../codemodel.go/src/index.js';
+import * as naming from '../../../naming.go/src/naming.js';
 import * as helpers from '../core/helpers.js';
 import { ImportManager } from '../core/imports.js';
 import { fixUpMethodName } from '../core/operations.js';
@@ -32,7 +31,7 @@ export class OperationGroupContent {
 const requiredHelpers = new RequiredHelpers();
 export function getServerName(client) {
     // for the fake server, we use the suffix Server instead of Client
-    return capitalize(client.name.replace(/[C|c]lient$/, 'Server'));
+    return naming.capitalize(client.name.replace(/[C|c]lient$/, 'Server'));
 }
 /**
  * Generates the contents for the *_server.go files.
@@ -42,8 +41,8 @@ export function getServerName(client) {
  */
 export function generateServers(pkg) {
     const operations = new Array();
-    for (const client of values(pkg.parent.clients)) {
-        if (client.clientAccessors.length === 0 && values(client.methods).all(method => { return helpers.isMethodInternal(method); })) {
+    for (const client of pkg.parent.clients) {
+        if (client.clientAccessors.length === 0 && helpers.clientHasNoExportedMethods(client)) {
             // client has no client accessors and no exported methods, skip it
             continue;
         }
@@ -66,7 +65,7 @@ export function generateServers(pkg) {
         // we might remove some clients from the list
         const finalSubClients = new Array();
         for (const clientAccessor of client.clientAccessors) {
-            if (values(clientAccessor.returns.methods).all(method => { return helpers.isMethodInternal(method); })) {
+            if (helpers.clientHasNoExportedMethods(clientAccessor.returns)) {
                 // client has no exported methods, skip it
                 continue;
             }
@@ -75,7 +74,7 @@ export function generateServers(pkg) {
             content += `\t${serverName} ${serverName}\n\n`;
             finalSubClients.push(clientAccessor.returns);
         }
-        for (const method of values(client.methods)) {
+        for (const method of client.methods) {
             if (helpers.isMethodInternal(method)) {
                 // method isn't exported, don't create a fake for it
                 continue;
@@ -145,7 +144,7 @@ export function generateServers(pkg) {
         }
         else {
             content += `\treturn &${serverTransport}{\n\t\tsrv: srv,\n`;
-            for (const method of values(finalMethods)) {
+            for (const method of finalMethods) {
                 let respType = go.getTypeDeclaration(method.returns, pkg);
                 switch (method.kind) {
                     case 'lroMethod':
@@ -154,11 +153,11 @@ export function generateServers(pkg) {
                             respType = `azfake.PagerResponder[${go.getTypeDeclaration(method.returns, pkg)}]`;
                         }
                         requiredHelpers.tracker = true;
-                        content += `\t\t${uncapitalize(fixUpMethodName(method))}: newTracker[azfake.PollerResponder[${respType}]](),\n`;
+                        content += `\t\t${naming.uncapitalize(fixUpMethodName(method))}: newTracker[azfake.PollerResponder[${respType}]](),\n`;
                         break;
                     case 'pageableMethod':
                         requiredHelpers.tracker = true;
-                        content += `\t\t${uncapitalize(fixUpMethodName(method))}: newTracker[azfake.PagerResponder[${respType}]](),\n`;
+                        content += `\t\t${naming.uncapitalize(fixUpMethodName(method))}: newTracker[azfake.PagerResponder[${respType}]](),\n`;
                         break;
                 }
             }
@@ -178,7 +177,7 @@ export function generateServers(pkg) {
                 content += `\ttr${serverName} *${serverName}Transport\n`;
             }
         }
-        for (const method of values(finalMethods)) {
+        for (const method of finalMethods) {
             // create state machines for any pager/poller operations
             let respType = go.getTypeDeclaration(method.returns, pkg);
             switch (method.kind) {
@@ -188,11 +187,11 @@ export function generateServers(pkg) {
                         respType = `azfake.PagerResponder[${go.getTypeDeclaration(method.returns, pkg)}]`;
                     }
                     requiredHelpers.tracker = true;
-                    content += `\t${uncapitalize(fixUpMethodName(method))} *tracker[azfake.PollerResponder[${respType}]]\n`;
+                    content += `\t${naming.uncapitalize(fixUpMethodName(method))} *tracker[azfake.PollerResponder[${respType}]]\n`;
                     break;
                 case 'pageableMethod':
                     requiredHelpers.tracker = true;
-                    content += `\t${uncapitalize(fixUpMethodName(method))} *tracker[azfake.PagerResponder[${go.getTypeDeclaration(method.returns, pkg)}]]\n`;
+                    content += `\t${naming.uncapitalize(fixUpMethodName(method))} *tracker[azfake.PagerResponder[${go.getTypeDeclaration(method.returns, pkg)}]]\n`;
                     break;
             }
         }
@@ -215,7 +214,7 @@ export function generateServers(pkg) {
     return new ServerContent(operations, generateServerInternal(pkg, requiredHelpers));
 }
 function getTransportInterceptorVarName(client) {
-    return `${camelCase(getServerName(client))}TransportInterceptor`;
+    return `${helpers.camelCase(getServerName(client))}TransportInterceptor`;
 }
 // method names for fakes dispatching
 const dispatchMethodFake = 'dispatchToMethodFake';
@@ -278,7 +277,7 @@ function generateServerTransportMethodDispatch(serverTransport, client, finalMet
     content += `\t\t\t res.resp, res.err, intercepted = ${interceptorVarName}.Do(req)\n\t\t}\n`;
     content += '\t\tif !intercepted {\n';
     content += '\t\t\tswitch method {\n';
-    for (const method of values(finalMethods)) {
+    for (const method of finalMethods) {
         const operationName = fixUpMethodName(method);
         content += `\t\t\tcase "${client.name}.${operationName}":\n`;
         content += `\t\t\t\tres.resp, res.err = ${receiverName}.dispatch${operationName}(req)\n`;
@@ -317,7 +316,7 @@ function generateServerTransportMethods(pkg, serverTransport, finalMethods, impo
     imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/fake/server');
     const receiverName = serverTransport[0].toLowerCase();
     let content = '';
-    for (const method of values(finalMethods)) {
+    for (const method of finalMethods) {
         content += `func (${receiverName} *${serverTransport}) dispatch${fixUpMethodName(method)}(req *http.Request) (*http.Response, error) {\n`;
         content += `\tif ${receiverName}.srv.${fixUpMethodName(method)} == nil {\n`;
         content += `\t\treturn nil, &nonRetriableError{errors.New("fake for method ${fixUpMethodName(method)} not implemented")}\n\t}\n`;
@@ -365,7 +364,8 @@ function generateServerTransportMethods(pkg, serverTransport, finalMethods, impo
                         }
                         let responseField = `server.GetResponse(respr)${respField}`;
                         if (method.returns.result.monomorphicType.kind === 'time') {
-                            responseField = `(*${method.returns.result.monomorphicType.format})(${responseField})`;
+                            imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+                            responseField = `(*datetime.${method.returns.result.monomorphicType.format})(${responseField})`;
                         }
                         content += `\tresp, err := server.MarshalResponseAs${method.returns.result.format}(respContent, ${responseField}, req)\n`;
                     }
@@ -377,7 +377,7 @@ function generateServerTransportMethods(pkg, serverTransport, finalMethods, impo
                 }
                 content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
                 // propagate any header response values into the *http.Response
-                for (const header of values(method.returns.headers)) {
+                for (const header of method.returns.headers) {
                     if (header.kind === 'headerMapResponse') {
                         content += `\tfor k, v := range server.GetResponse(respr).${header.fieldName} {\n`;
                         content += '\t\tif v != nil {\n';
@@ -415,7 +415,7 @@ function generateServerTransportMethods(pkg, serverTransport, finalMethods, impo
  */
 function dispatchForOperationBody(pkg, receiverName, method, imports) {
     const methodParamGroups = helpers.getMethodParamGroups(method);
-    const numPathParams = values(methodParamGroups.pathParams).where((each) => { return !go.isLiteralParameter(each.style); }).count();
+    const numPathParams = methodParamGroups.pathParams.filter((each) => !go.isLiteralParameter(each.style)).length;
     let content = '';
     if (numPathParams > 0) {
         imports.add('regexp');
@@ -428,7 +428,7 @@ function dispatchForOperationBody(pkg, receiverName, method, imports) {
         content += '\t\treturn nil, fmt.Errorf("failed to parse path %s", req.URL.Path)\n\t}\n';
     }
     const allQueryParams = methodParamGroups.encodedQueryParams.concat(methodParamGroups.unencodedQueryParams);
-    if (values(allQueryParams).where((each) => { return each.location === 'method' && !go.isLiteralParameter(each.style); }).any()) {
+    if (allQueryParams.find((each) => each.location === 'method' && !go.isLiteralParameter(each.style))) {
         content += '\tqp := req.URL.Query()\n';
     }
     // note that these are mutually exclusive
@@ -463,7 +463,8 @@ function dispatchForOperationBody(pkg, receiverName, method, imports) {
                         default: {
                             let bodyTypeName = go.getTypeDeclaration(bodyParam.type, pkg);
                             if (bodyParam.type.kind === 'time') {
-                                bodyTypeName = bodyParam.type.format;
+                                imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime');
+                                bodyTypeName = `datetime.${bodyParam.type.format}`;
                             }
                             content += `\tbody, err := server.UnmarshalRequestAs${bodyParam.bodyFormat}[${bodyTypeName}](req)\n`;
                             content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
@@ -670,7 +671,7 @@ function dispatchForOperationBody(pkg, receiverName, method, imports) {
         // construct the partial body params type and unmarshal it
         content += '\ttype partialBodyParams struct {\n';
         for (const partialBodyParam of partialBodyParams) {
-            content += `\t\t${capitalize(partialBodyParam.name)} ${helpers.star(partialBodyParam.byValue)}${go.getTypeDeclaration(partialBodyParam.type, pkg)} \`json:"${partialBodyParam.serializedName}"\`\n`;
+            content += `\t\t${naming.capitalize(partialBodyParam.name)} ${helpers.star(partialBodyParam.byValue)}${go.getTypeDeclaration(partialBodyParam.type, pkg)} \`json:"${partialBodyParam.serializedName}"\`\n`;
         }
         content += '\t}\n';
         content += `\tbody, err := server.UnmarshalRequestAs${partialBodyParams[0].format}[partialBodyParams](req)\n`;
@@ -680,7 +681,7 @@ function dispatchForOperationBody(pkg, receiverName, method, imports) {
     content += result.content;
     // translate each partial body param to its field within the unmarshalled body
     for (const partialBodyParam of partialBodyParams) {
-        result.params.set(partialBodyParam.name, `${helpers.star(partialBodyParam.byValue)}body.${capitalize(partialBodyParam.name)}`);
+        result.params.set(partialBodyParam.name, `${helpers.star(partialBodyParam.byValue)}body.${naming.capitalize(partialBodyParam.name)}`);
     }
     const apiCall = `:= ${receiverName}.srv.${fixUpMethodName(method)}(${populateApiParams(pkg, method, result.params, imports)})`;
     if (method.kind === 'pageableMethod') {
@@ -721,8 +722,8 @@ function getMethodStatusCodes(method) {
  */
 function dispatchForLROBody(pkg, receiverName, method, imports) {
     const operationName = fixUpMethodName(method);
-    const localVarName = uncapitalize(operationName);
-    const operationStateMachine = `${receiverName}.${uncapitalize(operationName)}`;
+    const localVarName = naming.uncapitalize(operationName);
+    const operationStateMachine = `${receiverName}.${naming.uncapitalize(operationName)}`;
     let content = `\t${localVarName} := ${operationStateMachine}.get(req)\n`;
     content += `\tif ${localVarName} == nil {\n`;
     content += dispatchForOperationBody(pkg, receiverName, method, imports);
@@ -751,8 +752,8 @@ function dispatchForLROBody(pkg, receiverName, method, imports) {
  */
 function dispatchForPagerBody(pkg, receiverName, method, imports) {
     const operationName = fixUpMethodName(method);
-    const localVarName = uncapitalize(operationName);
-    const operationStateMachine = `${receiverName}.${uncapitalize(operationName)}`;
+    const localVarName = naming.uncapitalize(operationName);
+    const operationStateMachine = `${receiverName}.${naming.uncapitalize(operationName)}`;
     let content = `\t${localVarName} := ${operationStateMachine}.get(req)\n`;
     content += `\tif ${localVarName} == nil {\n`;
     content += dispatchForOperationBody(pkg, receiverName, method, imports);
@@ -811,7 +812,7 @@ function parseHeaderPathQueryParams(pkg, method, imports) {
     let content = '';
     const paramValues = new Map();
     const createLocalVariableName = function (param, suffix) {
-        const paramName = `${uncapitalize(param.name)}${suffix}`;
+        const paramName = `${naming.uncapitalize(param.name)}${suffix}`;
         paramValues.set(param.name, paramName);
         return paramName;
     };
@@ -832,7 +833,7 @@ function parseHeaderPathQueryParams(pkg, method, imports) {
     // track the param groups that need to be instantiated/populated.
     // we track the params separately as it might be a subset of ParameterGroup.params
     const paramGroups = new Map();
-    for (const param of values(consolidateHostParams(method.parameters))) {
+    for (const param of consolidateHostParams(method.parameters)) {
         if (param.location === 'client' || go.isLiteralParameter(param.style)) {
             // client params and parameter literals aren't passed to APIs
             continue;
@@ -956,7 +957,7 @@ function parseHeaderPathQueryParams(pkg, method, imports) {
                     content += '\t\tif parseErr != nil {\n\t\t\treturn nil, parseErr\n\t\t}\n';
                 }
                 else if (elementFormat === 'float32' || elementFormat === 'float64' || elementFormat === 'int32' || elementFormat === 'int64') {
-                    fromVar = `parsed${capitalize(elementFormat)}`;
+                    fromVar = `parsed${naming.capitalize(elementFormat)}`;
                     content += `\t\t${fromVar}, parseErr := ${emitNumericConversion(`${paramValue}[i]`, elementFormat)}\n`;
                     content += '\t\tif parseErr != nil {\n\t\t\treturn nil, parseErr\n\t\t}\n';
                 }
@@ -967,14 +968,14 @@ function parseHeaderPathQueryParams(pkg, method, imports) {
                 }
                 else if (elementFormat === 'Std' || elementFormat === 'URL') {
                     imports.add('encoding/base64');
-                    fromVar = `parsed${capitalize(elementFormat)}`;
+                    fromVar = `parsed${naming.capitalize(elementFormat)}`;
                     content += `\t\t${fromVar}, parseErr := base64.${elementFormat}Encoding.DecodeString(${paramValue}[i])\n`;
                     content += '\t\tif parseErr != nil {\n\t\t\treturn nil, parseErr\n\t\t}\n';
                 }
-                else if (elementFormat === 'dateTimeRFC1123' || elementFormat === 'dateTimeRFC3339' || elementFormat === 'timeUnix') {
+                else if (elementFormat === 'RFC1123' || elementFormat === 'RFC3339' || elementFormat === 'Unix') {
                     imports.add('time');
-                    fromVar = `parsed${capitalize(elementFormat)}`;
-                    if (elementFormat === 'timeUnix') {
+                    fromVar = `parsed${naming.capitalize(elementFormat)}`;
+                    if (elementFormat === 'Unix') {
                         imports.add('strconv');
                         content += `\t\tp, parseErr := strconv.ParseInt(${paramValue}[i], 10, 64)\n`;
                         content += '\t\tif parseErr != nil {\n\t\t\treturn nil, parseErr\n\t\t}\n';
@@ -982,7 +983,7 @@ function parseHeaderPathQueryParams(pkg, method, imports) {
                     }
                     else {
                         let format = 'time.RFC3339Nano';
-                        if (elementFormat === 'dateTimeRFC1123') {
+                        if (elementFormat === 'RFC1123') {
                             format = 'time.RFC1123';
                         }
                         content += `\t\t${fromVar}, parseErr := time.Parse(${format}, ${paramValue}[i])\n`;
@@ -1019,26 +1020,15 @@ function parseHeaderPathQueryParams(pkg, method, imports) {
             content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
         }
         else if (param.type.kind === 'time') {
-            if (param.type.format === 'dateType' || param.type.format === 'timeRFC3339') {
-                imports.add('time');
-                let format = helpers.dateFormat;
-                if (param.type.format === 'timeRFC3339') {
-                    format = helpers.timeRFC3339Format;
-                }
-                let from = `time.Parse("${format}", ${paramValue})`;
-                if (!go.isRequiredParameter(param.style)) {
-                    requiredHelpers.parseOptional = true;
-                    from = `parseOptional(${paramValue}, func(v string) (time.Time, error) { return time.Parse("${format}", v) })`;
-                }
-                content += `\t${createLocalVariableName(param, 'Param')}, err := ${from}\n`;
-                content += '\tif err != nil {\n\t\treturn nil, err\n\t}\n';
-            }
-            else if (param.type.format === 'dateTimeRFC1123' || param.type.format === 'dateTimeRFC3339') {
-                imports.add('time');
-                let format = 'time.RFC3339Nano';
-                if (param.type.format === 'dateTimeRFC1123') {
-                    format = 'time.RFC1123';
-                }
+            const formatMap = {
+                'PlainDate': helpers.plainDateFormat,
+                'PlainTime': helpers.plainTimeFormat,
+                'RFC1123': helpers.RFC1123Format,
+                'RFC3339': helpers.RFC3339Format,
+            };
+            imports.add('time');
+            if (param.type.format in formatMap) {
+                const format = formatMap[param.type.format];
                 let from = `time.Parse(${format}, ${paramValue})`;
                 if (!go.isRequiredParameter(param.style)) {
                     requiredHelpers.parseOptional = true;
@@ -1142,49 +1132,56 @@ function parseHeaderPathQueryParams(pkg, method, imports) {
         }
     }
     // create the param groups and populate their values
-    for (const paramGroup of values(paramGroups.keys())) {
+    for (const paramGroup of paramGroups.keys()) {
         if (paramGroup.required) {
-            content += `\t${uncapitalize(paramGroup.name)} := ${go.getTypeDeclaration(paramGroup, pkg)}{\n`;
-            for (const param of values(paramGroups.get(paramGroup))) {
-                content += `\t\t${capitalize(param.name)}: ${getFinalParamValue(pkg, param, paramValues)},\n`;
+            content += `\t${naming.uncapitalize(paramGroup.name)} := ${go.getTypeDeclaration(paramGroup, pkg)}{\n`;
+            const params = paramGroups.get(paramGroup);
+            if (params) {
+                for (const param of params) {
+                    content += `\t\t${naming.capitalize(param.name)}: ${getFinalParamValue(pkg, param, paramValues)},\n`;
+                }
             }
             content += '\t}\n';
         }
         else {
-            content += `\tvar ${uncapitalize(paramGroup.name)} *${go.getTypeDeclaration(paramGroup, pkg)}\n`;
+            content += `\tvar ${naming.uncapitalize(paramGroup.name)} *${go.getTypeDeclaration(paramGroup, pkg)}\n`;
             const params = paramGroups.get(paramGroup);
             const paramNilCheck = new Array();
-            for (const param of values(params)) {
-                // check array before body in case the body is just an array
-                if (param.type.kind === 'slice') {
-                    paramNilCheck.push(`len(${getFinalParamValue(pkg, param, paramValues)}) > 0`);
-                }
-                else if (param.kind === 'bodyParam') {
-                    if (param.bodyFormat === 'binary') {
-                        imports.add('io');
-                        paramNilCheck.push('req.Body != nil');
+            if (params) {
+                for (const param of params) {
+                    // check array before body in case the body is just an array
+                    if (param.type.kind === 'slice') {
+                        paramNilCheck.push(`len(${getFinalParamValue(pkg, param, paramValues)}) > 0`);
                     }
-                    else {
+                    else if (param.kind === 'bodyParam') {
+                        if (param.bodyFormat === 'binary') {
+                            imports.add('io');
+                            paramNilCheck.push('req.Body != nil');
+                        }
+                        else {
+                            imports.add('reflect');
+                            paramNilCheck.push('!reflect.ValueOf(body).IsZero()');
+                        }
+                    }
+                    else if (go.isFormBodyParameter(param) || param.kind === 'multipartFormBodyParam') {
                         imports.add('reflect');
-                        paramNilCheck.push('!reflect.ValueOf(body).IsZero()');
+                        paramNilCheck.push(`!reflect.ValueOf(${param.name}).IsZero()`);
+                    }
+                    else {
+                        paramNilCheck.push(`${getFinalParamValue(pkg, param, paramValues)} != nil`);
                     }
-                }
-                else if (go.isFormBodyParameter(param) || param.kind === 'multipartFormBodyParam') {
-                    imports.add('reflect');
-                    paramNilCheck.push(`!reflect.ValueOf(${param.name}).IsZero()`);
-                }
-                else {
-                    paramNilCheck.push(`${getFinalParamValue(pkg, param, paramValues)} != nil`);
                 }
             }
             content += `\tif ${paramNilCheck.join(' || ')} {\n`;
-            content += `\t\t${uncapitalize(paramGroup.name)} = &${go.getTypeDeclaration(paramGroup, pkg)}{\n`;
-            for (const param of values(params)) {
-                let byRef = '&';
-                if (param.byValue || (!go.isRequiredParameter(param.style) && param.kind !== 'bodyParam' && !go.isFormBodyParameter(param) && param.kind !== 'multipartFormBodyParam')) {
-                    byRef = '';
+            content += `\t\t${naming.uncapitalize(paramGroup.name)} = &${go.getTypeDeclaration(paramGroup, pkg)}{\n`;
+            if (params) {
+                for (const param of params) {
+                    let byRef = '&';
+                    if (param.byValue || (!go.isRequiredParameter(param.style) && param.kind !== 'bodyParam' && !go.isFormBodyParameter(param) && param.kind !== 'multipartFormBodyParam')) {
+                        byRef = '';
+                    }
+                    content += `\t\t\t${naming.capitalize(param.name)}: ${byRef}${getFinalParamValue(pkg, param, paramValues)},\n`;
                 }
-                content += `\t\t\t${capitalize(param.name)}: ${byRef}${getFinalParamValue(pkg, param, paramValues)},\n`;
             }
             content += '\t\t}\n';
             content += '\t}\n';
@@ -1214,11 +1211,11 @@ function populateApiParams(pkg, method, paramValues, imports) {
         params.push('req.Context()');
     }
     // now create the API call sig
-    for (const param of values(helpers.getMethodParameters(method, consolidateHostParams))) {
+    for (const param of helpers.getMethodParameters(method, consolidateHostParams)) {
         if (param.kind === 'paramGroup') {
             if (param.groupName === method.optionalParamsGroup.groupName) {
                 // this is the optional params type. in some cases we just pass nil
-                const countParams = values(param.params).where((each) => { return each.kind !== 'resumeTokenParam'; }).count();
+                const countParams = param.params.filter((each) => each.kind !== 'resumeTokenParam').length;
                 if (countParams === 0) {
                     // if the options param is empty or only contains the resume token param just pass nil
                     params.push('nil');
@@ -1227,7 +1224,7 @@ function populateApiParams(pkg, method, paramValues, imports) {
             }
             // by convention, for param groups, the param parsing code
             // creates a local var with the name of the param
-            params.push(uncapitalize(param.name));
+            params.push(naming.uncapitalize(param.name));
             continue;
         }
         imports.addForType(param.type);
@@ -1314,7 +1311,7 @@ function getFinalParamValue(pkg, param, paramValues) {
     }
     else if (param.kind === 'partialBodyParam') {
         // use the value from the unmarshaled, intermediate struct type
-        return `body.${capitalize(param.name)}`;
+        return `body.${naming.capitalize(param.name)}`;
     }
     return paramValue;
 }
@@ -1324,14 +1321,14 @@ function getFinalParamValue(pkg, param, paramValues) {
 // there's no way to reliably split the host back up into its constituent parameters.
 // so we just pass the full value as a single host parameter.
 function consolidateHostParams(params) {
-    if (!values(params).where((each) => { return each.kind === 'uriParam'; }).any()) {
+    if (!params.find((each) => each.kind === 'uriParam')) {
         // no host params
         return params;
     }
     // consolidate multiple host params into a single "host" param
     const consolidatedParams = new Array();
     let hostParamAdded = false;
-    for (const param of values(params)) {
+    for (const param of params) {
         if (param.kind !== 'uriParam') {
             consolidatedParams.push(param);
         }
@@ -1357,8 +1354,8 @@ function getAPIParametersSig(pkg, method, imports) {
         imports.add('context');
         params.push('ctx context.Context');
     }
-    for (const methodParam of values(methodParams)) {
-        let paramName = uncapitalize(methodParam.name);
+    for (const methodParam of methodParams) {
+        let paramName = naming.uncapitalize(methodParam.name);
         if (methodParam.kind === 'uriParam') {
             paramName = 'host';
         }