node-nlp
Version:
Library for NLU (Natural Language Understanding) done in Node.js
1,014 lines (994 loc) • 49.4 kB
JavaScript
/** @license ms-rest-azure-js
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*/
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('ms-rest-js')) :
typeof define === 'function' && define.amd ? define(['exports', 'ms-rest-js'], factory) :
(factory((global.msRestAzure = {}),global.msRest));
}(this, (function (exports,msRestJs) { 'use strict';
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function() {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __awaiter(thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
}
// Copyright (c) Microsoft Corporation. All rights reserved.
/**
* A long-running operation polling strategy base class that other polling strategies should extend.
*/
var LROPollStrategy = /** @class */ (function () {
function LROPollStrategy(_azureServiceClient, _pollState) {
this._azureServiceClient = _azureServiceClient;
this._pollState = _pollState;
}
LROPollStrategy.prototype.getOperationStatus = function () {
return this._pollState.state;
};
/**
* Get whether or not this poll strategy's LRO is finished.
* @returns Whether or not this poll strategy's LRO is finished.
*/
LROPollStrategy.prototype.isFinished = function () {
return isFinished(this._pollState.state);
};
/**
* Send poll requests that check the LRO's status until it is determined that the LRO is finished.
* @returns Whether or not the LRO succeeded.
*/
LROPollStrategy.prototype.pollUntilFinished = function () {
return __awaiter(this, void 0, void 0, function () {
var delayInSeconds;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!!this.isFinished()) return [3 /*break*/, 3];
delayInSeconds = getDelayInSeconds(this._azureServiceClient, this._pollState.mostRecentResponse);
return [4 /*yield*/, msRestJs.delay(delayInSeconds * 1000)];
case 1:
_a.sent();
return [4 /*yield*/, this.sendPollRequest()];
case 2:
_a.sent();
return [3 /*break*/, 0];
case 3: return [2 /*return*/, this.isFinalStatusAcceptable()];
}
});
});
};
LROPollStrategy.prototype.shouldDoFinalGetResourceRequest = function () {
var initialRequestMethod = this._pollState.initialResponse.request.method;
return !this._pollState.resource && (initialRequestMethod === "PUT" || initialRequestMethod === "PATCH" || initialRequestMethod === "POST");
};
LROPollStrategy.prototype.getMostRecentResponse = function () {
return this._pollState.mostRecentResponse;
};
LROPollStrategy.prototype.getOperationResponse = function () {
return __awaiter(this, void 0, void 0, function () {
var response, result, resource;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!this.shouldDoFinalGetResourceRequest()) return [3 /*break*/, 2];
return [4 /*yield*/, this.doFinalGetResourceRequest()];
case 1:
_a.sent();
_a.label = 2;
case 2:
response = this._pollState.mostRecentResponse;
result = __assign({}, response, { headers: response.headers.clone() });
resource = this._pollState.resource;
if (!resource) {
result.bodyAsText = response.bodyAsText;
result.parsedBody = response.parsedBody;
}
else if (typeof resource.valueOf() === "string") {
result.bodyAsText = resource;
result.parsedBody = JSON.parse(resource);
}
else {
result.bodyAsText = JSON.stringify(resource);
result.parsedBody = resource;
}
return [2 /*return*/, result];
}
});
});
};
LROPollStrategy.prototype.getRestError = function () {
var error = new msRestJs.RestError("");
error.request = msRestJs.stripRequest(this._pollState.mostRecentRequest);
error.response = this._pollState.mostRecentResponse;
error.message = "Long running operation failed with status: \"" + this._pollState.state + "\".";
error.body = this._pollState.resource;
if (error.body) {
var innerError = error.body.error;
if (innerError) {
if (innerError.message) {
error.message = "Long running operation failed with error: \"" + innerError.message + "\".";
}
if (innerError.code) {
error.code = innerError.code;
}
}
}
return error;
};
LROPollStrategy.prototype.updateState = function (url, shouldDeserialize) {
var _this = this;
return this.updateOperationStatus(url, shouldDeserialize).then(function (result) {
_this._pollState.state = getProvisioningState(result.parsedBody) || "Succeeded";
_this._pollState.mostRecentResponse = result;
_this._pollState.mostRecentRequest = result.request;
try {
_this._pollState.resource = getResponseBody(result);
}
catch (error) {
_this._pollState.resource = undefined;
var resultStatus = result.status;
if (_this._pollState.initialResponse.request.method !== "DELETE" || resultStatus < 400 || 499 < resultStatus) {
throw error;
}
}
});
};
/**
* Retrieves operation status by querying the operation URL.
* @param {string} statusUrl URL used to poll operation result.
*/
LROPollStrategy.prototype.updateOperationStatus = function (statusUrl, shouldDeserialize) {
var requestUrl = statusUrl.replace(" ", "%20");
var httpRequest = new msRestJs.WebResource(requestUrl, "GET");
var pollState = this._pollState;
httpRequest.operationSpec = pollState.mostRecentRequest.operationSpec;
httpRequest.shouldDeserialize = shouldDeserialize;
httpRequest.operationResponseGetter = getOperationResponse;
var options = pollState.options;
if (options && options.customHeaders) {
var customHeaders = options.customHeaders;
for (var _i = 0, _a = Object.keys(customHeaders); _i < _a.length; _i++) {
var headerName = _a[_i];
httpRequest.headers.set(headerName, customHeaders[headerName]);
}
}
return this._azureServiceClient.sendRequest(httpRequest);
};
LROPollStrategy.prototype.getPollState = function () {
return this._pollState;
};
return LROPollStrategy;
}());
function getOperationResponse(operationSpec, response) {
var statusCode = response.status;
var operationResponses = operationSpec.responses;
var result = operationResponses[statusCode];
if (!result) {
if (statusCode === 200) {
result = operationResponses[201] || operationResponses[202];
}
else if (201 <= statusCode && statusCode <= 299) {
result = {};
}
}
return result;
}
function getDelayInSeconds(azureServiceClient, previousResponse) {
var delayInSeconds = 30;
if (azureServiceClient.longRunningOperationRetryTimeout != undefined) {
delayInSeconds = azureServiceClient.longRunningOperationRetryTimeout;
}
else {
var retryAfterHeaderValue = previousResponse.headers.get("retry-after");
if (retryAfterHeaderValue) {
var retryAfterDelayInSeconds = parseInt(retryAfterHeaderValue);
if (!Number.isNaN(retryAfterDelayInSeconds)) {
delayInSeconds = retryAfterDelayInSeconds;
}
}
}
return delayInSeconds;
}
function getProvisioningState(responseBody) {
var result;
if (responseBody) {
if (responseBody.provisioningState) {
result = responseBody.provisioningState;
}
else if (responseBody.properties) {
result = responseBody.properties.provisioningState;
}
}
return result;
}
function getResponseBody(response) {
var result;
try {
if (response.parsedBody) {
result = response.parsedBody;
}
else if (response.bodyAsText && response.bodyAsText.length > 0) {
result = JSON.parse(response.bodyAsText);
}
}
catch (error) {
var deserializationError = new msRestJs.RestError("Error \"" + error + "\" occurred in parsing the responseBody \" +\n \"while creating the PollingState for Long Running Operation- \"" + response.bodyAsText + "\"");
deserializationError.request = response.request;
deserializationError.response = response;
throw deserializationError;
}
return result;
}
function getStatusFromResponse(response, responseBody) {
if (responseBody == undefined) {
responseBody = getResponseBody(response);
}
var result;
switch (response.status) {
case 202:
result = "InProgress";
break;
case 204:
result = "Succeeded";
break;
case 201:
result = getProvisioningState(responseBody) || "InProgress";
break;
case 200:
var provisioningState = getProvisioningState(responseBody);
if (provisioningState) {
result = provisioningState;
}
else if (getAzureAsyncOperationHeaderValue(response) || getLocationHeaderValue(response)) {
result = "InProgress";
}
else {
result = "Succeeded";
}
break;
default:
result = "Failed";
break;
}
return result;
}
var terminalStates = ["Succeeded", "Failed", "Canceled"];
/**
* Get whether or not a long-running operation with the provided status is finished.
* @param status The current status of a long-running operation.
* @returns Whether or not a long-running operation with the provided status is finished.
*/
function isFinished(status) {
return terminalStates.indexOf(status) !== -1;
}
/**
* Create a new long-running operation polling strategy based on the provided initial response.
* @param initialResponse The initial response to the long-running operation's initial request.
* @param azureServiceClient The AzureServiceClient that was used to send the initial request.
* @param options Any options that were provided to the initial request.
*/
function createLROPollStrategyFromInitialResponse(initialResponse, azureServiceClient, options) {
var initialRequestMethod = initialResponse.request.method;
var initialResponseStatus = initialResponse.status;
var lroPollStrategyType;
if (getAzureAsyncOperationHeaderValue(initialResponse)) {
lroPollStrategyType = "AzureAsyncOperation";
}
else if (getLocationHeaderValue(initialResponse)) {
lroPollStrategyType = "Location";
}
else if (initialRequestMethod === "PUT" || initialRequestMethod === "PATCH") {
lroPollStrategyType = "GetResource";
}
else if (initialResponseStatus !== 201 && initialResponseStatus !== 202 && !isFinished(getStatusFromResponse(initialResponse))) {
throw new Error("Can't determine long running operation polling strategy.");
}
var result;
if (lroPollStrategyType) {
var resource = getResponseBody(initialResponse);
var lroPollState = {
pollStrategyType: lroPollStrategyType,
options: options,
initialResponse: initialResponse,
mostRecentResponse: initialResponse,
mostRecentRequest: initialResponse.request,
azureAsyncOperationHeaderValue: getAzureAsyncOperationHeaderValue(initialResponse),
locationHeaderValue: getLocationHeaderValue(initialResponse),
resource: resource,
state: getStatusFromResponse(initialResponse, resource)
};
result = createLROPollStrategyFromPollState(azureServiceClient, lroPollState);
}
else {
result = undefined;
}
return result;
}
function createLROPollStrategyFromPollState(azureServiceClient, lroPollState) {
var result;
switch (lroPollState.pollStrategyType) {
case "AzureAsyncOperation":
result = new AzureAsyncOperationLROPollStrategy(azureServiceClient, lroPollState);
break;
case "Location":
result = new LocationLROPollStrategy(azureServiceClient, lroPollState);
break;
case "GetResource":
result = new GetResourceLROPollStrategy(azureServiceClient, lroPollState);
break;
default:
throw new Error("Unrecognized LRO poll strategy type: \"" + lroPollState.pollStrategyType + "\"");
break;
}
return result;
}
function getLocationHeaderValue(response) {
return response.headers.get("location");
}
/**
* A long-running operation polling strategy that is based on the location header.
*/
var LocationLROPollStrategy = /** @class */ (function (_super) {
__extends(LocationLROPollStrategy, _super);
function LocationLROPollStrategy() {
return _super !== null && _super.apply(this, arguments) || this;
}
LocationLROPollStrategy.prototype.locationStrategyShouldDeserialize = function (parsedResponse) {
var shouldDeserialize = false;
var initialResponse = this._pollState.initialResponse;
var initialRequestMethod = initialResponse.request.method;
var statusCode = parsedResponse.status;
if (statusCode === 200 ||
(statusCode === 201 && (initialRequestMethod === "PUT" || initialRequestMethod === "PATCH")) ||
(statusCode === 204 && (initialRequestMethod === "DELETE" || initialRequestMethod === "POST"))) {
shouldDeserialize = true;
}
return shouldDeserialize;
};
/**
* Retrieve PUT operation status by polling from "location" header.
* @param {string} method - The HTTP method.
* @param {PollingState} pollingState - The object to persist current operation state.
*/
LocationLROPollStrategy.prototype.sendPollRequest = function () {
var lroPollState = this._pollState;
return this.updateOperationStatus(lroPollState.locationHeaderValue, this.locationStrategyShouldDeserialize.bind(this)).then(function (result) {
var locationHeaderValue = getLocationHeaderValue(result);
if (locationHeaderValue) {
lroPollState.locationHeaderValue = locationHeaderValue;
}
lroPollState.mostRecentResponse = result;
lroPollState.mostRecentRequest = result.request;
var initialResponse = lroPollState.initialResponse;
var initialRequestMethod = initialResponse.request.method;
var initialResponseStatusCode = initialResponse.status;
var statusCode = result.status;
if (statusCode === 202) {
lroPollState.state = "InProgress";
}
else if (statusCode === 200 ||
(statusCode === 201 && (initialRequestMethod === "PUT" || initialRequestMethod === "PATCH")) ||
(statusCode === 204 && (initialRequestMethod === "DELETE" || initialRequestMethod === "POST"))) {
lroPollState.state = "Succeeded";
lroPollState.resource = getResponseBody(result);
}
else if (statusCode === 404 && initialRequestMethod === "POST" &&
(initialResponseStatusCode === 200 || initialResponseStatusCode === 201 || initialResponseStatusCode === 202)) {
lroPollState.state = "Failed";
lroPollState.resource = getResponseBody(result);
}
else if (400 <= statusCode && statusCode <= 499) {
var resultBody = result.bodyAsText;
throw new msRestJs.RestError(resultBody, undefined, statusCode, msRestJs.stripRequest(result.request), result, resultBody);
}
else {
throw new Error("The response with status code " + statusCode + " from polling for long running operation url \"" + lroPollState.locationHeaderValue + "\" is not valid.");
}
});
};
LocationLROPollStrategy.prototype.isFinalStatusAcceptable = function () {
var lroPollState = this._pollState;
var initialResponse = lroPollState.initialResponse;
var initialResponseStatusCode = initialResponse.status;
return lroPollState.state === "Succeeded" ||
(initialResponse.request.method === "POST" && lroPollState.mostRecentResponse.status === 404 &&
(initialResponseStatusCode === 200 ||
initialResponseStatusCode === 201 ||
initialResponseStatusCode === 202));
};
LocationLROPollStrategy.prototype.shouldDoFinalGetResourceRequest = function () {
var lroPollState = this._pollState;
var initialResponse = lroPollState.initialResponse;
var result;
var initialRequestMethod = initialResponse.request.method;
var initialResponseStatusCode = initialResponse.status;
if (initialRequestMethod === "POST" && lroPollState.mostRecentResponse.status === 404 &&
(initialResponseStatusCode === 200 ||
initialResponseStatusCode === 201 ||
initialResponseStatusCode === 202)) {
result = false;
}
else {
result = _super.prototype.shouldDoFinalGetResourceRequest.call(this) ||
(initialRequestMethod === "POST" && initialResponseStatusCode === 201);
}
return result;
};
LocationLROPollStrategy.prototype.doFinalGetResourceRequest = function () {
var lroPollState = this._pollState;
var initialResponse = lroPollState.initialResponse;
var getResourceRequestUrl;
var initialResponseStatusCode = initialResponse.status;
var initialRequest = initialResponse.request;
if (initialRequest.method === "POST" &&
(initialResponseStatusCode === 200 ||
initialResponseStatusCode === 201 ||
initialResponseStatusCode === 202)) {
getResourceRequestUrl = lroPollState.locationHeaderValue;
}
else {
getResourceRequestUrl = initialRequest.url;
}
return this.updateState(getResourceRequestUrl, true);
};
return LocationLROPollStrategy;
}(LROPollStrategy));
function getAzureAsyncOperationHeaderValue(response) {
return response.headers.get("azure-asyncoperation");
}
/**
* A long-running operation polling strategy that is based on the azure-asyncoperation header.
*/
var AzureAsyncOperationLROPollStrategy = /** @class */ (function (_super) {
__extends(AzureAsyncOperationLROPollStrategy, _super);
function AzureAsyncOperationLROPollStrategy() {
return _super !== null && _super.apply(this, arguments) || this;
}
/**
* Retrieve operation status by polling from "azure-asyncoperation" header.
* @param {PollingState} pollingState - The object to persist current operation state.
* @param {boolean} inPostOrDelete - Invoked by Post Or Delete operation.
*/
AzureAsyncOperationLROPollStrategy.prototype.sendPollRequest = function () {
var lroPollState = this._pollState;
return this.updateOperationStatus(lroPollState.azureAsyncOperationHeaderValue, false).then(function (response) {
var statusCode = response.status;
var parsedResponse = response.parsedBody;
if (statusCode !== 200 && statusCode !== 201 && statusCode !== 202 && statusCode !== 204) {
var error = new msRestJs.RestError("Invalid status code (" + statusCode + ") with response body \"" + response.bodyAsText + "\" occurred when polling for operation status.");
error.statusCode = statusCode;
error.request = msRestJs.stripRequest(response.request);
error.response = response;
error.body = parsedResponse;
throw error;
}
if (!parsedResponse) {
throw new Error("The response from long running operation does not contain a body.");
}
else if (!parsedResponse.status) {
throw new Error("The response \"" + response.bodyAsText + "\" from long running operation does not contain the status property.");
}
var azureAsyncOperationHeaderValue = getAzureAsyncOperationHeaderValue(response);
if (azureAsyncOperationHeaderValue) {
lroPollState.azureAsyncOperationHeaderValue = azureAsyncOperationHeaderValue;
}
lroPollState.state = parsedResponse.status;
lroPollState.mostRecentResponse = response;
lroPollState.mostRecentRequest = response.request;
lroPollState.resource = getResponseBody(response);
});
};
AzureAsyncOperationLROPollStrategy.prototype.shouldDoFinalGetResourceRequest = function () {
var lroPollState = this._pollState;
var initialResponse = lroPollState.initialResponse;
var initialRequestMethod = initialResponse.request.method;
var result = false;
if (initialRequestMethod === "PUT" || initialRequestMethod === "PATCH") {
result = true;
}
else {
if (lroPollState.locationHeaderValue) {
var initialResponseStatusCode = initialResponse.status;
if (initialRequestMethod === "POST") {
result = initialResponseStatusCode === 200 || initialResponseStatusCode === 201 || initialResponseStatusCode === 202;
}
else if (initialRequestMethod === "DELETE") {
result = initialResponseStatusCode === 200 || initialResponseStatusCode === 202;
}
}
}
return result;
};
AzureAsyncOperationLROPollStrategy.prototype.doFinalGetResourceRequest = function () {
var lroPollState = this._pollState;
var locationHeaderValue = lroPollState.locationHeaderValue;
var initialResponse = lroPollState.initialResponse;
var initialRequest = initialResponse.request;
var getResourceRequestUrl = initialRequest.url;
if (locationHeaderValue) {
var initialRequestMethod = initialRequest.method;
var initialResponseStatusCode = initialResponse.status;
if (initialRequestMethod === "POST" && (initialResponseStatusCode === 200 || initialResponseStatusCode === 201 || initialResponseStatusCode === 202)) {
getResourceRequestUrl = locationHeaderValue;
}
else if (initialRequestMethod === "DELETE" && (initialResponseStatusCode === 200 || initialResponseStatusCode === 202)) {
getResourceRequestUrl = locationHeaderValue;
}
}
return this.updateState(getResourceRequestUrl, true);
};
AzureAsyncOperationLROPollStrategy.prototype.isFinalStatusAcceptable = function () {
var lroPollState = this._pollState;
var initialResponse = lroPollState.initialResponse;
var initialResponseStatusCode = initialResponse.status;
return lroPollState.state === "Succeeded" ||
(initialResponse.request.method === "POST" && (initialResponseStatusCode === 200 || initialResponseStatusCode === 201));
};
return AzureAsyncOperationLROPollStrategy;
}(LROPollStrategy));
/**
* A long-running operation polling strategy that is based on the resource's provisioning state.
*/
var GetResourceLROPollStrategy = /** @class */ (function (_super) {
__extends(GetResourceLROPollStrategy, _super);
function GetResourceLROPollStrategy() {
return _super !== null && _super.apply(this, arguments) || this;
}
GetResourceLROPollStrategy.prototype.sendPollRequest = function () {
var lroPollState = this._pollState;
return this.updateOperationStatus(lroPollState.initialResponse.request.url, false).then(function (result) {
var statusCode = result.status;
var responseBody = result.parsedBody;
if (statusCode !== 200 && statusCode !== 201 && statusCode !== 202 && statusCode !== 204) {
var error = new msRestJs.RestError("Invalid status code with response body \"" + result.bodyAsText + "\" occurred when polling for operation status.");
error.statusCode = statusCode;
error.request = msRestJs.stripRequest(result.request);
error.response = result;
error.body = responseBody;
throw error;
}
if (!result.parsedBody) {
throw new Error("The response from long running operation does not contain a body.");
}
lroPollState.state = getProvisioningState(result.parsedBody) || "Succeeded";
lroPollState.mostRecentResponse = result;
lroPollState.mostRecentRequest = result.request;
lroPollState.resource = getResponseBody(result);
});
};
GetResourceLROPollStrategy.prototype.isFinalStatusAcceptable = function () {
return this._pollState.state === "Succeeded";
};
GetResourceLROPollStrategy.prototype.doFinalGetResourceRequest = function () {
return this.sendPollRequest();
};
return GetResourceLROPollStrategy;
}(LROPollStrategy));
// Copyright (c) Microsoft Corporation. All rights reserved.
/**
* An HTTP operation response that provides special methods for interacting with LROs (long running
* operations).
*/
var LROPoller = /** @class */ (function () {
/**
* Create a new HttpLongRunningOperationResponse.
* @param _lroPollStrategy The LROPollStrategy that this HttpLongRunningOperationResponse will
* use to interact with the LRO.
*/
function LROPoller(_lroPollStrategy, _initialResponse) {
this._lroPollStrategy = _lroPollStrategy;
this._initialResponse = _initialResponse;
}
/**
* Get the first response that the service sent back when the LRO was initiated.
*/
LROPoller.prototype.getInitialResponse = function () {
return this._initialResponse;
};
/**
* Get the most recent response that the service sent back during this LRO.
*/
LROPoller.prototype.getMostRecentResponse = function () {
var lroPollStrategy = this._lroPollStrategy;
return !lroPollStrategy ? this._initialResponse : lroPollStrategy.getMostRecentResponse();
};
/**
* Get whether or not the LRO is finished.
*/
LROPoller.prototype.isFinished = function () {
var lroPollStrategy = this._lroPollStrategy;
return !lroPollStrategy ? true : lroPollStrategy.isFinished();
};
/**
* Get whether or not the LRO is finished and its final state is acceptable. If the LRO has not
* finished yet, then undefined will be returned. An "acceptable" final state is determined by the
* LRO strategy that the Azure service uses to perform long running operations.
*/
LROPoller.prototype.isFinalStatusAcceptable = function () {
var result;
var lroPollStrategy = this._lroPollStrategy;
if (!lroPollStrategy) {
result = true;
}
else if (lroPollStrategy.isFinished()) {
result = lroPollStrategy.isFinalStatusAcceptable();
}
return result;
};
/**
* Get the current status of the LRO.
*/
LROPoller.prototype.getOperationStatus = function () {
var lroPollStrategy = this._lroPollStrategy;
return !lroPollStrategy ? "Succeeded" : lroPollStrategy.getOperationStatus();
};
/**
* If the LRO is finished and in an acceptable state, then return the HttpOperationResponse. If
* the LRO is finished and not in an acceptable state, then throw the error that the LRO produced.
* If the LRO is not finished, then return undefined.
*/
LROPoller.prototype.getOperationResponse = function () {
var result;
var lroPollStrategy = this._lroPollStrategy;
if (!lroPollStrategy) {
result = Promise.resolve(this._initialResponse);
}
else if (!lroPollStrategy.isFinished()) {
result = Promise.resolve(undefined);
}
else if (lroPollStrategy.isFinalStatusAcceptable()) {
result = lroPollStrategy.getOperationResponse();
}
else {
throw lroPollStrategy.getRestError();
}
return result;
};
/**
* Send a single poll request and return the LRO's state.
*/
LROPoller.prototype.poll = function () {
var result;
var lroPollStrategy = this._lroPollStrategy;
if (!lroPollStrategy) {
result = Promise.resolve("Succeeded");
}
else {
result = lroPollStrategy.sendPollRequest().then(function () {
return lroPollStrategy.getOperationStatus();
});
}
return result;
};
/**
* Send poll requests that check the LRO's status until it is determined that the LRO is finished.
*/
LROPoller.prototype.pollUntilFinished = function () {
return __awaiter(this, void 0, void 0, function () {
var result, lroPollStrategy;
return __generator(this, function (_a) {
lroPollStrategy = this._lroPollStrategy;
if (!lroPollStrategy) {
result = Promise.resolve(flattenAzureResponse(this._initialResponse));
}
else {
result = lroPollStrategy.pollUntilFinished().then(function (succeeded) {
if (succeeded) {
return lroPollStrategy.getOperationResponse().then(flattenAzureResponse);
}
else {
throw lroPollStrategy.getRestError();
}
});
}
return [2 /*return*/, result];
});
});
};
/**
* Get an LROPollState object that can be used to poll this LRO in a different context (such as on
* a different process or a different machine). If the LRO couldn't produce an LRO polling
* strategy, then this will return undefined.
*/
LROPoller.prototype.getPollState = function () {
var lroPollStrategy = this._lroPollStrategy;
return !lroPollStrategy ? undefined : lroPollStrategy.getPollState();
};
return LROPoller;
}());
function createLROPollerFromInitialResponse(azureServiceClient, initialResponse, options) {
var lroPollStrategy = createLROPollStrategyFromInitialResponse(initialResponse, azureServiceClient, options);
return new LROPoller(lroPollStrategy, initialResponse);
}
function createLROPollerFromPollState(azureServiceClient, lroMemento) {
var lroPollStrategy = createLROPollStrategyFromPollState(azureServiceClient, lroMemento);
return new LROPoller(lroPollStrategy, lroMemento.initialResponse);
}
function flattenAzureResponse(response) {
var _a = response.request, operationResponseGetter = _a.operationResponseGetter, operationSpec = _a.operationSpec;
return msRestJs.flattenResponse(response, operationResponseGetter && operationSpec && operationResponseGetter(operationSpec, response));
}
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
/**
* The default language in the request header.
*
* @const
* @type {string}
*/
var DEFAULT_LANGUAGE = "en-us";
/**
* The ms-rest-azure version.
* @const
* @type {string}
*/
var msRestAzureVersion = "0.1.0";
// Copyright (c) Microsoft Corporation. All rights reserved.
/**
* @class
* Initializes a new instance of the AzureServiceClient class.
* @constructor
*
* @param {msRest.ServiceClientCredentilas} credentials - ApplicationTokenCredentials or
* UserTokenCredentials object used for authentication.
* @param {AzureServiceClientOptions} options - The parameter options used by AzureServiceClient
*/
var AzureServiceClient = /** @class */ (function (_super) {
__extends(AzureServiceClient, _super);
function AzureServiceClient(credentials, options) {
var _this = _super.call(this, credentials, options = updateOptionsWithDefaultValues(options)) || this;
_this.acceptLanguage = DEFAULT_LANGUAGE;
// For convenience, if the credentials have an associated AzureEnvironment,
// automatically use the baseUri from that environment.
var env = credentials.environment;
if (env && !_this.baseUri) {
_this.baseUri = env.resourceManagerEndpointUrl;
}
if (options.acceptLanguage != undefined) {
_this.acceptLanguage = options.acceptLanguage;
}
if (options.longRunningOperationRetryTimeout != undefined) {
_this.longRunningOperationRetryTimeout = options.longRunningOperationRetryTimeout;
}
_this.addUserAgentInfo("ms-rest-azure/" + msRestAzureVersion);
return _this;
}
/**
* Send the initial request of a LRO (long running operation) and get back an
* LROPoller that provides methods for polling the LRO and checking if the LRO is finished.
* @param operationArguments The arguments to the operation.
* @param operationSpec The specification for the operation.
* @param options Additional options to be sent while making the request.
* @returns The LROPoller object that provides methods for interacting with the LRO.
*/
AzureServiceClient.prototype.sendLRORequest = function (operationArguments, operationSpec, options) {
var _this = this;
return this.sendOperationRequest(operationArguments, operationSpec)
.then(function (initialResponse) { return createLROPollerFromInitialResponse(_this, initialResponse._response, options); });
};
/**
* Provides a mechanism to make a request that will poll and provide the final result.
* @param {msRest.RequestPrepareOptions|msRest.WebResource} request - The request object
* @param {AzureRequestOptionsBase} [options] Additional options to be sent while making the request
* @returns {Promise<msRest.HttpOperationResponse>} The HttpOperationResponse containing the final polling request, response and the responseBody.
*/
AzureServiceClient.prototype.sendLongRunningRequest = function (request, options) {
return this.beginLongRunningRequest(request, options)
.then(function (lroResponse) { return lroResponse.pollUntilFinished(); })
.then(function (res) { return res._response; });
};
/**
* Send the initial request of a LRO (long running operation) and get back an
* HttpLongRunningOperationResponse that provides methods for polling the LRO and checking if the
* LRO is finished.
* @param {msRest.RequestPrepareOptions|msRest.WebResource} request - The request object
* @param {AzureRequestOptionsBase} [options] Additional options to be sent while making the request
* @returns {Promise<LROPoller>} The HttpLongRunningOperationResponse
* that provides methods for interacting with the LRO.
*/
AzureServiceClient.prototype.beginLongRunningRequest = function (request, options) {
var _this = this;
return this.sendRequest(request)
.then(function (initialResponse) { return createLROPollerFromInitialResponse(_this, initialResponse, options); });
};
/**
* Restore an LROPoller from the provided LROPollState. This method can be used to recreate an
* LROPoller on a different process or machine.
*/
AzureServiceClient.prototype.restoreLROPoller = function (lroPollState) {
return createLROPollerFromPollState(this, lroPollState);
};
return AzureServiceClient;
}(msRestJs.ServiceClient));
function updateOptionsWithDefaultValues(options) {
if (!options) {
options = {};
}
if (options.generateClientRequestIdHeader == undefined) {
options.generateClientRequestIdHeader = true;
}
return options;
}
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
var BaseResourceMapper = {
serializedName: "BaseResource",
type: {
name: "Composite",
className: "BaseResource",
modelProperties: {}
}
};
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
var CloudErrorMapper = {
serializedName: "CloudError",
type: {
name: "Composite",
className: "CloudError",
modelProperties: {
code: {
required: true,
serializedName: "code",
type: {
name: "String"
}
},
message: {
required: true,
serializedName: "message",
type: {
name: "String"
}
},
target: {
serializedName: "target",
type: {
name: "String"
}
},
details: {
serializedName: "details",
type: {
name: "Sequence",
element: {
serializedName: "CloudErrorElementType",
type: {
name: "Composite",
className: "CloudError"
}
}
}
},
innerError: {
required: false,
serializedName: "innererror",
type: {
name: "Object"
}
},
additionalInfo: {
required: false,
serializedName: "additionalInfo",
type: {
name: "Composite",
className: "AdditionalInfoElement",
modelProperties: {
type: {
required: true,
serializedName: "type",
type: {
name: "String"
}
},
info: {
required: false,
serializedName: "info",
type: {
name: "Object"
}
}
}
}
}
}
}
};
// Copyright (c) Microsoft Corporation. All rights reserved.
/**
* Creates a new CognitiveServicesCredentials object.
*
* @constructor
* @param {string} subscriptionKey The CognitiveServices subscription key
*/
var CognitiveServicesCredentials = /** @class */ (function (_super) {
__extends(CognitiveServicesCredentials, _super);
function CognitiveServicesCredentials(subscriptionKey) {
var _this = this;
if (!subscriptionKey || (subscriptionKey && typeof subscriptionKey.valueOf() !== "string")) {
throw new Error("subscriptionKey cannot be null or undefined and must be of type string.");
}
var options = {
inHeader: {
"Ocp-Apim-Subscription-Key": subscriptionKey,
"X-BingApis-SDK-Client": "node-SDK"
}
};
_this = _super.call(this, options) || this;
return _this;
}
return CognitiveServicesCredentials;
}(msRestJs.ApiKeyCredentials));
// Copyright (c) Microsoft Corporation. All rights reserved.
exports.AzureServiceClient = AzureServiceClient;
exports.BaseResourceMapper = BaseResourceMapper;
exports.CloudErrorMapper = CloudErrorMapper;
exports.CognitiveServicesCredentials = CognitiveServicesCredentials;
exports.LROPoller = LROPoller;
exports.DEFAULT_LANGUAGE = DEFAULT_LANGUAGE;
exports.msRestAzureVersion = msRestAzureVersion;
Object.defineProperty(exports, '__esModule', { value: true });
})));
//# sourceMappingURL=msRestAzure.js.map