@azure-tools/typespec-rust 0.41.3 → 0.41.5

package/dist/src/codegen/clients.js

@@ -1090,6 +1090,51 @@ function applyHeaderParams(indent, use, method, paramGroups, inClosure, requestV
 function isOptionalContentTypeHeader(headerParam) {
     return headerParam.kind === 'headerScalar' && headerParam.optional && headerParam.header.toLowerCase() === 'content-type';
 }
+function getOptionalContentTypeParam(paramGroups) {
+    for (const headerParam of paramGroups.header) {
+        if (isOptionalContentTypeHeader(headerParam)) {
+            return headerParam;
+        }
+    }
+    return undefined;
+}
+function constructPartialBodyRequestContent(indent, use, paramGroups, inClosure, bodyVarName) {
+    if (paramGroups.partialBody.length === 0) {
+        throw new CodegenError('InternalError', 'expected partial body params for request content construction');
+    }
+    const requestContentType = paramGroups.partialBody[0].type;
+    use.addForType(requestContentType);
+    let body = `${indent.get()}let ${bodyVarName}: ${inClosure ? 'Result<' : ''}${helpers.getTypeDeclaration(requestContentType)}${inClosure ? '>' : ''} = ${requestContentType.content.name} {\n`;
+    indent.push();
+    for (const partialBodyParam of paramGroups.partialBody) {
+        if (partialBodyParam.type.content !== requestContentType.content) {
+            throw new CodegenError('InternalError', `spread param ${partialBodyParam.name} has conflicting model type ${partialBodyParam.type.content.name}, expected model type ${requestContentType.content.name}`);
+        }
+        if (partialBodyParam.optional) {
+            body += `${indent.get()}${partialBodyParam.name}: options.${partialBodyParam.name}${inClosure ? '.clone()' : ''},\n`;
+            continue;
+        }
+        let initializer = partialBodyParam.name;
+        if (inClosure) {
+            initializer += '.clone()';
+        }
+        if (requestContentType.content.visibility === 'pub') {
+            initializer = `Some(${initializer})`;
+        }
+        if (initializer !== partialBodyParam.name) {
+            initializer = `${partialBodyParam.name}: ${initializer}`;
+        }
+        body += `${indent.get()}${initializer},\n`;
+    }
+    body += `${indent.pop().get()}}.try_into()`;
+    if (inClosure) {
+        body += `;\n`;
+    }
+    else {
+        body += `?;\n`;
+    }
+    return body;
+}
 /**
  * emits the code for building the HTTP request.
  * assumes that there's a local var 'url' which is the Url.
@@ -1111,13 +1156,7 @@ function constructRequest(indent, use, method, paramGroups, inClosure, urlVarNam
     const requestVarName = helpers.getUniqueVarName(method.params, ['request', 'core_req']);
     let body = `${indent.get()}let ${(forceMut || paramGroups.header.length > 0) ? 'mut ' : ''}${requestVarName} = Request::new(${urlVarName}${cloneUrl ? '.clone()' : ''}, Method::${utils.capitalize(method.httpMethod)});\n`;
     body += applyHeaderParams(indent, use, method, paramGroups, inClosure, requestVarName);
-    let optionalContentTypeParam;
-    for (const headerParam of paramGroups.header) {
-        // if the content-type header is optional, we need to emit it inside the "if let Some(body)" clause below.
-        if (isOptionalContentTypeHeader(headerParam)) {
-            optionalContentTypeParam = headerParam;
-        }
-    }
+    const optionalContentTypeParam = getOptionalContentTypeParam(paramGroups);
     const bodyParam = paramGroups.body;
     if (bodyParam) {
         body += getParamValueHelper(indent, bodyParam, () => {
@@ -1130,52 +1169,37 @@ function constructRequest(indent, use, method, paramGroups, inClosure, urlVarNam
         });
     }
     else if (paramGroups.partialBody.length > 0) {
-        // all partial body params should point to the same underlying model type.
-        const requestContentType = paramGroups.partialBody[0].type;
-        use.addForType(requestContentType);
         if (inClosure) {
-            body += `${indent.get()}let body: Result<${helpers.getTypeDeclaration(requestContentType)}> = ${requestContentType.content.name} {\n`;
-        }
-        else {
-            body += `${indent.get()}let body: ${helpers.getTypeDeclaration(requestContentType)} = ${requestContentType.content.name} {\n`;
-        }
-        indent.push();
-        for (const partialBodyParam of paramGroups.partialBody) {
-            if (partialBodyParam.type.content !== requestContentType.content) {
-                throw new CodegenError('InternalError', `spread param ${partialBodyParam.name} has conflicting model type ${partialBodyParam.type.content.name}, expected model type ${requestContentType.content.name}`);
-            }
-            if (partialBodyParam.optional) {
-                body += `${indent.get()}${partialBodyParam.name}: options.${partialBodyParam.name}${inClosure ? '.clone()' : ''},\n`;
-                continue;
-            }
-            let initializer = partialBodyParam.name;
-            if (inClosure) {
-                initializer = initializer + '.clone()';
-            }
-            if (requestContentType.content.visibility === 'pub') {
-                // spread param maps to a non-internal model, so it must be wrapped in Some()
-                initializer = `Some(${initializer})`;
-            }
-            // can't use shorthand init if it's more than just the param name
-            if (initializer !== partialBodyParam.name) {
-                initializer = `${partialBodyParam.name}: ${initializer}`;
-            }
-            body += `${indent.get()}${initializer},\n`;
-        }
-        if (inClosure) {
-            body += `${indent.pop().get()}}.try_into();\n`;
-            body += `${indent.get()}if let Ok(body) = body { ${requestVarName}.set_body(body); }\n`;
-        }
-        else {
-            body += `${indent.pop().get()}}.try_into()?;\n`;
-            body += `${indent.get()}${requestVarName}.set_body(body);\n`;
+            throw new CodegenError('InternalError', 'partial body request construction in closures must use a dedicated fallible path');
         }
+        body += constructPartialBodyRequestContent(indent, use, paramGroups, inClosure, 'body');
+        body += `${indent.get()}${requestVarName}.set_body(body);\n`;
     }
     return {
         requestVarName: requestVarName,
         content: body
     };
 }
+function constructFallibleInitialPollerRequest(indent, use, method, paramGroups, requestVarName) {
+    if (paramGroups.partialBody.length === 0) {
+        throw new CodegenError('InternalError', 'expected partial body params for fallible poller request construction');
+    }
+    const optionalContentTypeParam = getOptionalContentTypeParam(paramGroups);
+    let body = constructPartialBodyRequestContent(indent, use, paramGroups, true, 'result');
+    body += `${indent.get()}match result {\n`;
+    body += `${indent.push().get()}Ok(body) => {\n`;
+    body += `${indent.push().get()}let mut ${requestVarName} = Request::new(url.clone(), Method::${utils.capitalize(method.httpMethod)});\n`;
+    body += applyHeaderParams(indent, use, method, paramGroups, true, requestVarName);
+    if (optionalContentTypeParam) {
+        body += `${indent.get()}${requestVarName}.insert_header("${optionalContentTypeParam.header.toLowerCase()}", ${getHeaderPathQueryParamValue(use, optionalContentTypeParam, false, false)});\n`;
+    }
+    body += `${indent.get()}${requestVarName}.set_body(body);\n`;
+    body += `${indent.get()}Ok((${requestVarName}, PollerContinuation::Links { next_link: url.clone(), final_link: None, }))\n`;
+    body += `${indent.pop().get()}}\n`;
+    body += `${indent.get()}Err(e) => Err(e),\n`;
+    body += `${indent.pop().get()}}\n`;
+    return body;
+}
 /**
  * Returns 'mut ' if the Url local var needs to be mutable, else the empty string.
  * @param paramGroups the param groups associated with the Url being constructed.
@@ -1274,6 +1298,110 @@ function getAsyncMethodBody(indent, use, client, method) {
     body += `${indent.get()}Ok(rsp.into())\n`;
     return body;
 }
+/**
+ * returns the generated helper type name for a pageable or LRO method.
+ *
+ * @param client the client that owns the method
+ * @param method the method that owns the helper type
+ * @param suffix the helper type suffix
+ * @returns the generated helper type name
+ */
+function getMethodHelperTypeName(client, method, suffix) {
+    return `${client.name}${utils.pascalCase(method.name, false)}${suffix}`;
+}
+/**
+ * emits a local helper struct used for minimal response deserialization.
+ *
+ * @param indent the indentation helper currently in scope
+ * @param helperStruct the helper struct to emit
+ * @returns the helper struct source
+ */
+function emitHelperStruct(indent, helperStruct) {
+    let body = `${indent.get()}#[derive(serde::Deserialize)]\n`;
+    body += `${indent.get()}struct ${helperStruct.name} {\n`;
+    indent.push();
+    for (const field of helperStruct.fields) {
+        if (field.serdeName && field.serdeName !== field.name) {
+            body += `${indent.get()}#[serde(rename = "${field.serdeName}")]\n`;
+        }
+        body += `${indent.get()}${field.name}: ${field.type},\n`;
+    }
+    body += `${indent.pop().get()}}\n`;
+    return body;
+}
+/**
+ * returns the helper struct(s) needed to deserialize only pageable continuation fields.
+ *
+ * @param indent the indentation helper currently in scope
+ * @param client the client that owns the method
+ * @param method the pageable method to inspect
+ * @returns the helper struct source and root type name, or undefined if not needed
+ */
+function getPageableResponseHelperStruct(indent, client, method) {
+    var _a, _b;
+    let nextLinkPath;
+    if (((_a = method.strategy) === null || _a === void 0 ? void 0 : _a.kind) === 'nextLink') {
+        nextLinkPath = method.strategy.nextLinkPath;
+    }
+    else if (((_b = method.strategy) === null || _b === void 0 ? void 0 : _b.kind) === 'continuationToken' && method.strategy.responseToken.kind === 'nextLink') {
+        nextLinkPath = method.strategy.responseToken.nextLinkPath;
+    }
+    if (!nextLinkPath) {
+        return undefined;
+    }
+    const typeName = getMethodHelperTypeName(client, method, 'Page');
+    const helperStructNames = nextLinkPath.map((_, i) => i === 0 ? typeName : `${typeName}${i + 1}`);
+    const helperStructs = new Array();
+    for (let i = nextLinkPath.length - 1; i >= 0; --i) {
+        const field = nextLinkPath[i];
+        helperStructs.unshift({
+            name: helperStructNames[i],
+            fields: [{
+                    name: field.name,
+                    serdeName: field.serde,
+                    type: i === nextLinkPath.length - 1 ? 'Option<String>' : `Option<${helperStructNames[i + 1]}>`,
+                }],
+        });
+    }
+    let content = '';
+    for (const helperStruct of helperStructs) {
+        content += emitHelperStruct(indent, helperStruct);
+        content += '\n';
+    }
+    return {
+        content,
+        typeName,
+    };
+}
+// To add Monitor helpers for pollers, uncomment this helper and wire it into
+// getLroMethodBody.
+/*
+function getLroMonitorHelperStruct(indent: helpers.indentation, client: rust.Client, method: rust.LroMethod): { content: string; typeName: string; statusField: rust.ModelField } | undefined {
+  const statusModel = helpers.unwrapType(method.returns.type);
+  if (statusModel.kind !== 'model') {
+    return undefined;
+  }
+
+  const statusField = helpers.getStatusField(statusModel);
+  if (!statusField) {
+    return undefined;
+  }
+
+  const typeName = getMethodHelperTypeName(client, method, 'Monitor');
+  return {
+    content: `${emitHelperStruct(indent, {
+      name: typeName,
+      fields: [{
+        name: statusField.name,
+        serdeName: statusField.serde,
+        type: helpers.getTypeDeclaration(statusField.type),
+      }],
+    })}\n`,
+    typeName,
+    statusField,
+  };
+}
+*/
 /**
  * constructs the body for a pageable client method
  *
@@ -1284,7 +1412,7 @@ function getAsyncMethodBody(indent, use, client, method) {
  * @returns the contents of the method body
  */
 function getPageableMethodBody(indent, use, client, method) {
-    var _a, _b;
+    var _a, _b, _c;
     use.add('azure_core::http', 'Method', 'Request', 'Url');
     use.add('azure_core::http::pager', 'PagerResult', 'PagerState');
     use.add('azure_core', 'Result');
@@ -1292,11 +1420,15 @@ function getPageableMethodBody(indent, use, client, method) {
     use.addForType(helpers.unwrapType(method.returns.type));
     const paramGroups = getMethodParamGroup(method);
     const urlVar = method.strategy ? 'first_url' : helpers.getUniqueVarName(method.params, ['url', 'url_var']);
+    const pageableResponseHelperStruct = getPageableResponseHelperStruct(indent, client, method);
     let body = checkEmptyRequiredPathParams(indent, paramGroups.path);
     body += 'let options = options.unwrap_or_default().into_owned();\n';
     body += `${indent.get()}let pipeline = self.pipeline.clone();\n`;
     body += `${indent.get()}let ${urlVarNeedsMut(paramGroups, method)}${urlVar} = self.${client.endpoint.name}.clone();\n`;
     body += constructUrl(indent, use, method, paramGroups, urlVar);
+    if (pageableResponseHelperStruct) {
+        body += pageableResponseHelperStruct.content;
+    }
     // passed to constructRequest. we only need to
     // clone it for the non-continuation case.
     let cloneUrl = false;
@@ -1415,7 +1547,7 @@ function getPageableMethodBody(indent, use, client, method) {
         use.add('azure_core', bodyFormat, 'http::RawResponse');
         body += `${indent.get()}let (status, headers, body) = rsp.deconstruct();\n`;
         const deserialize = `${bodyFormat}::from_${bodyFormat}`;
-        body += `${indent.get()}let res: ${helpers.getTypeDeclaration(helpers.unwrapType(method.returns.type))} = ${deserialize}(&body)?;\n`;
+        body += `${indent.get()}let res: ${(_b = pageableResponseHelperStruct === null || pageableResponseHelperStruct === void 0 ? void 0 : pageableResponseHelperStruct.typeName) !== null && _b !== void 0 ? _b : helpers.getTypeDeclaration(helpers.unwrapType(method.returns.type))} = ${deserialize}(&body)?;\n`;
         body += `${indent.get()}let rsp = RawResponse::from_bytes(status, headers, body).into();\n`;
     }
     if (method.strategy) {
@@ -1483,7 +1615,7 @@ function getPageableMethodBody(indent, use, client, method) {
         // non-continuation case, so we don't need to worry about next links, continuation tokens, etc...
         body += `${indent.get()}Ok(PagerResult::Done { response: rsp.into() })\n`;
     }
-    if (((_b = method.strategy) === null || _b === void 0 ? void 0 : _b.kind) === 'nextLink') {
+    if (((_c = method.strategy) === null || _c === void 0 ? void 0 : _c.kind) === 'nextLink') {
         body += `${indent.pop().get()}}\n`;
     }
     body += `${indent.pop().get()}})\n`; // end Box::pin(async move {
@@ -1529,7 +1661,9 @@ function getLroMethodBody(crate, indent, use, client, method) {
         body += `${indent.get()}let ${paramGroups.apiVersion.name} = ${getHeaderPathQueryParamValue(use, paramGroups.apiVersion, true, true)}.clone();\n`;
     }
     // we call this eagerly so that we have access to the request var name
-    const initialRequestResult = constructRequest(indent, use, method, paramGroups, true, urlVar, true, false);
+    const initialRequestResult = paramGroups.partialBody.length > 0
+        ? { requestVarName: helpers.getUniqueVarName(method.params, ['request', 'core_req']), content: '' }
+        : constructRequest(indent, use, method, paramGroups, true, urlVar, true, false);
     const declareRequest = function (indent, use, method, paramGroups, requestVarName, linkExpr, forceMut, optionsPrefix) {
         let mutRequest = '';
         // if the only header is optional Content-Type it will not be used
@@ -1542,7 +1676,10 @@ function getLroMethodBody(crate, indent, use, client, method) {
     };
     body += `${indent.get()}Ok(${method.returns.type.name}::new(\n`;
     body += `${indent.push().get()}move |poller_state: PollerState, poller_options| {\n`;
-    body += `${indent.push().get()}let (mut ${initialRequestResult.requestVarName}, continuation) = ${helpers.buildMatch(indent, 'poller_state', [{
+    const fallibleInitialPollerRequest = paramGroups.partialBody.length > 0
+        ? constructFallibleInitialPollerRequest(indent, use, method, paramGroups, initialRequestResult.requestVarName)
+        : undefined;
+    body += `${indent.push().get()}let ${fallibleInitialPollerRequest ? 'poller_request: Result<(Request, PollerContinuation)>' : `(mut ${initialRequestResult.requestVarName}, continuation)`} = ${helpers.buildMatch(indent, 'poller_state', [{
             pattern: `PollerState::More(continuation)`,
             body: (indent) => {
                 var _a, _b;
@@ -1562,14 +1699,18 @@ function getLroMethodBody(crate, indent, use, client, method) {
                     body += `${indent.get()}query_builder.build();\n`;
                 }
                 body += declareRequest(indent, use, method, paramGroups, initialRequestResult.requestVarName, 'next_link.clone()');
-                body += `${indent.get()}(${initialRequestResult.requestVarName}, PollerContinuation::Links { next_link, final_link })\n`;
+                body += fallibleInitialPollerRequest
+                    ? `${indent.get()}Ok((${initialRequestResult.requestVarName}, PollerContinuation::Links { next_link, final_link }))\n`
+                    : `${indent.get()}(${initialRequestResult.requestVarName}, PollerContinuation::Links { next_link, final_link })\n`;
                 return body;
             },
         }, {
             pattern: 'PollerState::Initial',
             body: (indent) => {
-                let body = initialRequestResult.content;
-                body += `${indent.get()}(${initialRequestResult.requestVarName}, PollerContinuation::Links { next_link: url.clone(), final_link: None, })\n`;
+                let body = fallibleInitialPollerRequest !== null && fallibleInitialPollerRequest !== void 0 ? fallibleInitialPollerRequest : initialRequestResult.content;
+                if (!fallibleInitialPollerRequest) {
+                    body += `${indent.get()}(${initialRequestResult.requestVarName}, PollerContinuation::Links { next_link: url.clone(), final_link: None, })\n`;
+                }
                 return body;
             },
         }])};\n`;
@@ -1630,6 +1771,10 @@ function getLroMethodBody(crate, indent, use, client, method) {
         body += 'let original_url = url.clone();\n';
     }
     body += `${indent.get()}Box::pin(async move {\n`;
+    if (fallibleInitialPollerRequest) {
+        body += `${indent.push().get()}let (mut ${initialRequestResult.requestVarName}, continuation) = poller_request?;\n`;
+        indent.pop();
+    }
     body += `${indent.push().get()}let rsp = pipeline.send(&ctx, &mut ${initialRequestResult.requestVarName}, ${getPipelineOptions(indent, use, method)}).await?;\n`;
     const needsMutBody = isArmPutLro || isArmPatchLro || isArmPostLro || isArmDeleteLro;
     body += `${indent.get()}let (status, headers, ${needsMutBody ? 'mut' : ''} body) = rsp.deconstruct();\n`;