@azure-tools/typespec-go 0.11.0 → 0.11.2

package/dist/codegen.go/src/core/operations.js

@@ -43,7 +43,11 @@ export function generateOperations(pkg, target, options) {
         }
         imports.add(azureARM ? 'github.com/Azure/azure-sdk-for-go/sdk/azcore/arm' : 'github.com/Azure/azure-sdk-for-go/sdk/azcore');
         // generate client type
-        let clientText = helpers.formatDocComment(client.docs);
+        let clientText = '';
+        if (client.apiVersion) {
+            clientText += `const ${client.apiVersion.name} ${go.getTypeDeclaration(client.apiVersion, pkg)} = ${helpers.formatLiteralValue(client.apiVersion.literal, false)}\n\n`;
+        }
+        clientText += helpers.formatDocComment(client.docs);
         clientText += "// Don't use this type directly, use ";
         if (client.instance?.kind === 'constructable' && client.instance.constructors.length === 1) {
             clientText += `${client.instance.constructors[0].name}() instead.\n`;
@@ -65,6 +69,9 @@ export function generateOperations(pkg, target, options) {
         else {
             clientText += 'a constructor function instead.\n';
         }
+        if (client.apiVersion) {
+            clientText += `//\n// Generated from API version ${client.apiVersion.literal.literal}\n`;
+        }
         const indent = new helpers.Indentation();
         clientText += `type ${client.name} struct {\n`;
         clientText += `${indent.get()}internal *${azureARM ? 'arm' : 'azcore'}.Client\n`;
@@ -453,28 +460,7 @@ function formatHeaderResponseValue(method, headerResp, respObj, zeroResp, import
             text += `${indent.get()}}\n`;
             return text;
         case 'scalar':
-            imports.add('strconv');
-            switch (headerResp.type.type) {
-                case 'bool':
-                    text += `${indent.get()}${name}, err := strconv.ParseBool(val)\n`;
-                    break;
-                case 'float32':
-                    text += `${indent.get()}${name}32, err := strconv.ParseFloat(val, 32)\n`;
-                    text += `${indent.get()}${name} := float32(${name}32)\n`;
-                    break;
-                case 'float64':
-                    text += `${indent.get()}${name}, err := strconv.ParseFloat(val, 64)\n`;
-                    break;
-                case 'int32':
-                    text += `${indent.get()}${name}32, err := strconv.ParseInt(val, 10, 32)\n`;
-                    text += `${indent.get()}${name} := int32(${name}32)\n`;
-                    break;
-                case 'int64':
-                    text += `${indent.get()}${name}, err := strconv.ParseInt(val, 10, 64)\n`;
-                    break;
-                default:
-                    throw new CodegenError('InternalError', `unhandled scalar type ${headerResp.type.type}`);
-            }
+            text += emitScalarParsing(headerResp.type, 'val', name, imports, indent);
             break;
         case 'string':
             text += `${indent.get()}${respObj}.${headerResp.fieldName} = &val\n`;
@@ -510,6 +496,35 @@ function formatHeaderResponseValue(method, headerResp, respObj, zeroResp, import
     text += `${indent.pop().get()}}\n`;
     return text;
 }
+/**
+ * emits the code for parsing scalar types from a string.
+ * note that the parsing error result is placed into a
+ * local var named "err".
+ *
+ * @param scalar the type of scalar to parse
+ * @param src the source var that contains the scalar in string format
+ * @param dst the destination var that contains the result
+ * @param imports the import manager currently in scope
+ * @param indent the indentation helper currently in scope
+ * @returns the scalar parsing code
+ */
+function emitScalarParsing(scalar, src, dst, imports, indent) {
+    imports.add('strconv');
+    switch (scalar.type) {
+        case 'bool':
+            return `${indent.get()}${dst}, err := strconv.ParseBool(${src})\n`;
+        case 'float32':
+            return `${indent.get()}${dst}32, err := strconv.ParseFloat(${src}, 32)\n` + `${indent.get()}${dst} := float32(${dst}32)\n`;
+        case 'float64':
+            return `${indent.get()}${dst}, err := strconv.ParseFloat(${src}, 64)\n`;
+        case 'int32':
+            return `${indent.get()}${dst}32, err := strconv.ParseInt(${src}, 10, 32)\n` + `${indent.get()}${dst} := int32(${dst}32)\n`;
+        case 'int64':
+            return `${indent.get()}${dst}, err := strconv.ParseInt(${src}, 10, 64)\n`;
+        default:
+            throw new CodegenError('InternalError', `unhandled scalar type ${scalar.type}`);
+    }
+}
 /**
  * returns the zero value for the specified method.
  * note that the zero value will be different depending
@@ -751,12 +766,6 @@ function callPipelineDoWithErrCheck(method, reqVarName, respVarName, indent) {
     text += `${indent.get()}${helpers.buildErrCheck(indent, 'err', zeroResp)}\n`;
     return text;
 }
-function genApiVersionDoc(apiVersions) {
-    if (apiVersions.length === 0) {
-        return '';
-    }
-    return `//\n// Generated from API version ${apiVersions.join(', ')}\n`;
-}
 function genRespErrorDoc(method) {
     if (!(method.returns.result?.kind === 'headAsBooleanResult') && !go.isPageableMethod(method)) {
         // when head-as-boolean is enabled, no error is returned for 4xx status codes.
@@ -783,18 +792,16 @@ function generateOperation(method, options, imports, indent) {
     }
     let text = '';
     const respErrDoc = genRespErrorDoc(method);
-    const apiVerDoc = genApiVersionDoc(method.apiVersions);
     if (method.docs.summary || method.docs.description) {
         text += helpers.formatDocCommentWithPrefix(methodName, method.docs);
     }
-    else if (respErrDoc.length > 0 || apiVerDoc.length > 0) {
+    else if (respErrDoc.length > 0) {
         // if the method has no doc comment but we're adding other
         // doc comments, add an empty method name comment. this preserves
         // existing behavior and makes the docs look better overall.
         text += `// ${methodName} -\n`;
     }
     text += respErrDoc;
-    text += apiVerDoc;
     if (go.isLROMethod(method)) {
         methodName = method.naming.internalMethod;
     }
@@ -854,6 +861,34 @@ function generateOperation(method, options, imports, indent) {
     text += '}\n\n';
     return text;
 }
+/**
+ * emits Go code to set ContentType on a MultipartContent variable if it has a fixed content type.
+ * handles both direct MultipartContent and slices of MultipartContent.
+ * returns the empty string if there's nothing to set.
+ *
+ * @param paramName the name of the multipart param
+ * @param wireType the underlying type of the multipart param
+ * @param indent the indentation helper currently in scope
+ * @returns setter code or the empty string
+ */
+function emitMultipartContentTypeSetter(paramName, wireType, indent) {
+    let text = '';
+    const unwrapped = helpers.recursiveUnwrapMapSlice(wireType);
+    if (unwrapped.kind !== 'multipartContent' || !unwrapped.contentType) {
+        return text;
+    }
+    switch (wireType.kind) {
+        case 'multipartContent':
+            text += `${indent.get()}${paramName}.ContentType = ${unwrapped.contentType.literal}\n`;
+            break;
+        case 'slice':
+            text += `${indent.get()}for i := range ${paramName} {\n`;
+            text += `${indent.push().get()}${paramName}[i].ContentType = ${unwrapped.contentType.literal}\n`;
+            text += `${indent.pop().get()}}\n`;
+            break;
+    }
+    return text;
+}
 function createProtocolRequest(azureARM, method, imports, indent) {
     let name = method.name;
     if (method.kind !== 'nextPageMethod') {
@@ -1086,7 +1121,12 @@ function createProtocolRequest(azureARM, method, imports, indent) {
             }
             text += emitQueryParam(qp, setter);
         }
-        text += `${indent.get()}req.Raw().URL.RawQuery = reqQP.Encode()\n`;
+        // reqQP.Encode() encodes space chars as '+' which is application/x-www-form-urlencoded
+        // thus not applicable for URIs. the correct URI encoding for SP is %20. note that literal '+'
+        // characters are encoded by reqQP.Encode() as %2B so there's no risk of replacing them.
+        // see https://www.rfc-editor.org/rfc/rfc3986 sections 2.1, 2.2, and 3.4
+        imports.add('strings');
+        text += `${indent.get()}req.Raw().URL.RawQuery = strings.ReplaceAll(reqQP.Encode(), "+", "%20")\n`;
     }
     // tack on any unencoded params to the end
     if (unencodedParams.length > 0) {
@@ -1140,9 +1180,22 @@ function createProtocolRequest(azureARM, method, imports, indent) {
     for (const param of methodParamGroups.headerParams.sort((a, b) => {
         return helpers.sortAscending(a.headerName, b.headerName);
     })) {
-        if (param.headerName.match(/^content-type$/)) {
+        if (param.headerName.match(/^content-type$/i)) {
             // canonicalize content-type as req.SetBody checks for it via its canonicalized name :(
             param.headerName = 'Content-Type';
+            // there's a corner case where we have a content-type param with no body
+            // param. for this case we still need to set the header inline.
+            if (methodParamGroups.bodyParam) {
+                // if the content-type is from a param, then the param will be passed
+                // explicitly to runtime.SetBody() so don't emit code to set it inline
+                if (go.isClientSideDefault(param.style)) {
+                    text += emitClientSideDefault(param, param.style, () => '', imports, indent);
+                    continue;
+                }
+                else if (param.style === 'required') {
+                    continue;
+                }
+            }
         }
         if (param.headerName === 'Content-Type' && param.style === 'literal') {
             // the content-type header will be set as part of emitSetBodyWithErrCheck
@@ -1186,6 +1239,29 @@ function createProtocolRequest(azureARM, method, imports, indent) {
         return content;
     };
     if (bodyParam) {
+        /** returns the source value for the content type */
+        const getContentTypeValue = function (src) {
+            switch (src.kind) {
+                case 'literal':
+                    return helpers.formatLiteralValue(src, false);
+                case 'parameterRef': {
+                    // find the param
+                    for (const param of method.parameters) {
+                        if (param.kind === 'headerScalarParam' && param.name === src.name) {
+                            if (go.isClientSideDefault(param.style)) {
+                                return getClientSideDefaultVarName(param);
+                            }
+                            let paramName = helpers.getParamName(param);
+                            if (param.type.kind === 'constant') {
+                                paramName = `string(${paramName})`;
+                            }
+                            return paramName;
+                        }
+                    }
+                    throw new CodegenError('InternalError', `didn't find parameter reference ${src.name}`);
+                }
+            }
+        };
         if (bodyParam.bodyFormat === 'JSON' || bodyParam.bodyFormat === 'XML') {
             // default to the body param name
             let body = helpers.getParamName(bodyParam);
@@ -1269,13 +1345,13 @@ function createProtocolRequest(azureARM, method, imports, indent) {
         }
         else if (bodyParam.bodyFormat === 'binary') {
             if (go.isRequiredParameter(bodyParam.style)) {
-                text += emitSetBodyWithErrCheck(`req.SetBody(${bodyParam.name}, ${bodyParam.contentType})`, contentType);
+                text += emitSetBodyWithErrCheck(`req.SetBody(${bodyParam.name}, ${getContentTypeValue(bodyParam.contentType)})`, contentType);
                 text += `${indent.get()}return req, nil\n`;
             }
             else {
                 text += emitParamGroupCheck(bodyParam);
                 indent.push();
-                text += emitSetBodyWithErrCheck(`req.SetBody(${helpers.getParamName(bodyParam)}, ${bodyParam.contentType})`, contentType);
+                text += emitSetBodyWithErrCheck(`req.SetBody(${helpers.getParamName(bodyParam)}, ${getContentTypeValue(bodyParam.contentType)})`, contentType);
                 text += `${indent.get()}return req, nil\n`;
                 indent.pop();
                 text += `${indent.get()}}\n`;
@@ -1287,14 +1363,14 @@ function createProtocolRequest(azureARM, method, imports, indent) {
             imports.add('github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming');
             if (go.isRequiredParameter(bodyParam.style)) {
                 text += `${indent.get()}body := streaming.NopCloser(strings.NewReader(${bodyParam.name}))\n`;
-                text += emitSetBodyWithErrCheck(`req.SetBody(body, ${bodyParam.contentType})`, contentType);
+                text += emitSetBodyWithErrCheck(`req.SetBody(body, ${getContentTypeValue(bodyParam.contentType)})`, contentType);
                 text += `${indent.get()}return req, nil\n`;
             }
             else {
                 text += emitParamGroupCheck(bodyParam);
                 indent.push();
                 text += `${indent.get()}body := streaming.NopCloser(strings.NewReader(${helpers.getParamName(bodyParam)}))\n`;
-                text += emitSetBodyWithErrCheck(`req.SetBody(body, ${bodyParam.contentType})`, contentType);
+                text += emitSetBodyWithErrCheck(`req.SetBody(body, ${getContentTypeValue(bodyParam.contentType)})`, contentType);
                 text += `${indent.get()}return req, nil\n`;
                 indent.pop();
                 text += `${indent.get()}}\n`;
@@ -1337,7 +1413,19 @@ function createProtocolRequest(azureARM, method, imports, indent) {
         text += `${indent.get()}return req, nil\n`;
     }
     else if (multipartBodyParams.length > 0) {
+        // emit content type setters for direct MultipartContent params with a fixed content type.
+        // this handles the case where the param itself is a MultipartContent or a slice of them
+        // (i.e. not wrapped in a model struct with toMultipartFormData()).
+        // note that tsp only allows homogeneous content types, which is why it's safe
+        // to unwrap the first param's type and check its contentType field.
+        text += emitMultipartContentTypeSetter(multipartBodyParams[0].name, multipartBodyParams[0].type, indent);
         if (multipartBodyParams.length === 1 && multipartBodyParams[0].type.kind === 'model' && multipartBodyParams[0].type.annotations.multipartFormData) {
+            // emit content type setters for model fields that have a fixed content type.
+            // toMultipartFormData() converts the model to map[string]any but doesn't set ContentType,
+            // so we must set it on each MultipartContent field before the conversion.
+            for (const field of multipartBodyParams[0].type.fields) {
+                text += emitMultipartContentTypeSetter(`${multipartBodyParams[0].name}.${field.name}`, field.type, indent);
+            }
             text += `${indent.get()}formData, err := ${multipartBodyParams[0].name}.toMultipartFormData()\n`;
             text += `${indent.get()}if err != nil {\n`;
             text += `${indent.push().get()}return nil, err\n`;
@@ -1394,8 +1482,17 @@ function createProtocolRequest(azureARM, method, imports, indent) {
     text += '}\n\n';
     return text;
 }
+/**
+ * returns the var name to use for a param's client-side default value
+ *
+ * @param param the param for which to name the var
+ * @returns the var name
+ */
+function getClientSideDefaultVarName(param) {
+    return naming.uncapitalize(param.name) + 'Default';
+}
 function emitClientSideDefault(param, csd, setterFormat, imports, indent) {
-    const defaultVar = naming.uncapitalize(param.name) + 'Default';
+    const defaultVar = getClientSideDefaultVarName(param);
     let text = `${indent.get()}${defaultVar} := ${helpers.formatLiteralValue(csd.defaultValue, true)}\n`;
     text += `${indent.get()}if options != nil && options.${naming.capitalize(param.name)} != nil {\n`;
     text += `${indent.push().get()}${defaultVar} = *options.${naming.capitalize(param.name)}\n`;
@@ -1411,7 +1508,13 @@ function emitClientSideDefault(param, csd, setterFormat, imports, indent) {
             serializedName = param.queryParameter;
             break;
     }
-    text += setterFormat(`"${serializedName}"`, helpers.formatValue(defaultVar, param.type, imports)) + '\n';
+    const setterFormatText = setterFormat(`"${serializedName}"`, helpers.formatValue(defaultVar, param.type, imports));
+    text += setterFormatText;
+    // setterFormat can return the empty string in some cases.
+    // if it does, there's no need for an extra new-line char.
+    if (setterFormatText.length > 0) {
+        text += '\n';
+    }
     return text;
 }
 function getMediaFormat(type, mediaType, param) {
@@ -1514,8 +1617,21 @@ function generateResponseUnmarshaller(method, type, format, unmarshalTarget, imp
         unmarshallerText += `${indent.get()}if err != nil {\n`;
         unmarshallerText += `${indent.push().get()}return ${zeroValue}, err\n`;
         unmarshallerText += `${indent.pop().get()}}\n`;
-        unmarshallerText += `${indent.get()}txt := string(body)\n`;
-        unmarshallerText += `${indent.get()}${unmarshalTarget} = &txt\n`;
+        let resultVar;
+        switch (type.kind) {
+            case 'scalar':
+                resultVar = 'parsedBody';
+                unmarshallerText += emitScalarParsing(type, 'string(body)', resultVar, imports, indent);
+                unmarshallerText += `${indent.get()}${helpers.buildErrCheck(indent, 'err', zeroValue)}\n`;
+                break;
+            case 'string':
+                resultVar = 'txt';
+                unmarshallerText += `${indent.get()}${resultVar} := string(body)\n`;
+                break;
+            default:
+                throw new CodegenError('UnsupportedTsp', `unsupported text return kind ${type.kind} for method ${method.receiver.type.name}.${method.name}`);
+        }
+        unmarshallerText += `${indent.get()}${unmarshalTarget} = &${resultVar}\n`;
     }
     else {
         // the remaining formats should have been handled elsewhere
@@ -1703,7 +1819,6 @@ function generateLROBeginMethod(method, options, imports, indent) {
     if (method.docs.summary || method.docs.description) {
         text += helpers.formatDocCommentWithPrefix(fixUpMethodName(method), method.docs);
         text += genRespErrorDoc(method);
-        text += genApiVersionDoc(method.apiVersions);
     }
     const zeroResp = getZeroReturnValue(method, 'lro');
     const methodParams = helpers.getMethodParameters(method);