@azure/arm-storage 16.1.1 → 17.0.0-alpha.20211111.1

package/rollup.config.js

@@ -1,37 +1,188 @@
-import rollup from "rollup";
-import nodeResolve from "rollup-plugin-node-resolve";
-import sourcemaps from "rollup-plugin-sourcemaps";
-
-/**
- * @type {rollup.RollupFileOptions}
- */
-const config = {
-  input: "./esm/storageManagementClient.js",
-  external: [
-    "@azure/ms-rest-js",
-    "@azure/ms-rest-azure-js"
-  ],
-  output: {
-    file: "./dist/arm-storage.js",
-    format: "umd",
-    name: "Azure.ArmStorage",
-    sourcemap: true,
-    globals: {
-      "@azure/ms-rest-js": "msRest",
-      "@azure/ms-rest-azure-js": "msRestAzure"
-    },
-    banner: `/*
+/*
  * Copyright (c) Microsoft Corporation.
  * Licensed under the MIT License.
  *
  * Code generated by Microsoft (R) AutoRest Code Generator.
  * Changes may cause incorrect behavior and will be lost if the code is regenerated.
- */`
-  },
-  plugins: [
-    nodeResolve({ mainFields: ['module', 'main'] }),
-    sourcemaps()
-  ]
+ */
+
+import nodeResolve from "@rollup/plugin-node-resolve";
+import cjs from "@rollup/plugin-commonjs";
+import sourcemaps from "rollup-plugin-sourcemaps";
+import multiEntry from "@rollup/plugin-multi-entry";
+import json from "@rollup/plugin-json";
+
+import nodeBuiltins from "builtin-modules";
+
+/**
+ * Gets the proper configuration needed for rollup's commonJS plugin for @opentelemetry/api.
+ *
+ * NOTE: this manual configuration is only needed because OpenTelemetry uses an
+ * __exportStar downleveled helper function to declare its exports which confuses
+ * rollup's automatic discovery mechanism.
+ *
+ * @returns an object reference that can be `...`'d into your cjs() configuration.
+ */
+export function openTelemetryCommonJs() {
+  const namedExports = {};
+
+  for (const key of [
+    "@opentelemetry/api",
+    "@azure/core-tracing/node_modules/@opentelemetry/api"
+  ]) {
+    namedExports[key] = [
+      "SpanKind",
+      "TraceFlags",
+      "getSpan",
+      "setSpan",
+      "SpanStatusCode",
+      "getSpanContext",
+      "setSpanContext"
+    ];
+  }
+
+  const releasedOpenTelemetryVersions = ["0.10.2", "1.0.0-rc.0"];
+
+  for (const version of releasedOpenTelemetryVersions) {
+    namedExports[
+      // working around a limitation in the rollup common.js plugin - it's not able to resolve these modules so the named exports listed above will not get applied. We have to drill down to the actual path.
+      `../../../common/temp/node_modules/.pnpm/@opentelemetry/api@${version}/node_modules/@opentelemetry/api/build/src/index.js`
+    ] = [
+      "SpanKind",
+      "TraceFlags",
+      "getSpan",
+      "setSpan",
+      "StatusCode",
+      "CanonicalCode",
+      "getSpanContext",
+      "setSpanContext"
+    ];
+  }
+
+  return namedExports;
+}
+
+// #region Warning Handler
+
+/**
+ * A function that can determine whether a rollupwarning should be ignored. If
+ * the function returns `true`, then the warning will not be displayed.
+ */
+
+function ignoreNiseSinonEvalWarnings(warning) {
+  return (
+    warning.code === "EVAL" &&
+    warning.id &&
+      (warning.id.includes("node_modules/nise") ||
+        warning.id.includes("node_modules/sinon")) === true
+  );
+}
+
+function ignoreChaiCircularDependencyWarnings(warning) {
+  return (
+    warning.code === "CIRCULAR_DEPENDENCY" &&
+    warning.importer && warning.importer.includes("node_modules/chai") === true
+  );
+}
+
+const warningInhibitors = [
+  ignoreChaiCircularDependencyWarnings,
+  ignoreNiseSinonEvalWarnings
+];
+
+/**
+ * Construct a warning handler for the shared rollup configuration
+ * that ignores certain warnings that are not relevant to testing.
+ */
+function makeOnWarnForTesting() {
+  return (warning, warn) => {
+    // If every inhibitor returns false (i.e. no inhibitors), then show the warning
+    if (warningInhibitors.every((inhib) => !inhib(warning))) {
+      warn(warning);
+    }
+  };
+}
+
+// #endregion
+
+function makeBrowserTestConfig() {
+  const config = {
+    input: {
+      include: ["dist-esm/test/**/*.spec.js"],
+      exclude: ["dist-esm/test/**/node/**"]
+    },
+    output: {
+      file: `dist-test/index.browser.js`,
+      format: "umd",
+      sourcemap: true
+    },
+    preserveSymlinks: false,
+    plugins: [
+      multiEntry({ exports: false }),
+      nodeResolve({
+        mainFields: ["module", "browser"]
+      }),
+      cjs({
+        namedExports: {
+          // Chai's strange internal architecture makes it impossible to statically
+          // analyze its exports.
+          chai: [
+            "version",
+            "use",
+            "util",
+            "config",
+            "expect",
+            "should",
+            "assert"
+          ],
+          ...openTelemetryCommonJs()
+        }
+      }),
+      json(),
+      sourcemaps()
+      //viz({ filename: "dist-test/browser-stats.html", sourcemap: true })
+    ],
+    onwarn: makeOnWarnForTesting(),
+    // Disable tree-shaking of test code.  In rollup-plugin-node-resolve@5.0.0,
+    // rollup started respecting the "sideEffects" field in package.json.  Since
+    // our package.json sets "sideEffects=false", this also applies to test
+    // code, which causes all tests to be removed by tree-shaking.
+    treeshake: false
+  };
+
+  return config;
+}
+
+const defaultConfigurationOptions = {
+  disableBrowserBundle: false
 };
 
-export default config;
+export function makeConfig(pkg, options) {
+  options = {
+    ...defaultConfigurationOptions,
+    ...(options || {})
+  };
+
+  const baseConfig = {
+    // Use the package's module field if it has one
+    input: pkg["module"] || "dist-esm/src/index.js",
+    external: [
+      ...nodeBuiltins,
+      ...Object.keys(pkg.dependencies),
+      ...Object.keys(pkg.devDependencies)
+    ],
+    output: { file: "dist/index.js", format: "cjs", sourcemap: true },
+    preserveSymlinks: false,
+    plugins: [sourcemaps(), nodeResolve(), cjs()]
+  };
+
+  const config = [baseConfig];
+
+  if (!options.disableBrowserBundle) {
+    config.push(makeBrowserTestConfig());
+  }
+
+  return config;
+}
+
+export default makeConfig(require("./package.json"));

package/src/coreClientLro.ts

@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * Code generated by Microsoft (R) AutoRest Code Generator.
+ * Changes may cause incorrect behavior and will be lost if the code is regenerated.
+ */
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import {
+  OperationArguments,
+  OperationSpec,
+  OperationResponseMap,
+  FullOperationResponse
+} from "@azure/core-client";
+import {
+  LroResourceLocationConfig,
+  GetLroStatusFromResponse,
+  LongRunningOperation,
+  LroConfig,
+  LroMode,
+  LroResponse,
+  LroStatus,
+  createGetLroStatusFromResponse,
+  RawResponse
+} from "./lro";
+
+export const successStates = ["succeeded"];
+export const failureStates = ["failed", "canceled", "cancelled"];
+export const terminalStates = successStates.concat(failureStates);
+
+export type SendOperationFn<T> = (
+  args: OperationArguments,
+  spec: OperationSpec
+) => Promise<LroResponse<T>>;
+
+export function createPollingMethod<TResult>(
+  sendOperationFn: SendOperationFn<TResult>,
+  GetLroStatusFromResponse: GetLroStatusFromResponse<TResult>,
+  args: OperationArguments,
+  spec: OperationSpec,
+  mode?: LroMode
+): (path?: string) => Promise<LroStatus<TResult>> {
+  /**
+   * Polling calls will always return a status object i.e. {"status": "success"}
+   * these intermediate responses are not described in the swagger so we need to
+   * pass custom mappers at runtime.
+   * This function replaces all the existing mappers to be able to deserialize a status object
+   * @param responses Original set of responses defined in the operation
+   */
+  function getCompositeMappers(responses: {
+    [responseCode: string]: OperationResponseMap;
+  }): {
+    [responseCode: string]: OperationResponseMap;
+  } {
+    return Object.keys(responses).reduce((acc, statusCode) => {
+      return {
+        ...acc,
+        [statusCode]: {
+          ...responses[statusCode],
+          bodyMapper: {
+            type: {
+              name: "Composite",
+              modelProperties: {
+                status: {
+                  serializedName: "status",
+                  type: {
+                    name: "String"
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+    }, {} as { [responseCode: string]: OperationResponseMap });
+  }
+  let response: LroStatus<TResult> | undefined = undefined;
+  const customerCallback = args?.options?.onResponse;
+  const updatedArgs = {
+    ...args,
+    options: {
+      ...args.options,
+      onResponse: (
+        rawResponse: FullOperationResponse,
+        flatResponse: unknown
+      ): void => {
+        response = GetLroStatusFromResponse(
+          {
+            statusCode: rawResponse.status,
+            body: rawResponse.parsedBody,
+            headers: rawResponse.headers.toJSON()
+          },
+          flatResponse as TResult
+        );
+        if (response.done) {
+          customerCallback?.(rawResponse, flatResponse);
+        }
+      }
+    }
+  };
+  // Make sure we don't send any body to the get request
+  const { requestBody, responses, ...restSpec } = spec;
+  if (mode === "AzureAsync") {
+    return async (path?: string) => {
+      await sendOperationFn(updatedArgs, {
+        ...restSpec,
+        responses: getCompositeMappers(responses),
+        httpMethod: "GET",
+        ...(path && { path })
+      });
+      return response!;
+    };
+  }
+  return async (path?: string) => {
+    await sendOperationFn(updatedArgs, {
+      ...restSpec,
+      responses: responses,
+      httpMethod: "GET",
+      ...(path && { path })
+    });
+    return response!;
+  };
+}
+
+/**
+ * We need to selectively deserialize our responses, only deserializing if we
+ * are in a final Lro response, not deserializing any polling non-terminal responses
+ */
+export function shouldDeserializeLro(lroResourceLocationConfig?: string) {
+  let initialOperationInfo: LroResponseInfo | undefined;
+  let isInitialRequest = true;
+
+  return (response: FullOperationResponse) => {
+    if (response.status < 200 || response.status >= 300) {
+      return true;
+    }
+
+    if (!initialOperationInfo) {
+      initialOperationInfo = getLroData(response);
+    } else {
+      isInitialRequest = false;
+    }
+
+    if (
+      initialOperationInfo.azureAsyncOperation ||
+      initialOperationInfo.operationLocation
+    ) {
+      return (
+        !isInitialRequest &&
+        isAsyncOperationFinalResponse(
+          response,
+          initialOperationInfo,
+          lroResourceLocationConfig
+        )
+      );
+    }
+
+    if (initialOperationInfo.location) {
+      return isLocationFinalResponse(response);
+    }
+
+    if (initialOperationInfo.requestMethod === "PUT") {
+      return isBodyPollingFinalResponse(response);
+    }
+
+    return true;
+  };
+}
+
+function isAsyncOperationFinalResponse(
+  response: FullOperationResponse,
+  initialOperationInfo: LroResponseInfo,
+  lroResourceLocationConfig?: string
+): boolean {
+  const status: string = response.parsedBody?.status || "Succeeded";
+  if (!terminalStates.includes(status.toLowerCase())) {
+    return false;
+  }
+
+  if (initialOperationInfo.requestMethod === "DELETE") {
+    return true;
+  }
+
+  if (
+    initialOperationInfo.requestMethod === "PUT" &&
+    lroResourceLocationConfig &&
+    lroResourceLocationConfig.toLowerCase() === "azure-asyncoperation"
+  ) {
+    return true;
+  }
+
+  if (
+    initialOperationInfo.requestMethod !== "PUT" &&
+    !initialOperationInfo.location
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+function isLocationFinalResponse(response: FullOperationResponse): boolean {
+  return response.status !== 202;
+}
+
+function isBodyPollingFinalResponse(response: FullOperationResponse): boolean {
+  const provisioningState: string =
+    response.parsedBody?.properties?.provisioningState || "Succeeded";
+
+  if (terminalStates.includes(provisioningState.toLowerCase())) {
+    return true;
+  }
+
+  return false;
+}
+
+interface LroResponseInfo {
+  requestMethod: string;
+  azureAsyncOperation?: string;
+  operationLocation?: string;
+  location?: string;
+}
+
+function getLroData(result: FullOperationResponse): LroResponseInfo {
+  return {
+    azureAsyncOperation: result.headers.get("azure-asyncoperation"),
+    operationLocation: result.headers.get("operation-location"),
+    location: result.headers.get("location"),
+    requestMethod: result.request.method
+  };
+}
+
+export function getSpecPath(spec: OperationSpec): string {
+  if (spec.path) {
+    return spec.path;
+  } else {
+    throw Error("Bad spec: request path is not found!");
+  }
+}
+
+export class CoreClientLro<T> implements LongRunningOperation<T> {
+  constructor(
+    private sendOperationFn: SendOperationFn<T>,
+    private args: OperationArguments,
+    private spec: OperationSpec,
+    private lroResourceLocationConfig?: LroResourceLocationConfig,
+    public requestPath: string = spec.path!,
+    public requestMethod: string = spec.httpMethod
+  ) {}
+  public async sendInitialRequest(
+    initializeState: (
+      rawResponse: RawResponse,
+      flatResponse: unknown
+    ) => boolean
+  ): Promise<LroResponse<T>> {
+    const { onResponse, ...restOptions } = this.args.options || {};
+    return this.sendOperationFn(
+      {
+        ...this.args,
+        options: {
+          ...restOptions,
+          onResponse: (
+            rawResponse: FullOperationResponse,
+            flatResponse: unknown
+          ) => {
+            const isCompleted = initializeState(
+              {
+                statusCode: rawResponse.status,
+                body: rawResponse.parsedBody,
+                headers: rawResponse.headers.toJSON()
+              },
+              flatResponse
+            );
+            if (isCompleted) {
+              onResponse?.(rawResponse, flatResponse);
+            }
+          }
+        }
+      },
+      this.spec
+    );
+  }
+
+  public async sendPollRequest(
+    config: LroConfig,
+    path: string
+  ): Promise<LroStatus<T>> {
+    const getLroStatusFromResponse = createGetLroStatusFromResponse(
+      this,
+      config,
+      this.lroResourceLocationConfig
+    );
+    return createPollingMethod(
+      this.sendOperationFn,
+      getLroStatusFromResponse,
+      this.args,
+      this.spec,
+      config.mode
+    )(path);
+  }
+
+  public async retrieveAzureAsyncResource(
+    path?: string
+  ): Promise<LroResponse<T>> {
+    const updatedArgs = { ...this.args };
+    if (updatedArgs.options) {
+      (updatedArgs.options as any).shouldDeserialize = true;
+    }
+    return createPollingMethod(
+      this.sendOperationFn,
+      (rawResponse, flatResponse) => ({
+        rawResponse,
+        flatResponse,
+        done: true
+      }),
+      updatedArgs,
+      this.spec
+    )(path);
+  }
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * Code generated by Microsoft (R) AutoRest Code Generator.
+ * Changes may cause incorrect behavior and will be lost if the code is regenerated.
+ */
+
+/// <reference lib="esnext.asynciterable" />
+export * from "./models";
+export { StorageManagementClient } from "./storageManagementClient";
+export { StorageManagementClientContext } from "./storageManagementClientContext";
+export * from "./operationsInterfaces";

package/src/lro/azureAsyncPolling.ts

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * Code generated by Microsoft (R) AutoRest Code Generator.
+ * Changes may cause incorrect behavior and will be lost if the code is regenerated.
+ */
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import {
+  failureStates,
+  LroResourceLocationConfig,
+  LongRunningOperation,
+  LroBody,
+  LroResponse,
+  LroStatus,
+  RawResponse,
+  successStates
+} from "./models";
+import { isUnexpectedPollingResponse } from "./requestUtils";
+
+function getResponseStatus(rawResponse: RawResponse): string {
+  const { status } = (rawResponse.body as LroBody) ?? {};
+  return status?.toLowerCase() ?? "succeeded";
+}
+
+function isAzureAsyncPollingDone(rawResponse: RawResponse): boolean {
+  const state = getResponseStatus(rawResponse);
+  if (
+    isUnexpectedPollingResponse(rawResponse) ||
+    failureStates.includes(state)
+  ) {
+    throw new Error(`Operation status: ${state}`);
+  }
+  return successStates.includes(state);
+}
+
+async function sendFinalRequest<TResult>(
+  lro: LongRunningOperation<TResult>,
+  lroResourceLocationConfig?: LroResourceLocationConfig,
+  resourceLocation?: string
+): Promise<LroResponse<TResult> | undefined> {
+  switch (lroResourceLocationConfig) {
+    case "original-uri":
+      return lro.retrieveAzureAsyncResource();
+    case "azure-async-operation":
+      return Promise.resolve(undefined);
+    case "location":
+    default:
+      return lro.retrieveAzureAsyncResource(resourceLocation);
+  }
+}
+
+export function processAzureAsyncOperationResult<TResult>(
+  lro: LongRunningOperation<TResult>,
+  resourceLocation?: string,
+  lroResourceLocationConfig?: LroResourceLocationConfig
+): (rawResponse: RawResponse, flatResponse: TResult) => LroStatus<TResult> {
+  return (
+    rawResponse: RawResponse,
+    flatResponse: TResult
+  ): LroStatus<TResult> => {
+    if (isAzureAsyncPollingDone(rawResponse)) {
+      if (resourceLocation === undefined) {
+        return { rawResponse, flatResponse, done: true };
+      } else {
+        return {
+          rawResponse,
+          flatResponse,
+          done: false,
+          next: async () => {
+            const finalResponse = await sendFinalRequest(
+              lro,
+              lroResourceLocationConfig,
+              resourceLocation
+            );
+            return {
+              ...(finalResponse ?? {
+                rawResponse,
+                flatResponse
+              }),
+              done: true
+            };
+          }
+        };
+      }
+    }
+    return {
+      rawResponse,
+      flatResponse,
+      done: false
+    };
+  };
+}

package/src/lro/bodyPolling.ts

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * Code generated by Microsoft (R) AutoRest Code Generator.
+ * Changes may cause incorrect behavior and will be lost if the code is regenerated.
+ */
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+import {
+  failureStates,
+  LroBody,
+  LroStatus,
+  RawResponse,
+  successStates
+} from "./models";
+import { isUnexpectedPollingResponse } from "./requestUtils";
+
+function getProvisioningState(rawResponse: RawResponse): string {
+  const { properties, provisioningState } = (rawResponse.body as LroBody) ?? {};
+  const state: string | undefined =
+    properties?.provisioningState ?? provisioningState;
+  return state?.toLowerCase() ?? "succeeded";
+}
+
+export function isBodyPollingDone(rawResponse: RawResponse): boolean {
+  const state = getProvisioningState(rawResponse);
+  if (
+    isUnexpectedPollingResponse(rawResponse) ||
+    failureStates.includes(state)
+  ) {
+    throw new Error(
+      `The long running operation has failed. The provisioning state: ${state}.`
+    );
+  }
+  return successStates.includes(state);
+}
+
+/**
+ * Creates a polling strategy based on BodyPolling which uses the provisioning state
+ * from the result to determine the current operation state
+ */
+export function processBodyPollingOperationResult<TResult>(
+  rawResponse: RawResponse,
+  flatResponse: TResult
+): LroStatus<TResult> {
+  return {
+    rawResponse,
+    flatResponse,
+    done: isBodyPollingDone(rawResponse)
+  };
+}