harperdb 3.1.3 → 3.1.4

package/node_modules/fastify-helmet/.dependabot/config.yml

@@ -0,0 +1,5 @@
+version: 1
+update_configs:
+  - package_manager: "javascript"
+    directory: "/"
+    update_schedule: "daily"

package/node_modules/fastify-helmet/.github/workflows/ci.yml

@@ -16,12 +16,3 @@ jobs:
       run: npm install --ignore-scripts
     - name: Test
       run: npm test
-
-  automerge:
-    needs: test
-    runs-on: ubuntu-latest
-    steps:
-      - uses: fastify/github-action-merge-dependabot@v1
-        if: ${{ github.actor == 'dependabot[bot]' && github.event_name == 'pull_request' }}
-        with:
-          github-token: ${{secrets.github_token}}

package/node_modules/fastify-helmet/README.md

@@ -21,8 +21,8 @@ const helmet = require('fastify-helmet')
 
 fastify.register(
   helmet,
-  // Example disables the `contentSecurityPolicy` middleware but keeps the rest.
-  { contentSecurityPolicy: false }
+  // Example of passing an option to x-powered-by middleware
+  { hidePoweredBy: { setTo: 'PHP 4.2.0' } }
 )
 
 fastify.listen(3000, err => {

package/node_modules/fastify-helmet/benchmarks/express.js

@@ -1,9 +1,9 @@
 'use strict'
 
-const express = require('express')
-const helmet = require('helmet')
+var express = require('express')
+var helmet = require('helmet')
 
-const app = express()
+var app = express()
 
 app.use(helmet())
 app.use(require('express-pino-logger')())

package/node_modules/fastify-helmet/benchmarks/koa.js

@@ -1,7 +1,7 @@
 'use strict'
 
-const Koa = require('koa')
-const app = new Koa()
+var Koa = require('koa')
+var app = new Koa()
 
 app.use(require('koa-pino-logger')())
 app.use(require('koa-helmet')())

package/node_modules/fastify-helmet/index.js

@@ -15,5 +15,3 @@ module.exports = fp(function (app, options, next) {
   fastify: '3.x',
   name: 'fastify-helmet'
 })
-
-module.exports.contentSecurityPolicy = helmet.contentSecurityPolicy

package/node_modules/fastify-helmet/node_modules/fastify-plugin/.github/workflows/ci.yml

@@ -0,0 +1,18 @@
+name: CI workflow
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [10.x, 12.x, 13.x]
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - name: Install Dependencies
+      run: npm install --ignore-scripts
+    - name: Test
+      run: npm test

package/node_modules/fastify-helmet/node_modules/fastify-plugin/.taprc

@@ -0,0 +1,5 @@
+esm: false
+ts: false
+jsx: false
+flow: false
+coverage: true

package/node_modules/fastify-helmet/node_modules/fastify-plugin/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Fastify
+
+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/node_modules/fastify-helmet/node_modules/fastify-plugin/README.md

@@ -0,0 +1,144 @@
+# fastify-plugin
+
+![CI workflow](https://github.com/fastify/fastify-plugin/workflows/CI%20workflow/badge.svg?branch=master)
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](http://standardjs.com/)
+
+`fastify-plugin` is a plugin helper for [Fastify](https://github.com/fastify/fastify).
+
+When you build plugins for Fastify and you want that them to be accessible in the same context where you require them, you have two ways:
+1. Use the `skip-override` hidden property
+2. Use this module
+
+__Note: the v2.x series of this module covers Fastify v3. For Fastify v2
+support refert to the v1.x series.__
+
+## Usage
+`fastify-plugin` can do three things for you:
+- Add the `skip-override` hidden property
+- Check the bare-minimum version of Fastify
+- Pass some custom metadata of the plugin to Fastify
+
+Example:
+```js
+const fp = require('fastify-plugin')
+
+module.exports = fp(function (fastify, opts, next) {
+  // your plugin code
+  next()
+})
+```
+
+## Metadata
+In addition if you use this module when creating new plugins, you can declare the dependencies, the name and the expected Fastify version that your plugin needs.
+
+#### Fastify version
+If you need to set a bare-minimum version of Fastify for your plugin, just add the [semver](http://semver.org/) range that you need:
+```js
+const fp = require('fastify-plugin')
+
+module.exports = fp(function (fastify, opts, next) {
+  // your plugin code
+  next()
+}, { fastify: '3.x' })
+```
+
+If you need to check the Fastify version only, you can pass just the version string.
+
+You can check [here](https://github.com/npm/node-semver#ranges) how to define a `semver` range.
+
+#### Name
+Fastify uses this option to validate dependency graph. On one hand it makes sure that no name collision occurs. On the other hand it makes possible to perform [dependency check](https://github.com/fastify/fastify-plugin#dependencies).
+```js
+const fp = require('fastify-plugin')
+
+function plugin (fastify, opts, next) {
+  // your plugin code
+  next()
+}
+
+module.exports = fp(plugin, {
+  fastify: '3.x',
+  name: 'your-plugin-name'
+})
+```
+
+#### Dependencies
+You can also check if the `plugins` and `decorators` which your plugin intend to use are present in the dependency graph.
+> *Note:* This is the point where registering `name` of the plugins become important, because you can reference `plugin` dependencies by their [name](https://github.com/fastify/fastify-plugin#name).
+```js
+const fp = require('fastify-plugin')
+
+function plugin (fastify, opts, next) {
+  // your plugin code
+  next()
+}
+
+module.exports = fp(plugin, {
+  fastify: '3.x',
+  decorators: {
+    fastify: ['plugin1', 'plugin2'],
+    reply: ['compress']
+  },
+  dependencies: ['plugin1-name', 'plugin2-name']
+})
+```
+
+#### Bundlers and Typescript
+`fastify-plugin` adds a `.default` and `[name]` property to the passed in function.
+The type definition would have to be updated to leverage this.
+
+## Known Issue: TypeScript Contextual Inference
+
+[Documentation Reference](https://www.typescriptlang.org/docs/handbook/functions.html#inferring-the-types)
+
+It is common for developers to inline their plugin with fastify-plugin such as:
+
+```js
+fp((fastify, opts, next) => { next() })
+fp(async (fastify, opts) => { return })
+```
+
+TypeScript can sometimes infer the types of the arguments for these functions. Plugins in fastify are recommended to be typed using either `FastifyPluginCallback` or `FastifyPluginAsync`. These two definitions only differ in two ways:
+
+1. The third argument `next` (the callback part)
+2. The return type `FastifyPluginCallback` or `FastifyPluginAsync`
+
+At this time, TypeScript inference is not smart enough to differentiate by definition argument length alone.
+
+Thus, if you are a TypeScript developer please use on the following patterns instead:
+
+```ts
+// Callback
+
+// Assign type directly
+const pluginCallback: FastifyPluginCallback = (fastify, options, next) => { }
+fp(pluginCallback)
+
+// or define your own function declaration that satisfies the existing definitions
+const pluginCallbackWithTypes = (fastify: FastifyInstance, options: FastifyPluginOptions, next: (error?: FastifyError) => void): void => { }
+fp(pluginCallbackWithTypes)
+// or inline
+fp((fastify: FastifyInstance, options: FastifyPluginOptions, next: (error?: FastifyError) => void): void => { })
+
+// Async
+
+// Assign type directly
+const pluginAsync: FastifyPluginAsync = async (fastify, options) => { }
+fp(pluginAsync)
+
+// or define your own function declaration that satisfies the existing definitions
+const pluginAsyncWithTypes = async (fastify: FastifyInstance, options: FastifyPluginOptions): Promise<void> => { }
+fp(pluginAsyncWithTypes)
+// or inline
+fp(async (fastify: FastifyInstance, options: FastifyPluginOptions): Promise<void> => { })
+```
+
+## Acknowledgements
+
+This project is kindly sponsored by:
+- [nearForm](http://nearform.com)
+- [LetzDoIt](http://www.letzdoitapp.com/)
+
+## License
+
+Licensed under [MIT](./LICENSE).

package/node_modules/fastify-helmet/node_modules/fastify-plugin/package.json

@@ -0,0 +1,69 @@
+{
+  "_args": [
+    [
+      "fastify-plugin@2.3.4",
+      "/home/ubuntu/buildAgent/work/20f715f46c2b009e"
+    ]
+  ],
+  "_from": "fastify-plugin@2.3.4",
+  "_id": "fastify-plugin@2.3.4",
+  "_inBundle": false,
+  "_integrity": "sha512-I+Oaj6p9oiRozbam30sh39BiuiqBda7yK2nmSPVwDCfIBlKnT8YB3MY+pRQc2Fcd07bf6KPGklHJaQ2Qu81TYQ==",
+  "_location": "/fastify-helmet/fastify-plugin",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "fastify-plugin@2.3.4",
+    "name": "fastify-plugin",
+    "escapedName": "fastify-plugin",
+    "rawSpec": "2.3.4",
+    "saveSpec": null,
+    "fetchSpec": "2.3.4"
+  },
+  "_requiredBy": [
+    "/fastify-helmet"
+  ],
+  "_resolved": "https://registry.npmjs.org/fastify-plugin/-/fastify-plugin-2.3.4.tgz",
+  "_spec": "2.3.4",
+  "_where": "/home/ubuntu/buildAgent/work/20f715f46c2b009e",
+  "author": {
+    "name": "Tomas Della Vedova - @delvedor",
+    "url": "http://delved.org"
+  },
+  "bugs": {
+    "url": "https://github.com/fastify/fastify-plugin/issues"
+  },
+  "dependencies": {
+    "semver": "^7.3.2"
+  },
+  "description": "Plugin helper for Fastify",
+  "devDependencies": {
+    "@types/node": "^13.13.2",
+    "fastify": "^3.3.0",
+    "proxyquire": "^2.1.3",
+    "standard": "^14.0.0",
+    "tap": "^14.10.7",
+    "tsd": "^0.11.0",
+    "typescript": "^3.8.2"
+  },
+  "homepage": "https://github.com/fastify/fastify-plugin#readme",
+  "keywords": [
+    "plugin",
+    "helper",
+    "fastify"
+  ],
+  "license": "MIT",
+  "main": "plugin.js",
+  "name": "fastify-plugin",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fastify/fastify-plugin.git"
+  },
+  "scripts": {
+    "test": "standard && tap test/*.js test/esm/*.js && npm run typescript",
+    "typescript": "tsd"
+  },
+  "types": "plugin.d.ts",
+  "version": "2.3.4"
+}

package/node_modules/fastify-helmet/node_modules/fastify-plugin/plugin.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="fastify" />
+
+import {
+  FastifyPluginCallback,
+  FastifyPluginAsync,
+} from 'fastify'
+
+/**
+ * This function does three things for you:
+ *   1. Add the `skip-override` hidden property
+ *   2. Check bare-minimum version of Fastify
+ *   3. Pass some custom metadata of the plugin to Fastify
+ * @param fn Fastify plugin function
+ * @param options Optional plugin options
+ */
+export default function fp<Options>(fn: FastifyPluginAsync<Options>, options?: PluginMetadata): FastifyPluginAsync<Options>;
+export default function fp<Options>(fn: FastifyPluginAsync<Options>, options?: string): FastifyPluginAsync<Options>;
+export default function fp<Options>(fn: FastifyPluginCallback<Options>, options?: PluginMetadata): FastifyPluginCallback<Options>;
+export default function fp<Options>(fn: FastifyPluginCallback<Options>, options?: string): FastifyPluginCallback<Options>;
+
+export interface PluginMetadata {
+  /** Bare-minimum version of Fastify for your plugin, just add the semver range that you need. */
+  fastify?: string,
+  name?: string,
+  /** Decorator dependencies for this plugin */
+  decorators?: {
+    fastify?: string[],
+    reply?: string[],
+    request?: string[]
+  },
+  /** The plugin dependencies */
+  dependencies?: string[]
+}
+
+// Exporting PluginOptions for backward compatibility after renaming it to PluginMetadata
+export interface PluginOptions extends PluginMetadata {}

package/node_modules/fastify-helmet/node_modules/fastify-plugin/plugin.js

@@ -0,0 +1,126 @@
+'use strict'
+
+const semver = require('semver')
+const console = require('console')
+const extractPluginName = require('./stackParser')
+const { join, dirname } = require('path')
+
+let count = 0
+
+function plugin (fn, options = {}) {
+  let autoName = false
+
+  if (typeof fn.default !== 'undefined') { // Support for 'export default' behaviour in transpiled ECMAScript module
+    fn = fn.default
+  }
+
+  if (typeof fn !== 'function') {
+    throw new TypeError(`fastify-plugin expects a function, instead got a '${typeof fn}'`)
+  }
+
+  fn[Symbol.for('skip-override')] = true
+
+  const pluginName = (options && options.name) || checkName(fn)
+
+  if (typeof options === 'string') {
+    checkVersion(options, pluginName)
+    options = {}
+  }
+
+  if (typeof options !== 'object' || Array.isArray(options) || options === null) {
+    throw new TypeError('The options object should be an object')
+  }
+
+  if (!options.name) {
+    autoName = true
+    options.name = pluginName + '-auto-' + count++
+  }
+
+  fn[Symbol.for('fastify.display-name')] = options.name
+
+  if (options.fastify) {
+    checkVersion(options.fastify, pluginName)
+  }
+
+  fn[Symbol.for('plugin-meta')] = options
+
+  // Faux modules support
+  if (!fn.default) {
+    fn.default = fn
+  }
+
+  // TypeScript support for named imports
+  // See https://github.com/fastify/fastify/issues/2404 for more details
+  // The type definitions would have to be update to match this.
+  const camelCase = toCamelCase(options.name)
+  if (!autoName && !fn[camelCase]) {
+    fn[camelCase] = fn
+  }
+
+  return fn
+}
+
+function checkName (fn) {
+  if (fn.name.length > 0) return fn.name
+
+  try {
+    throw new Error('anonymous function')
+  } catch (e) {
+    return extractPluginName(e.stack)
+  }
+}
+
+function toCamelCase (name) {
+  const newName = name.replace(/-(.)/g, function (match, g1) {
+    return g1.toUpperCase()
+  })
+  return newName
+}
+
+function resolvePkgPath (mainFilename) {
+  return join(dirname(require.resolve('fastify', { paths: [mainFilename] })), 'package.json')
+}
+
+function tryGetPath (p) {
+  var pkgPath
+  try {
+    pkgPath = resolvePkgPath(p)
+  } catch (_) {
+  }
+  return pkgPath
+}
+
+function checkVersion (version, pluginName) {
+  if (typeof version !== 'string') {
+    throw new TypeError(`fastify-plugin expects a version string, instead got '${typeof version}'`)
+  }
+
+  // TODO refactor this check and move it inside Fastify itself. https://github.com/fastify/fastify/issues/2507
+  var fastifyVersion
+  var pkgPath
+  if (require.main && require.main.filename) {
+    // We need to dynamically compute this to support yarn pnp
+    pkgPath = tryGetPath(require.main.filename)
+  }
+  if (!pkgPath && process.argv[1]) {
+    // We need this to support native ESM context
+    pkgPath = tryGetPath(process.argv[1])
+  }
+  if (!pkgPath) {
+    // In bundlers, there is no require.main.filename so we go ahead and require directly
+    pkgPath = 'fastify/package.json'
+  }
+
+  try {
+    fastifyVersion = semver.coerce(require(pkgPath).version)
+  } catch (_) {
+    console.info('fastify not found, proceeding anyway')
+  }
+
+  if (fastifyVersion && !semver.satisfies(fastifyVersion, version)) {
+    throw new Error(`fastify-plugin: ${pluginName} - expected '${version}' fastify version, '${fastifyVersion}' is installed`)
+  }
+}
+
+plugin.default = plugin
+module.exports = plugin

package/node_modules/fastify-helmet/node_modules/fastify-plugin/plugin.test-d.ts

@@ -0,0 +1,72 @@
+import fp from './plugin';
+import fastify, { FastifyPluginCallback, FastifyPluginAsync, FastifyError, FastifyInstance, FastifyPluginOptions } from 'fastify';
+import { expectAssignable, expectError } from 'tsd'
+
+interface Options {
+  foo: string
+}
+
+// Callback
+
+const pluginCallback: FastifyPluginCallback = (fastify, options, next) => { }
+expectAssignable<FastifyPluginCallback>(fp(pluginCallback))
+
+const pluginCallbackWithTypes = (fastify: FastifyInstance, options: FastifyPluginOptions, next: (error?: FastifyError) => void): void => { }
+expectAssignable<FastifyPluginCallback>(fp(pluginCallbackWithTypes))
+
+expectAssignable<FastifyPluginCallback>(fp((fastify: FastifyInstance, options: FastifyPluginOptions, next: (error?: FastifyError) => void): void => { }))
+
+expectAssignable<FastifyPluginCallback>(fp(pluginCallback, '' ))
+expectAssignable<FastifyPluginCallback>(fp(pluginCallback, {
+  fastify: '',
+  name: '',
+  decorators: {
+    fastify: [ '' ],
+    reply: [ '' ],
+    request: [ '' ]
+  },
+  dependencies: [ '' ]
+}))
+
+const pluginCallbackWithOptions: FastifyPluginCallback<Options> = (fastify, options, next) => {
+  expectAssignable<string>(options.foo)
+}
+
+expectAssignable<FastifyPluginCallback<Options>>(fp(pluginCallbackWithOptions))
+
+// Async
+
+const pluginAsync: FastifyPluginAsync = async (fastify, options) => { }
+expectAssignable<FastifyPluginAsync>(fp(pluginAsync))
+
+const pluginAsyncWithTypes = async (fastify: FastifyInstance, options: FastifyPluginOptions): Promise<void> => { }
+expectAssignable<FastifyPluginAsync>(fp(pluginAsyncWithTypes))
+
+expectAssignable<FastifyPluginAsync>(fp(async (fastify: FastifyInstance, options: FastifyPluginOptions): Promise<void> => { }))
+expectAssignable<FastifyPluginAsync>(fp(pluginAsync, '' ))
+expectAssignable<FastifyPluginAsync>(fp(pluginAsync, {
+  fastify: '',
+  name: '',
+  decorators: {
+    fastify: [ '' ],
+    reply: [ '' ],
+    request: [ '' ]
+  },
+  dependencies: [ '' ]
+}))
+
+const pluginAsyncWithOptions: FastifyPluginAsync<Options> = async (fastify, options) => {
+  expectAssignable<string>(options.foo)
+}
+
+expectAssignable<FastifyPluginAsync<Options>>(fp(pluginAsyncWithOptions))
+
+// Fastify register
+
+const server = fastify()
+server.register(fp(pluginCallback))
+server.register(fp(pluginCallbackWithTypes))
+server.register(fp(pluginCallbackWithOptions))
+server.register(fp(pluginAsync))
+server.register(fp(pluginAsyncWithTypes))
+server.register(fp(pluginAsyncWithOptions))

package/node_modules/fastify-helmet/node_modules/fastify-plugin/stackParser.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const fpStackTracePattern = /at\s{1}(?:.*\.)?plugin\s{1}.*\n\s*(.*)/
+const fileNamePattern = /(\w*(\.\w*)*)\..*/
+
+module.exports = function extractPluginName (stack) {
+  const m = stack.match(fpStackTracePattern)
+
+  // get last section of path and match for filename
+  return m ? m[1].split(/[/\\]/).slice(-1)[0].match(fileNamePattern)[1] : 'anonymous'
+}

package/node_modules/fastify-helmet/node_modules/fastify-plugin/test/bundlers.test.js

@@ -0,0 +1,85 @@
+'use strict'
+
+const { test } = require('tap')
+const fp = require('../plugin')
+
+test('webpack removes require.main.filename', (t) => {
+  const filename = require.main.filename
+  const info = console.info
+  t.tearDown(() => {
+    require.main.filename = filename
+    console.info = info
+  })
+
+  require.main.filename = null
+
+  console.info = function (msg) {
+    t.fail('logged: ' + msg)
+  }
+
+  fp((fastify, opts, next) => {
+    next()
+  }, {
+    fastify: '^3.0.0'
+  })
+
+  t.end()
+})
+
+test('support faux modules', (t) => {
+  const plugin = fp((fastify, opts, next) => {
+    next()
+  })
+
+  t.is(plugin.default, plugin)
+  t.end()
+})
+
+test('support ts named imports', (t) => {
+  const plugin = fp((fastify, opts, next) => {
+    next()
+  }, {
+    name: 'hello'
+  })
+
+  t.is(plugin.hello, plugin)
+  t.end()
+})
+
+test('from kebabo-case to camelCase', (t) => {
+  const plugin = fp((fastify, opts, next) => {
+    next()
+  }, {
+    name: 'hello-world'
+  })
+
+  t.is(plugin.helloWorld, plugin)
+  t.end()
+})
+
+test('from kebab-case to camelCase multiple words', (t) => {
+  const plugin = fp((fastify, opts, next) => {
+    next()
+  }, {
+    name: 'hello-long-world'
+  })
+
+  t.is(plugin.helloLongWorld, plugin)
+  t.end()
+})
+
+test('from kebab-case to camelCase multiple words does not override', (t) => {
+  const fn = (fastify, opts, next) => {
+    next()
+  }
+
+  const foobar = {}
+  fn.helloLongWorld = foobar
+
+  const plugin = fp(fn, {
+    name: 'hello-long-world'
+  })
+
+  t.is(plugin.helloLongWorld, foobar)
+  t.end()
+})