@microlink/mql 0.11.6-0 → 0.11.6-1

package/package.json

@@ -2,10 +2,8 @@
   "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.11.6-0",
+  "version": "0.11.6-1",
   "types": "lightweight/index.d.ts",
-  "main": "src/node.js",
-  "module": "src/node.mjs",
   "exports": {
     "require": "./src/node.js",
     "default": "./lightweight/index.js"
@@ -88,10 +86,7 @@
   },
   "files": [
     "lightweight",
-    "src/factory.js",
-    "src/index.d.ts",
-    "src/ky.js",
-    "src/node.js"
+    "src"
   ],
   "license": "MIT",
   "ava": {
@@ -124,7 +119,7 @@
   },
   "standard": {
     "ignore": [
-      "dist",
+      "src/node.mjs",
       "lightweight/index.js"
     ]
   },
@@ -139,7 +134,7 @@
   "scripts": {
     "build": "rollup -c rollup.config.js --bundleConfigAsCjs",
     "clean": "rm -rf node_modules",
-    "clean:build": "rm -rf dist lightweight/index.js",
+    "clean:build": "rm -rf lightweight/index.js",
     "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",

package/src/lightweight.js

@@ -0,0 +1,60 @@
+'use strict'
+
+const urlHttp = require('url-http/lightweight')
+const { flattie: flatten } = require('flattie')
+const factory = require('./factory')
+const { default: ky } = require('ky')
+
+class MicrolinkError extends Error {
+  constructor (props) {
+    super()
+    this.name = 'MicrolinkError'
+    Object.assign(this, props)
+    this.description = this.message
+    this.message = this.code
+      ? `${this.code}, ${this.description}`
+      : this.description
+  }
+}
+
+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()
+    const { headers, status: statusCode } = response
+    return { url: response.url, body, headers, statusCode }
+  } catch (err) {
+    if (err.response) {
+      const { response } = err
+      err.response = {
+        ...response,
+        headers: Array.from(response.headers.entries()).reduce(
+          (acc, [key, value]) => {
+            acc[key] = value
+            return acc
+          },
+          {}
+        ),
+        statusCode: response.status,
+        body: await response.text()
+      }
+    }
+    throw err
+  }
+}
+
+const mql = factory({
+  MicrolinkError,
+  urlHttp,
+  got,
+  flatten,
+  VERSION: '__MQL_VERSION__'
+})
+
+module.exports = mql
+module.exports.MicrolinkError = mql.MicrolinkError
+module.exports.getApiUrl = mql.getApiUrl
+module.exports.mapRules = mql.mapRules
+module.exports.version = mql.version

package/src/node.d.ts

@@ -0,0 +1,29 @@
+import { MqlPayload, MqlOptions, MicrolinkApiOptions } from '../lightweight'
+
+export { MqlError, MqlPayload } from '../lightweight'
+
+export type MqlResponse = MqlPayload & {
+  response: {
+    url: string;
+    isFromCache?: boolean;
+    statusCode: number;
+    headers: { [key: string]: string };
+    body: MqlPayload
+  };
+}
+
+declare function mql(
+  url: string,
+  opts?: MqlOptions & MicrolinkApiOptions,
+  gotOpts?: object
+): Promise<MqlResponse>;
+
+declare namespace mql {
+  function stream(
+    url: string,
+    opts?: MqlOptions & MicrolinkApiOptions,
+    gotOpts?: object
+  ): NodeJS.ReadableStream;
+}
+
+export default mql;

package/src/node.mjs

@@ -0,0 +1,158 @@
+import require$$0 from 'whoops';
+import require$$1 from 'url-http/lightweight';
+import require$$2 from 'got';
+import * as require$$3 from 'flattie';
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var node$1 = {exports: {}};
+
+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 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.`;
+      throw new MicrolinkError({
+        status: 'fail',
+        data: { url: message },
+        more: 'https://microlink.io/docs/api/api-parameters/url',
+        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 === 'buffer'
+        ? { body: response.body, response }
+        : { ...response.body, response }
+    } catch (err) {
+      const { response = {} } = err;
+      const {
+        statusCode,
+        body: rawBody,
+        headers = {},
+        url: uri = apiUrl
+      } = response;
+      const isBodyBuffer = isBuffer(rawBody);
+
+      const body =
+        isObject(rawBody) && !isBodyBuffer
+          ? rawBody
+          : parseBody(isBodyBuffer ? rawBody.toString() : rawBody, err, uri);
+
+      throw new MicrolinkError({
+        ...body,
+        message: body.message,
+        url: uri,
+        statusCode,
+        headers
+      })
+    }
+  };
+
+  const getApiUrl = (
+    url,
+    { data, apiKey, endpoint, retry, cache, ...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 };
+    return [apiUrl, { ...gotOpts, responseType, cache, retry, 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.MicrolinkError = MicrolinkError;
+  mql.getApiUrl = getApiUrl;
+  mql.fetchFromApi = fetchFromApi;
+  mql.mapRules = mapRules;
+  mql.version = VERSION;
+  mql.stream = got.stream;
+  mql.buffer = createMql({ responseType: 'buffer' });
+
+  return mql
+};
+
+var factory_1 = factory;
+
+node$1.exports = factory_1({
+  MicrolinkError: require$$0('MicrolinkError'),
+  urlHttp: require$$1,
+  got: require$$2.extend({ headers: { 'user-agent': undefined } }),
+  flatten: require$$3.flattie,
+  VERSION: '0.11.6-0'
+});
+
+var render = node$1.exports.render = (input, { width = '650px' } = {}) => {
+  if (input && input.url && input.type) {
+    return `<img width="${width}" src="${input.url}" />`
+  }
+  return input
+};
+
+var nodeExports = node$1.exports;
+var node = /*@__PURE__*/getDefaultExportFromCjs(nodeExports);
+
+export { node as default, render };