fastify 2.10.0 → 2.13.0

package/lib/decorate.js

@@ -4,13 +4,15 @@
 
 const {
   kReply,
-  kRequest
+  kRequest,
+  kState
 } = require('./symbols.js')
 
 const {
   codes: {
     FST_ERR_DEC_ALREADY_PRESENT,
-    FST_ERR_DEC_MISSING_DEPENDENCY
+    FST_ERR_DEC_MISSING_DEPENDENCY,
+    FST_ERR_DEC_AFTER_START
   }
 } = require('./errors')
 
@@ -34,6 +36,7 @@ function decorate (instance, name, fn, dependencies) {
 }
 
 function decorateFastify (name, fn, dependencies) {
+  assertNotStarted(this, name)
   decorate(this, name, fn, dependencies)
   return this
 }
@@ -63,15 +66,23 @@ function checkDependencies (instance, deps) {
 }
 
 function decorateReply (name, fn, dependencies) {
+  assertNotStarted(this, name)
   decorate(this[kReply].prototype, name, fn, dependencies)
   return this
 }
 
 function decorateRequest (name, fn, dependencies) {
+  assertNotStarted(this, name)
   decorate(this[kRequest].prototype, name, fn, dependencies)
   return this
 }
 
+function assertNotStarted (instance, name) {
+  if (instance[kState].started) {
+    throw new FST_ERR_DEC_AFTER_START(name)
+  }
+}
+
 module.exports = {
   add: decorateFastify,
   exist: checkExistence,

package/lib/errors.js

@@ -27,6 +27,7 @@ createError('FST_ERR_CTP_EMPTY_JSON_BODY', "Body cannot be empty when content-ty
 */
 createError('FST_ERR_DEC_ALREADY_PRESENT', "The decorator '%s' has already been added!")
 createError('FST_ERR_DEC_MISSING_DEPENDENCY', "The decorator is missing dependency '%s'.")
+createError('FST_ERR_DEC_AFTER_START', "The decorator '%s' has been added after start!")
 
 /**
  * hooks
@@ -46,6 +47,8 @@ createError('FST_ERR_REP_INVALID_PAYLOAD_TYPE', "Attempted to send payload of in
 createError('FST_ERR_REP_ALREADY_SENT', 'Reply was already sent.')
 createError('FST_ERR_REP_SENT_VALUE', 'The only possible value for reply.sent is true.')
 createError('FST_ERR_SEND_INSIDE_ONERR', 'You cannot use `send` inside the `onError` hook')
+createError('FST_ERR_SEND_UNDEFINED_ERR', 'Undefined error has occured')
+createError('FST_ERR_BAD_STATUS_CODE', 'Called reply with malformed status code')
 
 /**
  * schemas
@@ -72,6 +75,11 @@ createError('FST_ERR_HTTP2_INVALID_VERSION', 'HTTP2 is available only from node
  */
 createError('FST_ERR_INIT_OPTS_INVALID', "Invalid initialization options: '%s'")
 
+/**
+ * router
+ */
+createError('FST_ERR_BAD_URL', "'%s' is not a valid url component", 400)
+
 function createError (code, message, statusCode = 500, Base = Error) {
   if (!code) throw new Error('Fastify error code must not be empty')
   if (!message) throw new Error('Fastify error message must not be empty')

package/lib/hooks.js

@@ -17,7 +17,8 @@ const supportedHooks = [
 const {
   codes: {
     FST_ERR_HOOK_INVALID_TYPE,
-    FST_ERR_HOOK_INVALID_HANDLER
+    FST_ERR_HOOK_INVALID_HANDLER,
+    FST_ERR_SEND_UNDEFINED_ERR
   }
 } = require('./errors')
 
@@ -78,6 +79,7 @@ function hookRunner (functions, runner, request, reply, cb) {
   }
 
   function handleReject (err) {
+    if (err === undefined) err = new FST_ERR_SEND_UNDEFINED_ERR()
     cb(err, request, reply)
   }
 

package/lib/logger.js

@@ -6,7 +6,7 @@
  * License: MIT (https://raw.githubusercontent.com/pinojs/pino-http/master/LICENSE)
  */
 
-const abstractLogging = require('abstract-logging')
+const nullLogger = require('abstract-logging')
 const pino = require('pino')
 const { serializersSym } = pino.symbols
 const { isValidLogger } = require('./validation')
@@ -82,7 +82,7 @@ function createLogger (options) {
     })
     return { logger, hasLogger: true }
   } else if (!options.logger) {
-    const logger = Object.create(abstractLogging)
+    const logger = nullLogger
     logger.child = () => logger
     return { logger, hasLogger: false }
   } else {

package/lib/reply.js

@@ -46,7 +46,8 @@ const {
     FST_ERR_REP_INVALID_PAYLOAD_TYPE,
     FST_ERR_REP_ALREADY_SENT,
     FST_ERR_REP_SENT_VALUE,
-    FST_ERR_SEND_INSIDE_ONERR
+    FST_ERR_SEND_INSIDE_ONERR,
+    FST_ERR_BAD_STATUS_CODE
   }
 } = require('./errors')
 
@@ -140,9 +141,10 @@ Reply.prototype.send = function (payload) {
     if (hasContentType === false || contentType.indexOf('charset') === -1) {
       this[kReplyHeaders]['content-type'] = CONTENT_TYPE.JSON
     }
-
-    preserializeHook(this, payload)
-    return this
+    if (typeof payload !== 'string') {
+      preserializeHook(this, payload)
+      return this
+    }
   }
 
   onSendHook(this, payload)
@@ -196,6 +198,10 @@ Reply.prototype.headers = function (headers) {
 }
 
 Reply.prototype.code = function (code) {
+  if (statusCodes[code] === undefined) {
+    throw new FST_ERR_BAD_STATUS_CODE()
+  }
+
   this.res.statusCode = code
   this[kReplyHasStatusCode] = true
   return this

package/lib/route.js

@@ -6,7 +6,7 @@ const Context = require('./context')
 const { buildMiddie, onRunMiddlewares } = require('./middleware')
 const { hookRunner, hookIterator } = require('./hooks')
 const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS']
-const supportedHooks = ['preParsing', 'preValidation', 'onRequest', 'preHandler', 'preSerialization', 'onResponse']
+const supportedHooks = ['preParsing', 'preValidation', 'onRequest', 'preHandler', 'preSerialization', 'onResponse', 'onSend']
 const validation = require('./validation')
 const buildSchema = validation.build
 const { buildSchemaCompiler } = validation
@@ -22,8 +22,10 @@ const {
 const {
   kRoutePrefix,
   kLogLevel,
+  kLogSerializers,
   kHooks,
   kSchemas,
+  kOptions,
   kSchemaCompiler,
   kSchemaResolver,
   kContentTypeParser,
@@ -180,6 +182,10 @@ function buildRouting (options) {
       opts.prefix = prefix
       opts.logLevel = opts.logLevel || this[kLogLevel]
 
+      if (this[kLogSerializers] || opts.logSerializers) {
+        opts.logSerializers = Object.assign(Object.create(this[kLogSerializers]), opts.logSerializers)
+      }
+
       if (opts.attachValidation == null) {
         opts.attachValidation = false
       }
@@ -207,33 +213,11 @@ function buildRouting (options) {
         this._errorHandler,
         opts.bodyLimit,
         opts.logLevel,
+        opts.logSerializers,
         opts.attachValidation,
         this[kReplySerializerDefault]
       )
 
-      // TODO this needs to be refactored so that buildSchemaCompiler is
-      // not called for every single route. Creating a new one for every route
-      // is going to be very expensive.
-      if (opts.schema) {
-        if (this[kSchemaCompiler] == null && this[kSchemaResolver]) {
-          done(new FST_ERR_SCH_MISSING_COMPILER(opts.method, url))
-          return
-        }
-
-        try {
-          if (opts.schemaCompiler == null && this[kSchemaCompiler] == null) {
-            const externalSchemas = this[kSchemas].getJsonSchemas({ onlyAbsoluteUri: true })
-            this.setSchemaCompiler(buildSchemaCompiler(externalSchemas, schemaCache))
-          }
-
-          buildSchema(context, opts.schemaCompiler || this[kSchemaCompiler], this[kSchemas], this[kSchemaResolver])
-        } catch (error) {
-          // bubble up the FastifyError instance
-          done(error.code ? error : new FST_ERR_SCH_BUILD(opts.method, url, error.message))
-          return
-        }
-      }
-
       for (const hook of supportedHooks) {
         if (opts[hook]) {
           if (Array.isArray(opts[hook])) {
@@ -245,7 +229,7 @@ function buildRouting (options) {
       }
 
       try {
-        router.on(opts.method, url, { version: opts.version }, routeHandler, context)
+        router.on(opts.method, opts.url, { version: opts.version }, routeHandler, context)
       } catch (err) {
         done(err)
         return
@@ -273,6 +257,24 @@ function buildRouting (options) {
         // Must store the 404 Context in 'preReady' because it is only guaranteed to
         // be available after all of the plugins and routes have been loaded.
         fourOhFour.setContext(this, context)
+
+        if (opts.schema) {
+          if (this[kSchemaCompiler] == null && this[kSchemaResolver]) {
+            throw new FST_ERR_SCH_MISSING_COMPILER(opts.method, url)
+          }
+
+          try {
+            if (opts.schemaCompiler == null && this[kSchemaCompiler] == null) {
+              const externalSchemas = this[kSchemas].getJsonSchemas({ onlyAbsoluteUri: true })
+              this.setSchemaCompiler(buildSchemaCompiler(externalSchemas, this[kOptions].ajv, schemaCache))
+            }
+
+            buildSchema(context, opts.schemaCompiler || this[kSchemaCompiler], this[kSchemas], this[kSchemaResolver])
+          } catch (error) {
+            // bubble up the FastifyError instance
+            throw (error.code ? error : new FST_ERR_SCH_BUILD(opts.method, url, error.message))
+          }
+        }
       })
 
       done(notHandledErr)
@@ -300,7 +302,7 @@ function buildRouting (options) {
 
     req.id = req.headers[requestIdHeader] || genReqId(req)
     req.originalUrl = req.url
-    var hostname = req.headers.host
+    var hostname = req.headers.host || req.headers[':authority']
     var ip = req.connection.remoteAddress
     var ips
 
@@ -312,7 +314,15 @@ function buildRouting (options) {
       }
     }
 
-    var childLogger = logger.child({ [requestIdLogLabel]: req.id, level: context.logLevel })
+    var loggerOpts = {
+      [requestIdLogLabel]: req.id,
+      level: context.logLevel
+    }
+
+    if (context.logSerializers) {
+      loggerOpts.serializers = context.logSerializers
+    }
+    var childLogger = logger.child(loggerOpts)
     childLogger[kDisableRequestLogging] = disableRequestLogging
 
     // added hostname, ip, and ips back to the Node req object to maintain backward compatibility

package/lib/schemas.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const fastClone = require('rfdc')({ circles: false, proto: true })
+const { kSchemaVisited } = require('./symbols')
 const kFluentSchema = Symbol.for('fluent-schema-object')
 
 const {
@@ -43,6 +44,10 @@ Schemas.prototype.resolve = function (id) {
 }
 
 Schemas.prototype.resolveRefs = function (routeSchemas, dontClearId, refResolver) {
+  if (routeSchemas[kSchemaVisited]) {
+    return routeSchemas
+  }
+
   // alias query to querystring schema
   if (routeSchemas.query) {
     // check if our schema has both querystring and query
@@ -96,6 +101,7 @@ Schemas.prototype.resolveRefs = function (routeSchemas, dontClearId, refResolver
     routeSchemas.params = this.getSchemaAnyway(routeSchemas.params)
   }
 
+  routeSchemas[kSchemaVisited] = true
   return routeSchemas
 }
 
@@ -117,7 +123,9 @@ Schemas.prototype.traverse = function (schema, refResolver) {
       }
     }
 
-    if (schema[key] !== null && typeof schema[key] === 'object') {
+    if (schema[key] !== null && typeof schema[key] === 'object' &&
+    (key !== 'enum' || (key === 'enum' && schema.type !== 'string'))) {
+      // don't traverse non-object values and the `enum` keyword when used for string type
       this.traverse(schema[key], refResolver)
     }
   }
@@ -135,7 +143,7 @@ Schemas.prototype.cleanId = function (schema) {
 }
 
 Schemas.prototype.getSchemaAnyway = function (schema) {
-  if (schema.oneOf || schema.allOf || schema.anyOf) return schema
+  if (schema.oneOf || schema.allOf || schema.anyOf || schema.$merge || schema.$patch) return schema
   if (!schema.type || !schema.properties) {
     return {
       type: 'object',

package/lib/server.js

@@ -24,6 +24,7 @@ function createServer (options, httpHandler) {
     }
   } else if (options.http2) {
     server = http2().createServer(httpHandler)
+    server.on('session', sessionTimeout(options.http2SessionTimeout))
   } else {
     server = http.createServer(httpHandler)
   }
@@ -148,4 +149,14 @@ function http2 () {
   }
 }
 
+function sessionTimeout (timeout) {
+  return function (session) {
+    session.setTimeout(timeout, close)
+  }
+}
+
+function close () {
+  this.close()
+}
+
 module.exports = { createServer }

package/lib/symbols.js

@@ -5,6 +5,7 @@ const keys = {
   kBodyLimit: Symbol('fastify.bodyLimit'),
   kRoutePrefix: Symbol('fastify.routePrefix'),
   kLogLevel: Symbol('fastify.logLevel'),
+  kLogSerializers: Symbol('fastify.logSerializers'),
   kHooks: Symbol('fastify.hooks'),
   kSchemas: Symbol('fastify.schemas'),
   kSchemaCompiler: Symbol('fastify.schemaCompiler'),
@@ -32,7 +33,8 @@ const keys = {
   kOptions: Symbol('fastify.options'),
   kGlobalHooks: Symbol('fastify.globalHooks'),
   kDisableRequestLogging: Symbol('fastify.disableRequestLogging'),
-  kPluginNameChain: Symbol('fastify.pluginNameChain')
+  kPluginNameChain: Symbol('fastify.pluginNameChain'),
+  kSchemaVisited: Symbol('fastify.schemaVisited')
 }
 
 module.exports = keys

package/lib/validation.js

@@ -119,6 +119,7 @@ function wrapValidationError (result, dataVar) {
   }
   var error = new Error(schemaErrorsText(result, dataVar))
   error.validation = result
+  error.validationContext = dataVar
   return error
 }
 
@@ -163,17 +164,22 @@ function schemaErrorsText (errors, dataVar) {
   return text.slice(0, -separator.length)
 }
 
-function buildSchemaCompiler (externalSchemas, cache) {
+function buildSchemaCompiler (externalSchemas, options, cache) {
   // This instance of Ajv is private
   // it should not be customized or used
-  const ajv = new Ajv({
+  const ajv = new Ajv(Object.assign({
     coerceTypes: true,
     useDefaults: true,
     removeAdditional: true,
     allErrors: true,
-    nullable: true,
-    cache
-  })
+    nullable: true
+  }, options.customOptions, { cache }))
+
+  if (options.plugins && options.plugins.length > 0) {
+    for (const plugin of options.plugins) {
+      plugin[0](ajv, plugin[1])
+    }
+  }
 
   if (Array.isArray(externalSchemas)) {
     externalSchemas.forEach(s => ajv.addSchema(s))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "2.10.0",
+  "version": "2.13.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "typings": "fastify.d.ts",
@@ -92,26 +92,28 @@
     "node": ">=6"
   },
   "devDependencies": {
-    "@types/node": "^11.13.19",
-    "@typescript-eslint/eslint-plugin": "^2.3.0",
-    "@typescript-eslint/parser": "^2.3.0",
+    "@types/node": "^12.12.30",
+    "@typescript-eslint/eslint-plugin": "^2.24.0",
+    "@typescript-eslint/parser": "^2.24.0",
     "JSONStream": "^1.3.5",
+    "ajv-merge-patch": "^4.1.0",
     "ajv-pack": "^0.3.1",
-    "autocannon": "^3.2.0",
+    "autocannon": "^3.2.2",
     "branch-comparer": "^0.4.0",
-    "concurrently": "^5.0.0",
+    "concurrently": "^5.1.0",
     "cors": "^2.8.5",
-    "coveralls": "^3.0.6",
+    "coveralls": "^3.0.11",
     "dns-prefetch-control": "^0.2.0",
-    "eslint": "^6.4.0",
-    "eslint-import-resolver-node": "^0.3.2",
+    "eslint": "^6.7.2",
+    "eslint-import-resolver-node": "^0.3.3",
+    "events.once": "^2.0.2",
     "fast-json-body": "^1.1.0",
-    "fastify-plugin": "^1.5.0",
-    "fluent-schema": "^0.7.4",
-    "form-data": "^2.5.0",
+    "fastify-plugin": "^1.6.1",
+    "fluent-schema": "^0.10.0",
+    "form-data": "^3.0.0",
     "frameguard": "^3.0.0",
-    "h2url": "^0.1.2",
-    "helmet": "^3.20.0",
+    "h2url": "^0.2.0",
+    "helmet": "^3.21.3",
     "hide-powered-by": "^1.0.0",
     "hsts": "^2.1.0",
     "http-errors": "^1.7.1",
@@ -128,28 +130,29 @@
     "simple-get": "^3.0.3",
     "snazzy": "^8.0.0",
     "split2": "^3.1.0",
-    "standard": "^14.0.0",
+    "standard": "^14.3.3",
     "tap": "^12.5.2",
     "tap-mocha-reporter": "^3.0.7",
     "then-sleep": "^1.0.1",
-    "typescript": "^3.6.3",
-    "x-xss-protection": "^1.1.0"
+    "typescript": "^3.8.3",
+    "x-xss-protection": "^1.1.0",
+    "yup": "^0.28.3"
   },
   "dependencies": {
-    "abstract-logging": "^1.0.0",
-    "ajv": "^6.10.2",
-    "avvio": "^6.2.2",
-    "fast-json-stringify": "^1.15.5",
-    "find-my-way": "^2.0.0",
+    "abstract-logging": "^2.0.0",
+    "ajv": "^6.12.0",
+    "avvio": "^6.3.1",
+    "fast-json-stringify": "^1.18.0",
+    "find-my-way": "^2.2.2",
     "flatstr": "^1.0.12",
-    "light-my-request": "^3.4.1",
-    "middie": "^4.0.1",
-    "pino": "^5.13.2",
-    "proxy-addr": "^2.0.4",
-    "readable-stream": "^3.1.1",
+    "light-my-request": "^3.7.2",
+    "middie": "^4.1.0",
+    "pino": "^5.17.0",
+    "proxy-addr": "^2.0.6",
+    "readable-stream": "^3.6.0",
     "rfdc": "^1.1.2",
-    "secure-json-parse": "^1.0.0",
-    "tiny-lru": "^7.0.0"
+    "secure-json-parse": "^2.1.0",
+    "tiny-lru": "^7.0.2"
   },
   "greenkeeper": {
     "ignore": [
@@ -157,6 +160,7 @@
       "boom",
       "joi",
       "@types/node",
+      "semver",
       "tap",
       "tap-mocha-reporter",
       "@typescript-eslint/eslint-plugin",

package/test/404s.test.js

@@ -1733,3 +1733,43 @@ test('Should fail to invoke callNotFound inside a 404 handler', t => {
     t.is(res.payload, '404 Not Found')
   })
 })
+
+test('400 in case of bad url (pre find-my-way v2.2.0 was a 404)', t => {
+  t.test('Dyamic route', t => {
+    t.plan(3)
+    const fastify = Fastify()
+    fastify.get('/hello/:id', () => t.fail('we should not be here'))
+    fastify.inject({
+      url: '/hello/%world',
+      method: 'GET'
+    }, (err, response) => {
+      t.error(err)
+      t.strictEqual(response.statusCode, 400)
+      t.deepEqual(JSON.parse(response.payload), {
+        error: 'Bad Request',
+        message: "'%world' is not a valid url component",
+        statusCode: 400
+      })
+    })
+  })
+
+  t.test('Wildcard', t => {
+    t.plan(3)
+    const fastify = Fastify()
+    fastify.get('*', () => t.fail('we should not be here'))
+    fastify.inject({
+      url: '/hello/%world',
+      method: 'GET'
+    }, (err, response) => {
+      t.error(err)
+      t.strictEqual(response.statusCode, 400)
+      t.deepEqual(JSON.parse(response.payload), {
+        error: 'Bad Request',
+        message: "'/hello/%world' is not a valid url component",
+        statusCode: 400
+      })
+    })
+  })
+
+  t.end()
+})

package/test/decorator.test.js

@@ -660,3 +660,83 @@ test('a decorator should addSchema to all the encapsulated tree', t => {
 
   fastify.ready(t.error)
 })
+
+test('after can access to a decorated instance and previous plugin decoration', t => {
+  t.plan(11)
+  const TEST_VALUE = {}
+  const OTHER_TEST_VALUE = {}
+  const NEW_TEST_VALUE = {}
+
+  const fastify = Fastify()
+
+  fastify.register(fp(function (instance, options, next) {
+    instance.decorate('test', TEST_VALUE)
+
+    next()
+  })).after(function (err, instance, done) {
+    t.error(err)
+    t.equal(instance.test, TEST_VALUE)
+
+    instance.decorate('test2', OTHER_TEST_VALUE)
+    done()
+  })
+
+  fastify.register(fp(function (instance, options, next) {
+    t.equal(instance.test, TEST_VALUE)
+    t.equal(instance.test2, OTHER_TEST_VALUE)
+
+    instance.decorate('test3', NEW_TEST_VALUE)
+
+    next()
+  })).after(function (err, instance, done) {
+    t.error(err)
+    t.equal(instance.test, TEST_VALUE)
+    t.equal(instance.test2, OTHER_TEST_VALUE)
+    t.equal(instance.test3, NEW_TEST_VALUE)
+
+    done()
+  })
+
+  fastify.get('/', function (req, res) {
+    t.equal(this.test, TEST_VALUE)
+    t.equal(this.test2, OTHER_TEST_VALUE)
+    res.send({})
+  })
+
+  fastify.inject('/')
+    .then(response => {
+      t.equal(response.statusCode, 200)
+    })
+})
+
+test('decorate* should throw if called after ready', t => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.get('/', (request, reply) => {
+    reply.send({
+      hello: 'world'
+    })
+  })
+
+  fastify.listen(0)
+    .then(() => {
+      try {
+        fastify.decorate('test', true)
+      } catch (e) {
+        t.is(e.message, "FST_ERR_DEC_AFTER_START: The decorator 'test' has been added after start!")
+      }
+      try {
+        fastify.decorateRequest('test', true)
+      } catch (e) {
+        t.is(e.message, "FST_ERR_DEC_AFTER_START: The decorator 'test' has been added after start!")
+      }
+      try {
+        fastify.decorateReply('test', true)
+      } catch (e) {
+        t.is(e.message, "FST_ERR_DEC_AFTER_START: The decorator 'test' has been added after start!")
+      }
+      return fastify.close()
+    })
+    .catch(err => t.fail(err))
+})

package/test/esm/esm.mjs

@@ -0,0 +1,13 @@
+import t from 'tap'
+import Fastify from '../../fastify.js'
+
+t.test('esm support', async t => {
+  const fastify = Fastify()
+
+  fastify.register(import('./plugin.mjs'), { foo: 'bar' })
+  fastify.register(import('./other.mjs'))
+
+  await fastify.ready()
+
+  t.strictEqual(fastify.foo, 'bar')
+})

package/test/esm/index.test.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const t = require('tap')
+const semver = require('semver')
+
+if (semver.lt(process.versions.node, '13.3.0')) {
+  t.skip('Skip because Node version <= 13.3.0')
+  t.end()
+} else {
+  // Node v8 throw a `SyntaxError: Unexpected token import`
+  // even if this branch is never touch in the code,
+  // by using `eval` we can avoid this issue.
+  // eslint-disable-next-line
+  new Function('module', 'return import(module)')('./esm.mjs').catch((err) => {
+    process.nextTick(() => {
+      throw err
+    })
+  })
+}

package/test/esm/other.mjs

@@ -0,0 +1,7 @@
+import t from 'tap'
+
+async function other (fastify, opts) {
+  t.strictEqual(fastify.foo, 'bar')
+}
+
+export default other

package/test/esm/plugin.mjs

@@ -0,0 +1,7 @@
+async function plugin (fastify, opts) {
+  fastify.decorate('foo', opts.foo)
+}
+
+plugin[Symbol.for('skip-override')] = true
+
+export default plugin