@azure-tools/typespec-rust 0.15.0 → 0.17.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

@@ -957,7 +957,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;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         let srcMethodName = method.name;
         if (method.kind === 'paging' && !srcMethodName.match(/^list/i)) {
             const chunks = codegen.deconstruct(srcMethodName);
@@ -1039,12 +1039,12 @@ export class Adapter {
             // if the method param's type DOES match the op param's type and the op param has multiple corresponding method params, it's a spread param
             // - e.g. op param is an intersection of multiple model types, and each model type is exposed as a discrete param
             if (opParam.kind === 'body' && opParam.type.kind === 'model' && (opParam.type.kind !== param.type.kind || opParam.correspondingMethodParams.length > 1)) {
-                adaptedParam = this.adaptMethodSpreadParameter(param, this.adaptBodyFormat(opParam.defaultContentType), opParam.type);
+                adaptedParam = this.adaptMethodSpreadParameter(param, this.adaptPayloadFormat(opParam.defaultContentType), opParam.type);
             }
             else {
                 adaptedParam = this.adaptMethodParameter(opParam);
             }
-            if (adaptedParam.kind === 'header' || adaptedParam.kind === 'query') {
+            if (adaptedParam.kind === 'headerScalar' || adaptedParam.kind === 'queryScalar') {
                 paramsMap.set(param, adaptedParam);
             }
             adaptedParam.docs = this.adaptDocs(param.summary, param.doc);
@@ -1052,7 +1052,7 @@ export class Adapter {
             // we specially handle an optional content-type header to ensure it's omitted
             // from the options bag type. this shows up when the request body is optional.
             // we can't generalize this to optional literal headers though.
-            if (adaptedParam.optional && (adaptedParam.kind !== 'header' || adaptedParam.header.toLowerCase() !== 'content-type')) {
+            if (adaptedParam.optional && (adaptedParam.kind !== 'headerScalar' || adaptedParam.header.toLowerCase() !== 'content-type')) {
                 let fieldType;
                 if (adaptedParam.kind === 'partialBody') {
                     // for partial body params, adaptedParam.type is the model type that's
@@ -1082,9 +1082,8 @@ export class Adapter {
                 rustMethod.params.push(adaptedParam);
             }
         }
-        /** called IFF the operation returns a modeled response */
-        const getBodyFormat = () => {
-            var _a, _b;
+        const getResponseFormat = () => {
+            var _a;
             // fetch the body format from the HTTP responses.
             // they should all have the same type so no need to match responses to type.
             let defaultContentType;
@@ -1100,9 +1099,9 @@ export class Adapter {
                 defaultContentType = httpResp.defaultContentType;
             }
             if (!defaultContentType) {
-                throw new AdapterError('InternalError', `unable to determine content type for method ${method.name}`, (_b = method.__raw) === null || _b === void 0 ? void 0 : _b.node);
+                return 'NoFormat';
             }
-            return this.adaptBodyFormat(defaultContentType);
+            return this.adaptResponseFormat(defaultContentType);
         };
         // add any response headers
         const responseHeaders = new Array();
@@ -1121,27 +1120,40 @@ export class Adapter {
                     // response headers if they need it.
                     continue;
                 }
+                else if (header.access === 'internal') {
+                    // if a header has been marked as internal then skip it.
+                    // this happens if the tsp includes the header for documentation
+                    // purposes but the desire is to omit it from the generated code.
+                    // we skip them instead of making them pub(crate) to avoid the
+                    // case where all headers are internal, which would result in a
+                    // marker type where all its trait methods aren't public, making
+                    // it effectively useless.
+                    continue;
+                }
                 responseHeaders.push(header);
             }
         }
+        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);
+            }
             // 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`, (_f = method.__raw) === null || _f === void 0 ? void 0 : _f.node);
+                throw new AdapterError('InternalError', `paged method ${method.name} has no synthesized response type`, (_g = method.__raw) === null || _g === void 0 ? void 0 : _g.node);
             }
             else if (synthesizedType.kind !== 'model') {
-                throw new AdapterError('UnsupportedTsp', `paged method ${method.name} synthesized response type has unexpected kind ${synthesizedType.kind}`, (_g = method.__raw) === null || _g === void 0 ? void 0 : _g.node);
+                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);
             }
-            const format = getBodyFormat();
             const synthesizedModel = this.getModel(synthesizedType, new Array());
             if (!this.crate.models.includes(synthesizedModel)) {
                 this.crate.models.push(synthesizedModel);
             }
             // 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`, (_h = method.__raw) === null || _h === void 0 ? void 0 : _h.node);
+                throw new AdapterError('InternalError', `paged method ${method.name} has no pageItemsSegments`, (_j = method.__raw) === null || _j === void 0 ? void 0 : _j.node);
             }
             // unwrap all of the segments for the paged response
             let unwrappedCount = 0;
@@ -1149,11 +1161,17 @@ export class Adapter {
             for (const pageItemsSegment of method.pagingMetadata.pageItemsSegments) {
                 const segment = pageItemsSegment;
                 let serde;
-                switch (format) {
-                    case 'json':
+                switch (responseFormat) {
+                    case 'JsonFormat':
+                        if (!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 'xml':
+                    case 'XmlFormat':
+                        if (!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;
                         break;
                 }
@@ -1175,19 +1193,19 @@ export class Adapter {
                 }
             }
             if (unwrappedCount !== method.pagingMetadata.pageItemsSegments.length) {
-                throw new AdapterError('InternalError', `failed to unwrap paged items for method ${method.name}`, (_j = method.__raw) === null || _j === void 0 ? void 0 : _j.node);
+                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, new rust.Payload(synthesizedModel, format))));
+                rustMethod.returns = new rust.Result(this.crate, new rust.PageIterator(this.crate, new rust.Response(this.crate, synthesizedModel, responseFormat)));
             }
             else {
-                rustMethod.returns = new rust.Result(this.crate, new rust.Pager(this.crate, new rust.Payload(synthesizedModel, format)));
+                rustMethod.returns = new rust.Result(this.crate, new rust.Pager(this.crate, new rust.Response(this.crate, synthesizedModel, responseFormat)));
             }
         }
         else if (method.response.type && !(method.response.type.kind === 'bytes' && method.response.type.encode === 'bytes')) {
-            const payloadResponse = new rust.Response(this.crate, new rust.Payload(this.typeToWireType(this.getType(method.response.type)), getBodyFormat()));
-            rustMethod.returns = new rust.Result(this.crate, payloadResponse);
+            const response = new rust.Response(this.crate, this.typeToWireType(this.getType(method.response.type)), responseFormat);
+            rustMethod.returns = new rust.Result(this.crate, response);
         }
         else if (responseHeaders.length > 0) {
             // for methods that don't return a modeled type but return headers,
@@ -1195,14 +1213,14 @@ export class Adapter {
             const markerType = new rust.MarkerType(`${rustClient.name}${codegen.pascalCase(method.name)}Result`);
             markerType.docs.summary = `Contains results for ${this.asDocLink(`${rustClient.name}::${methodName}()`, `crate::generated::clients::${rustClient.name}::${methodName}()`)}`;
             this.crate.models.push(markerType);
-            rustMethod.returns = new rust.Result(this.crate, new rust.Response(this.crate, markerType));
+            rustMethod.returns = new rust.Result(this.crate, new rust.Response(this.crate, markerType, responseFormat));
         }
         else if (method.response.type && method.response.type.kind === 'bytes' && method.response.type.encode === 'bytes') {
             // bytes encoding indicates a streaming binary response
             rustMethod.returns = new rust.Result(this.crate, new rust.RawResponse(this.crate));
         }
         else {
-            rustMethod.returns = new rust.Result(this.crate, new rust.Response(this.crate, this.getUnitType()));
+            rustMethod.returns = new rust.Result(this.crate, new rust.Response(this.crate, this.getUnitType(), responseFormat));
         }
         const responseHeadersMap = this.adaptResposeHeaders(responseHeaders);
         rustMethod.responseHeaders = this.adaptResponseHeadersTrait(rustClient, rustMethod, Array.from(responseHeadersMap.values()));
@@ -1261,6 +1279,7 @@ export class Adapter {
         const recursiveTypeName = function (type) {
             switch (type.kind) {
                 case 'enum':
+                case 'marker':
                 case 'model':
                     return type.name;
                 case 'hashmap':
@@ -1281,31 +1300,23 @@ export class Adapter {
         let implFor;
         switch (method.returns.type.kind) {
             case 'pageIterator':
-                implFor = method.returns.type.type.content;
-                break;
             case 'pager':
                 implFor = method.returns.type.type;
                 break;
             case 'response':
-                if (method.returns.type.content.kind !== 'marker' && method.returns.type.content.kind !== 'payload') {
+                if (method.returns.type.content.kind === 'unit') {
+                    // this is to filter out unit from ResponseTypes.
+                    // methods that return unit should have been skipped by our caller
+                    // so we should never hit this (if we do, we have a bug elsewhere).
                     throw new AdapterError('InternalError', `unexpected method content kind ${method.returns.type.content.kind}`);
                 }
-                implFor = method.returns.type.content;
+                implFor = method.returns.type;
                 break;
             default:
                 // this is RawResponse which should have been previously skipped
                 throw new AdapterError('InternalError', `unexpected method return kind ${method.returns.type.kind}`);
         }
-        let traitName;
-        switch (implFor.kind) {
-            case 'marker':
-                traitName = implFor.name;
-                break;
-            case 'payload':
-                traitName = recursiveTypeName(implFor.type);
-                break;
-        }
-        traitName += 'Headers';
+        const traitName = `${recursiveTypeName(implFor.content)}Headers`;
         // NOTE: the complete doc text will be emitted at codegen time
         const docs = this.asDocLink(`${client.name}::${method.name}()`, `crate::generated::clients::${client.name}::${method.name}()`);
         const responseHeadersTrait = new rust.ResponseHeadersTrait(traitName, implFor, docs);
@@ -1404,7 +1415,7 @@ export class Adapter {
      * @returns a Rust method parameter
      */
     adaptMethodParameter(param) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         /**
          * used to create keys for this.clientMethodParams
          * @param param the param for which to create a key
@@ -1451,7 +1462,7 @@ export class Adapter {
                     requestType = new rust.Bytes(this.crate);
                 }
                 else {
-                    requestType = new rust.Payload(this.typeToWireType(paramType), this.adaptBodyFormat(param.defaultContentType));
+                    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));
                 break;
@@ -1487,25 +1498,76 @@ export class Adapter {
                     adaptedParam = new rust.HeaderHashMapParameter(paramName, param.serializedName, paramLoc, param.optional, paramType);
                 }
                 else {
-                    adaptedParam = new rust.HeaderParameter(paramName, param.serializedName, paramLoc, param.optional, this.typeToWireType(paramType));
+                    paramType = this.typeToWireType(paramType);
+                    switch (paramType.kind) {
+                        case 'hashmap':
+                        case 'jsonValue':
+                        case 'model':
+                        case 'slice':
+                        case 'str':
+                        case 'Vec':
+                            throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for scalar header ${param.serializedName}`, (_e = param.__raw) === null || _e === void 0 ? void 0 : _e.node);
+                    }
+                    adaptedParam = new rust.HeaderScalarParameter(paramName, param.serializedName, paramLoc, param.optional, paramType);
                     adaptedParam.isApiVersion = param.isApiVersionParam;
                 }
                 break;
             case 'path':
-                adaptedParam = new rust.PathParameter(paramName, param.serializedName, paramLoc, param.optional, this.typeToWireType(paramType), param.allowReserved);
+                {
+                    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;
+                        }
+                    }
+                    if (isRefSlice(paramType)) {
+                        adaptedParam = new rust.PathCollectionParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, param.allowReserved, style, param.explode);
+                    }
+                    else if (paramType.kind === 'hashmap') {
+                        adaptedParam = new rust.PathHashMapParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, param.allowReserved, style, param.explode);
+                    }
+                    else {
+                        switch (paramType.kind) {
+                            case 'jsonValue':
+                            case 'model':
+                            case 'slice':
+                            case 'str':
+                            case 'Vec':
+                                throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for scalar path ${param.serializedName}`, (_g = param.__raw) === null || _g === void 0 ? void 0 : _g.node);
+                        }
+                        adaptedParam = new rust.PathScalarParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, param.allowReserved, style);
+                    }
+                }
                 break;
             case 'query':
-                if (param.collectionFormat) {
-                    const format = param.collectionFormat === 'simple' ? 'csv' : (param.collectionFormat === 'form' ? 'multi' : param.collectionFormat);
-                    if (paramType.kind !== 'Vec' && !isRefSlice(paramType)) {
-                        throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for QueryCollectionParameter`, (_e = param.__raw) === null || _e === void 0 ? void 0 : _e.node);
+                paramType = this.typeToWireType(paramType);
+                if (paramType.kind === 'Vec' || isRefSlice(paramType)) {
+                    let format = param.explode ? 'multi' : 'csv';
+                    if (param.collectionFormat) {
+                        format = param.collectionFormat === 'simple' ? 'csv' : (param.collectionFormat === 'form' ? 'multi' : param.collectionFormat);
                     }
                     // 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') {
+                    // 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);
+                }
                 else {
+                    switch (paramType.kind) {
+                        case 'jsonValue':
+                        case 'model':
+                        case 'slice':
+                        case 'str':
+                            throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for scalar query ${param.serializedName}`, (_h = param.__raw) === null || _h === void 0 ? void 0 : _h.node);
+                    }
                     // TODO: hard-coded encoding setting, https://github.com/Azure/typespec-azure/issues/1314
-                    adaptedParam = new rust.QueryParameter(paramName, param.serializedName, paramLoc, param.optional, this.typeToWireType(paramType), true);
+                    adaptedParam = new rust.QueryScalarParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, true);
                     adaptedParam.isApiVersion = param.isApiVersionParam;
                 }
                 break;
@@ -1604,42 +1666,36 @@ export class Adapter {
      */
     adaptMethodSpreadParameter(param, format, opParamType) {
         var _a, _b;
-        switch (format) {
-            case 'json':
-            case 'xml': {
-                // 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;
-                        break;
-                    }
-                }
-                if (serializedName === undefined) {
-                    throw new AdapterError('InternalError', `didn't find body model property for spread parameter ${param.name}`, (_a = param.__raw) === null || _a === void 0 ? void 0 : _a.node);
-                }
-                // this is the internal model type that the spread params coalesce into
-                const payloadType = this.getType(opParamType);
-                if (payloadType.kind !== 'model') {
-                    throw new AdapterError('InternalError', `unexpected kind ${payloadType.kind} for spread body param`, (_b = opParamType.__raw) === null || _b === void 0 ? void 0 : _b.node);
-                }
-                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)));
-                return adaptedParam;
+        // 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;
+                break;
             }
         }
+        if (serializedName === undefined) {
+            throw new AdapterError('InternalError', `didn't find body model property for spread parameter ${param.name}`, (_a = param.__raw) === null || _a === void 0 ? void 0 : _a.node);
+        }
+        // this is the internal model type that the spread params coalesce into
+        const payloadType = this.getType(opParamType);
+        if (payloadType.kind !== 'model') {
+            throw new AdapterError('InternalError', `unexpected kind ${payloadType.kind} for spread body param`, (_b = opParamType.__raw) === null || _b === void 0 ? void 0 : _b.node);
+        }
+        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)));
+        return adaptedParam;
     }
     /**
-     * converts a Content-Type header value into a Rust body format
+     * converts a Content-Type header value into a payload format
      *
      * @param contentType the value of the Content-Type header
-     * @returns a Rust body format
+     * @returns a payload format
      */
-    adaptBodyFormat(contentType) {
-        // we only recognize/support JSON, text, and XML content types.
+    adaptPayloadFormat(contentType) {
+        // we only recognize/support JSON and XML content types.
         if (contentType.match(/json/i)) {
-            this.crate.addDependency(new rust.CrateDependency('serde_json'));
             return 'json';
         }
         else if (contentType.match(/xml/i)) {
@@ -1651,6 +1707,27 @@ export class Adapter {
             throw new AdapterError('InternalError', `unexpected contentType ${contentType}`);
         }
     }
+    /**
+     * converts an accept header value into a response format
+     *
+     * @param accept the value of the Content-Type header
+     * @returns a response format
+     */
+    adaptResponseFormat(accept) {
+        // we only recognize/support JSON and XML content types.
+        // anything else is NoFormat
+        if (accept.match(/json/i)) {
+            return 'JsonFormat';
+        }
+        else if (accept.match(/xml/i)) {
+            // XML support is disabled by default
+            this.crate.addDependency(new rust.CrateDependency('azure_core', ['xml']));
+            return 'XmlFormat';
+        }
+        else {
+            return 'NoFormat';
+        }
+    }
 }
 /** typeguard to determine if type is a Ref<Slice> */
 function isRefSlice(type) {