@azure-tools/typespec-rust 0.24.1 → 0.25.0

package/dist/src/tcgcadapter/adapter.js

@@ -60,7 +60,6 @@ export class Adapter {
     constructor(ctx, options) {
         this.types = new Map();
         this.clientMethodParams = new Map();
-        this.renamedMethods = new Set();
         this.fieldsMap = new Map();
         this.ctx = ctx;
         this.options = options;
@@ -133,7 +132,7 @@ export class Adapter {
      */
     getEnum(sdkEnum) {
         var _a;
-        const enumName = codegen.capitalize(sdkEnum.name);
+        const enumName = codegen.deconstruct(sdkEnum.name).map((each) => codegen.capitalize(each)).join('');
         let rustEnum = this.types.get(enumName);
         if (rustEnum) {
             return rustEnum;
@@ -503,6 +502,11 @@ export class Adapter {
                 return this.getStringType();
             }
             case 'nullable':
+                if (type.type.kind === 'model' && type.type.isGeneratedName) {
+                    // if the nullable type's target type is a synthesized
+                    // type, we need to propagate the docs to it
+                    type.type.doc = type.doc;
+                }
                 // TODO: workaround until https://github.com/Azure/typespec-rust/issues/42 is fixed
                 return this.getType(type.type, stack);
             case 'offsetDateTime': {
@@ -780,7 +784,7 @@ export class Adapter {
      * @returns a Rust client
      */
     recursiveAdaptClient(client, parent) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         let clientName = client.name;
         // NOTE: if the client has the @clientName decorator applied then use that verbatim
         if (parent && !hasClientNameDecorator(client.decorators)) {
@@ -826,30 +830,35 @@ export class Adapter {
             (function (AuthTypes) {
                 AuthTypes[AuthTypes["Default"] = 0] = "Default";
                 AuthTypes[AuthTypes["NoAuth"] = 1] = "NoAuth";
-                AuthTypes[AuthTypes["WithAut"] = 2] = "WithAut";
+                AuthTypes[AuthTypes["WithAuth"] = 2] = "WithAuth";
             })(AuthTypes || (AuthTypes = {}));
             let authType = AuthTypes.Default;
             /**
              * processes a credential, potentially adding its supporting client constructor
              *
+             * @param rustClient the client for which the constructor will be added
+             * @param param the tsp parameter that contains cred
              * @param cred the credential type to process
              * @param constructable the constructable for the current Rust client
-             * @param throwOnDefault when true, throws an error on unsupported credential types
              * @returns the AuthTypes enum for the credential that was handled, or AuthTypes.Default if none were
              */
-            const processCredential = (rustClient, cred, constructable, throwOnDefault) => {
+            const processCredential = (rustClient, param, cred, constructable) => {
+                var _a, _b;
                 switch (cred.type) {
                     case 'noAuth':
                         return AuthTypes.NoAuth;
                     case 'oauth2': {
                         constructable.constructors.push(this.createTokenCredentialCtor(rustClient, cred));
-                        return AuthTypes.WithAut;
+                        return AuthTypes.WithAuth;
                     }
                     default:
-                        if (throwOnDefault) {
-                            throw new AdapterError('UnsupportedTsp', `credential scheme type ${cred.type} NYI`);
-                        }
-                        return AuthTypes.Default;
+                        this.ctx.program.reportDiagnostic({
+                            code: 'UnsupportedAuthenticationScheme',
+                            severity: 'warning',
+                            message: `authentication scheme ${cred.type} is not supported`,
+                            target: (_b = (_a = param.__raw) === null || _a === void 0 ? void 0 : _a.node) !== null && _b !== void 0 ? _b : NoTarget,
+                        });
+                        return AuthTypes.WithAuth;
                 }
             };
             const ctorParams = new Array();
@@ -858,7 +867,7 @@ export class Adapter {
                     case 'credential':
                         switch (param.type.kind) {
                             case 'credential':
-                                authType |= processCredential(rustClient, param.type.scheme, rustClient.constructable, true);
+                                authType |= processCredential(rustClient, param, param.type.scheme, rustClient.constructable);
                                 break;
                             case 'union': {
                                 const variantKinds = new Array();
@@ -867,13 +876,8 @@ export class Adapter {
                                     // if OAuth2 is specified then emit that and skip any unsupported ones.
                                     // this prevents emitting the with_no_credential constructor in cases
                                     // where it might not actually be supported.
-                                    authType |= processCredential(rustClient, variantType.scheme, rustClient.constructable, false);
-                                }
-                                // no supported credential types were specified
-                                if (authType === AuthTypes.Default) {
-                                    throw new AdapterError('UnsupportedTsp', `credential scheme types ${variantKinds.join()} NYI`, (_a = param.__raw) === null || _a === void 0 ? void 0 : _a.node);
+                                    authType |= processCredential(rustClient, param, variantType.scheme, rustClient.constructable);
                                 }
-                                continue;
                             }
                         }
                         break;
@@ -912,26 +916,16 @@ export class Adapter {
                                 // there's either a suffix on the endpoint param, more template arguments, or both.
                                 // either way we need to create supplemental info on the constructable.
                                 // NOTE: we remove the {endpoint} segment and trailing forward slash as we use
-                                // Url::join to concatenate the two and not string replacement.
-                                let serverUrl = endpointType.serverUrl.replace(`{${templateArg.serializedName}}/`, '');
-                                // NOTE: the behavior of Url::join requires that the path ends with a forward slash.
-                                // if there are any query params, splice it in as required else just append it.
-                                if (serverUrl.includes('?')) {
-                                    if (serverUrl[serverUrl.indexOf('?') - 1] !== '/') {
-                                        serverUrl = serverUrl.replace('?', '/?');
-                                    }
-                                }
-                                else if (serverUrl[serverUrl.length - 1] !== '/') {
-                                    serverUrl += '/';
-                                }
+                                // UrlExt::append_path() to concatenate the two and not string replacement.
+                                const serverUrl = endpointType.serverUrl.replace(`{${templateArg.serializedName}}/`, '');
                                 rustClient.constructable.endpoint = new rust.SupplementalEndpoint(serverUrl);
                                 continue;
                             }
                             const clientParam = this.adaptClientParameter(templateArg, rustClient.constructable);
                             if (clientParam.kind !== 'clientSupplementalEndpoint') {
-                                throw new AdapterError('InternalError', `unexpected client parameter kind ${clientParam.kind}`, (_b = templateArg.__raw) === null || _b === void 0 ? void 0 : _b.node);
+                                throw new AdapterError('InternalError', `unexpected client parameter kind ${clientParam.kind}`, (_a = templateArg.__raw) === null || _a === void 0 ? void 0 : _a.node);
                             }
-                            (_c = rustClient.constructable.endpoint) === null || _c === void 0 ? void 0 : _c.parameters.push(clientParam);
+                            (_b = rustClient.constructable.endpoint) === null || _b === void 0 ? void 0 : _b.parameters.push(clientParam);
                             ctorParams.push(clientParam);
                         }
                         break;
@@ -991,7 +985,7 @@ export class Adapter {
                     code: 'LroPagingNotSupported',
                     severity: 'warning',
                     message: `skip emitting Paging LRO ${method.name}`,
-                    target: (_e = (_d = method.__raw) === null || _d === void 0 ? void 0 : _d.node) !== null && _e !== void 0 ? _e : NoTarget,
+                    target: (_d = (_c = method.__raw) === null || _c === void 0 ? void 0 : _c.node) !== null && _d !== void 0 ? _d : NoTarget,
                 });
                 continue;
             }
@@ -1112,13 +1106,17 @@ export class Adapter {
      * @param rustClient the client to which the method belongs
      */
     adaptMethod(method, rustClient) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
         let srcMethodName = method.name;
         if (method.kind === 'paging' && !srcMethodName.match(/^list/i)) {
             const chunks = codegen.deconstruct(srcMethodName);
-            chunks[0] = 'list';
+            if (chunks[0] === 'get') {
+                chunks[0] = 'list';
+            }
+            else {
+                chunks.unshift('list');
+            }
             srcMethodName = codegen.camelCase(chunks);
-            this.renamedMethods.add(srcMethodName);
             this.ctx.program.reportDiagnostic({
                 code: 'PagingMethodRename',
                 severity: 'warning',
@@ -1126,13 +1124,18 @@ export class Adapter {
                 target: (_b = (_a = method.__raw) === null || _a === void 0 ? void 0 : _a.node) !== null && _b !== void 0 ? _b : NoTarget,
             });
         }
-        else if (this.renamedMethods.has(srcMethodName)) {
-            throw new AdapterError('NameCollision', `method name ${srcMethodName} collides with a renamed method`, (_c = method.__raw) === null || _c === void 0 ? void 0 : _c.node);
-        }
         const languageIndependentName = method.crossLanguageDefinitionId;
         const methodName = naming.getEscapedReservedName(snakeCaseName(srcMethodName), 'fn');
+        if (srcMethodName !== method.name) {
+            // if the method was renamed then ensure it doesn't collide
+            for (const existingMethod of rustClient.methods) {
+                if (existingMethod.name === methodName) {
+                    throw new AdapterError('NameCollision', `renamed method ${srcMethodName} collides with an existing method`, (_c = method.__raw) === null || _c === void 0 ? void 0 : _c.node);
+                }
+            }
+        }
         const optionsLifetime = new rust.Lifetime('a');
-        const methodOptionsStruct = new rust.Struct(`${rustClient.name}${codegen.pascalCase(srcMethodName)}Options`, 'pub');
+        const methodOptionsStruct = new rust.Struct(`${rustClient.name}${codegen.pascalCase(srcMethodName, false)}Options`, 'pub');
         methodOptionsStruct.lifetime = optionsLifetime;
         methodOptionsStruct.docs.summary = `Options to be passed to ${this.asDocLink(`${rustClient.name}::${methodName}()`, `crate::generated::clients::${rustClient.name}::${methodName}()`)}`;
         const clientMethodOptions = new rust.ExternalType(this.crate, 'ClientMethodOptions', 'azure_core::http');
@@ -1149,27 +1152,16 @@ export class Adapter {
         const pub = method.access === 'public' ? 'pub' : 'pubCrate';
         const methodOptions = new rust.MethodOptions(methodOptionsStruct);
         const httpMethod = method.operation.verb;
-        // if path is more than just "/" strip off any leading forward slash.
-        // this is because Url::join will treat the path as absolute, overwriting
-        // any existing path on the endpoint.
-        // e.g. if endpoint is https://contoso.com/foo/bar and httpPath is /some/sub/path
-        // then calling Url::join will provide result https://contoso.com/some/sub/path
-        // which is not what we want.
-        // the only exception is if this is the root before the query string
-        let httpPath = method.operation.path;
-        if (httpPath.length > 1 && httpPath[0] === '/' && !httpPath.startsWith('/?')) {
-            httpPath = httpPath.slice(1);
-        }
         let rustMethod;
         switch (method.kind) {
             case 'basic':
-                rustMethod = new rust.AsyncMethod(methodName, languageIndependentName, rustClient, pub, methodOptions, httpMethod, httpPath);
+                rustMethod = new rust.AsyncMethod(methodName, languageIndependentName, rustClient, pub, methodOptions, httpMethod, method.operation.path);
                 break;
             case 'paging':
-                rustMethod = new rust.PageableMethod(methodName, languageIndependentName, rustClient, pub, methodOptions, httpMethod, httpPath);
+                rustMethod = new rust.PageableMethod(methodName, languageIndependentName, rustClient, pub, methodOptions, httpMethod, method.operation.path);
                 break;
             case 'lro':
-                rustMethod = new rust.LroMethod(methodName, languageIndependentName, rustClient, pub, methodOptions, httpMethod, httpPath);
+                rustMethod = new rust.LroMethod(methodName, languageIndependentName, rustClient, pub, methodOptions, httpMethod, method.operation.path);
                 break;
             default:
                 throw new AdapterError('UnsupportedTsp', `method kind ${method.kind} NYI`, (_d = method.__raw) === null || _d === void 0 ? void 0 : _d.node);
@@ -1381,14 +1373,8 @@ export class Adapter {
             if (unwrappedCount !== method.pagingMetadata.pageItemsSegments.length) {
                 throw new AdapterError('InternalError', `failed to unwrap paged items for method ${method.name}`, (_m = method.__raw) === null || _m === void 0 ? void 0 : _m.node);
             }
-            // if the response contains more than the Vec<T> and next_link then use a PageIterator
-            if (synthesizedModel.fields.length > 2) {
-                rustMethod.returns = new rust.Result(this.crate, new rust.PageIterator(this.crate, new rust.Response(this.crate, synthesizedModel, responseFormat)));
-            }
-            else {
-                this.crate.addDependency(new rust.CrateDependency('async-trait'));
-                rustMethod.returns = new rust.Result(this.crate, new rust.Pager(this.crate, new rust.Response(this.crate, synthesizedModel, responseFormat)));
-            }
+            this.crate.addDependency(new rust.CrateDependency('async-trait'));
+            rustMethod.returns = new rust.Result(this.crate, new rust.Pager(this.crate, new rust.Response(this.crate, synthesizedModel, responseFormat)));
         }
         else if (method.kind === 'lro') {
             const format = responseFormat === 'NoFormat' ? 'JsonFormat' : responseFormat;
@@ -1420,7 +1406,7 @@ export class Adapter {
         else if (responseHeaders.length > 0) {
             // for methods that don't return a modeled type but return headers,
             // we need to return a marker type
-            const markerType = new rust.MarkerType(`${rustClient.name}${codegen.pascalCase(method.name)}Result`);
+            const markerType = new rust.MarkerType(`${rustClient.name}${codegen.pascalCase(method.name, false)}Result`);
             markerType.docs.summary = `Contains results for ${this.asDocLink(`${rustClient.name}::${methodName}()`, `crate::generated::clients::${rustClient.name}::${methodName}()`)}`;
             this.crate.models.push(markerType);
             let resultType;
@@ -1453,7 +1439,11 @@ export class Adapter {
         rustMethod.responseHeaders = this.adaptResponseHeadersTrait(rustClient, rustMethod, Array.from(responseHeadersMap.values()));
         if (method.kind === 'paging') {
             // can't do this until the method has been completely adapted
-            rustMethod.strategy = this.adaptPageableMethodStrategy(method, paramsMap, responseHeadersMap);
+            const pageableMethod = rustMethod;
+            pageableMethod.strategy = this.adaptPageableMethodStrategy(method, paramsMap, responseHeadersMap);
+            if (((_p = pageableMethod.strategy) === null || _p === void 0 ? void 0 : _p.kind) === 'nextLink') {
+                pageableMethod.strategy.reinjectedParams = this.adaptPageableMethodReinjectionParams(method, paramsMap);
+            }
         }
     }
     /**
@@ -1534,7 +1524,6 @@ export class Adapter {
         // response header traits are only ever for marker types and payloads
         let implFor;
         switch (method.returns.type.kind) {
-            case 'pageIterator':
             case 'pager':
             case 'poller':
                 implFor = method.returns.type.type;
@@ -1564,7 +1553,7 @@ export class Adapter {
      * @returns the pageable strategy
      */
     adaptPageableMethodStrategy(method, paramsMap, respHeadersMap) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f;
         const buildNextLinkPath = (segments) => {
             var _a, _b;
             // build the field path for the next link segments
@@ -1600,11 +1589,14 @@ export class Adapter {
                     if (!tokenParam) {
                         throw new AdapterError('InternalError', `missing continuation token request parameter name ${tokenResp.name} for operation ${method.name}`, (_b = method.__raw) === null || _b === void 0 ? void 0 : _b.node);
                     }
+                    else if (tokenParam.kind !== 'headerScalar' && tokenParam.kind !== 'queryScalar') {
+                        throw new AdapterError('InternalError', `unexpected continuation token request parameter kind ${tokenParam.kind} for operation ${method.name}`, (_c = method.__raw) === null || _c === void 0 ? void 0 : _c.node);
+                    }
                     requestToken = tokenParam;
                     break;
                 }
                 default:
-                    throw new AdapterError('InternalError', `unhandled continuationTokenParameterSegment kind ${tokenReq.kind}`, (_c = tokenReq.__raw) === null || _c === void 0 ? void 0 : _c.node);
+                    throw new AdapterError('InternalError', `unhandled continuationTokenParameterSegment kind ${tokenReq.kind}`, (_d = tokenReq.__raw) === null || _d === void 0 ? void 0 : _d.node);
             }
             // find the continuation token response
             let responseToken;
@@ -1616,7 +1608,7 @@ export class Adapter {
                 case 'responseheader': {
                     const tokenHeader = respHeadersMap.get(tokenResp);
                     if (!tokenHeader) {
-                        throw new AdapterError('InternalError', `missing continuation token response header name ${tokenResp.name} for operation ${method.name}`, (_d = method.__raw) === null || _d === void 0 ? void 0 : _d.node);
+                        throw new AdapterError('InternalError', `missing continuation token response header name ${tokenResp.name} for operation ${method.name}`, (_e = method.__raw) === null || _e === void 0 ? void 0 : _e.node);
                     }
                     if (tokenHeader.kind !== 'responseHeaderScalar') {
                         throw new AdapterError('InternalError', `unexpected response header kind ${tokenHeader.kind}`);
@@ -1625,7 +1617,7 @@ export class Adapter {
                     break;
                 }
                 default:
-                    throw new AdapterError('InternalError', `missing continuation token`, (_e = method.__raw) === null || _e === void 0 ? void 0 : _e.node);
+                    throw new AdapterError('InternalError', `missing continuation token`, (_f = method.__raw) === null || _f === void 0 ? void 0 : _f.node);
             }
             return new rust.PageableStrategyContinuationToken(requestToken, responseToken);
         }
@@ -1634,6 +1626,39 @@ export class Adapter {
             return undefined;
         }
     }
+    /**
+     * returns the array of pageable method parameters for reinjection.
+     * if no parameters require reinjection, the array is empty.
+     *
+     * @param method the pageable method
+     * @param paramsMap maps tcgc method params to Rust params
+     * @returns an array containing the method parameters for reinjection
+     */
+    adaptPageableMethodReinjectionParams(method, paramsMap) {
+        var _a;
+        if (!method.pagingMetadata.nextLinkReInjectedParametersSegments) {
+            return [];
+        }
+        const paramsForReinjection = new Array();
+        for (const reinjectedParamSegment of method.pagingMetadata.nextLinkReInjectedParametersSegments) {
+            for (const reinjectedParam of reinjectedParamSegment) {
+                if (reinjectedParam.kind !== 'method') {
+                    throw new Error('unexpected param kind');
+                }
+                const rustParam = paramsMap.get(reinjectedParam);
+                if (!rustParam) {
+                    throw new AdapterError('InternalError', `missing reinjection parameter name ${reinjectedParam.name} for operation ${method.name}`, (_a = method.__raw) === null || _a === void 0 ? void 0 : _a.node);
+                }
+                else if (rustParam.kind === 'headerScalar') {
+                    // we only care about the query params here.
+                    // any header parameters are handled elsewhere.
+                    continue;
+                }
+                paramsForReinjection.push(rustParam);
+            }
+        }
+        return paramsForReinjection;
+    }
     /**
      * converts a tcgc operation parameter into a Rust method parameter
      *
@@ -1719,7 +1744,7 @@ export class Adapter {
                     adaptedParam = new rust.HeaderCollectionParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, format);
                 }
                 else if (param.serializedName === 'x-ms-meta') {
-                    if (paramType.kind !== 'hashmap') {
+                    if (paramType.kind !== 'hashmap' && !isRefHashMap(paramType)) {
                         throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for header ${param.serializedName}`, (_d = param.__raw) === null || _d === void 0 ? void 0 : _d.node);
                     }
                     adaptedParam = new rust.HeaderHashMapParameter(paramName, param.serializedName, paramLoc, param.optional, paramType);
@@ -1753,7 +1778,7 @@ export class Adapter {
                     if (isRefSlice(paramType)) {
                         adaptedParam = new rust.PathCollectionParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, param.allowReserved, style, param.explode);
                     }
-                    else if (paramType.kind === 'hashmap') {
+                    else if (paramType.kind === 'hashmap' || isRefHashMap(paramType)) {
                         adaptedParam = new rust.PathHashMapParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, param.allowReserved, style, param.explode);
                     }
                     else {
@@ -1779,7 +1804,7 @@ export class Adapter {
                     // TODO: hard-coded encoding setting, https://github.com/Azure/typespec-azure/issues/1314
                     adaptedParam = new rust.QueryCollectionParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, true, format);
                 }
-                else if (paramType.kind === 'hashmap') {
+                else if (paramType.kind === 'hashmap' || isRefHashMap(paramType)) {
                     // TODO: hard-coded encoding setting, https://github.com/Azure/typespec-azure/issues/1314
                     adaptedParam = new rust.QueryHashMapParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, true, param.explode);
                 }
@@ -1851,6 +1876,16 @@ export class Adapter {
             }
             case 'encodedBytes':
                 return this.getRefType(this.getEncodedBytes(type.encoding, true));
+            case 'decimal':
+            case 'Etag':
+            case 'hashmap':
+            case 'jsonValue':
+            case 'offsetDateTime':
+            case 'safeint':
+            case 'Url':
+                // these types all require conversion
+                // to String so we don't need to own them
+                return this.getRefType(type);
         }
         return undefined;
     }
@@ -1963,6 +1998,10 @@ export class Adapter {
         }
     }
 }
+/** type guard to determine if type is a Ref<HashMap> */
+function isRefHashMap(type) {
+    return shared.asTypeOf(type, 'hashmap', 'ref') !== undefined;
+}
 /** type guard to determine if type is a Ref<Slice> */
 function isRefSlice(type) {
     return shared.asTypeOf(type, 'slice', 'ref') !== undefined;