@microlink/mql 0.10.32 → 0.10.34

package/package.json

@@ -2,7 +2,7 @@
   "name": "@microlink/mql",
   "description": "Microlink Query Language. The official HTTP client to interact with Microlink API for Node.js, browsers & Deno.",
   "homepage": "https://nicedoc.io/microlinkhq/mql",
-  "version": "0.10.32",
+  "version": "0.10.34",
   "browser": "src/browser.js",
   "main": "src/node.js",
   "author": {
@@ -44,18 +44,20 @@
   ],
   "dependencies": {
     "flattie": "~1.1.0",
-    "got": "~11.8.5",
+    "got": "~11.8.6",
     "url-http": "~1.0.7",
     "whoops": "~4.1.1"
   },
   "devDependencies": {
     "@commitlint/cli": "latest",
     "@commitlint/config-conventional": "latest",
+    "@ksmithut/prettier-standard": "latest",
     "@rollup/plugin-commonjs": "latest",
     "@rollup/plugin-node-resolve": "latest",
     "@rollup/plugin-replace": "latest",
     "@rollup/plugin-terser": "latest",
     "abort-controller": "latest",
+    "async-listen": "latest",
     "ava": "3",
     "beauty-error": "latest",
     "c8": "latest",
@@ -80,7 +82,7 @@
     "standard-markdown": "latest",
     "standard-version": "latest",
     "stream-to-promise": "latest",
-    "test-listen": "latest",
+    "tsd": "latest",
     "web-streams-polyfill": "latest"
   },
   "engines": {
@@ -92,6 +94,25 @@
     "lightweight",
     "src"
   ],
+  "scripts": {
+    "build": "rollup -c rollup.config.js --bundleConfigAsCjs",
+    "build:kys": "[ -f src/ky.js ] || rollup node_modules/ky/distribution/index.js --format=umd --name=ky --exports=named --file=src/ky.js",
+    "clean": "rm -rf node_modules",
+    "clean:build": "rm -rf dist",
+    "contributors": "(npx git-authors-cli && npx finepack --sort-ignore-object-at ava && git add package.json && git commit -m 'build: contributors' --no-verify) || true",
+    "dev": "npm run build -- -w",
+    "lint": "standard && tsd",
+    "postrelease": "npm run release:tags && npm run release:github && (ci-publish || npm publish --access=public)",
+    "prebuild": "npm run clean:build && npm run build:kys",
+    "prerelease": "npm run update:check",
+    "pretest": "npm run lint && npm run build",
+    "release": "standard-version -a",
+    "release:github": "conventional-github-releaser -p angular",
+    "release:tags": "git push --follow-tags origin HEAD:master",
+    "test": "c8 ava --verbose",
+    "update": "ncu -u",
+    "update:check": "ncu -- --error-level 2"
+  },
   "license": "MIT",
   "ava": {
     "files": [
@@ -111,7 +132,8 @@
   },
   "nano-staged": {
     "*.js,!*.min.js,": [
-      "prettier-standard"
+      "prettier-standard",
+      "standard --fix"
     ],
     "*.md": [
       "standard-markdown"
@@ -135,26 +157,10 @@
       "postbump": "npm run build"
     }
   },
+  "tsd": {
+    "directory": "test"
+  },
   "types": "index.d.ts",
   "umd:main": "dist/mql.js",
-  "unpkg": "dist/mql.js",
-  "scripts": {
-    "build": "rollup -c rollup.config.js --bundleConfigAsCjs",
-    "build:kys": "[ -f src/ky.js ] || rollup node_modules/ky/distribution/index.js --format=umd --name=ky --exports=named --file=src/ky.js",
-    "clean": "rm -rf node_modules",
-    "clean:build": "rm -rf dist",
-    "contributors": "(npx git-authors-cli && npx finepack --sort-ignore-object-at ava && git add package.json && git commit -m 'build: contributors' --no-verify) || true",
-    "dev": "npm run build -- -w",
-    "lint": "standard",
-    "postrelease": "npm run release:tags && npm run release:github && (ci-publish || npm publish --access=public)",
-    "prebuild": "npm run clean:build && npm run build:kys",
-    "prerelease": "npm run update:check",
-    "pretest": "npm run lint && npm run build",
-    "release": "standard-version -a",
-    "release:github": "conventional-github-releaser -p angular",
-    "release:tags": "git push --follow-tags origin HEAD:master",
-    "test": "c8 ava --verbose",
-    "update": "ncu -u",
-    "update:check": "ncu -- --error-level 2"
-  }
-}
+  "unpkg": "dist/mql.js"
+}

package/src/browser.js

@@ -20,6 +20,7 @@ class MicrolinkError extends Error {
 
 const got = async (url, opts) => {
   try {
+    if (opts.retry > 0) opts.retry = opts.retry + 1
     if (opts.timeout === undefined) opts.timeout = false
     const response = await ky(url, opts)
     const body = await response.json()

package/src/factory.js

@@ -28,14 +28,7 @@ const parseBody = (input, error, url) => {
   }
 }
 
-const factory = ({
-  VERSION,
-  MicrolinkError,
-  urlHttp,
-  stringify,
-  got,
-  flatten
-}) => {
+const factory = ({ VERSION, MicrolinkError, urlHttp, got, flatten }) => {
   const assertUrl = (url = '') => {
     if (!urlHttp(url)) {
       const message = `The \`url\` as \`${url}\` is not valid. Ensure it has protocol (http or https) and hostname.`
@@ -59,7 +52,7 @@ const factory = ({
     }, {})
   }
 
-  const fetchFromApi = async (apiUrl, opts = {}, retryCount = 0) => {
+  const fetchFromApi = async (apiUrl, opts = {}) => {
     try {
       const response = await got(apiUrl, opts)
       return opts.responseType === 'buffer'
@@ -80,10 +73,6 @@ const factory = ({
           ? rawBody
           : parseBody(isBodyBuffer ? rawBody.toString() : rawBody, err, uri)
 
-      if (body.code === 'EFATALCLIENT' && retryCount++ < 2) {
-        return fetchFromApi(apiUrl, opts, retryCount)
-      }
-
       throw new MicrolinkError({
         ...body,
         message: body.message,

package/src/ky.js

@@ -12,6 +12,24 @@
             const status = `${code} ${title}`.trim();
             const reason = status ? `status code ${status}` : 'an unknown error';
             super(`Request failed with ${reason}`);
+            Object.defineProperty(this, "response", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "request", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "options", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
             this.name = 'HTTPError';
             this.response = response;
             this.request = request;
@@ -22,6 +40,12 @@
     class TimeoutError extends Error {
         constructor(request) {
             super('Request timed out');
+            Object.defineProperty(this, "request", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
             this.name = 'TimeoutError';
             this.request = request;
         }
@@ -32,7 +56,7 @@
 
     const validateAndMerge = (...sources) => {
         for (const source of sources) {
-            if ((!isObject(source) || Array.isArray(source)) && typeof source !== 'undefined') {
+            if ((!isObject(source) || Array.isArray(source)) && source !== undefined) {
                 throw new TypeError('The `options` argument must be an object');
             }
         }
@@ -79,8 +103,26 @@
         return returnValue;
     };
 
+    const supportsRequestStreams = (() => {
+        let duplexAccessed = false;
+        let hasContentType = false;
+        const supportsReadableStream = typeof globalThis.ReadableStream === 'function';
+        const supportsRequest = typeof globalThis.Request === 'function';
+        if (supportsReadableStream && supportsRequest) {
+            hasContentType = new globalThis.Request('https://empty.invalid', {
+                body: new globalThis.ReadableStream(),
+                method: 'POST',
+                // @ts-expect-error - Types are outdated.
+                get duplex() {
+                    duplexAccessed = true;
+                    return 'half';
+                },
+            }).headers.has('Content-Type');
+        }
+        return duplexAccessed && !hasContentType;
+    })();
     const supportsAbortController = typeof globalThis.AbortController === 'function';
-    const supportsStreams = typeof globalThis.ReadableStream === 'function';
+    const supportsResponseStreams = typeof globalThis.ReadableStream === 'function';
     const supportsFormData = typeof globalThis.FormData === 'function';
     const requestMethods = ['get', 'post', 'put', 'patch', 'head', 'delete'];
     const responseTypes = {
@@ -104,6 +146,7 @@
         statusCodes: retryStatusCodes,
         afterStatusCodes: retryAfterStatusCodes,
         maxRetryAfter: Number.POSITIVE_INFINITY,
+        backoffLimit: Number.POSITIVE_INFINITY,
     };
     const normalizeRetryOptions = (retry = {}) => {
         if (typeof retry === 'number') {
@@ -126,30 +169,139 @@
     };
 
     // `Promise.race()` workaround (#91)
-    const timeout = async (request, abortController, options) => new Promise((resolve, reject) => {
-        const timeoutId = setTimeout(() => {
-            if (abortController) {
-                abortController.abort();
+    async function timeout(request, abortController, options) {
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                if (abortController) {
+                    abortController.abort();
+                }
+                reject(new TimeoutError(request));
+            }, options.timeout);
+            void options
+                .fetch(request)
+                .then(resolve)
+                .catch(reject)
+                .then(() => {
+                clearTimeout(timeoutId);
+            });
+        });
+    }
+
+    // https://github.com/sindresorhus/delay/tree/ab98ae8dfcb38e1593286c94d934e70d14a4e111
+    async function delay(ms, { signal }) {
+        return new Promise((resolve, reject) => {
+            if (signal) {
+                signal.throwIfAborted();
+                signal.addEventListener('abort', abortHandler, { once: true });
             }
-            reject(new TimeoutError(request));
-        }, options.timeout);
-        void options
-            .fetch(request)
-            .then(resolve)
-            .catch(reject)
-            .then(() => {
-            clearTimeout(timeoutId);
+            function abortHandler() {
+                clearTimeout(timeoutId);
+                reject(signal.reason);
+            }
+            const timeoutId = setTimeout(() => {
+                signal?.removeEventListener('abort', abortHandler);
+                resolve();
+            }, ms);
         });
-    });
-    const delay = async (ms) => new Promise(resolve => {
-        setTimeout(resolve, ms);
-    });
+    }
 
     class Ky {
+        static create(input, options) {
+            const ky = new Ky(input, options);
+            const fn = async () => {
+                if (typeof ky._options.timeout === 'number' && ky._options.timeout > maxSafeTimeout) {
+                    throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
+                }
+                // Delay the fetch so that body method shortcuts can set the Accept header
+                await Promise.resolve();
+                let response = await ky._fetch();
+                for (const hook of ky._options.hooks.afterResponse) {
+                    // eslint-disable-next-line no-await-in-loop
+                    const modifiedResponse = await hook(ky.request, ky._options, ky._decorateResponse(response.clone()));
+                    if (modifiedResponse instanceof globalThis.Response) {
+                        response = modifiedResponse;
+                    }
+                }
+                ky._decorateResponse(response);
+                if (!response.ok && ky._options.throwHttpErrors) {
+                    let error = new HTTPError(response, ky.request, ky._options);
+                    for (const hook of ky._options.hooks.beforeError) {
+                        // eslint-disable-next-line no-await-in-loop
+                        error = await hook(error);
+                    }
+                    throw error;
+                }
+                // If `onDownloadProgress` is passed, it uses the stream API internally
+                /* istanbul ignore next */
+                if (ky._options.onDownloadProgress) {
+                    if (typeof ky._options.onDownloadProgress !== 'function') {
+                        throw new TypeError('The `onDownloadProgress` option must be a function');
+                    }
+                    if (!supportsResponseStreams) {
+                        throw new Error('Streams are not supported in your environment. `ReadableStream` is missing.');
+                    }
+                    return ky._stream(response.clone(), ky._options.onDownloadProgress);
+                }
+                return response;
+            };
+            const isRetriableMethod = ky._options.retry.methods.includes(ky.request.method.toLowerCase());
+            const result = (isRetriableMethod ? ky._retry(fn) : fn());
+            for (const [type, mimeType] of Object.entries(responseTypes)) {
+                result[type] = async () => {
+                    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+                    ky.request.headers.set('accept', ky.request.headers.get('accept') || mimeType);
+                    const awaitedResult = await result;
+                    const response = awaitedResult.clone();
+                    if (type === 'json') {
+                        if (response.status === 204) {
+                            return '';
+                        }
+                        const arrayBuffer = await response.clone().arrayBuffer();
+                        const responseSize = arrayBuffer.byteLength;
+                        if (responseSize === 0) {
+                            return '';
+                        }
+                        if (options.parseJson) {
+                            return options.parseJson(await response.text());
+                        }
+                    }
+                    return response[type]();
+                };
+            }
+            return result;
+        }
         // eslint-disable-next-line complexity
         constructor(input, options = {}) {
-            var _a, _b, _c;
-            this._retryCount = 0;
+            Object.defineProperty(this, "request", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "abortController", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "_retryCount", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: 0
+            });
+            Object.defineProperty(this, "_input", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "_options", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
             this._input = input;
             this._options = {
                 // TODO: credentials can be removed when the spec change is implemented in all browsers. Context: https://www.chromestatus.com/feature/4539473312350208
@@ -162,13 +314,13 @@
                     beforeError: [],
                     afterResponse: [],
                 }, options.hooks),
-                method: normalizeRequestMethod((_a = options.method) !== null && _a !== void 0 ? _a : this._input.method),
+                method: normalizeRequestMethod(options.method ?? this._input.method),
                 // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
                 prefixUrl: String(options.prefixUrl || ''),
                 retry: normalizeRetryOptions(options.retry),
                 throwHttpErrors: options.throwHttpErrors !== false,
-                timeout: typeof options.timeout === 'undefined' ? 10000 : options.timeout,
-                fetch: (_b = options.fetch) !== null && _b !== void 0 ? _b : globalThis.fetch.bind(globalThis),
+                timeout: options.timeout ?? 10000,
+                fetch: options.fetch ?? globalThis.fetch.bind(globalThis),
             };
             if (typeof this._input !== 'string' && !(this._input instanceof URL || this._input instanceof globalThis.Request)) {
                 throw new TypeError('`input` must be a string, URL, or Request');
@@ -185,12 +337,17 @@
             if (supportsAbortController) {
                 this.abortController = new globalThis.AbortController();
                 if (this._options.signal) {
+                    const originalSignal = this._options.signal;
                     this._options.signal.addEventListener('abort', () => {
-                        this.abortController.abort();
+                        this.abortController.abort(originalSignal.reason);
                     });
                 }
                 this._options.signal = this.abortController.signal;
             }
+            if (supportsRequestStreams) {
+                // @ts-expect-error - Types are outdated.
+                this._options.duplex = 'half';
+            }
             this.request = new globalThis.Request(this._input, this._options);
             if (this._options.searchParams) {
                 // eslint-disable-next-line unicorn/prevent-abbreviations
@@ -205,74 +362,15 @@
                     || this._options.body instanceof URLSearchParams) && !(this._options.headers && this._options.headers['content-type'])) {
                     this.request.headers.delete('content-type');
                 }
-                this.request = new globalThis.Request(new globalThis.Request(url, this.request), this._options);
+                // The spread of `this.request` is required as otherwise it misses the `duplex` option for some reason and throws.
+                this.request = new globalThis.Request(new globalThis.Request(url, { ...this.request }), this._options);
             }
             if (this._options.json !== undefined) {
                 this._options.body = JSON.stringify(this._options.json);
-                this.request.headers.set('content-type', (_c = this._options.headers.get('content-type')) !== null && _c !== void 0 ? _c : 'application/json');
+                this.request.headers.set('content-type', this._options.headers.get('content-type') ?? 'application/json');
                 this.request = new globalThis.Request(this.request, { body: this._options.body });
             }
         }
-        // eslint-disable-next-line @typescript-eslint/promise-function-async
-        static create(input, options) {
-            const ky = new Ky(input, options);
-            const fn = async () => {
-                if (ky._options.timeout > maxSafeTimeout) {
-                    throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
-                }
-                // Delay the fetch so that body method shortcuts can set the Accept header
-                await Promise.resolve();
-                let response = await ky._fetch();
-                for (const hook of ky._options.hooks.afterResponse) {
-                    // eslint-disable-next-line no-await-in-loop
-                    const modifiedResponse = await hook(ky.request, ky._options, ky._decorateResponse(response.clone()));
-                    if (modifiedResponse instanceof globalThis.Response) {
-                        response = modifiedResponse;
-                    }
-                }
-                ky._decorateResponse(response);
-                if (!response.ok && ky._options.throwHttpErrors) {
-                    let error = new HTTPError(response, ky.request, ky._options);
-                    for (const hook of ky._options.hooks.beforeError) {
-                        // eslint-disable-next-line no-await-in-loop
-                        error = await hook(error);
-                    }
-                    throw error;
-                }
-                // If `onDownloadProgress` is passed, it uses the stream API internally
-                /* istanbul ignore next */
-                if (ky._options.onDownloadProgress) {
-                    if (typeof ky._options.onDownloadProgress !== 'function') {
-                        throw new TypeError('The `onDownloadProgress` option must be a function');
-                    }
-                    if (!supportsStreams) {
-                        throw new Error('Streams are not supported in your environment. `ReadableStream` is missing.');
-                    }
-                    return ky._stream(response.clone(), ky._options.onDownloadProgress);
-                }
-                return response;
-            };
-            const isRetriableMethod = ky._options.retry.methods.includes(ky.request.method.toLowerCase());
-            const result = (isRetriableMethod ? ky._retry(fn) : fn());
-            for (const [type, mimeType] of Object.entries(responseTypes)) {
-                result[type] = async () => {
-                    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-                    ky.request.headers.set('accept', ky.request.headers.get('accept') || mimeType);
-                    const awaitedResult = await result;
-                    const response = awaitedResult.clone();
-                    if (type === 'json') {
-                        if (response.status === 204) {
-                            return '';
-                        }
-                        if (options.parseJson) {
-                            return options.parseJson(await response.text());
-                        }
-                    }
-                    return response[type]();
-                };
-            }
-            return result;
-        }
         _calculateRetryDelay(error) {
             this._retryCount++;
             if (this._retryCount < this._options.retry.limit && !(error instanceof TimeoutError)) {
@@ -289,7 +387,7 @@
                         else {
                             after *= 1000;
                         }
-                        if (typeof this._options.retry.maxRetryAfter !== 'undefined' && after > this._options.retry.maxRetryAfter) {
+                        if (this._options.retry.maxRetryAfter !== undefined && after > this._options.retry.maxRetryAfter) {
                             return 0;
                         }
                         return after;
@@ -299,7 +397,7 @@
                     }
                 }
                 const BACKOFF_FACTOR = 0.3;
-                return BACKOFF_FACTOR * (2 ** (this._retryCount - 1)) * 1000;
+                return Math.min(this._options.retry.backoffLimit, BACKOFF_FACTOR * (2 ** (this._retryCount - 1)) * 1000);
             }
             return 0;
         }
@@ -312,12 +410,11 @@
         async _retry(fn) {
             try {
                 return await fn();
-                // eslint-disable-next-line @typescript-eslint/no-implicit-any-catch
             }
             catch (error) {
                 const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);
                 if (ms !== 0 && this._retryCount > 0) {
-                    await delay(ms);
+                    await delay(ms, { signal: this._options.signal });
                     for (const hook of this._options.hooks.beforeRetry) {
                         // eslint-disable-next-line no-await-in-loop
                         const hookResult = await hook({
@@ -357,6 +454,16 @@
         _stream(response, onDownloadProgress) {
             const totalBytes = Number(response.headers.get('content-length')) || 0;
             let transferredBytes = 0;
+            if (response.status === 204) {
+                if (onDownloadProgress) {
+                    onDownloadProgress({ percent: 1, totalBytes, transferredBytes }, new Uint8Array());
+                }
+                return new globalThis.Response(null, {
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: response.headers,
+                });
+            }
             return new globalThis.Response(new globalThis.ReadableStream({
                 async start(controller) {
                     const reader = response.body.getReader();
@@ -379,7 +486,11 @@
                     }
                     await read();
                 },
-            }));
+            }), {
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+            });
         }
     }
 
@@ -400,7 +511,7 @@
 
     exports.HTTPError = HTTPError;
     exports.TimeoutError = TimeoutError;
-    exports["default"] = ky;
+    exports.default = ky;
 
     Object.defineProperty(exports, '__esModule', { value: true });
 

package/src/node.js

@@ -1,7 +1,7 @@
 module.exports = require('./factory')({
   MicrolinkError: require('whoops')('MicrolinkError'),
   urlHttp: require('url-http/lightweight'),
-  got: require('got'),
+  got: require('got').extend({ headers: { 'user-agent': undefined } }),
   flatten: require('flattie').flattie,
   VERSION: require('../package.json').version
 })