@browserless/function 10.5.4 → 10.6.1

package/package.json

@@ -2,7 +2,7 @@
   "name": "@browserless/function",
   "description": "Run abritrary JavaScript inside a browser sandbox",
   "homepage": "https://browserless.js.org",
-  "version": "10.5.4",
+  "version": "10.6.1",
   "main": "src/index.js",
   "author": {
     "email": "hello@microlink.io",
@@ -29,20 +29,14 @@
     "serverless"
   ],
   "dependencies": {
-    "@browserless/errors": "^10.5.2",
-    "debug-logfmt": "~1.2.1",
-    "deepmerge": "~4.3.1",
-    "p-reflect": "~2.1.0",
+    "isolated-function": "~0.1.4",
     "p-retry": "~4.6.1",
-    "p-timeout": "~4.1.0",
-    "require-one-of": "~1.0.19",
-    "serialize-error": "~8.1.0",
-    "vm2": "~3.9.19"
+    "require-one-of": "~1.0.19"
   },
   "devDependencies": {
-    "@browserless/test": "^10.5.2",
+    "@browserless/test": "^10.6.0",
     "ava": "5",
-    "browserless": "^10.5.4",
+    "browserless": "^10.6.0",
     "lodash": "latest"
   },
   "engines": {
@@ -60,5 +54,5 @@
     "timeout": "2m",
     "workerThreads": false
   },
-  "gitHead": "f65b4f579d2ff9408ae9e8363202b8b2f5d14b9b"
+  "gitHead": "44f9a1f22ea2020949e8d7465362908e3fd8e1a7"
 }

package/src/function.js

@@ -1,51 +1,22 @@
 'use strict'
 
-const path = require('path')
-
-const createVm = require('./vm')
-
-const scriptPath = path.resolve(__dirname, 'function.js')
+const isolatedFunction = require('isolated-function')
 
 const createFn = code => `
-async ({ url, gotoOpts, browserWSEndpoint, ...opts }) => {
-  const { serializeError } = require('serialize-error')
-
-  const getBrowserless = require('browserless')
-  const browserless = await getBrowserless({ mode: 'connect', browserWSEndpoint }).createContext()
-  const fnWrapper = fn => (page, response) => {
-    if (!response && opts.response) {
-      const { status, statusText, headers, html } = opts.response
-      response = {
-        ok: () => status === 0 || (status >= 200 && opts.status <= 299),
-        fromCache: () => false,
-        fromServiceWorker: () => false,
-        url: () => url,
-        text: () => html,
-        statusText: () => statusText,
-        json: () => JSON.parse(html),
-        headers: () => headers,
-        status: () => status
-      }
-    }
-
-    return fn({ ...opts, page, response, url })
-  }
-  const browserFn = browserless.evaluate(fnWrapper(${code}), gotoOpts)
-
+async (url, browserWSEndpoint, opts) => {
+  const puppeteer = require('@cloudflare/puppeteer')
+  const browser = await puppeteer.connect({ browserWSEndpoint })
+  const page = (await browser.pages())[1]
   try {
-    const value = await browserFn(url)
-    return { isFulfilled: true, isRejected: false, value }
-  } catch (error) {
-    return { isFulfilled: false, isRejected: true, reason: serializeError(error) }
+    return await (${code})({ page, ...opts })
   } finally {
-    await browserless.destroyContext()
-    await browserless.browser().then(browser => browser.disconnect())
+    await browser.disconnect()
   }
 }`
 
-module.exports = ({ url, code, vmOpts, gotoOpts, browserWSEndpoint, ...opts }) => {
-  const vm = createVm(vmOpts)
-  const fn = createFn(code)
-  const run = vm(fn, scriptPath)
-  return run({ url, gotoOpts, browserWSEndpoint, ...opts })
+module.exports = async ({ url, code, vmOpts, browserWSEndpoint, ...opts }) => {
+  const [fn, teardown] = isolatedFunction(createFn(code), { ...vmOpts, throwError: false })
+  const result = await fn(url, browserWSEndpoint, opts)
+  await teardown()
+  return result
 }

package/src/index.js

@@ -1,60 +1,41 @@
 'use strict'
 
-const { ensureError, browserTimeout } = require('@browserless/errors')
-const debug = require('debug-logfmt')('browserless:function')
+const { isBrowserlessError, ensureError } = require('@browserless/errors')
 const requireOneOf = require('require-one-of')
-const pTimeout = require('p-timeout')
-const pRetry = require('p-retry')
-
-const { AbortError } = pRetry
-
 const runFunction = require('./function')
 
 const stringify = fn => fn.toString().trim().replace(/;$/, '')
 
-module.exports = (
-  fn,
-  { getBrowserless = requireOneOf(['browserless']), retry = 2, timeout = 30000, ...opts } = {}
-) => {
-  return async (url, fnOpts = {}) => {
-    const browserlessPromise = getBrowserless()
-    let isRejected = false
-
-    async function run () {
-      const browserless = await browserlessPromise
-      const browser = await browserless.browser()
-      const browserWSEndpoint = browser.wsEndpoint()
-
-      const { value, reason, isFulfilled } = await runFunction({
-        url,
-        code: stringify(fn),
-        browserWSEndpoint,
-        ...opts,
-        ...fnOpts
-      })
-
-      if (isFulfilled) return value
-      throw ensureError(reason)
+module.exports =
+  (
+    fn,
+    {
+      getBrowserless = requireOneOf(['browserless']),
+      retry = 2,
+      timeout = 30000,
+      gotoOpts,
+      ...opts
+    } = {}
+  ) =>
+    async (url, fnOpts = {}) => {
+      const browserlessPromise = getBrowserless()
+      const browser = await browserlessPromise
+      const browserless = await browser.createContext()
+
+      return browserless.withPage((page, goto) => async () => {
+        const { device } = await goto(page, { url, timeout, ...gotoOpts })
+        const result = await runFunction({
+          url,
+          code: stringify(fn),
+          browserWSEndpoint: (await browserless.browser()).wsEndpoint(),
+          device,
+          ...opts,
+          ...fnOpts
+        })
+
+        if (result.isFulfilled) return result
+        const error = ensureError(result.value)
+        if (isBrowserlessError(error)) throw error
+        return result
+      })()
     }
-
-    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

@@ -1,34 +0,0 @@
-'use strict'
-
-const pReflect = require('p-reflect')
-const merge = require('deepmerge')
-const { NodeVM } = require('vm2')
-const path = require('path')
-
-const DEFAULT_VM_OPTS = {
-  console: 'off',
-  sandbox: {},
-  strict: true,
-  require: {
-    resolve: pkgName => path.resolve(process.cwd(), 'node_modules', pkgName),
-    external: {
-      modules: ['serialize-error', 'browserless']
-    }
-  }
-}
-
-const createVm = (opts = {}) => new NodeVM(merge(DEFAULT_VM_OPTS, opts))
-
-const compile = (vm, fn, scriptPath) => {
-  const code = `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))
-  }
-}