@browserless/function 9.2.3

package/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright © 2019 Microlink <hello@microlink.io> (microlink.io)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@browserless/function",
+  "description": "Run abritrary JavaScript inside a browser sandbox",
+  "homepage": "https://browserless.js.org",
+  "version": "9.2.3",
+  "main": "src/index.js",
+  "author": {
+    "email": "hello@microlink.io",
+    "name": "microlink.io",
+    "url": "https://microlink.io"
+  },
+  "repository": {
+    "directory": "packages/function",
+    "type": "git",
+    "url": "git+https://github.com/microlinkhq/browserless.git#master"
+  },
+  "bugs": {
+    "url": "https://github.com/microlinkhq/browserless/issues"
+  },
+  "keywords": [
+    "browser",
+    "browserless",
+    "chrome",
+    "chromeless",
+    "core",
+    "function",
+    "headless",
+    "puppeteer",
+    "serverless"
+  ],
+  "dependencies": {
+    "@browserless/errors": "^9.1.6",
+    "debug-logfmt": "~1.0.4",
+    "deepmerge": "~4.2.2",
+    "execa": "~5.1.1",
+    "p-event": "~4.2.0",
+    "p-reflect": "~2.1.0",
+    "p-retry": "~4.6.0",
+    "p-timeout": "~4.1.0",
+    "require-one-of": "~1.0.15",
+    "serialize-error": "~8.1.0",
+    "vm2": "~3.9.3"
+  },
+  "devDependencies": {
+    "ava": "latest",
+    "browserless": "latest",
+    "nyc": "latest",
+    "puppeteer": "latest"
+  },
+  "engines": {
+    "node": ">= 12"
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "test": "NODE_ENV=test nyc ava"
+  },
+  "license": "MIT",
+  "ava": {
+    "timeout": "2m",
+    "verbose": true
+  },
+  "gitHead": "dac162639d969ba1862516bfb3273158af205f5c"
+}

package/src/function.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const path = require('path')
+
+const createVm = require('./vm')
+
+const scriptPath = path.resolve(__dirname, 'function.js')
+
+const createFn = code => `
+async ({ url, query, gotoOpts, browserWSEndpoint }) => {
+  const { serializeError } = require('serialize-error')
+
+  const getBrowserless = require('browserless')
+  const browserless = await getBrowserless({ mode: 'connect', browserWSEndpoint }).createContext()
+  const fnWrapper = fn => (page, response) => fn({ page, response, query })
+  const browserFn = browserless.evaluate(fnWrapper(${code}), gotoOpts)
+
+  try {
+    const value = await browserFn(url)
+    await browserless.destroyContext()
+    return { isFulfilled: true, isRejected: false, value }
+  } catch(error) {
+    await browserless.destroyContext()
+    return { isFulfilled: false, isRejected: true, reason: serializeError(error) }
+  }
+}`
+
+process.on('message', async ({ url, code, query, vmOpts, gotoOpts, browserWSEndpoint }) => {
+  const vm = createVm(vmOpts)
+  const fn = createFn(code.endsWith(';') ? code.slice(0, -1) : code)
+  const run = vm(fn, scriptPath)
+  process.send(await run({ url, query, gotoOpts, browserWSEndpoint }))
+})

package/src/index.js

@@ -0,0 +1,69 @@
+'use strict'
+
+const { ensureError, browserTimeout } = require('@browserless/errors')
+const debug = require('debug-logfmt')('browserless:function')
+const requireOneOf = require('require-one-of')
+const { driver } = require('browserless')
+const pTimeout = require('p-timeout')
+const pRetry = require('p-retry')
+const pEvent = require('p-event')
+const execa = require('execa')
+const path = require('path')
+
+const { AbortError } = pRetry
+
+const execPath = path.resolve(__dirname, 'function.js')
+
+module.exports = (
+  fn,
+  { getBrowserless = requireOneOf(['browserless']), retry = 2, timeout = 30000, ...opts }
+) => {
+  return async (url, query = {}) => {
+    const browserlessPromise = getBrowserless()
+    let isRejected = false
+
+    async function run () {
+      const browserless = await browserlessPromise
+      const browser = await browserless.browser()
+      const browserWSEndpoint = browser.wsEndpoint()
+
+      const subprocess = execa.node(execPath, { killSignal: 'SIGKILL', timeout })
+      subprocess.stderr.pipe(process.stderr)
+
+      debug('spawn', { pid: subprocess.pid })
+
+      subprocess.send({
+        url,
+        code: fn.toString(),
+        query,
+        browserWSEndpoint,
+        ...opts
+      })
+
+      const { value, reason, isFulfilled } = await pEvent(subprocess, 'message')
+      await driver.close(subprocess)
+      if (isFulfilled) return value
+      throw ensureError(reason)
+    }
+
+    const task = () =>
+      pRetry(run, {
+        retries: retry,
+        onFailedAttempt: async error => {
+          if (error.name === 'AbortError') throw error
+          if (isRejected) throw new AbortError()
+          await (await browserlessPromise).respawn()
+          const { message, attemptNumber, retriesLeft } = error
+          debug('retry', { attemptNumber, retriesLeft, message })
+        }
+      })
+
+    // main
+    const result = await pTimeout(task(), timeout, () => {
+      isRejected = true
+      throw browserTimeout({ timeout })
+    })
+
+    return result
+  }
+}

package/src/vm.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const pReflect = require('p-reflect')
+const { NodeVM } = require('vm2')
+const merge = require('deepmerge')
+
+const DEFAULT_VM_OPTS = {
+  console: 'off',
+  sandbox: {},
+  require: {
+    external: {
+      modules: ['serialize-error', 'browserless']
+    }
+  }
+}
+
+const createVm = (opts = {}) => new NodeVM(merge(DEFAULT_VM_OPTS, opts))
+
+const compile = (vm, fn, scriptPath) => {
+  const code = `'use strict'; module.exports = ${fn.toString()}`
+  return vm.run(code, scriptPath)
+}
+
+module.exports = opts => {
+  const vm = createVm(opts)
+
+  return (fn, scriptPath) => {
+    const run = compile(vm, fn, scriptPath)
+    return (...args) => pReflect(run(...args))
+  }
+}