@azure/arm-managedapplications 1.1.0 → 2.0.0-beta.1

package/src/applicationClient.ts

@@ -0,0 +1,222 @@
+/*
+ * 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.
+ */
+
+import * as coreClient from "@azure/core-client";
+import * as coreAuth from "@azure/core-auth";
+import "@azure/core-paging";
+import { PagedAsyncIterableIterator } from "@azure/core-paging";
+import { ApplicationsImpl, ApplicationDefinitionsImpl } from "./operations";
+import { Applications, ApplicationDefinitions } from "./operationsInterfaces";
+import * as Parameters from "./models/parameters";
+import * as Mappers from "./models/mappers";
+import { ApplicationClientContext } from "./applicationClientContext";
+import {
+  ApplicationClientOptionalParams,
+  Operation,
+  ApplicationClientListOperationsNextOptionalParams,
+  ApplicationClientListOperationsOptionalParams,
+  ApplicationClientListOperationsNextNextOptionalParams,
+  ApplicationClientListOperationsResponse,
+  ApplicationClientListOperationsNextResponse,
+  ApplicationClientListOperationsNextNextResponse
+} from "./models";
+
+/// <reference lib="esnext.asynciterable" />
+export class ApplicationClient extends ApplicationClientContext {
+  /**
+   * Initializes a new instance of the ApplicationClient class.
+   * @param credentials Subscription credentials which uniquely identify client subscription.
+   * @param subscriptionId The ID of the target subscription.
+   * @param options The parameter options
+   */
+  constructor(
+    credentials: coreAuth.TokenCredential,
+    subscriptionId: string,
+    options?: ApplicationClientOptionalParams
+  ) {
+    super(credentials, subscriptionId, options);
+    this.applications = new ApplicationsImpl(this);
+    this.applicationDefinitions = new ApplicationDefinitionsImpl(this);
+  }
+
+  /**
+   * Lists all of the available Microsoft.Solutions REST API operations.
+   * @param options The options parameters.
+   */
+  public listOperations(
+    options?: ApplicationClientListOperationsOptionalParams
+  ): PagedAsyncIterableIterator<Operation> {
+    const iter = this.listOperationsPagingAll(options);
+    return {
+      next() {
+        return iter.next();
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+      byPage: () => {
+        return this.listOperationsPagingPage(options);
+      }
+    };
+  }
+
+  private async *listOperationsPagingPage(
+    options?: ApplicationClientListOperationsOptionalParams
+  ): AsyncIterableIterator<Operation[]> {
+    let result = await this._listOperations(options);
+    yield result.value || [];
+    let continuationToken = result.nextLink;
+    while (continuationToken) {
+      result = await this._listOperationsNext(continuationToken, options);
+      continuationToken = result.nextLink;
+      yield result.value || [];
+    }
+  }
+
+  private async *listOperationsPagingAll(
+    options?: ApplicationClientListOperationsOptionalParams
+  ): AsyncIterableIterator<Operation> {
+    for await (const page of this.listOperationsPagingPage(options)) {
+      yield* page;
+    }
+  }
+
+  /**
+   * ListOperationsNext
+   * @param nextLink The nextLink from the previous successful call to the ListOperations method.
+   * @param options The options parameters.
+   */
+  public listOperationsNext(
+    nextLink: string,
+    options?: ApplicationClientListOperationsNextOptionalParams
+  ): PagedAsyncIterableIterator<Operation> {
+    const iter = this.listOperationsNextPagingAll(nextLink, options);
+    return {
+      next() {
+        return iter.next();
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+      byPage: () => {
+        return this.listOperationsNextPagingPage(nextLink, options);
+      }
+    };
+  }
+
+  private async *listOperationsNextPagingPage(
+    nextLink: string,
+    options?: ApplicationClientListOperationsNextOptionalParams
+  ): AsyncIterableIterator<Operation[]> {
+    let result = await this._listOperationsNext(nextLink, options);
+    yield result.value || [];
+    let continuationToken = result.nextLink;
+    while (continuationToken) {
+      result = await this._listOperationsNextNext(continuationToken, options);
+      continuationToken = result.nextLink;
+      yield result.value || [];
+    }
+  }
+
+  private async *listOperationsNextPagingAll(
+    nextLink: string,
+    options?: ApplicationClientListOperationsNextOptionalParams
+  ): AsyncIterableIterator<Operation> {
+    for await (const page of this.listOperationsNextPagingPage(
+      nextLink,
+      options
+    )) {
+      yield* page;
+    }
+  }
+
+  /**
+   * Lists all of the available Microsoft.Solutions REST API operations.
+   * @param options The options parameters.
+   */
+  private _listOperations(
+    options?: ApplicationClientListOperationsOptionalParams
+  ): Promise<ApplicationClientListOperationsResponse> {
+    return this.sendOperationRequest({ options }, listOperationsOperationSpec);
+  }
+
+  /**
+   * ListOperationsNext
+   * @param nextLink The nextLink from the previous successful call to the ListOperations method.
+   * @param options The options parameters.
+   */
+  private _listOperationsNext(
+    nextLink: string,
+    options?: ApplicationClientListOperationsNextOptionalParams
+  ): Promise<ApplicationClientListOperationsNextResponse> {
+    return this.sendOperationRequest(
+      { nextLink, options },
+      listOperationsNextOperationSpec
+    );
+  }
+
+  /**
+   * ListOperationsNextNext
+   * @param nextLink The nextLink from the previous successful call to the ListOperationsNext method.
+   * @param options The options parameters.
+   */
+  private _listOperationsNextNext(
+    nextLink: string,
+    options?: ApplicationClientListOperationsNextNextOptionalParams
+  ): Promise<ApplicationClientListOperationsNextNextResponse> {
+    return this.sendOperationRequest(
+      { nextLink, options },
+      listOperationsNextNextOperationSpec
+    );
+  }
+
+  applications: Applications;
+  applicationDefinitions: ApplicationDefinitions;
+}
+// Operation Specifications
+const serializer = coreClient.createSerializer(Mappers, /* isXml */ false);
+
+const listOperationsOperationSpec: coreClient.OperationSpec = {
+  path: "/providers/Microsoft.Solutions/operations",
+  httpMethod: "GET",
+  responses: {
+    200: {
+      bodyMapper: Mappers.OperationListResult
+    }
+  },
+  queryParameters: [Parameters.apiVersion],
+  urlParameters: [Parameters.$host],
+  headerParameters: [Parameters.accept],
+  serializer
+};
+const listOperationsNextOperationSpec: coreClient.OperationSpec = {
+  path: "{nextLink}",
+  httpMethod: "GET",
+  responses: {
+    200: {
+      bodyMapper: Mappers.OperationListResult
+    }
+  },
+  queryParameters: [Parameters.apiVersion],
+  urlParameters: [Parameters.$host, Parameters.nextLink],
+  headerParameters: [Parameters.accept],
+  serializer
+};
+const listOperationsNextNextOperationSpec: coreClient.OperationSpec = {
+  path: "{nextLink}",
+  httpMethod: "GET",
+  responses: {
+    200: {
+      bodyMapper: Mappers.OperationListResult
+    }
+  },
+  queryParameters: [Parameters.apiVersion],
+  urlParameters: [Parameters.$host, Parameters.nextLink],
+  headerParameters: [Parameters.accept],
+  serializer
+};

package/src/applicationClientContext.ts

@@ -0,0 +1,70 @@
+/*
+ * 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.
+ */
+
+import * as coreClient from "@azure/core-client";
+import * as coreAuth from "@azure/core-auth";
+import { ApplicationClientOptionalParams } from "./models";
+
+export class ApplicationClientContext extends coreClient.ServiceClient {
+  $host: string;
+  apiVersion: string;
+  subscriptionId: string;
+
+  /**
+   * Initializes a new instance of the ApplicationClientContext class.
+   * @param credentials Subscription credentials which uniquely identify client subscription.
+   * @param subscriptionId The ID of the target subscription.
+   * @param options The parameter options
+   */
+  constructor(
+    credentials: coreAuth.TokenCredential,
+    subscriptionId: string,
+    options?: ApplicationClientOptionalParams
+  ) {
+    if (credentials === undefined) {
+      throw new Error("'credentials' cannot be null");
+    }
+    if (subscriptionId === undefined) {
+      throw new Error("'subscriptionId' cannot be null");
+    }
+
+    // Initializing default values for options
+    if (!options) {
+      options = {};
+    }
+    const defaults: ApplicationClientOptionalParams = {
+      requestContentType: "application/json; charset=utf-8",
+      credential: credentials
+    };
+
+    const packageDetails = `azsdk-js-arm-managedapplications/2.0.0-beta.1`;
+    const userAgentPrefix =
+      options.userAgentOptions && options.userAgentOptions.userAgentPrefix
+        ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}`
+        : `${packageDetails}`;
+
+    if (!options.credentialScopes) {
+      options.credentialScopes = ["https://management.azure.com/.default"];
+    }
+    const optionsWithDefaults = {
+      ...defaults,
+      ...options,
+      userAgentOptions: {
+        userAgentPrefix
+      },
+      baseUri: options.endpoint || "https://management.azure.com"
+    };
+    super(optionsWithDefaults);
+    // Parameter assignments
+    this.subscriptionId = subscriptionId;
+
+    // Assigning values to Constant parameters
+    this.$host = options.$host || "https://management.azure.com";
+    this.apiVersion = options.apiVersion || "2018-06-01";
+  }
+}

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 { ApplicationClient } from "./applicationClient";
+export { ApplicationClientContext } from "./applicationClientContext";
+export * from "./operationsInterfaces";