@azure-tools/typespec-rust 0.25.0 → 0.27.0

package/dist/src/tcgcadapter/adapter.js

@@ -11,6 +11,7 @@ import * as naming from './naming.js';
 import * as shared from '../shared/shared.js';
 import * as tcgc from '@azure-tools/typespec-client-generator-core';
 import * as rust from '../codemodel/index.js';
+import { FinalStateValue } from "@azure-tools/typespec-azure-core";
 /**
  * AdapterError is thrown when the emitter fails to convert part of the tcgc code
  * model to the emitter code model. this could be due to the emitter not supporting
@@ -42,7 +43,7 @@ export class Adapter {
         // same as TypeSpec.Xml.@name. however, it's filtered out by default
         // so we need to add it to the allow list of decorators
         const ctx = await tcgc.createSdkContext(context, '@azure-tools/typespec-rust', {
-            additionalDecorators: ['TypeSpec\\.@encodedName', '@clientName'],
+            additionalDecorators: ['TypeSpec\\.@encodedName', '@clientName', 'Azure.ClientGenerator.Core.@deserializeEmptyStringAsNull'],
             disableUsageAccessPropagationToBase: true,
         });
         context.program.reportDiagnostics(ctx.diagnostics);
@@ -78,7 +79,7 @@ export class Adapter {
             this.crate.addDependency(new rust.CrateDependency('serde'));
         }
         if (this.crate.clients.length > 0 || this.crate.enums.length > 0 || this.crate.models.length > 0 || this.crate.unions.length > 0) {
-            this.crate.addDependency(new rust.CrateDependency('typespec_client_core', ['derive']));
+            this.crate.addDependency(new rust.CrateDependency('azure_core'));
         }
         this.crate.sortContent();
         return this.crate;
@@ -120,8 +121,6 @@ export class Adapter {
             }
             const rustModel = this.getModel(model);
             this.crate.models.push(rustModel);
-            // presence of models requires the derive feature
-            this.crate.addDependency(new rust.CrateDependency('typespec_client_core', ['derive']));
         }
     }
     /**
@@ -131,13 +130,36 @@ export class Adapter {
      * @returns a Rust enum
      */
     getEnum(sdkEnum) {
-        var _a;
+        var _a, _b;
         const enumName = codegen.deconstruct(sdkEnum.name).map((each) => codegen.capitalize(each)).join('');
         let rustEnum = this.types.get(enumName);
         if (rustEnum) {
             return rustEnum;
         }
-        rustEnum = new rust.Enum(enumName, sdkEnum.access === 'public', !sdkEnum.isFixed);
+        let enumType;
+        switch (sdkEnum.valueType.kind) {
+            case 'float':
+            case 'float32':
+                enumType = 'f32';
+                break;
+            case 'float64':
+                enumType = 'f64';
+                break;
+            case 'int8':
+            case 'int16':
+            case 'int32':
+                enumType = 'i32';
+                break;
+            case 'int64':
+                enumType = 'i64';
+                break;
+            case 'string':
+                enumType = 'String';
+                break;
+            default:
+                throw new AdapterError('UnsupportedTsp', `unsupported enum underlying type ${sdkEnum.valueType.kind}`, (_a = sdkEnum.__raw) === null || _a === void 0 ? void 0 : _a.node);
+        }
+        rustEnum = new rust.Enum(enumName, sdkEnum.access === 'public', !sdkEnum.isFixed, enumType);
         rustEnum.docs = this.adaptDocs(sdkEnum.summary, sdkEnum.doc);
         this.types.set(enumName, rustEnum);
         const rustEnumNameToSdkEnumName = new Map();
@@ -145,7 +167,7 @@ export class Adapter {
             const enumValueName = naming.fixUpEnumValueName(value);
             const existingMapping = rustEnumNameToSdkEnumName.get(enumValueName);
             if (existingMapping) {
-                throw new AdapterError('NameCollision', `enum values ${value.name} and ${existingMapping} coalesce into the same name ${enumValueName}`, (_a = sdkEnum.__raw) === null || _a === void 0 ? void 0 : _a.node);
+                throw new AdapterError('NameCollision', `enum values ${value.name} and ${existingMapping} coalesce into the same name ${enumValueName}`, (_b = sdkEnum.__raw) === null || _b === void 0 ? void 0 : _b.node);
             }
             rustEnumNameToSdkEnumName.set(enumValueName, value.name);
             const rustEnumValue = new rust.EnumValue(enumValueName, rustEnum, value.value);
@@ -177,14 +199,16 @@ export class Adapter {
      *
      * @param model the tcgc model to convert
      * @param stack is a stack of model type names used to detect recursive type definitions
+     * @param modelName optional parameter to override model name
      * @returns a Rust model
      */
-    getModel(model, stack) {
+    getModel(model, stack, modelName) {
         var _a, _b, _c, _d;
-        if (model.name.length === 0) {
+        modelName = modelName !== null && modelName !== void 0 ? modelName : model.name;
+        if (modelName.length === 0) {
             throw new AdapterError('InternalError', 'unnamed model', (_a = model.__raw) === null || _a === void 0 ? void 0 : _a.node); // TODO: this might no longer be an issue
         }
-        const modelName = codegen.capitalize(model.name);
+        modelName = codegen.capitalize(modelName);
         let rustModel = this.types.get(modelName);
         if (rustModel) {
             return rustModel;
@@ -409,6 +433,9 @@ export class Adapter {
         if (!this.fieldsMap.get(property)) {
             this.fieldsMap.set(property, modelField);
         }
+        if (property.decorators.find((decorator) => decorator.name === 'Azure.ClientGenerator.Core.@deserializeEmptyStringAsNull') !== undefined) {
+            modelField.flags |= rust.ModelFieldFlags.DeserializeEmptyStringAsNone;
+        }
         return modelField;
     }
     /**
@@ -1106,7 +1133,7 @@ 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, _p;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
         let srcMethodName = method.name;
         if (method.kind === 'paging' && !srcMethodName.match(/^list/i)) {
             const chunks = codegen.deconstruct(srcMethodName);
@@ -1138,7 +1165,14 @@ export class Adapter {
         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');
+        let clientMethodOptions;
+        switch (method.kind) {
+            case 'paging':
+                clientMethodOptions = new rust.ExternalType(this.crate, 'PagerOptions', 'azure_core::http::pager');
+                break;
+            default:
+                clientMethodOptions = new rust.ExternalType(this.crate, 'ClientMethodOptions', 'azure_core::http');
+        }
         clientMethodOptions.lifetime = optionsLifetime;
         const methodOptionsField = new rust.StructField('method_options', 'pub', clientMethodOptions);
         methodOptionsField.docs.summary = 'Allows customization of the method call.';
@@ -1161,10 +1195,29 @@ export class Adapter {
                 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, method.operation.path);
+                {
+                    let lroFinalResultStrategy = new rust.LroFinalResultStrategyOriginalUri();
+                    if (method.lroMetadata.finalStateVia !== FinalStateValue.originalUri) {
+                        switch (method.lroMetadata.finalStateVia) {
+                            case FinalStateValue.operationLocation:
+                                lroFinalResultStrategy = new rust.LroFinalResultStrategyHeader('operation-location');
+                                break;
+                            case FinalStateValue.location:
+                                lroFinalResultStrategy = new rust.LroFinalResultStrategyHeader('location');
+                                break;
+                            case FinalStateValue.azureAsyncOperation:
+                                lroFinalResultStrategy = new rust.LroFinalResultStrategyHeader('azure-asyncoperation');
+                                break;
+                            default:
+                                throw new AdapterError('UnsupportedTsp', `lroMetadata.finalStateVia ${method.lroMetadata.finalStateVia} NYI`, (_d = method.__raw) === null || _d === void 0 ? void 0 : _d.node);
+                        }
+                        lroFinalResultStrategy.propertyName = method.lroMetadata.finalResultPath;
+                    }
+                    rustMethod = new rust.LroMethod(methodName, languageIndependentName, rustClient, pub, methodOptions, httpMethod, method.operation.path, lroFinalResultStrategy);
+                }
                 break;
             default:
-                throw new AdapterError('UnsupportedTsp', `method kind ${method.kind} NYI`, (_d = method.__raw) === null || _d === void 0 ? void 0 : _d.node);
+                throw new AdapterError('UnsupportedTsp', `method kind ${method.kind} NYI`, (_e = method.__raw) === null || _e === void 0 ? void 0 : _e.node);
         }
         rustMethod.docs = this.adaptDocs(method.summary, method.doc);
         rustClient.methods.push(rustMethod);
@@ -1187,7 +1240,12 @@ export class Adapter {
                 }).any();
             }).first();
             if (!opParam) {
-                throw new AdapterError('InternalError', `didn't find operation parameter for method ${method.name} parameter ${param.name}`, (_e = param.__raw) === null || _e === void 0 ? void 0 : _e.node);
+                throw new AdapterError('InternalError', `didn't find operation parameter for method ${method.name} parameter ${param.name}`, (_f = param.__raw) === null || _f === void 0 ? void 0 : _f.node);
+            }
+            if (opParam.kind === 'header' && opParam.serializedName.toLowerCase() === 'x-ms-client-request-id') {
+                // x-ms-client-request-id is automatically inserted into requests via
+                // a pipeline policy. so we don't want to expose this as an actual param.
+                continue;
             }
             let adaptedParam;
             // for spread params there are two cases we need to consider.
@@ -1311,16 +1369,16 @@ export class Adapter {
         const responseFormat = getResponseFormat();
         if (method.kind === 'paging') {
             if (responseFormat === 'NoFormat') {
-                throw new AdapterError('InternalError', `paged method ${method.name} unexpected response format ${responseFormat}`, (_f = method.__raw) === null || _f === void 0 ? void 0 : _f.node);
+                throw new AdapterError('InternalError', `paged method ${method.name} unexpected response format ${responseFormat}`, (_g = method.__raw) === null || _g === void 0 ? void 0 : _g.node);
             }
             // for paged methods, tcgc models method.response.type as an Array<T>.
             // however, we want the synthesized paged response envelope type instead.
             const synthesizedType = method.operation.responses[0].type;
             if (!synthesizedType) {
-                throw new AdapterError('InternalError', `paged method ${method.name} has no synthesized response type`, (_g = method.__raw) === null || _g === void 0 ? void 0 : _g.node);
+                throw new AdapterError('InternalError', `paged method ${method.name} has no synthesized response type`, (_h = method.__raw) === null || _h === void 0 ? void 0 : _h.node);
             }
             else if (synthesizedType.kind !== 'model') {
-                throw new AdapterError('UnsupportedTsp', `paged method ${method.name} synthesized response type has unexpected kind ${synthesizedType.kind}`, (_h = method.__raw) === null || _h === void 0 ? void 0 : _h.node);
+                throw new AdapterError('UnsupportedTsp', `paged method ${method.name} synthesized response type has unexpected kind ${synthesizedType.kind}`, (_j = method.__raw) === null || _j === void 0 ? void 0 : _j.node);
             }
             const synthesizedModel = this.getModel(synthesizedType, new Array());
             if (!this.crate.models.includes(synthesizedModel)) {
@@ -1328,7 +1386,7 @@ export class Adapter {
             }
             // for the pager response type, remove the Option<T> around the Vec<T> for the page items
             if (!method.pagingMetadata.pageItemsSegments) {
-                throw new AdapterError('InternalError', `paged method ${method.name} has no pageItemsSegments`, (_j = method.__raw) === null || _j === void 0 ? void 0 : _j.node);
+                throw new AdapterError('InternalError', `paged method ${method.name} has no pageItemsSegments`, (_k = method.__raw) === null || _k === void 0 ? void 0 : _k.node);
             }
             // unwrap all of the segments for the paged response
             let unwrappedCount = 0;
@@ -1339,13 +1397,13 @@ export class Adapter {
                 switch (responseFormat) {
                     case 'JsonFormat':
                         if (segment.kind !== 'property' || !segment.serializationOptions.json) {
-                            throw new AdapterError('InternalError', `paged method ${method.name} is missing JSON serialization data`, (_k = method.__raw) === null || _k === void 0 ? void 0 : _k.node);
+                            throw new AdapterError('InternalError', `paged method ${method.name} is missing JSON serialization data`, (_l = method.__raw) === null || _l === void 0 ? void 0 : _l.node);
                         }
                         serde = segment.serializationOptions.json.name;
                         break;
                     case 'XmlFormat':
                         if (segment.kind !== 'property' || !segment.serializationOptions.xml) {
-                            throw new AdapterError('InternalError', `paged method ${method.name} is missing XML serialization data`, (_l = method.__raw) === null || _l === void 0 ? void 0 : _l.node);
+                            throw new AdapterError('InternalError', `paged method ${method.name} is missing XML serialization data`, (_m = method.__raw) === null || _m === void 0 ? void 0 : _m.node);
                         }
                         serde = segment.serializationOptions.xml.name;
                         break;
@@ -1371,16 +1429,16 @@ 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);
+                throw new AdapterError('InternalError', `failed to unwrap paged items for method ${method.name}`, (_o = method.__raw) === null || _o === void 0 ? void 0 : _o.node);
             }
             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;
-            const responseType = this.typeToWireType(this.getModel(method.lroMetadata.logicalResult));
-            if (responseType.kind !== 'model') {
-                throw new AdapterError('InternalError', `envelope result for ${method.name} is not a model`, (_o = method.__raw) === null || _o === void 0 ? void 0 : _o.node);
+            const statusType = this.typeToWireType(this.getModel(method.lroMetadata.pollingInfo.responseModel, undefined, `${rustClient.name}${codegen.pascalCase(rustMethod.name, false)}OperationStatus`));
+            if (statusType.kind !== 'model') {
+                throw new AdapterError('InternalError', `status type for an LRO method '${method.name}' is not a model`, (_p = method.__raw) === null || _p === void 0 ? void 0 : _p.node);
             }
             const pushModels = (model, crate) => {
                 if (crate.models.some(m => m === model)) {
@@ -1396,8 +1454,17 @@ export class Adapter {
                     }
                 }
             };
-            pushModels(responseType, this.crate);
-            rustMethod.returns = new rust.Result(this.crate, new rust.Poller(this.crate, new rust.Response(this.crate, responseType, format)));
+            pushModels(statusType, this.crate);
+            const poller = new rust.Poller(this.crate, new rust.Response(this.crate, statusType, format));
+            if (((_q = method.response.type) === null || _q === void 0 ? void 0 : _q.kind) === "model") {
+                const responseType = this.typeToWireType(this.getModel(method.response.type));
+                if (responseType.kind !== 'model') {
+                    throw new AdapterError('InternalError', `response type for an LRO method '${method.name}' is not a model`, (_r = method.__raw) === null || _r === void 0 ? void 0 : _r.node);
+                }
+                pushModels(responseType, this.crate);
+                poller.resultType = new rust.Response(this.crate, responseType, format);
+            }
+            rustMethod.returns = new rust.Result(this.crate, poller);
         }
         else if (method.response.type && !(method.response.type.kind === 'bytes' && method.response.type.encode === 'bytes')) {
             const response = new rust.Response(this.crate, this.typeToWireType(this.getType(method.response.type)), responseFormat);
@@ -1441,7 +1508,7 @@ export class Adapter {
             // can't do this until the method has been completely adapted
             const pageableMethod = rustMethod;
             pageableMethod.strategy = this.adaptPageableMethodStrategy(method, paramsMap, responseHeadersMap);
-            if (((_p = pageableMethod.strategy) === null || _p === void 0 ? void 0 : _p.kind) === 'nextLink') {
+            if (((_s = pageableMethod.strategy) === null || _s === void 0 ? void 0 : _s.kind) === 'nextLink') {
                 pageableMethod.strategy.reinjectedParams = this.adaptPageableMethodReinjectionParams(method, paramsMap);
             }
         }