@azure-tools/typespec-rust 0.19.0 → 0.21.0

package/dist/src/tcgcadapter/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/tcgcadapter/adapter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/tcgcadapter/adapter.ts"],"names":[],"mappings":"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"}

package/dist/src/tcgcadapter/adapter.js

@@ -2,7 +2,7 @@
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
-// cspell: ignore responseheader subclients lropaging
+// cspell: ignore addl responseheader subclients lropaging
 import * as codegen from '@azure-tools/codegen';
 import { values } from '@azure-tools/linq';
 import { NoTarget } from '@typespec/compiler';
@@ -173,7 +173,7 @@ export class Adapter {
      * @returns a Rust model
      */
     getModel(model, stack) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         if (model.name.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
         }
@@ -204,6 +204,7 @@ export class Adapter {
         for (const prop of model.properties) {
             allProps.push(prop);
         }
+        let addlProps = model.additionalProperties;
         let parent = model.baseModel;
         while (parent) {
             for (const parentProp of parent.properties) {
@@ -215,7 +216,14 @@ export class Adapter {
                 }
                 allProps.push(parentProp);
             }
-            // TODO: propagate additional properties https://github.com/Azure/typespec-rust/issues/4
+            // propagate parent's additional properties if we don't yet have any.
+            // if we do, ensure that their kinds match.
+            if (!addlProps) {
+                addlProps = parent.additionalProperties;
+            }
+            else if (parent.additionalProperties && addlProps.kind !== parent.additionalProperties.kind) {
+                throw new AdapterError('UnsupportedTsp', `model ${model.name} has additional properties kind ${addlProps.kind} which conflicts with parent model ${parent.name} additional properties kind ${parent.additionalProperties.kind}`, (_b = model.__raw) === null || _b === void 0 ? void 0 : _b.node);
+            }
             parent = parent.baseModel;
         }
         for (const property of allProps) {
@@ -231,15 +239,25 @@ export class Adapter {
                     // we just adapt it here as a regular model field.
                 }
                 else {
-                    throw new AdapterError('UnsupportedTsp', `model property kind ${property.kind} NYI`, (_b = property.__raw) === null || _b === void 0 ? void 0 : _b.node);
+                    throw new AdapterError('UnsupportedTsp', `model property kind ${(_c = property.__raw) === null || _c === void 0 ? void 0 : _c.kind} NYI`, (_d = property.__raw) === null || _d === void 0 ? void 0 : _d.node);
                 }
             }
             const structField = this.getModelField(property, rustModel.visibility, stack);
             rustModel.fields.push(structField);
         }
+        if (addlProps) {
+            const addlPropsType = this.getHashMap(this.typeToWireType(this.getType(addlProps)));
+            const addlPropsField = new rust.ModelAdditionalProperties('additional_properties', 'pub', this.getOptionType(addlPropsType));
+            addlPropsField.docs.summary = 'contains unnamed additional properties';
+            rustModel.fields.push(addlPropsField);
+        }
         stack.pop();
         return rustModel;
     }
+    getSerializedPropertyName(property) {
+        var _a, _b, _c, _d, _e;
+        return property.kind === 'property' ? (_d = (_b = (_a = property.serializationOptions.json) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : (_c = property.serializationOptions.xml) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : (_e = property.serializationOptions.multipart) === null || _e === void 0 ? void 0 : _e.name : undefined;
+    }
     /**
      * converts a tcgc model property to a model field
      *
@@ -249,17 +267,19 @@ export class Adapter {
      * @returns a Rust model field
      */
     getModelField(property, modelVisibility, stack) {
+        var _a;
         let fieldType = this.getType(property.type, stack);
         // if the field's type is a model and it's in the type stack then
         // box it. this is to avoid infinitely recursive type definitions.
         if (fieldType.kind === 'model' && stack.includes(fieldType.name)) {
-            fieldType = new rust.Box(fieldType);
+            fieldType = this.getBoxType(fieldType);
         }
         // for public models each field is always an Option<T>.
         if (modelVisibility === 'pub' || property.optional) {
-            fieldType = new rust.Option(fieldType.kind === 'box' ? fieldType : this.typeToWireType(fieldType));
+            fieldType = this.getOptionType(fieldType.kind === 'box' ? fieldType : this.typeToWireType(fieldType));
         }
-        const modelField = new rust.ModelField(naming.getEscapedReservedName(snakeCaseName(property.name), 'prop'), property.serializedName, modelVisibility, fieldType, property.optional);
+        const serializedName = (_a = this.getSerializedPropertyName(property)) !== null && _a !== void 0 ? _a : property.name;
+        const modelField = new rust.ModelField(naming.getEscapedReservedName(snakeCaseName(property.name), 'prop'), serializedName, modelVisibility, fieldType, property.optional);
         modelField.docs = this.adaptDocs(property.summary, property.doc);
         // if this is a literal, add a doc comment explaining its behavior
         const unwrappedType = shared.unwrapOption(fieldType);
@@ -423,6 +443,16 @@ export class Adapter {
                 throw new AdapterError('UnsupportedTsp', `unhandled tcgc type ${type.kind}`, (_b = type.__raw) === null || _b === void 0 ? void 0 : _b.node);
         }
     }
+    /** returns a Box type */
+    getBoxType(type) {
+        const typeKey = recursiveKeyName('box', type);
+        let boxType = this.types.get(typeKey);
+        if (!boxType) {
+            boxType = new rust.Box(type);
+            this.types.set(typeKey, boxType);
+        }
+        return boxType;
+    }
     /** returns an EncodedBytes type with the specified encoding */
     getEncodedBytes(encoding, asSlice) {
         const keyName = `encodedBytes-${encoding}${asSlice ? '-slice' : ''}`;
@@ -445,6 +475,16 @@ export class Adapter {
         this.types.set(keyName, hashmapType);
         return hashmapType;
     }
+    /** returns an Option<T> where T is specified in type */
+    getOptionType(type) {
+        const typeKey = recursiveKeyName('option', type);
+        let optionType = this.types.get(typeKey);
+        if (!optionType) {
+            optionType = new rust.Option(type);
+            this.types.set(typeKey, optionType);
+        }
+        return optionType;
+    }
     /** returns the specified type wrapped in a Ref */
     getRefType(type) {
         const typeKey = recursiveKeyName('ref', type);
@@ -833,19 +873,21 @@ export class Adapter {
             this.adaptClientAccessor(client, child, rustClient, subClient);
         }
         for (const method of client.methods) {
-            if (method.kind === 'lro' || method.kind === 'lropaging') {
-                // skip LROs for now so that codegen is unblocked
+            if (method.kind === 'lropaging') {
+                // skip Paging LROs for now so that codegen is unblocked
                 // TODO: https://github.com/Azure/typespec-rust/issues/188
                 this.ctx.program.reportDiagnostic({
-                    code: 'LroNotSupported',
+                    code: 'LroPagingNotSupported',
                     severity: 'warning',
-                    message: `skip emitting LRO ${method.name}`,
+                    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,
                 });
                 continue;
             }
             this.adaptMethod(method, rustClient);
         }
+        // Set the tracing namespace for tracing based on the client's namespace
+        rustClient.languageIndependentName = client.crossLanguageDefinitionId;
         this.crate.clients.push(rustClient);
         return rustClient;
     }
@@ -959,7 +1001,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;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
         let srcMethodName = method.name;
         if (method.kind === 'paging' && !srcMethodName.match(/^list/i)) {
             const chunks = codegen.deconstruct(srcMethodName);
@@ -987,6 +1029,12 @@ export class Adapter {
         const methodOptionsField = new rust.StructField('method_options', 'pub', clientMethodOptions);
         methodOptionsField.docs.summary = 'Allows customization of the method call.';
         methodOptionsStruct.fields.push(methodOptionsField);
+        if (method.kind === 'lro') {
+            const pollerOptions = new rust.ExternalType(this.crate, 'PollerOptions', 'azure_core::http::poller');
+            const pollerOptionsField = new rust.StructField('poller_options', 'pub', pollerOptions);
+            pollerOptionsField.docs.summary = 'Allows customization of the [`Poller`](azure_core::http::poller::Poller).';
+            methodOptionsStruct.fields.push(pollerOptionsField);
+        }
         const pub = method.access === 'public' ? 'pub' : 'pubCrate';
         const methodOptions = new rust.MethodOptions(methodOptionsStruct);
         const httpMethod = method.operation.verb;
@@ -1009,6 +1057,9 @@ export class Adapter {
             case 'paging':
                 rustMethod = new rust.PageableMethod(methodName, languageIndependentName, rustClient, pub, methodOptions, httpMethod, httpPath);
                 break;
+            case 'lro':
+                rustMethod = new rust.LroMethod(methodName, languageIndependentName, rustClient, pub, methodOptions, httpMethod, httpPath);
+                break;
             default:
                 throw new AdapterError('UnsupportedTsp', `method kind ${method.kind} NYI`, (_d = method.__raw) === null || _d === void 0 ? void 0 : _d.node);
         }
@@ -1047,8 +1098,11 @@ export class Adapter {
             else {
                 adaptedParam = this.adaptMethodParameter(opParam);
             }
-            if (adaptedParam.kind === 'headerScalar' || adaptedParam.kind === 'queryScalar') {
-                paramsMap.set(param, adaptedParam);
+            switch (adaptedParam.kind) {
+                case 'headerScalar':
+                case 'queryScalar':
+                    paramsMap.set(param, adaptedParam);
+                    break;
             }
             adaptedParam.docs = this.adaptDocs(param.summary, param.doc);
             rustMethod.params.push(adaptedParam);
@@ -1069,7 +1123,7 @@ export class Adapter {
                     fieldType = field.type;
                 }
                 else {
-                    fieldType = new rust.Option(adaptedParam.type);
+                    fieldType = this.getOptionType(adaptedParam.type);
                 }
                 const optionsField = new rust.StructField(adaptedParam.name, 'pub', fieldType);
                 optionsField.docs = adaptedParam.docs;
@@ -1104,7 +1158,7 @@ export class Adapter {
             if (!defaultContentType) {
                 return 'NoFormat';
             }
-            return this.adaptResponseFormat(defaultContentType);
+            return this.adaptPayloadFormatType(defaultContentType);
         };
         // add any response headers
         const responseHeaders = new Array();
@@ -1166,13 +1220,13 @@ export class Adapter {
                 let serde;
                 switch (responseFormat) {
                     case 'JsonFormat':
-                        if (!segment.serializationOptions.json) {
+                        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);
                         }
                         serde = segment.serializationOptions.json.name;
                         break;
                     case 'XmlFormat':
-                        if (!segment.serializationOptions.xml) {
+                        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);
                         }
                         serde = segment.serializationOptions.xml.name;
@@ -1180,11 +1234,14 @@ export class Adapter {
                 }
                 for (let i = 0; i < typeToUnwrap.fields.length; ++i) {
                     const field = typeToUnwrap.fields[i];
+                    if (field.kind === 'additionalProperties') {
+                        continue;
+                    }
                     if (field.serde === serde) {
                         // check if this has already been unwrapped (e.g. type is shared across operations)
                         if (field.type.kind === 'option') {
-                            typeToUnwrap.fields[i].type = typeToUnwrap.fields[i].type.type;
-                            typeToUnwrap.fields[i].flags |= rust.ModelFieldFlags.PageItems;
+                            field.type = (field.type).type;
+                            field.flags |= rust.ModelFieldFlags.PageItems;
                         }
                         // move to the next segment
                         if (field.type.kind === 'model') {
@@ -1206,6 +1263,29 @@ export class Adapter {
                 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 pushModels = (model, crate) => {
+                if (crate.models.some(m => m === model)) {
+                    return;
+                }
+                crate.models.push(model);
+                for (const field of model.fields) {
+                    let fieldType = field.type;
+                    fieldType = fieldType.kind === 'option' ? fieldType.type : fieldType;
+                    fieldType = fieldType.kind === 'Vec' ? fieldType.type : fieldType;
+                    if (fieldType.kind === 'model') {
+                        pushModels(fieldType, crate);
+                    }
+                }
+            };
+            pushModels(responseType, this.crate);
+            rustMethod.returns = new rust.Result(this.crate, new rust.Poller(this.crate, new rust.Response(this.crate, responseType, format)));
+        }
         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);
             rustMethod.returns = new rust.Result(this.crate, response);
@@ -1304,6 +1384,7 @@ export class Adapter {
         switch (method.returns.type.kind) {
             case 'pageIterator':
             case 'pager':
+            case 'poller':
                 implFor = method.returns.type.type;
                 break;
             case 'response':
@@ -1335,7 +1416,7 @@ export class Adapter {
      * @returns the pageable strategy
      */
     adaptPageableMethodStrategy(method, paramsMap, respHeadersMap) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         if (method.pagingMetadata.nextLinkOperation) {
             // TODO: https://github.com/Azure/autorest.rust/issues/103
             throw new AdapterError('UnsupportedTsp', 'next page operation NYI', (_a = method.__raw) === null || _a === void 0 ? void 0 : _a.node);
@@ -1403,12 +1484,12 @@ export class Adapter {
                     break;
                 }
                 default:
-                    throw new AdapterError('InternalError', `unhandled continuationTokenResponseSegment kind ${tokenResp.kind}`);
+                    throw new AdapterError('InternalError', `missing continuation token`, (_l = method.__raw) === null || _l === void 0 ? void 0 : _l.node);
             }
             return new rust.PageableStrategyContinuationToken(requestToken, responseToken);
         }
         else {
-            throw new AdapterError('InternalError', `unknown paging strategy for operation ${method.name}`, (_l = method.__raw) === null || _l === void 0 ? void 0 : _l.node);
+            throw new AdapterError('InternalError', `unknown paging strategy for operation ${method.name}`, (_m = method.__raw) === null || _m === void 0 ? void 0 : _m.node);
         }
     }
     /**
@@ -1467,7 +1548,8 @@ export class Adapter {
                 else {
                     requestType = new rust.Payload(this.typeToWireType(paramType), this.adaptPayloadFormat(param.defaultContentType));
                 }
-                adaptedParam = new rust.BodyParameter(paramName, paramLoc, param.optional, new rust.RequestContent(this.crate, requestType));
+                const requestFormatType = this.adaptPayloadFormatType(param.defaultContentType);
+                adaptedParam = new rust.BodyParameter(paramName, paramLoc, param.optional, new rust.RequestContent(this.crate, requestType, requestFormatType));
                 break;
             }
             case 'cookie':
@@ -1519,14 +1601,12 @@ export class Adapter {
                 {
                     paramType = this.typeToWireType(paramType);
                     let style = 'simple';
-                    {
-                        const tspStyleString = param.style;
-                        if (!['simple', 'path', 'label', 'matrix'].includes(tspStyleString)) {
-                            throw new AdapterError('InternalError', `unsupported style ${tspStyleString} for parameter ${param.serializedName}`, (_f = param.__raw) === null || _f === void 0 ? void 0 : _f.node);
-                        }
-                        else {
-                            style = tspStyleString;
-                        }
+                    const tspStyleString = param.style;
+                    if (!['simple', 'path', 'label', 'matrix'].includes(tspStyleString)) {
+                        throw new AdapterError('InternalError', `unsupported style ${tspStyleString} for parameter ${param.serializedName}`, (_f = param.__raw) === null || _f === void 0 ? void 0 : _f.node);
+                    }
+                    else {
+                        style = tspStyleString;
                     }
                     if (isRefSlice(paramType)) {
                         adaptedParam = new rust.PathCollectionParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, param.allowReserved, style, param.explode);
@@ -1678,8 +1758,8 @@ export class Adapter {
         // find the corresponding field within the model so we can get its index
         let serializedName;
         for (const property of opParamType.properties) {
-            if (property.name === param.name) {
-                serializedName = property.serializedName;
+            if (property.kind === 'property' && property.name === param.name) {
+                serializedName = this.getSerializedPropertyName(property);
                 break;
             }
         }
@@ -1693,7 +1773,8 @@ export class Adapter {
         }
         const paramName = naming.getEscapedReservedName(snakeCaseName(param.name), 'param');
         const paramLoc = 'method';
-        const adaptedParam = new rust.PartialBodyParameter(paramName, paramLoc, param.optional, serializedName, this.getType(param.type), new rust.RequestContent(this.crate, new rust.Payload(payloadType, format)));
+        const formatType = shared.getPayloadFormatType(format);
+        const adaptedParam = new rust.PartialBodyParameter(paramName, paramLoc, param.optional, serializedName, this.getType(param.type), new rust.RequestContent(this.crate, new rust.Payload(payloadType, format), formatType));
         return adaptedParam;
     }
     /**
@@ -1717,18 +1798,18 @@ export class Adapter {
         }
     }
     /**
-     * converts an accept header value into a response format
+     * converts an accept or content-type header value into a payload format type
      *
-     * @param accept the value of the Content-Type header
+     * @param contentType the value of the Accept or Content-Type header
      * @returns a response format
      */
-    adaptResponseFormat(accept) {
+    adaptPayloadFormatType(contentType) {
         // we only recognize/support JSON and XML content types.
         // anything else is NoFormat
-        if (accept.match(/json/i)) {
+        if (contentType.match(/json/i)) {
             return 'JsonFormat';
         }
-        else if (accept.match(/xml/i)) {
+        else if (contentType.match(/xml/i)) {
             // XML support is disabled by default
             this.crate.addDependency(new rust.CrateDependency('azure_core', ['xml']));
             return 'XmlFormat';
@@ -1781,17 +1862,18 @@ function snakeCaseName(name) {
  * this is idempotent so providing the same type will create
  * the same key.
  *
- * obj is recursively unwrapped, and each layer is used to construct
+ * type is recursively unwrapped, and each layer is used to construct
  * the key. e.g. if obj is a HashMap<String, Vec<i32>> this would
  * unwrap to hashmap-Vec-i32.
  *
  * @param root the starting value for the key
- * @param obj the type for which to create the key
+ * @param type the type for which to create the key
  * @returns a string containing the complete map key
  */
 function recursiveKeyName(root, type) {
     switch (type.kind) {
         case 'Vec':
+        case 'box':
             return recursiveKeyName(`${root}-${type.kind}`, type.type);
         case 'encodedBytes':
             return `${root}-${type.kind}-${type.encoding}${type.slice ? '-slice' : ''}`;
@@ -1804,9 +1886,16 @@ function recursiveKeyName(root, type) {
         case 'offsetDateTime':
             return `${root}-${type.kind}-${type.encoding}${type.utc ? '-utc' : ''}`;
         case 'model':
+        case 'struct':
             return `${root}-${type.kind}-${type.name}`;
+        case 'literal':
+            return `${recursiveKeyName(`${root}-${type.kind}`, type.valueKind)}-${type.value}`;
+        case 'payload':
+            return recursiveKeyName(`${root}-${type.kind}-${type.format}`, type.type);
         case 'ref':
             return recursiveKeyName(`${root}-${type.kind}`, type.type);
+        case 'requestContent':
+            return recursiveKeyName(`${root}-${type.kind}`, type.content);
         case 'safeint':
         case 'decimal':
             return `${root}-${type.kind}${type.stringEncoding ? '-string' : ''}`;