feat: add @actions/cache

node_modules/@azure/ms-rest-js/lib/policies/deserializationPolicy.ts

@@ -0,0 +1,294 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+import { HttpOperationResponse } from "../httpOperationResponse";
+import { OperationResponse } from "../operationResponse";
+import { OperationSpec, isStreamOperation } from "../operationSpec";
+import { RestError } from "../restError";
+import { Mapper, MapperType } from "../serializer";
+import * as utils from "../util/utils";
+import { parseXML } from "../util/xml";
+import { WebResourceLike } from "../webResource";
+import {
+  BaseRequestPolicy,
+  RequestPolicy,
+  RequestPolicyFactory,
+  RequestPolicyOptionsLike,
+} from "./requestPolicy";
+
+/**
+ * The content-types that will indicate that an operation response should be deserialized in a
+ * particular way.
+ */
+export interface DeserializationContentTypes {
+  /**
+   * The content-types that indicate that an operation response should be deserialized as JSON.
+   * Defaults to [ "application/json", "text/json" ].
+   */
+  json?: string[];
+
+  /**
+   * The content-types that indicate that an operation response should be deserialized as XML.
+   * Defaults to [ "application/xml", "application/atom+xml" ].
+   */
+  xml?: string[];
+}
+
+/**
+ * Create a new serialization RequestPolicyCreator that will serialized HTTP request bodies as they
+ * pass through the HTTP pipeline.
+ */
+export function deserializationPolicy(
+  deserializationContentTypes?: DeserializationContentTypes
+): RequestPolicyFactory {
+  return {
+    create: (nextPolicy: RequestPolicy, options: RequestPolicyOptionsLike) => {
+      return new DeserializationPolicy(nextPolicy, deserializationContentTypes, options);
+    },
+  };
+}
+
+export const defaultJsonContentTypes = ["application/json", "text/json"];
+export const defaultXmlContentTypes = ["application/xml", "application/atom+xml"];
+
+/**
+ * A RequestPolicy that will deserialize HTTP response bodies and headers as they pass through the
+ * HTTP pipeline.
+ */
+export class DeserializationPolicy extends BaseRequestPolicy {
+  public readonly jsonContentTypes: string[];
+  public readonly xmlContentTypes: string[];
+
+  constructor(
+    nextPolicy: RequestPolicy,
+    deserializationContentTypes: DeserializationContentTypes | undefined,
+    options: RequestPolicyOptionsLike
+  ) {
+    super(nextPolicy, options);
+
+    this.jsonContentTypes =
+      (deserializationContentTypes && deserializationContentTypes.json) || defaultJsonContentTypes;
+    this.xmlContentTypes =
+      (deserializationContentTypes && deserializationContentTypes.xml) || defaultXmlContentTypes;
+  }
+
+  public async sendRequest(request: WebResourceLike): Promise<HttpOperationResponse> {
+    return this._nextPolicy
+      .sendRequest(request)
+      .then((response: HttpOperationResponse) =>
+        deserializeResponseBody(this.jsonContentTypes, this.xmlContentTypes, response)
+      );
+  }
+}
+
+function getOperationResponse(
+  parsedResponse: HttpOperationResponse
+): undefined | OperationResponse {
+  let result: OperationResponse | undefined;
+  const request: WebResourceLike = parsedResponse.request;
+  const operationSpec: OperationSpec | undefined = request.operationSpec;
+  if (operationSpec) {
+    const operationResponseGetter:
+      | undefined
+      | ((
+          operationSpec: OperationSpec,
+          response: HttpOperationResponse
+        ) => undefined | OperationResponse) = request.operationResponseGetter;
+    if (!operationResponseGetter) {
+      result = operationSpec.responses[parsedResponse.status];
+    } else {
+      result = operationResponseGetter(operationSpec, parsedResponse);
+    }
+  }
+  return result;
+}
+
+function shouldDeserializeResponse(parsedResponse: HttpOperationResponse): boolean {
+  const shouldDeserialize: undefined | boolean | ((response: HttpOperationResponse) => boolean) =
+    parsedResponse.request.shouldDeserialize;
+  let result: boolean;
+  if (shouldDeserialize === undefined) {
+    result = true;
+  } else if (typeof shouldDeserialize === "boolean") {
+    result = shouldDeserialize;
+  } else {
+    result = shouldDeserialize(parsedResponse);
+  }
+  return result;
+}
+
+export function deserializeResponseBody(
+  jsonContentTypes: string[],
+  xmlContentTypes: string[],
+  response: HttpOperationResponse
+): Promise<HttpOperationResponse> {
+  return parse(jsonContentTypes, xmlContentTypes, response).then((parsedResponse) => {
+    const shouldDeserialize: boolean = shouldDeserializeResponse(parsedResponse);
+    if (shouldDeserialize) {
+      const operationSpec: OperationSpec | undefined = parsedResponse.request.operationSpec;
+      if (operationSpec && operationSpec.responses) {
+        const statusCode: number = parsedResponse.status;
+
+        const expectedStatusCodes: string[] = Object.keys(operationSpec.responses);
+
+        const hasNoExpectedStatusCodes: boolean =
+          expectedStatusCodes.length === 0 ||
+          (expectedStatusCodes.length === 1 && expectedStatusCodes[0] === "default");
+
+        const responseSpec: OperationResponse | undefined = getOperationResponse(parsedResponse);
+
+        const isExpectedStatusCode: boolean = hasNoExpectedStatusCodes
+          ? 200 <= statusCode && statusCode < 300
+          : !!responseSpec;
+        if (!isExpectedStatusCode) {
+          const defaultResponseSpec: OperationResponse = operationSpec.responses.default;
+          if (defaultResponseSpec) {
+            const initialErrorMessage: string = isStreamOperation(operationSpec)
+              ? `Unexpected status code: ${statusCode}`
+              : (parsedResponse.bodyAsText as string);
+
+            const error = new RestError(initialErrorMessage);
+            error.statusCode = statusCode;
+            error.request = utils.stripRequest(parsedResponse.request);
+            error.response = utils.stripResponse(parsedResponse);
+
+            let parsedErrorResponse: { [key: string]: any } = parsedResponse.parsedBody;
+            try {
+              if (parsedErrorResponse) {
+                const defaultResponseBodyMapper: Mapper | undefined =
+                  defaultResponseSpec.bodyMapper;
+                if (
+                  defaultResponseBodyMapper &&
+                  defaultResponseBodyMapper.serializedName === "CloudError"
+                ) {
+                  if (parsedErrorResponse.error) {
+                    parsedErrorResponse = parsedErrorResponse.error;
+                  }
+                  if (parsedErrorResponse.code) {
+                    error.code = parsedErrorResponse.code;
+                  }
+                  if (parsedErrorResponse.message) {
+                    error.message = parsedErrorResponse.message;
+                  }
+                } else {
+                  let internalError: any = parsedErrorResponse;
+                  if (parsedErrorResponse.error) {
+                    internalError = parsedErrorResponse.error;
+                  }
+
+                  error.code = internalError.code;
+                  if (internalError.message) {
+                    error.message = internalError.message;
+                  }
+                }
+
+                if (defaultResponseBodyMapper) {
+                  let valueToDeserialize: any = parsedErrorResponse;
+                  if (
+                    operationSpec.isXML &&
+                    defaultResponseBodyMapper.type.name === MapperType.Sequence
+                  ) {
+                    valueToDeserialize =
+                      typeof parsedErrorResponse === "object"
+                        ? parsedErrorResponse[defaultResponseBodyMapper.xmlElementName!]
+                        : [];
+                  }
+                  error.body = operationSpec.serializer.deserialize(
+                    defaultResponseBodyMapper,
+                    valueToDeserialize,
+                    "error.body"
+                  );
+                }
+              }
+            } catch (defaultError) {
+              error.message = `Error \"${defaultError.message}\" occurred in deserializing the responseBody - \"${parsedResponse.bodyAsText}\" for the default response.`;
+            }
+            return Promise.reject(error);
+          }
+        } else if (responseSpec) {
+          if (responseSpec.bodyMapper) {
+            let valueToDeserialize: any = parsedResponse.parsedBody;
+            if (operationSpec.isXML && responseSpec.bodyMapper.type.name === MapperType.Sequence) {
+              valueToDeserialize =
+                typeof valueToDeserialize === "object"
+                  ? valueToDeserialize[responseSpec.bodyMapper.xmlElementName!]
+                  : [];
+            }
+            try {
+              parsedResponse.parsedBody = operationSpec.serializer.deserialize(
+                responseSpec.bodyMapper,
+                valueToDeserialize,
+                "operationRes.parsedBody"
+              );
+            } catch (error) {
+              const restError = new RestError(
+                `Error ${error} occurred in deserializing the responseBody - ${parsedResponse.bodyAsText}`
+              );
+              restError.request = utils.stripRequest(parsedResponse.request);
+              restError.response = utils.stripResponse(parsedResponse);
+              return Promise.reject(restError);
+            }
+          } else if (operationSpec.httpMethod === "HEAD") {
+            // head methods never have a body, but we return a boolean to indicate presence/absence of the resource
+            parsedResponse.parsedBody = response.status >= 200 && response.status < 300;
+          }
+
+          if (responseSpec.headersMapper) {
+            parsedResponse.parsedHeaders = operationSpec.serializer.deserialize(
+              responseSpec.headersMapper,
+              parsedResponse.headers.rawHeaders(),
+              "operationRes.parsedHeaders"
+            );
+          }
+        }
+      }
+    }
+    return Promise.resolve(parsedResponse);
+  });
+}
+
+function parse(
+  jsonContentTypes: string[],
+  xmlContentTypes: string[],
+  operationResponse: HttpOperationResponse
+): Promise<HttpOperationResponse> {
+  const errorHandler = (err: Error & { code: string }) => {
+    const msg = `Error "${err}" occurred while parsing the response body - ${operationResponse.bodyAsText}.`;
+    const errCode = err.code || RestError.PARSE_ERROR;
+    const e = new RestError(
+      msg,
+      errCode,
+      operationResponse.status,
+      operationResponse.request,
+      operationResponse,
+      operationResponse.bodyAsText
+    );
+    return Promise.reject(e);
+  };
+
+  if (!operationResponse.request.streamResponseBody && operationResponse.bodyAsText) {
+    const text = operationResponse.bodyAsText;
+    const contentType: string = operationResponse.headers.get("Content-Type") || "";
+    const contentComponents: string[] = !contentType
+      ? []
+      : contentType.split(";").map((component) => component.toLowerCase());
+    if (
+      contentComponents.length === 0 ||
+      contentComponents.some((component) => jsonContentTypes.indexOf(component) !== -1)
+    ) {
+      return new Promise<HttpOperationResponse>((resolve) => {
+        operationResponse.parsedBody = JSON.parse(text);
+        resolve(operationResponse);
+      }).catch(errorHandler);
+    } else if (contentComponents.some((component) => xmlContentTypes.indexOf(component) !== -1)) {
+      return parseXML(text)
+        .then((body) => {
+          operationResponse.parsedBody = body;
+          return operationResponse;
+        })
+        .catch(errorHandler);
+    }
+  }
+
+  return Promise.resolve(operationResponse);
+}