api-def 0.9.1 → 0.9.3

package/esm/Requester.js

@@ -1,253 +1,252 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    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) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { inferResponseType, isAcceptableStatus, isNetworkError } from "./ApiUtils";
-import RequestContext from "./RequestContext";
-import { EventResultType, RequestEvent } from "./ApiConstants";
-import retry from "./util/retry";
-import MockRequestBackend from "./backend/MockRequestBackend";
-import { convertToRequestError, isRequestError, RequestErrorCode } from "./RequestError";
-import { textDecode } from "./TextDecoding";
-const locks = {};
-const runningOperations = {};
-const MOCK_REQUEST_BACKEND = new MockRequestBackend();
-export const submit = (host, config, mocking) => __awaiter(void 0, void 0, void 0, function* () {
-    const computedConfig = host.computeConfig(config);
-    const backend = mocking ? MOCK_REQUEST_BACKEND : host.getRequestBackend();
-    const context = new RequestContext(backend, host, computedConfig, host.computePath(host.path, config), mocking);
-    const { key } = context;
-    // don't do this -- should only be for GET requests anyway and should be opt-in
-    /*
-    // if we are already running this request just return the same promise, no need to do it again
-    const sameRequest = runningOperations[key];
-    if (sameRequest) {
-      return sameRequest;
-    }
-    */
-    const { lock } = context.computedConfig || {};
-    if (typeof lock === "string") {
-        const lockedContext = locks[lock];
-        if (lockedContext && lockedContext.id !== context.id) {
-            lockedContext.cancel();
-        }
-        locks[lock] = context;
-    }
-    try {
-        let response = yield (runningOperations[key] = makeRequest(context));
-        const successEventResult = yield context.triggerEvent(RequestEvent.Success);
-        if (successEventResult &&
-            successEventResult.type === EventResultType.Respond) {
-            context.response = response = successEventResult.response;
-        }
-        delete runningOperations[key];
-        return response;
-    }
-    catch (error) {
-        delete runningOperations[key];
-        throw error;
-    }
-    finally {
-        if (typeof lock === "string") {
-            delete locks[lock];
-        }
-    }
-});
-const parseRetryOptions = (retryConfig) => {
-    if (retryConfig && typeof retryConfig === "object") {
-        return retryConfig;
-    }
-    if (typeof retryConfig === "number") {
-        return { maxAttempts: retryConfig };
-    }
-    return { maxAttempts: 0 };
-};
-const makeRequest = (context) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
-    const beforeSendEventResult = yield context.triggerEvent(RequestEvent.BeforeSend);
-    if (beforeSendEventResult &&
-        beforeSendEventResult.type === EventResultType.Respond) {
-        return (context.response = beforeSendEventResult.response);
-    }
-    // validation
-    if (context.validation.query) {
-        try {
-            context.computedConfig.queryObject = context.validation.query.parse(context.computedConfig.queryObject);
-        }
-        catch (error) {
-            throw convertToRequestError({
-                error: error,
-                code: RequestErrorCode.VALIDATION_QUERY_VALIDATE_ERROR,
-                context: context,
-            });
-        }
-    }
-    if (context.validation.body) {
-        try {
-            context.computedConfig.body = context.validation.body.parse(context.computedConfig.body);
-        }
-        catch (error) {
-            throw convertToRequestError({
-                error: error,
-                code: RequestErrorCode.VALIDATION_BODY_VALIDATE_ERROR,
-                context: context,
-            });
-        }
-    }
-    const retryOptions = parseRetryOptions((_a = context.computedConfig) === null || _a === void 0 ? void 0 : _a.retry);
-    const internalRetryOptions = {
-        retries: retryOptions.maxAttempts,
-        // assume most users won't want to tune the delay between retries
-        minTimeout: (_b = retryOptions.minDelay) !== null && _b !== void 0 ? _b : 200,
-        maxTimeout: (_c = retryOptions.maxDelay) !== null && _c !== void 0 ? _c : 1000,
-        randomize: true,
-    };
-    context.stats.attempt = 0;
-    const performRequest = (fnBail, attemptCount) => __awaiter(void 0, void 0, void 0, function* () {
-        context.stats.attempt++;
-        try {
-            const { promise, canceler } = context.backend.makeRequest(context);
-            context.addCanceller(canceler);
-            const response = yield promise;
-            const parsedResponse = (yield parseResponse(context, response));
-            if (!isAcceptableStatus(parsedResponse.status, context.computedConfig.acceptableStatus)) {
-                throw convertToRequestError({
-                    error: new Error(`[api-def] Invalid response status code '${parsedResponse.status}'`),
-                    response: parsedResponse,
-                    code: RequestErrorCode.REQUEST_INVALID_STATUS,
-                    context: context,
-                });
-            }
-            context.response = parsedResponse;
-            return (parsedResponse);
-        }
-        catch (rawError) {
-            if (context.cancelled) {
-                rawError.isCancelledRequest = true;
-            }
-            const error = yield parseError(context, rawError);
-            context.error = error;
-            context.response = error.response;
-            const errorEventResult = yield context.triggerEvent(RequestEvent.Error);
-            if ((errorEventResult === null || errorEventResult === void 0 ? void 0 : errorEventResult.type) === EventResultType.Respond) {
-                return errorEventResult.response;
-            }
-            // allow retry logic to handle network errors
-            //const shouldNaturallyRetry = ApiUtils.isNetworkError(error);
-            //if (shouldNaturallyRetry) {
-            //  throw error;
-            //}
-            // if we have an event that tells us to retry, we must do it
-            const forceRetry = (errorEventResult === null || errorEventResult === void 0 ? void 0 : errorEventResult.type) === EventResultType.Retry;
-            if (forceRetry) {
-                return performRequest(fnBail, attemptCount);
-            }
-            // allow retry logic to handle
-            if (!retryOptions.shouldRetry || retryOptions.shouldRetry(error)) {
-                throw error;
-            }
-            // error is unrecoverable, bail
-            const unrecoverableErrorEventResult = yield context.triggerEvent(RequestEvent.UnrecoverableError);
-            if (unrecoverableErrorEventResult) {
-                if (unrecoverableErrorEventResult.type === EventResultType.Respond) {
-                    return unrecoverableErrorEventResult.response;
-                }
-            }
-            fnBail(error);
-        }
-    });
-    const response = yield retry(performRequest, internalRetryOptions);
-    if (context.validation.response) {
-        try {
-            response.data = context.validation.response.parse(response.data);
-        }
-        catch (error) {
-            throw convertToRequestError({
-                error: error,
-                code: RequestErrorCode.VALIDATION_RESPONSE_VALIDATE_ERROR,
-                context: context,
-            });
-        }
-    }
-    return (response);
-});
-const parseResponse = (context, response, error) => __awaiter(void 0, void 0, void 0, function* () {
-    var _d;
-    if (response) {
-        const parsedResponse = yield context.backend.convertResponse(context, response);
-        // lowercase all header names
-        parsedResponse.headers = parsedResponse.__lowercaseHeaders || Object.keys(parsedResponse.headers).reduce((headers, header) => {
-            headers[header.toLowerCase()] = parsedResponse.headers[header];
-            return headers;
-        }, {});
-        const contentType = parsedResponse.headers["content-type"];
-        const inferredResponseType = inferResponseType(contentType);
-        if (!error) {
-            // expand to array buffer once we support that in inferResponseType
-            if (inferredResponseType === "text" && context.responseType === "json") {
-                throw convertToRequestError({
-                    error: new Error(`[api-def] Expected '${context.responseType}' response, got '${inferredResponseType}' (from 'Content-Type' of '${contentType}')`),
-                    code: RequestErrorCode.REQUEST_MISMATCH_RESPONSE_TYPE,
-                    response: parsedResponse,
-                    context: context,
-                });
-            }
-            // transform arrayBuffer to json
-            if (inferredResponseType === "arraybuffer" && context.responseType === "json") {
-                if (parsedResponse.data &&
-                    typeof parsedResponse.data === "object") {
-                    const data = response.data;
-                    if (((_d = data.constructor) === null || _d === void 0 ? void 0 : _d.name) === "ArrayBuffer") {
-                        try {
-                            const decodedData = (response.data = textDecode(data));
-                            response.data = JSON.parse(decodedData);
-                        }
-                        catch (e) {
-                            throw convertToRequestError({
-                                error: new Error(`[api-def] Expected '${context.responseType}' response, got '${inferredResponseType}' (from 'Content-Type' of '${contentType}')`),
-                                code: RequestErrorCode.REQUEST_MISMATCH_RESPONSE_TYPE,
-                                response: parsedResponse,
-                                context: context,
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        return parsedResponse;
-    }
-    return response;
-});
-const parseError = (context, rawError) => __awaiter(void 0, void 0, void 0, function* () {
-    var _e;
-    let error;
-    if (isRequestError(rawError)) {
-        error = rawError;
-    }
-    else {
-        const extractedResponse = yield context.backend.extractResponseFromError(rawError);
-        let errorResponse = undefined;
-        if (extractedResponse !== undefined) {
-            errorResponse = yield parseResponse(context, extractedResponse, true);
-        }
-        let code = isNetworkError(rawError) ? RequestErrorCode.REQUEST_NETWORK_ERROR : RequestErrorCode.MISC_UNKNOWN_ERROR;
-        if (errorResponse) {
-            if (!isAcceptableStatus(errorResponse.status, context.computedConfig.acceptableStatus)) {
-                code = RequestErrorCode.REQUEST_INVALID_STATUS;
-            }
-        }
-        else {
-            if (rawError.code === "ENOTFOUND" || ((_e = rawError.cause) === null || _e === void 0 ? void 0 : _e.code) === "ENOTFOUND") {
-                code = RequestErrorCode.REQUEST_HOST_NAME_NOT_FOUND;
-            }
-        }
-        const errorInfo = context.backend.getErrorInfo(rawError, errorResponse);
-        error = convertToRequestError(Object.assign({ error: rawError, response: errorResponse, code: code, context: context }, errorInfo));
-    }
-    return error;
-});
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { EventResultType, RequestEvent } from "./ApiConstants";
+import { inferResponseType, isAcceptableStatus, isNetworkError } from "./ApiUtils";
+import RequestContext from "./RequestContext";
+import { RequestErrorCode, convertToRequestError, isRequestError } from "./RequestError";
+import { textDecode } from "./TextDecoding";
+import MockRequestBackend from "./backend/MockRequestBackend";
+import retry from "./util/retry";
+const locks = {};
+const runningOperations = {};
+const MOCK_REQUEST_BACKEND = new MockRequestBackend();
+export const submit = (host, config, mocking) => __awaiter(void 0, void 0, void 0, function* () {
+    const computedConfig = host.computeConfig(config);
+    const backend = mocking ? MOCK_REQUEST_BACKEND : host.getRequestBackend();
+    const context = new RequestContext(backend, host, computedConfig, host.computePath(host.path, config), mocking);
+    const { key } = context;
+    // don't do this -- should only be for GET requests anyway and should be opt-in
+    /*
+    // if we are already running this request just return the same promise, no need to do it again
+    const sameRequest = runningOperations[key];
+    if (sameRequest) {
+      return sameRequest;
+    }
+    */
+    const { lock } = context.computedConfig || {};
+    if (typeof lock === "string") {
+        const lockedContext = locks[lock];
+        if (lockedContext && lockedContext.id !== context.id) {
+            lockedContext.cancel();
+        }
+        locks[lock] = context;
+    }
+    try {
+        let response = yield (runningOperations[key] = makeRequest(context));
+        const successEventResult = yield context.triggerEvent(RequestEvent.Success);
+        if (successEventResult && successEventResult.type === EventResultType.Respond) {
+            context.response = response = successEventResult.response;
+        }
+        delete runningOperations[key];
+        return response;
+    }
+    catch (error) {
+        delete runningOperations[key];
+        throw error;
+    }
+    finally {
+        if (typeof lock === "string") {
+            delete locks[lock];
+        }
+    }
+});
+const parseRetryOptions = (retryConfig) => {
+    if (retryConfig && typeof retryConfig === "object") {
+        return retryConfig;
+    }
+    if (typeof retryConfig === "number") {
+        return { maxAttempts: retryConfig };
+    }
+    return { maxAttempts: 0 };
+};
+const makeRequest = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c;
+    const beforeSendEventResult = yield context.triggerEvent(RequestEvent.BeforeSend);
+    if (beforeSendEventResult && beforeSendEventResult.type === EventResultType.Respond) {
+        return (context.response = beforeSendEventResult.response);
+    }
+    // validation
+    if (context.validation.query) {
+        try {
+            context.computedConfig.queryObject = context.validation.query.parse(context.computedConfig.queryObject);
+        }
+        catch (error) {
+            throw convertToRequestError({
+                error: error,
+                code: RequestErrorCode.VALIDATION_QUERY_VALIDATE_ERROR,
+                context: context,
+            });
+        }
+    }
+    if (context.validation.body) {
+        try {
+            context.computedConfig.body = context.validation.body.parse(context.computedConfig.body);
+        }
+        catch (error) {
+            throw convertToRequestError({
+                error: error,
+                code: RequestErrorCode.VALIDATION_BODY_VALIDATE_ERROR,
+                context: context,
+            });
+        }
+    }
+    const retryOptions = parseRetryOptions((_a = context.computedConfig) === null || _a === void 0 ? void 0 : _a.retry);
+    const internalRetryOptions = {
+        retries: retryOptions.maxAttempts,
+        // assume most users won't want to tune the delay between retries
+        minTimeout: (_b = retryOptions.minDelay) !== null && _b !== void 0 ? _b : 200,
+        maxTimeout: (_c = retryOptions.maxDelay) !== null && _c !== void 0 ? _c : 1000,
+        randomize: true,
+    };
+    context.stats.attempt = 0;
+    const performRequest = (fnBail, attemptCount) => __awaiter(void 0, void 0, void 0, function* () {
+        context.stats.attempt++;
+        try {
+            const { promise, canceler } = context.backend.makeRequest(context);
+            context.addCanceller(canceler);
+            const response = yield promise;
+            const parsedResponse = (yield parseResponse(context, response));
+            if (!isAcceptableStatus(parsedResponse.status, context.computedConfig.acceptableStatus)) {
+                throw convertToRequestError({
+                    error: new Error(`[api-def] Invalid response status code '${parsedResponse.status}'`),
+                    response: parsedResponse,
+                    code: RequestErrorCode.REQUEST_INVALID_STATUS,
+                    context: context,
+                });
+            }
+            context.response = parsedResponse;
+            return parsedResponse;
+        }
+        catch (rawError) {
+            if (context.cancelled) {
+                rawError.isCancelledRequest = true;
+            }
+            const error = yield parseError(context, rawError);
+            context.error = error;
+            context.response = error.response;
+            const errorEventResult = yield context.triggerEvent(RequestEvent.Error);
+            if ((errorEventResult === null || errorEventResult === void 0 ? void 0 : errorEventResult.type) === EventResultType.Respond) {
+                return errorEventResult.response;
+            }
+            // allow retry logic to handle network errors
+            //const shouldNaturallyRetry = ApiUtils.isNetworkError(error);
+            //if (shouldNaturallyRetry) {
+            //  throw error;
+            //}
+            // if we have an event that tells us to retry, we must do it
+            const forceRetry = (errorEventResult === null || errorEventResult === void 0 ? void 0 : errorEventResult.type) === EventResultType.Retry;
+            if (forceRetry) {
+                return performRequest(fnBail, attemptCount);
+            }
+            // allow retry logic to handle
+            if (!retryOptions.shouldRetry || retryOptions.shouldRetry(error)) {
+                throw error;
+            }
+            // error is unrecoverable, bail
+            const unrecoverableErrorEventResult = yield context.triggerEvent(RequestEvent.UnrecoverableError);
+            if (unrecoverableErrorEventResult) {
+                if (unrecoverableErrorEventResult.type === EventResultType.Respond) {
+                    return unrecoverableErrorEventResult.response;
+                }
+            }
+            fnBail(error);
+        }
+    });
+    const response = yield retry(performRequest, internalRetryOptions);
+    if (context.validation.response) {
+        try {
+            response.data = context.validation.response.parse(response.data);
+        }
+        catch (error) {
+            throw convertToRequestError({
+                error: error,
+                code: RequestErrorCode.VALIDATION_RESPONSE_VALIDATE_ERROR,
+                context: context,
+            });
+        }
+    }
+    return response;
+});
+const parseResponse = (context, response, error) => __awaiter(void 0, void 0, void 0, function* () {
+    var _d;
+    if (response) {
+        const parsedResponse = yield context.backend.convertResponse(context, response);
+        // lowercase all header names
+        parsedResponse.headers =
+            parsedResponse.__lowercaseHeaders ||
+                Object.keys(parsedResponse.headers).reduce((headers, header) => {
+                    headers[header.toLowerCase()] = parsedResponse.headers[header];
+                    return headers;
+                }, {});
+        const contentType = parsedResponse.headers["content-type"];
+        const inferredResponseType = inferResponseType(contentType);
+        if (!error) {
+            // expand to array buffer once we support that in inferResponseType
+            if (inferredResponseType === "text" && context.responseType === "json") {
+                throw convertToRequestError({
+                    error: new Error(`[api-def] Expected '${context.responseType}' response, got '${inferredResponseType}' (from 'Content-Type' of '${contentType}')`),
+                    code: RequestErrorCode.REQUEST_MISMATCH_RESPONSE_TYPE,
+                    response: parsedResponse,
+                    context: context,
+                });
+            }
+            // transform arrayBuffer to json
+            if (inferredResponseType === "arraybuffer" && context.responseType === "json") {
+                if (parsedResponse.data && typeof parsedResponse.data === "object") {
+                    const data = response.data;
+                    if (((_d = data.constructor) === null || _d === void 0 ? void 0 : _d.name) === "ArrayBuffer") {
+                        try {
+                            const decodedData = (response.data = textDecode(data));
+                            response.data = JSON.parse(decodedData);
+                        }
+                        catch (e) {
+                            throw convertToRequestError({
+                                error: new Error(`[api-def] Expected '${context.responseType}' response, got '${inferredResponseType}' (from 'Content-Type' of '${contentType}')`),
+                                code: RequestErrorCode.REQUEST_MISMATCH_RESPONSE_TYPE,
+                                response: parsedResponse,
+                                context: context,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return parsedResponse;
+    }
+    return response;
+});
+const parseError = (context, rawError) => __awaiter(void 0, void 0, void 0, function* () {
+    var _e;
+    let error;
+    if (isRequestError(rawError)) {
+        error = rawError;
+    }
+    else {
+        const extractedResponse = yield context.backend.extractResponseFromError(rawError);
+        let errorResponse = undefined;
+        if (extractedResponse !== undefined) {
+            errorResponse = yield parseResponse(context, extractedResponse, true);
+        }
+        let code = isNetworkError(rawError) ? RequestErrorCode.REQUEST_NETWORK_ERROR : RequestErrorCode.MISC_UNKNOWN_ERROR;
+        if (errorResponse) {
+            if (!isAcceptableStatus(errorResponse.status, context.computedConfig.acceptableStatus)) {
+                code = RequestErrorCode.REQUEST_INVALID_STATUS;
+            }
+        }
+        else {
+            if (rawError.code === "ENOTFOUND" || ((_e = rawError.cause) === null || _e === void 0 ? void 0 : _e.code) === "ENOTFOUND") {
+                code = RequestErrorCode.REQUEST_HOST_NAME_NOT_FOUND;
+            }
+        }
+        const errorInfo = context.backend.getErrorInfo(rawError, errorResponse);
+        error = convertToRequestError(Object.assign({ error: rawError, response: errorResponse, code: code, context: context }, errorInfo));
+    }
+    return error;
+});

package/esm/TextDecoding.d.ts

@@ -1 +1 @@
-export declare const textDecode: (inputArrayOrBuffer: any, options?: any) => string;
+export declare const textDecode: (inputArrayOrBuffer: any, options?: any) => string;