@microlink/mql 0.15.1 → 0.16.1

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://microlink.io/mql",
-  "version": "0.15.1",
+  "version": "0.16.1",
   "types": "dist/index.d.ts",
   "exports": {
     "types": "./dist/index.d.ts",
@@ -49,12 +49,11 @@
   ],
   "dependencies": {
     "flattie": "~1.1.1",
-    "ky": "~1.14.3"
+    "ky": "~2.0.0"
   },
   "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",
@@ -76,12 +75,11 @@
     "tsd": "latest"
   },
   "engines": {
-    "node": ">= 18"
+    "node": ">= 22"
   },
   "files": [
     "dist",
     "src/constants.js",
-    "src/factory.js",
     "src/index.js",
     "src/main.mjs"
   ],
@@ -121,7 +119,7 @@
   },
   "nano-staged": {
     "*.js": [
-      "prettier-standard",
+      "npx -y @kikobeats/prettier-standard",
       "standard --fix"
     ],
     "*.md": [

package/src/constants.js

@@ -6,7 +6,13 @@ module.exports = {
   VERSION,
   USER_AGENT: `mql/${VERSION}`,
   /**
-   * Retry status codes, excluding 429 (too many requests).
+   * Based on Ky default retry status codes, excluding 429:
+   * https://github.com/sindresorhus/ky/blob/main/source/core/constants.ts
    */
-  RETRY_STATUS_CODES: [408, 413, 500, 502, 503, 504, 521, 522, 524]
+  RETRY_STATUS_CODES: [408, 413, 500, 502, 503, 504, 521, 522, 524],
+  /**
+   * Based on Ky default Retry-After status codes, excluding 429:
+   * https://github.com/sindresorhus/ky/blob/main/source/core/constants.ts
+   */
+  RETRY_AFTER_STATUS_CODES: [413, 503]
 }

package/src/index.js

@@ -3,14 +3,59 @@
 const { flattie: flatten } = require('flattie')
 const { default: ky } = require('ky')
 
-const { VERSION, USER_AGENT, RETRY_STATUS_CODES } = require('./constants')
+const {
+  VERSION,
+  USER_AGENT,
+  RETRY_STATUS_CODES,
+  RETRY_AFTER_STATUS_CODES
+} = require('./constants')
+
+const ENDPOINT = {
+  FREE: 'https://api.microlink.io/',
+  PRO: 'https://pro.microlink.io/'
+}
+
+const STREAM_RESPONSE_TYPE = 'arrayBuffer'
 
 const kyInstance = ky.extend({
   headers: { 'user-agent': USER_AGENT },
-  retry: { statusCodes: RETRY_STATUS_CODES }
+  retry: {
+    statusCodes: RETRY_STATUS_CODES,
+    afterStatusCodes: RETRY_AFTER_STATUS_CODES
+  }
 })
 
-const factory = require('./factory')('arrayBuffer')
+const isObject = input => input !== null && typeof input === 'object'
+
+const isBuffer = input =>
+  typeof input?.constructor?.isBuffer === 'function' &&
+  input.constructor.isBuffer(input)
+
+const parseBody = (input, error, url) => {
+  try {
+    return JSON.parse(input)
+  } catch (_) {
+    const message = input || error.message
+
+    return {
+      status: 'error',
+      data: { url: message },
+      more: 'https://microlink.io/efatalclient',
+      code: 'EFATALCLIENT',
+      message,
+      url
+    }
+  }
+}
+
+const isURL = url => {
+  try {
+    const { protocol } = new URL(url)
+    return protocol === 'http:' || protocol === 'https:'
+  } catch (_) {
+    return false
+  }
+}
 
 class MicrolinkError extends Error {
   constructor (props) {
@@ -24,44 +69,130 @@ class MicrolinkError extends Error {
   }
 }
 
-const got = async (url, { responseType, ...opts }) => {
+const assertUrl = (url = '') => {
+  if (!isURL(url)) {
+    const message = `The \`url\` as \`${url}\` is not valid. Ensure it has protocol (http or https) and hostname.`
+    throw new MicrolinkError({
+      status: 'fail',
+      data: { url: message },
+      more: 'https://microlink.io/einvalurlclient',
+      code: 'EINVALURLCLIENT',
+      message,
+      url
+    })
+  }
+}
+
+const mapRules = rules => {
+  if (!isObject(rules)) return
+  return Object.fromEntries(
+    Object.entries(flatten(rules)).map(([key, value]) => [
+      `data.${key}`,
+      value.toString()
+    ])
+  )
+}
+
+const doFetch = async (apiUrl, { responseType, ...opts }) => {
+  if (opts.timeout === undefined) opts.timeout = false
+  const response = await kyInstance(apiUrl, opts)
+  const body = await response[responseType]()
+  const { headers, status: statusCode } = response
+  return { url: response.url, body, headers, statusCode }
+}
+
+const fetchFromApi = async (apiUrl, opts = {}) => {
   try {
-    if (opts.timeout === undefined) opts.timeout = false
-    const response = await kyInstance(url, opts)
-    const body = await response[responseType]()
-    const { headers, status: statusCode } = response
-    return { url: response.url, body, headers, statusCode }
+    const response = await doFetch(apiUrl, opts)
+    return opts.responseType === STREAM_RESPONSE_TYPE
+      ? response
+      : { ...response.body, response }
   } catch (error) {
-    if (error.response) {
-      const { response } = error
-      error.response = {
-        ...response,
-        headers: Array.from(response.headers.entries()).reduce(
-          (acc, [key, value]) => {
-            acc[key] = value
-            return acc
-          },
-          {}
-        ),
-        statusCode: response.status,
-        body: await response.text()
+    const { response = {} } = error
+    const { statusCode: responseStatusCode, status } = response
+    const {
+      body: rawBody,
+      headers: responseHeaders,
+      url: uri = apiUrl
+    } = response
+
+    const statusCode = responseStatusCode ?? status
+    const headers =
+      typeof responseHeaders?.entries === 'function'
+        ? Object.fromEntries(responseHeaders.entries())
+        : responseHeaders || {}
+
+    let bodyInput = error.data ?? rawBody
+    const isBodyReadableStream = typeof bodyInput?.getReader === 'function'
+
+    if (
+      (bodyInput === undefined || isBodyReadableStream) &&
+      typeof response.text === 'function'
+    ) {
+      try {
+        bodyInput = await response.text()
+      } catch (_) {
+        bodyInput = undefined
       }
     }
-    throw error
+
+    const isBodyBuffer = isBuffer(bodyInput)
+    const body =
+      isObject(bodyInput) && !isBodyBuffer
+        ? bodyInput
+        : parseBody(isBodyBuffer ? bodyInput.toString() : bodyInput, error, uri)
+
+    throw new MicrolinkError({
+      ...body,
+      url: uri,
+      statusCode,
+      headers
+    })
   }
 }
 
-got.stream = (...args) => kyInstance(...args).then(res => res.body)
+const getApiUrl = (
+  url,
+  { data, apiKey, endpoint, ...opts } = {},
+  { responseType = 'json', headers: reqHeaders = {}, ...gotOpts } = {}
+) => {
+  const isPro = !!apiKey
+  const apiEndpoint = endpoint || ENDPOINT[isPro ? 'PRO' : 'FREE']
 
-const mql = factory({
-  MicrolinkError,
-  got,
-  flatten,
-  VERSION
-})
+  const apiUrl = `${apiEndpoint}?${new URLSearchParams({
+    url,
+    ...mapRules(data),
+    ...flatten(opts)
+  })}`
+
+  const headers = isPro ? { ...reqHeaders, 'x-api-key': apiKey } : reqHeaders
+
+  if (opts.stream) responseType = STREAM_RESPONSE_TYPE
+
+  return [apiUrl, { ...gotOpts, responseType, headers }]
+}
+
+const createMql = defaultOpts => async (url, opts, gotOpts) => {
+  assertUrl(url)
+  const [apiUrl, fetchOpts] = getApiUrl(url, opts, {
+    ...defaultOpts,
+    ...gotOpts
+  })
+  return fetchFromApi(apiUrl, fetchOpts)
+}
+
+const mql = createMql()
+
+mql.extend = createMql
+mql.MicrolinkError = MicrolinkError
+mql.getApiUrl = getApiUrl
+mql.fetchFromApi = fetchFromApi
+mql.mapRules = mapRules
+mql.version = VERSION
+mql.stream = (...args) => kyInstance(...args).then(res => res.body)
 
 module.exports = mql
-module.exports.arrayBuffer = mql.extend({ responseType: 'arrayBuffer' })
+module.exports.arrayBuffer = mql.extend({ responseType: STREAM_RESPONSE_TYPE })
 module.exports.buffer = module.exports.arrayBuffer
 module.exports.extend = mql.extend
 module.exports.fetchFromApi = mql.fetchFromApi

package/src/factory.js

@@ -1,144 +0,0 @@
-const ENDPOINT = {
-  FREE: 'https://api.microlink.io/',
-  PRO: 'https://pro.microlink.io/'
-}
-
-const isObject = input => input !== null && typeof input === 'object'
-
-const isBuffer = input =>
-  input != null &&
-  input.constructor != null &&
-  typeof input.constructor.isBuffer === 'function' &&
-  input.constructor.isBuffer(input)
-
-const parseBody = (input, error, url) => {
-  try {
-    return JSON.parse(input)
-  } catch (_) {
-    const message = input || error.message
-
-    return {
-      status: 'error',
-      data: { url: message },
-      more: 'https://microlink.io/efatalclient',
-      code: 'EFATALCLIENT',
-      message,
-      url
-    }
-  }
-}
-
-const isURL = url => {
-  try {
-    return /^https?:\/\//i.test(new URL(url).href)
-  } catch (_) {
-    return false
-  }
-}
-
-const factory = streamResponseType => ({
-  VERSION,
-  MicrolinkError,
-  got,
-  flatten
-}) => {
-  const assertUrl = (url = '') => {
-    if (!isURL(url)) {
-      const message = `The \`url\` as \`${url}\` is not valid. Ensure it has protocol (http or https) and hostname.`
-      throw new MicrolinkError({
-        status: 'fail',
-        data: { url: message },
-        more: 'https://microlink.io/einvalurlclient',
-        code: 'EINVALURLCLIENT',
-        message,
-        url
-      })
-    }
-  }
-
-  const mapRules = rules => {
-    if (!isObject(rules)) return
-    const flatRules = flatten(rules)
-    return Object.keys(flatRules).reduce((acc, key) => {
-      acc[`data.${key}`] = flatRules[key].toString()
-      return acc
-    }, {})
-  }
-
-  const fetchFromApi = async (apiUrl, opts = {}) => {
-    try {
-      const response = await got(apiUrl, opts)
-      return opts.responseType === streamResponseType
-        ? response
-        : { ...response.body, response }
-    } catch (error) {
-      const { response = {} } = error
-      const {
-        statusCode,
-        body: rawBody,
-        headers = {},
-        url: uri = apiUrl
-      } = response
-      const isBodyBuffer = isBuffer(rawBody)
-
-      const body =
-        isObject(rawBody) && !isBodyBuffer
-          ? rawBody
-          : parseBody(isBodyBuffer ? rawBody.toString() : rawBody, error, uri)
-
-      throw new MicrolinkError({
-        ...body,
-        message: body.message,
-        url: uri,
-        statusCode,
-        headers
-      })
-    }
-  }
-
-  const getApiUrl = (
-    url,
-    { data, apiKey, endpoint, ...opts } = {},
-    { responseType = 'json', headers: gotHeaders, ...gotOpts } = {}
-  ) => {
-    const isPro = !!apiKey
-    const apiEndpoint = endpoint || ENDPOINT[isPro ? 'PRO' : 'FREE']
-
-    const apiUrl = `${apiEndpoint}?${new URLSearchParams({
-      url,
-      ...mapRules(data),
-      ...flatten(opts)
-    }).toString()}`
-
-    const headers = isPro
-      ? { ...gotHeaders, 'x-api-key': apiKey }
-      : { ...gotHeaders }
-
-    if (opts.stream) {
-      responseType = streamResponseType
-    }
-    return [apiUrl, { ...gotOpts, responseType, headers }]
-  }
-
-  const createMql = defaultOpts => async (url, opts, gotOpts) => {
-    assertUrl(url)
-    const [apiUrl, fetchOpts] = getApiUrl(url, opts, {
-      ...defaultOpts,
-      ...gotOpts
-    })
-    return fetchFromApi(apiUrl, fetchOpts)
-  }
-
-  const mql = createMql()
-  mql.extend = createMql
-  mql.MicrolinkError = MicrolinkError
-  mql.getApiUrl = getApiUrl
-  mql.fetchFromApi = fetchFromApi
-  mql.mapRules = mapRules
-  mql.version = VERSION
-  mql.stream = got.stream
-
-  return mql
-}
-
-module.exports = factory