@azure-tools/typespec-rust 0.1.0 → 0.2.0

package/dist/src/codegen/clients.js

@@ -4,30 +4,38 @@
 *--------------------------------------------------------------------------------------------*/
 import * as codegen from '@azure-tools/codegen';
 import * as helpers from './helpers.js';
+import queryString from 'query-string';
 import { Use } from './use.js';
-// emits the content for all client files
-export function emitClients(crate) {
-    const clientFiles = new Array();
+import * as rust from '../codemodel/index.js';
+/**
+ * emits the content for all client files
+ *
+ * @param crate the crate for which to emit clients
+ * @param targetDir the directory to contain the client content
+ * @returns client content or undefined if the crate contains no clients
+ */
+export function emitClients(crate, targetDir) {
     if (crate.clients.length === 0) {
-        return clientFiles;
+        return undefined;
     }
+    const clientFiles = new Array();
     const clientMods = new Array();
     // emit the clients, one file per client
     for (const client of crate.clients) {
         const use = new Use();
-        const indentation = new helpers.indentation();
+        const indent = new helpers.indentation();
         let pubInClients = '';
         if (!client.constructable) {
             // the constructable client will need access to these fields
-            pubInClients = 'pub(in crate::generated::clients) ';
+            pubInClients = 'pub(crate) ';
         }
         let body = `pub struct ${client.name} {\n`;
         for (const field of client.fields) {
             use.addForType(field.type);
-            body += `${indentation.get()}${pubInClients}${field.name}: ${helpers.getTypeDeclaration(field.type)},\n`;
+            body += `${indent.get()}${pubInClients}${field.name}: ${helpers.getTypeDeclaration(field.type)},\n`;
         }
         use.addType('azure_core', 'Pipeline');
-        body += `${indentation.get()}${pubInClients}pipeline: Pipeline,\n`;
+        body += `${indent.get()}${pubInClients}pipeline: Pipeline,\n`;
         body += '}\n\n'; // end client
         if (client.constructable) {
             body += '#[derive(Clone, Debug)]\n';
@@ -36,7 +44,7 @@ export function emitClients(crate) {
                 body += ' {\n';
                 for (const field of client.constructable.options.type.fields) {
                     use.addForType(field.type);
-                    body += `${indentation.get()}${field.name}: ${helpers.getTypeDeclaration(field.type)},\n`;
+                    body += `${indent.get()}${helpers.emitPub(field.pub)}${field.name}: ${helpers.getTypeDeclaration(field.type)},\n`;
                 }
                 body += '}\n\n'; // end client options
             }
@@ -50,33 +58,33 @@ export function emitClients(crate) {
             use.addType('azure_core', 'Result');
             for (let i = 0; i < client.constructable.constructors.length; ++i) {
                 const constructor = client.constructable.constructors[i];
-                body += `${indentation.get()}pub fn ${constructor.name}(${getConstructorParamsSig(constructor.parameters, client.constructable.options, use)}) -> Result<Self> {\n`;
+                body += `${indent.get()}pub fn ${constructor.name}(${getConstructorParamsSig(constructor.parameters, client.constructable.options, use)}) -> Result<Self> {\n`;
                 // by convention, the endpoint param is always the first ctor param
                 const endpointParamName = constructor.parameters[0].name;
-                body += `${indentation.push().get()}let mut ${endpointParamName} = Url::parse(${endpointParamName}.as_ref())?;\n`;
-                body += `${indentation.get()}${endpointParamName}.query_pairs_mut().clear();\n`;
+                body += `${indent.push().get()}let mut ${endpointParamName} = Url::parse(${endpointParamName}.as_ref())?;\n`;
+                body += `${indent.get()}${endpointParamName}.set_query(None);\n`;
                 // if there's a credential param, create the necessary auth policy
                 const authPolicy = getAuthPolicy(constructor, use);
                 if (authPolicy) {
-                    body += `${indentation.get()}${authPolicy}\n`;
+                    body += `${indent.get()}${authPolicy}\n`;
                 }
-                body += `${indentation.get()}let options = options.unwrap_or_default();\n`;
-                body += `${indentation.get()}Ok(Self {\n`;
+                body += `${indent.get()}let options = options.unwrap_or_default();\n`;
+                body += `${indent.get()}Ok(Self {\n`;
                 // propagate any client option fields to the client initializer
-                indentation.push();
+                indent.push();
                 for (const field of getClientOptionsFields(client.constructable.options)) {
-                    body += `${indentation.get()}${field.name}: options.${field.name},\n`;
+                    body += `${indent.get()}${field.name}: options.${field.name},\n`;
                 }
-                body += `${indentation.get()}${endpointParamName},\n`;
-                body += `${indentation.get()}pipeline: Pipeline::new(\n`;
-                body += `${indentation.push().get()}option_env!("CARGO_PKG_NAME"),\n`;
-                body += `${indentation.get()}option_env!("CARGO_PKG_VERSION"),\n`;
-                body += `${indentation.get()}options.client_options,\n`;
-                body += `${indentation.get()}Vec::default(),\n`;
-                body += `${indentation.get()}${authPolicy ? 'vec![auth_policy]' : 'Vec::default()'},\n`;
-                body += `${indentation.pop().get()}),\n`; // end Pipeline::new
-                body += `${indentation.pop().get()}})\n`; // end Ok
-                body += `${indentation.pop().get()}}\n`; // end constructor
+                body += `${indent.get()}${endpointParamName},\n`;
+                body += `${indent.get()}pipeline: Pipeline::new(\n`;
+                body += `${indent.push().get()}option_env!("CARGO_PKG_NAME"),\n`;
+                body += `${indent.get()}option_env!("CARGO_PKG_VERSION"),\n`;
+                body += `${indent.get()}options.client_options,\n`;
+                body += `${indent.get()}Vec::default(),\n`;
+                body += `${indent.get()}${authPolicy ? 'vec![auth_policy]' : 'Vec::default()'},\n`;
+                body += `${indent.pop().get()}),\n`; // end Pipeline::new
+                body += `${indent.pop().get()}})\n`; // end Ok
+                body += `${indent.pop().get()}}\n`; // end constructor
                 // ensure extra new-line between ctors and/or client methods
                 if (i + 1 < client.constructable.constructors.length || client.methods.length > 0) {
                     body += '\n';
@@ -85,8 +93,8 @@ export function emitClients(crate) {
         }
         for (let i = 0; i < client.methods.length; ++i) {
             const method = client.methods[i];
-            let returnType;
-            let async = 'async ';
+            const returnType = helpers.getTypeDeclaration(method.returns);
+            let async = '';
             // NOTE: when methodBody is called, the starting indentation
             // will be correct for the current scope, so there's no need
             // for the callee to indent right away.
@@ -94,52 +102,47 @@ export function emitClients(crate) {
             use.addForType(method.returns);
             switch (method.kind) {
                 case 'async':
-                    returnType = helpers.getTypeDeclaration(method.returns);
+                    async = 'async ';
                     methodBody = (indentation) => {
                         return getAsyncMethodBody(indentation, use, client, method);
                     };
                     break;
+                case 'pageable':
+                    methodBody = (indentation) => {
+                        return getPageableMethodBody(indentation, use, client, method);
+                    };
+                    break;
                 case 'clientaccessor':
-                    async = '';
-                    returnType = method.returns.name;
                     methodBody = (indentation) => {
                         return getClientAccessorMethodBody(indentation, method);
                     };
                     break;
             }
-            body += `${indentation.get()}${helpers.formatDocComment(method.docs)}`;
-            body += `${indentation.get()}${helpers.emitPub(method.pub)}${async}fn ${method.name}(${getMethodParamsSig(method, use)}) -> ${returnType} {\n`;
-            body += `${indentation.push().get()}${methodBody(indentation)}\n`;
-            body += `${indentation.pop().get()}}\n`; // end method
+            body += `${indent.get()}${helpers.formatDocComment(method.docs)}`;
+            body += `${indent.get()}${helpers.emitPub(method.pub)}${async}fn ${method.name}(${getMethodParamsSig(method, use)}) -> ${returnType} {\n`;
+            body += `${indent.push().get()}${methodBody(indent)}\n`;
+            body += `${indent.pop().get()}}\n`; // end method
             if (i + 1 < client.methods.length) {
                 body += '\n';
             }
         }
         body += '}\n\n'; // end client impl
         if (client.constructable) {
-            // emit the builder function for client options
-            const clientOptionsType = client.constructable.options;
-            const builderTypeName = getOptionsBuilderTypeName(clientOptionsType, false);
-            body += `impl ${clientOptionsType.type.name} {\n`;
-            body += `${indentation.get()}pub fn builder() -> builders::${builderTypeName} {\n`;
-            body += `${indentation.push().get()}builders::${builderTypeName}::new()\n`;
-            body += `${indentation.pop().get()}}\n`;
-            body += '}\n\n'; // end impl
             // emit default trait impl for client options type
+            const clientOptionsType = client.constructable.options;
             body += `impl Default for ${clientOptionsType.type.name} {\n`;
-            body += `${indentation.get()}fn default() -> Self {\n`;
-            body += `${indentation.push().get()}Self {\n`;
-            indentation.push();
+            body += `${indent.get()}fn default() -> Self {\n`;
+            body += `${indent.push().get()}Self {\n`;
+            indent.push();
             for (const field of clientOptionsType.type.fields) {
                 if (!field.defaultValue) {
                     throw new Error(`missing default value for struct field ${clientOptionsType.type.name}.${field.name}`);
                 }
-                body += `${indentation.get()}${field.name}: ${field.defaultValue},\n`;
+                body += `${indent.get()}${field.name}: ${field.defaultValue},\n`;
             }
-            body += `${indentation.pop().get()}}\n`;
-            body += `${indentation.pop().get()}}\n`;
+            body += `${indent.pop().get()}}\n`;
+            body += `${indent.pop().get()}}\n`;
             body += '}\n\n'; // end impl
-            body += createClientOptionsBuilderImpl(indentation, clientOptionsType, use);
         }
         // emit method options
         for (let i = 0; i < client.methods.length; ++i) {
@@ -151,70 +154,99 @@ export function emitClients(crate) {
             body += `${helpers.emitPub(method.pub)}struct ${helpers.getTypeDeclaration(method.options.type)} {\n`;
             for (const field of method.options.type.fields) {
                 use.addForType(field.type);
-                body += `${indentation.get()}${field.name}: ${helpers.getTypeDeclaration(field.type)},\n`;
+                body += `${indent.get()}${helpers.emitPub(field.pub)}${field.name}: ${helpers.getTypeDeclaration(field.type)},\n`;
             }
             body += '}\n\n'; // end options
-            body += `impl${getLifetimeAnnotation(method.options.type)}${helpers.getTypeDeclaration(method.options.type)} {\n`;
-            body += `${indentation.get()}pub fn builder() -> builders::${getOptionsBuilderTypeName(method.options, true)} {\n`;
-            body += `${indentation.push().get()}builders::${getOptionsBuilderTypeName(method.options, false)}::new()\n`;
-            body += `${indentation.pop().get()}}\n`; // end builder()
-            body += '}\n'; // end options impl
+            if (method.kind === 'pageable') {
+                body += `impl${getLifetimeAnnotation(method.options.type)} ${helpers.getTypeDeclaration(method.options.type)} {\n`;
+                body += `${indent.get()}pub fn into_owned(self) -> ${method.options.type.name}<'static> {\n`;
+                body += `${indent.push().get()}${method.options.type.name} {\n`;
+                indent.push();
+                for (const field of method.options.type.fields) {
+                    if (field.type.kind === 'external' && field.type.name === 'ClientMethodOptions') {
+                        body += `${indent.get()}${field.name}: ClientMethodOptions {\n`;
+                        body += `${indent.push().get()}context: self.${field.name}.context.into_owned(),\n`;
+                        body += `${indent.pop().get()}},\n`;
+                        continue;
+                    }
+                    body += `${indent.get()}${field.name}: self.${field.name},\n`;
+                }
+                body += `${indent.pop().get()}}\n`;
+                body += `${indent.pop().get()}}\n`;
+                body += '}\n';
+            }
             if (i + 1 < client.methods.length) {
                 body += '\n';
             }
         }
         body += '\n';
-        body += createPubModBuilders(client, use);
         let content = helpers.contentPreamble();
         content += use.text();
         content += body;
         const clientMod = codegen.deconstruct(client.name).join('_');
-        clientFiles.push({ name: `${clientMod}.rs`, content: content });
-        clientMods.push(clientMod);
-    }
-    // now emit the mod.rs file for the clients
-    let content = helpers.contentPreamble();
-    const sortedMods = clientMods.sort((a, b) => { return helpers.sortAscending(a, b); });
-    for (const clientMod of sortedMods) {
-        content += `pub mod ${clientMod};\n`;
+        clientFiles.push({ name: `${targetDir}/${clientMod}.rs`, content: content });
+        clientMods.push(new rust.Module(clientMod, true));
     }
-    clientFiles.push({ name: 'mod.rs', content: content });
-    return clientFiles;
+    return { clients: clientFiles, modules: clientMods };
 }
+/**
+ * creates the parameter signature for a client constructor
+ * e.g. "foo: i32, bar: String, options: ClientOptions"
+ *
+ * @param params the params to include in the signature. can be empty
+ * @param options the client options type. will always be the last parameter
+ * @param use the use statement builder currently in scope
+ * @returns the client constructor params sig
+ */
 function getConstructorParamsSig(params, options, use) {
     const paramsSig = new Array();
     for (const param of params) {
         use.addForType(param.type);
-        paramsSig.push(`${param.name}: ${helpers.getTypeDeclaration(param.type)}`);
+        paramsSig.push(`${param.name}: ${param.ref ? '&' : ''}${helpers.getTypeDeclaration(param.type)}`);
     }
     paramsSig.push(`options: ${helpers.getTypeDeclaration(options)}`);
     return paramsSig.join(', ');
 }
+/**
+ * creates the parameter signature for a client method
+ * e.g. "foo: i32, bar: String, options: MethodOptions"
+ *
+ * @param method the Rust method for which to create the param sig
+ * @param use the use statement builder currently in scope
+ * @returns the method params sig
+ */
 function getMethodParamsSig(method, use) {
     const paramsSig = new Array();
     paramsSig.push(formatParamTypeName(method.self));
-    for (const param of method.params) {
-        if (param.type.kind === 'literal') {
-            // literal params are embedded directly in the code (e.g. accept header param)
-            continue;
-        }
-        // don't add client params to the method param sig
-        if (method.kind !== 'clientaccessor' && param.location === 'method') {
-            use.addForType(param.type);
-            paramsSig.push(`${param.name}: ${formatParamTypeName(param)}`);
-        }
-    }
+    // client accessors only have a self param so skip checking for params
     if (method.kind !== 'clientaccessor') {
+        for (const param of method.params) {
+            if (param.type.kind === 'literal') {
+                // literal params are embedded directly in the code (e.g. accept header param)
+                continue;
+            }
+            // don't add client or optional params to the method param sig
+            if (param.location === 'method' && !param.optional) {
+                use.addForType(param.type);
+                paramsSig.push(`${param.name}: ${formatParamTypeName(param)}`);
+            }
+        }
         paramsSig.push(`options: ${helpers.getTypeDeclaration(method.options, true)}`);
     }
     return paramsSig.join(', ');
 }
-// creates the auth policy if the ctor contains a credential param.
-// the policy will be named auth_policy.
+/**
+ * returns the auth policy instantiation code if the ctor contains a credential param.
+ * the policy will be a local var named auth_policy.
+ *
+ * @param ctor the constructor for which to instantiate an auth policy
+ * @param use the use statement builder currently in scope
+ * @returns the auth policy instantiation code or undefined if not required
+ */
 function getAuthPolicy(ctor, use) {
     for (const param of ctor.parameters) {
         if (param.type.kind === 'arc' && param.type.type.kind === 'tokenCredential') {
-            use.addType('azure_core', 'BearerTokenCredentialPolicy');
+            use.addTypes('azure_core', ['BearerTokenCredentialPolicy', 'Policy']);
             const scopes = new Array();
             for (const scope of param.type.type.scopes) {
                 scopes.push(`"${scope}"`);
@@ -224,6 +256,13 @@ function getAuthPolicy(ctor, use) {
     }
     return undefined;
 }
+/**
+ * returns the complete text for the provided parameter's type
+ * e.g. self, &String, mut SomeStruct
+ *
+ * @param param the parameter for which to create the
+ * @returns the parameter's type declaration
+ */
 function formatParamTypeName(param) {
     let format = '';
     if (param.ref) {
@@ -232,118 +271,39 @@ function formatParamTypeName(param) {
     if (param.mut) {
         format += 'mut ';
     }
-    if (param.type) {
-        format += helpers.getTypeDeclaration(param.type);
+    if (param.kind) {
+        const methodParam = param;
+        let paramType = methodParam.type;
+        if (methodParam.kind === 'partialBody') {
+            // for partial body params, methodParam.type is the model type that's
+            // sent in the request. we want the field within the model for this param.
+            const field = methodParam.type.type.fields.find(f => { return f.name === methodParam.name; });
+            if (!field) {
+                throw new Error(`didn't find spread param field ${methodParam.name} in type ${methodParam.type.type.name}`);
+            }
+            paramType = field.type;
+            if (paramType.kind === 'option') {
+                // this is the case where the spread param maps to a non-internal model.
+                // for this case, we unwrap the Option<T> to get the underlying type.
+                paramType = paramType.type;
+            }
+        }
+        format += helpers.getTypeDeclaration(paramType);
     }
     else {
         format += param.name;
     }
     return format;
 }
-function createClientOptionsBuilderImpl(indentation, options, use) {
-    use.addType('azure_core::builders', 'ClientOptionsBuilder');
-    use.addTypes('azure_core', ['Policy', 'RetryOptions', /*'TelemetryOptions', */ 'TransportOptions']);
-    use.addType('std::sync', 'Arc');
-    const emitWithMethod = function (indentation, name, into) {
-        let withPolicies = `${indentation.get()}fn with_${name}<P>(mut self, ${name}: P) -> Self `;
-        withPolicies += `where P: Into<${into}>, Self: Sized {\n`;
-        withPolicies += `${indentation.push().get()}self.client_options.set_${name}(${name});\n`;
-        withPolicies += `${indentation.get()}self\n`;
-        withPolicies += `${indentation.pop().get()}}\n\n`;
-        return withPolicies;
-    };
-    let implBuilder = `impl ClientOptionsBuilder for ${options.type.name} {\n`;
-    implBuilder += emitWithMethod(indentation, 'per_call_policies', 'Vec<Arc<dyn Policy>>');
-    implBuilder += emitWithMethod(indentation, 'per_try_policies', 'Vec<Arc<dyn Policy>>');
-    implBuilder += emitWithMethod(indentation, 'retry', 'RetryOptions');
-    // TODO: https://github.com/Azure/azure-sdk-for-rust/issues/1753
-    //implBuilder += emitWithMethod(indentation, 'telemetry', 'TelemetryOptions');
-    implBuilder += emitWithMethod(indentation, 'transport', 'TransportOptions');
-    implBuilder += '}\n\n';
-    return implBuilder;
-}
-function createPubModBuilders(client, use) {
-    const indentation = new helpers.indentation();
-    let body = 'pub mod builders {\n';
-    body += `${indentation.get()}use super::*;\n\n`;
-    const emitNewFunction = function (indentation, options) {
-        let newFunction = `${indentation.push().get()}pub(super) fn new() -> Self {\n`;
-        newFunction += `${indentation.push().get()}Self {\n`;
-        newFunction += `${indentation.push().get()}options: ${options.type.name}::default(),\n`;
-        newFunction += `${indentation.pop().get()}}\n`;
-        newFunction += `${indentation.pop().get()}}\n\n`;
-        return newFunction;
-    };
-    const emitBuildMethod = function (indentation, options) {
-        let buildMethod = `${indentation.get()}pub fn build(&self) -> ${options.type.name} {\n`;
-        buildMethod += `${indentation.push().get()}self.options.clone()\n`;
-        buildMethod += `${indentation.pop().get()}}\n`;
-        return buildMethod;
-    };
-    if (client.constructable) {
-        // emit the builder type for client options
-        const clientOptionsType = client.constructable.options;
-        const builderTypeName = getOptionsBuilderTypeName(clientOptionsType, false);
-        body += `${indentation.get()}pub struct ${builderTypeName} {\n`;
-        body += `${indentation.push().get()}options: ${clientOptionsType.type.name},\n`;
-        body += `${indentation.pop().get()}}\n\n`; // end struct
-        body += `${indentation.get()}impl ${builderTypeName} {\n`;
-        body += emitNewFunction(indentation, clientOptionsType);
-        body += emitBuildMethod(indentation, clientOptionsType);
-        for (const field of getClientOptionsFields(client.constructable.options)) {
-            let typeName = helpers.getTypeDeclaration(field.type);
-            let into = '';
-            if (field.type.kind === 'String') {
-                // for Strings, we define these as "impl Into<String>" so that passing a str will just work
-                typeName = `impl Into<${typeName}>`;
-                into = '.into()';
-            }
-            body += `\n${indentation.get()}pub fn with_${field.name}(mut self, ${field.name}: ${typeName}) -> Self {\n`;
-            body += `${indentation.push().get()}self.options.${field.name} = ${field.name}${into};\n`;
-            body += `${indentation.get()}self\n`;
-            body += `${indentation.pop().get()}}\n`;
-        }
-        body += `${indentation.pop().get()}}\n\n`; // end impl
-    }
-    // emit the client method options builders
-    for (let i = 0; i < client.methods.length; ++i) {
-        const method = client.methods[i];
-        if (method.kind === 'clientaccessor') {
-            continue;
-        }
-        use.addType('azure_core', 'Context');
-        use.addType('azure_core::builders', 'ClientMethodOptionsBuilder');
-        const optionsBuilderTypeName = getOptionsBuilderTypeName(method.options, true);
-        body += `${indentation.get()}pub struct ${optionsBuilderTypeName} {\n`;
-        body += `${indentation.push().get()}options: ${helpers.getTypeDeclaration(method.options.type)},\n`;
-        body += `${indentation.pop().get()}}\n\n`; // end struct
-        body += `${indentation.get()}impl ${getOptionsBuilderTypeName(method.options, 'anonymous')} {\n`;
-        body += emitNewFunction(indentation, method.options);
-        body += emitBuildMethod(indentation, method.options);
-        body += `${indentation.pop().get()}}\n\n`; // end impl
-        body += `${indentation.get()}impl${getLifetimeAnnotation(method.options.type)}ClientMethodOptionsBuilder${getLifetimeAnnotation(method.options.type)}for ${optionsBuilderTypeName} {\n`;
-        body += `${indentation.push().get()}fn with_context(mut self, context: &${getLifetimeName(method.options.type)}Context) -> Self {\n`;
-        body += `${indentation.push().get()}self.options.${getClientMethodOptionsFieldName(method.options)}.set_context(context);\n`;
-        body += `${indentation.get()}self\n`;
-        body += `${indentation.pop().get()}}\n`; // end with_context
-        body += `${indentation.pop().get()}}\n`; // end ClientMethodOptionsBuilder impl
-        if (i + 1 < client.methods.length) {
-            body += '\n';
-        }
-    }
-    body += '}\n'; // end pub mod builders
-    return body;
-}
-function getOptionsBuilderTypeName(option, withLifetime) {
-    if (!withLifetime || !option.type.lifetime) {
-        return `${option.type.name}Builder`;
-    }
-    else if (withLifetime === 'anonymous') {
-        return `${option.type.name}Builder${helpers.AnonymousLifetimeAnnotation}`;
-    }
-    return `${option.type.name}Builder${helpers.getGenericLifetimeAnnotation(option.type.lifetime)}`;
-}
-// returns a filtered array of struct fields from the client options types
+/**
+ * returns a subset of struct fields from the client options types.
+ * at present, only the core ClientOptions field is omitted.
+ *
+ * can return an empty array if there are no client options.
+ *
+ * @param option the client options type to enumerate
+ * @returns the subset of struct fields
+ */
 function getClientOptionsFields(option) {
     const fields = new Array();
     for (const field of option.type.fields) {
@@ -355,27 +315,12 @@ function getClientOptionsFields(option) {
     }
     return fields;
 }
-function getClientMethodOptionsFieldName(option) {
-    for (const field of option.type.fields) {
-        // startsWith to ignore possible lifetime annotation suffix
-        if (helpers.getTypeDeclaration(field.type).startsWith('ClientMethodOptions')) {
-            return field.name;
-        }
-    }
-    throw new Error(`didn't find ClientMethodOptions field in ${option.type.name}`);
-}
-function getLifetimeAnnotation(type) {
-    if (type.lifetime) {
-        return `${helpers.getGenericLifetimeAnnotation(type.lifetime)} `;
-    }
-    return ' ';
-}
-function getLifetimeName(type) {
-    if (type.lifetime) {
-        return `${type.lifetime.name} `;
-    }
-    return ' ';
-}
+/**
+ * returns the name of the endpoint field within the client
+ *
+ * @param client the client in which to find the endpoint field
+ * @returns the name of the endpoint field
+ */
 function getEndpointFieldName(client) {
     // find the endpoint field. it's the only one that's
     // a Url. the name will be uniform across clients
@@ -393,29 +338,43 @@ function getEndpointFieldName(client) {
     }
     return endpointFieldName;
 }
-function getClientAccessorMethodBody(indentation, clientAccessor) {
+/**
+ * constructs the body for a client accessor method
+ *
+ * @param indent the indentation helper currently in scope
+ * @param clientAccessor the client accessor for which to construct the body
+ * @returns the contents of the method body
+ */
+function getClientAccessorMethodBody(indent, clientAccessor) {
     let body = `${clientAccessor.returns.name} {\n`;
     const endpointFieldName = getEndpointFieldName(clientAccessor.returns);
-    body += `${indentation.push().get()}${endpointFieldName}: self.${endpointFieldName}.clone(),\n`;
-    body += `${indentation.get()}pipeline: self.pipeline.clone(),\n`;
-    body += `${indentation.pop().get()}}`;
+    body += `${indent.push().get()}${endpointFieldName}: self.${endpointFieldName}.clone(),\n`;
+    body += `${indent.get()}pipeline: self.pipeline.clone(),\n`;
+    body += `${indent.pop().get()}}`;
     return body;
 }
-function getAsyncMethodBody(indentation, use, client, method) {
-    use.addTypes('azure_core', ['AsClientMethodOptions', 'Method', 'Request']);
-    let body = 'let options = options.unwrap_or_default();\n';
-    body += `${indentation.get()}let mut ctx = options.method_options.context();\n`;
-    body += `${indentation.get()}let mut url = self.${getEndpointFieldName(client)}.clone();\n`;
+/**
+ * enumerates method parameters and returns them based on groups
+ *
+ * @param method the method containing the parameters to group
+ * @returns the groups parameters
+ */
+function getMethodParamGroup(method) {
     // collect and sort all the header/path/query params
     const headerParams = new Array();
     const pathParams = new Array();
     const queryParams = new Array();
+    const partialBodyParams = new Array();
     for (const param of method.params) {
         switch (param.kind) {
             case 'header':
             case 'headerCollection':
+            case 'headerHashMap':
                 headerParams.push(param);
                 break;
+            case 'partialBody':
+                partialBodyParams.push(param);
+                break;
             case 'path':
                 pathParams.push(param);
                 break;
@@ -428,65 +387,322 @@ function getAsyncMethodBody(indentation, use, client, method) {
     headerParams.sort((a, b) => { return helpers.sortAscending(a.header, b.header); });
     pathParams.sort((a, b) => { return helpers.sortAscending(a.segment, b.segment); });
     queryParams.sort((a, b) => { return helpers.sortAscending(a.key, b.key); });
-    let path = `"${method.httpPath}"`;
-    if (pathParams.length > 0) {
+    let bodyParam;
+    for (const param of method.params) {
+        if (param.kind === 'body') {
+            if (bodyParam) {
+                throw new Error(`method ${method.name} has multiple body parameters`);
+            }
+            bodyParam = param;
+        }
+    }
+    return {
+        body: bodyParam,
+        header: headerParams,
+        partialBody: partialBodyParams,
+        path: pathParams,
+        query: queryParams,
+    };
+}
+/**
+ * wraps the emitted code emitted by setter in a "let Some" block
+ * if the parameter is optional, else the value of setter is returned.
+ *
+ * NOTE: for optional params, by convention, we'll create a local named param.name.
+ * setter MUST reference by param.name so it works for optional and required params.
+ *
+ * @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
+ * @returns
+ */
+function getParamValueHelper(indent, param, 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}`,
+            body: setter,
+        });
+        return op + '\n';
+    }
+    return setter();
+}
+/**
+ * emits the code for building the request URL.
+ * assumes that there's a mutable local var 'url'
+ *
+ * @param indent the indentation helper currently in scope
+ * @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
+ * @returns the URL construction code
+ */
+function constructUrl(indent, use, method, paramGroups, fromSelf = true) {
+    // for paths that contain query parameters, we must set the query params separately.
+    // 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');
+    }
+    let body = '';
+    let path = `"${pathChunks[0]}"`;
+    if (paramGroups.path.length > 0) {
         // we have path params that need to have their segments replaced with the param values
-        body += `${indentation.get()}let mut path = String::from(${path});\n`;
-        for (const pathParam of pathParams) {
-            body += `${indentation.get()}path = path.replace("{${pathParam.segment}}", &${getHeaderPathQueryParamValue(pathParam)});\n`;
+        body += `${indent.get()}let mut path = String::from(${path});\n`;
+        for (const pathParam of paramGroups.path) {
+            body += `${indent.get()}path = path.replace("{${pathParam.segment}}", &${getHeaderPathQueryParamValue(use, pathParam, fromSelf)});\n`;
         }
         path = '&path';
     }
-    body += `${indentation.get()}url.set_path(${path});\n`;
-    for (const queryParam of queryParams) {
+    body += `${indent.get()}url.set_path(${path});\n`;
+    if (pathChunks.length === 2) {
+        body += `${indent.get()}url.query_pairs_mut()`;
+        // set the query params that were in the path
+        const qps = queryString.parse(pathChunks[1]);
+        for (const qp of Object.keys(qps)) {
+            const val = qps[qp];
+            if (val) {
+                if (typeof val === 'string') {
+                    body += `.append_pair("${qp}", "${val}")`;
+                }
+                else {
+                    for (const v of val) {
+                        body += `.append_pair("${qp}", "${v}")`;
+                    }
+                }
+            }
+            else {
+                body += `.append_key_only("${qp}")`;
+            }
+        }
+        body += ';\n';
+    }
+    for (const queryParam of paramGroups.query) {
         if (queryParam.kind === 'queryCollection' && queryParam.format === 'multi') {
-            const valueVar = queryParam.name[0];
-            body += `${indentation.get()}for ${valueVar} in ${queryParam.name}.iter() {\n`;
-            body += `${indentation.push().get()}url.query_pairs_mut().append_pair("${queryParam.key}", ${valueVar});\n`;
-            body += `${indentation.pop().get()}}\n`;
+            body += getParamValueHelper(indent, queryParam, () => {
+                const valueVar = queryParam.name[0];
+                let text = `${indent.get()}for ${valueVar} in ${queryParam.name}.iter() {\n`;
+                text += `${indent.push().get()}url.query_pairs_mut().append_pair("${queryParam.key}", ${valueVar});\n`;
+                text += `${indent.pop().get()}}\n`;
+                return text;
+            });
         }
         else {
-            body += `${indentation.get()}url.query_pairs_mut().append_pair("${queryParam.key}", &${getHeaderPathQueryParamValue(queryParam)});\n`;
+            body += getParamValueHelper(indent, queryParam, () => {
+                return `${indent.get()}url.query_pairs_mut().append_pair("${queryParam.key}", &${getHeaderPathQueryParamValue(use, queryParam, fromSelf)});\n`;
+            });
         }
     }
-    body += `${indentation.get()}let mut request = Request::new(url, Method::${codegen.capitalize(method.httpMethod)});\n`;
-    for (const headerParam of headerParams) {
-        body += `${indentation.get()}request.insert_header("${headerParam.header.toLowerCase()}", ${getHeaderPathQueryParamValue(headerParam)});\n`;
+    return body;
+}
+/**
+ * emits the code for building the HTTP request.
+ * assumes that there's a local var 'url' which is the Url.
+ * creates a mutable local 'request' which is the Request instance.
+ *
+ * @param indent the indentation helper currently in scope
+ * @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
+ * @returns the request construction code
+ */
+function constructRequest(indent, use, method, paramGroups, fromSelf = true) {
+    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 (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;
+            }
+            return `${indent.get()}request.insert_header("${headerParam.header.toLowerCase()}", ${getHeaderPathQueryParamValue(use, headerParam, fromSelf)});\n`;
+        });
     }
-    const bodyParam = getBodyParameter(method);
+    const bodyParam = paramGroups.body;
     if (bodyParam) {
-        body += `${indentation.get()}request.set_body(${bodyParam.name});\n`;
+        body += getParamValueHelper(indent, bodyParam, () => {
+            return `${indent.get()}request.set_body(${bodyParam.name});\n`;
+        });
+    }
+    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);
+        body += `${indent.get()}let body: ${helpers.getTypeDeclaration(requestContentType)} = ${requestContentType.type.name} {\n`;
+        indent.push();
+        for (const partialBodyParam of paramGroups.partialBody) {
+            if (partialBodyParam.type.type !== requestContentType.type) {
+                throw new Error(`spread param ${partialBodyParam.name} has conflicting model type ${partialBodyParam.type.type.name}, expected model type ${requestContentType.type.name}`);
+            }
+            let initializer = partialBodyParam.name;
+            if (partialBodyParam.optional) {
+                initializer = `${partialBodyParam.name}: options.${partialBodyParam.name}`;
+            }
+            else if (!requestContentType.type.internal) {
+                // spread param maps to a non-internal model, so it must be wrapped in Some()
+                initializer = `${partialBodyParam.name}: Some(${partialBodyParam.name})`;
+            }
+            body += `${indent.get()}${initializer},\n`;
+        }
+        body += `${indent.pop().get()}}.try_into()?;\n`;
+        body += `${indent.get()}request.set_body(body);\n`;
     }
-    body += `${indentation.get()}self.pipeline.send(&mut ctx, &mut request).await\n`;
     return body;
 }
-function getBodyParameter(method) {
-    let bodyParam;
+/**
+ * constructs the body for an async client method
+ *
+ * @param indent the indentation helper currently in scope
+ * @param use the use statement builder currently in scope
+ * @param client the client to which the method belongs
+ * @param method the method for the body to build
+ * @returns the contents of the method body
+ */
+function getAsyncMethodBody(indent, use, client, method) {
+    use.addTypes('azure_core', ['AsClientMethodOptions', 'Method', 'Request']);
+    let body = 'let options = options.unwrap_or_default();\n';
+    body += `${indent.get()}let mut ctx = options.method_options.context();\n`;
+    body += `${indent.get()}let mut url = self.${getEndpointFieldName(client)}.clone();\n`;
+    const paramGroups = getMethodParamGroup(method);
+    body += constructUrl(indent, use, method, paramGroups);
+    body += constructRequest(indent, use, method, paramGroups);
+    body += `${indent.get()}self.pipeline.send(&mut ctx, &mut request).await\n`;
+    return body;
+}
+/**
+ * constructs the body for a pageable client method
+ *
+ * @param indent the indentation helper currently in scope
+ * @param use the use statement builder currently in scope
+ * @param client the client to which the method belongs
+ * @param method the method for the body to build
+ * @returns the contents of the method body
+ */
+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');
+    }
+    const nextLinkName = method.strategy.nextLinkName;
+    use.addTypes('azure_core', ['Method', 'Pager', 'Request', 'Response', 'Result', 'Url']);
+    use.addType('typespec_client_core::http', 'PagerResult');
+    use.addType('typespec_client_core', 'json');
+    use.addForType(method.returns.type.type);
+    const paramGroups = getMethodParamGroup(method);
+    let body = 'let options = options.unwrap_or_default().into_owned();\n';
+    body += `${indent.get()}let endpoint = self.${getEndpointFieldName(client)}.clone();\n`;
+    body += `${indent.get()}let pipeline = self.pipeline.clone();\n`;
+    // clone any other client params
     for (const param of method.params) {
-        if (param.kind === 'body') {
-            if (bodyParam) {
-                throw new Error(`method ${method.name} has multiple body parameters`);
-            }
-            bodyParam = param;
+        if (param.location === 'client') {
+            body += `${indent.get()}let ${param.name} = self.${param.name}.clone();\n`;
         }
     }
-    return bodyParam;
+    body += `${indent.get()}Ok(Pager::from_callback(move |${nextLinkName}: Option<Url>| {\n`;
+    body += `${indent.push().get()}let mut url: Url;\n`;
+    body += indent.get() + helpers.buildMatch(indent, nextLinkName, [{
+            pattern: `Some(${nextLinkName})`,
+            body: (indent) => `${indent.get()}url = ${nextLinkName};\n`
+        }, {
+            pattern: 'None',
+            body: (indent) => {
+                let none = `${indent.get()}url = endpoint.clone();\n`;
+                none += constructUrl(indent, use, method, paramGroups, false);
+                return none;
+            }
+        }]);
+    body += ';\n';
+    // here we want the T in Pager<T>
+    const returnType = helpers.getTypeDeclaration(method.returns.type.type);
+    body += constructRequest(indent, use, method, paramGroups, false);
+    body += `${indent.get()}let mut 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(&mut 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}),\n`
+        }, {
+            pattern: 'None',
+            returns: 'PagerResult::Complete',
+            body: () => `${indent.get()}response: (rsp),\n`
+        }])}`;
+    body += ')\n'; // end Ok
+    body += `${indent.pop().get()}}\n`; // end async move
+    body += `${indent.pop().get()}}))`; // end Ok/Pager::from_callback
+    return body;
 }
-function getHeaderPathQueryParamValue(param) {
+/**
+ * contains the code to use when populating a header/path/query value
+ * from a parameter of that type.
+ *
+ * if the param's type is a String, then the return value is simply the
+ * param's name. the non-String cases require some kind of conversion.
+ * this could simply be a to_string() call, e.g. "paramName.to_string()".
+ * other cases might be more complex.
+ *
+ * @param use the use statement builder currently in scope
+ * @param param the param for which to get the value
+ * @param fromSelf applicable for client params. when true, the prefix "self." is included
+ * @returns
+ */
+function getHeaderPathQueryParamValue(use, param, fromSelf = true) {
     let paramName = '';
-    if (param.location === 'client') {
+    // when fromSelf is false we assume that there's a local with the same name.
+    // e.g. in pageable methods where we need to clone the params so they can be
+    // passed to a future that can outlive the calling method.
+    if (param.location === 'client' && fromSelf) {
         paramName = 'self.';
     }
+    const encodeBytes = function (type, param) {
+        use.addType('azure_core', 'base64');
+        let encoding;
+        switch (type.encoding) {
+            case 'std':
+                encoding = 'base64::encode';
+                break;
+            case 'url':
+                encoding = 'base64::encode_url_safe';
+                break;
+        }
+        return `${encoding}(${param})`;
+    };
     if (param.kind === 'headerCollection' || param.kind === 'queryCollection') {
         if (param.format === 'multi') {
             throw new Error('multi should have been handled outside getHeaderPathQueryParamValue');
         }
-        return `${param.name}.join("${getCollectionDelimiter(param.format)}")`;
+        else if (param.type.type.kind === 'String') {
+            return `${param.name}.join("${getCollectionDelimiter(param.format)}")`;
+        }
+        // convert the items to strings
+        let strConv = 'i.to_string()';
+        if (param.type.type.kind === 'encodedBytes') {
+            strConv = encodeBytes(param.type.type, 'i');
+        }
+        return `${param.name}.iter().map(|i| ${strConv}).collect::<Vec<String>>().join("${getCollectionDelimiter(param.format)}")`;
     }
     switch (param.type.kind) {
         case 'String':
             paramName += param.name;
             break;
+        case 'encodedBytes':
+            return encodeBytes(param.type, param.name);
+        case 'enum':
+        case 'hashmap':
+        case 'offsetDateTime':
+        case 'scalar':
+            paramName += `${param.name}.to_string()`;
+            break;
         case 'implTrait':
             // only done for method params so no need to include paramName prefix
             return `${param.name}.into()`;
@@ -497,6 +713,12 @@ function getHeaderPathQueryParamValue(param) {
     }
     return paramName;
 }
+/**
+ * returns the delimiter character for the provided format type
+ *
+ * @param format the format collection type
+ * @returns the delimiter character
+ */
 function getCollectionDelimiter(format) {
     switch (format) {
         case 'csv':
@@ -507,8 +729,19 @@ function getCollectionDelimiter(format) {
             return ' ';
         case 'tsv':
             return '\t';
-        default:
-            throw new Error(`unhandled collection format ${format}`);
     }
 }
+/**
+ * returns the lifetime annotation for the provide struct.
+ * can return the empty string if the struct has no lifetime.
+ *
+ * @param type the struct for which to get the annotation
+ * @returns the annotation or empty string
+ */
+function getLifetimeAnnotation(type) {
+    if (type.lifetime) {
+        return `${helpers.getGenericLifetimeAnnotation(type.lifetime)}`;
+    }
+    return '';
+}
 //# sourceMappingURL=clients.js.map