@zuplo/cli 6.72.2 → 6.72.7

package/node_modules/@fastify/reply-from/node_modules/fastify-plugin/test/bundlers.test.js

@@ -0,0 +1,110 @@
+'use strict'
+
+const { test } = require('node:test')
+const fp = require('..')
+
+test('webpack removes require.main.filename', t => {
+  const filename = require.main.filename
+  const info = console.info
+  t.after(() => {
+    require.main.filename = filename
+    console.info = info
+  })
+
+  require.main.filename = null
+
+  console.info = function (msg) {
+    t.assert.fail('logged: ' + msg)
+  }
+
+  fp((_fastify, _opts, next) => {
+    next()
+  }, {
+    fastify: '^5.0.0'
+  })
+})
+
+test('support faux modules', (t) => {
+  const plugin = fp((_fastify, _opts, next) => {
+    next()
+  })
+
+  t.assert.strictEqual(plugin.default, plugin)
+})
+
+test('support faux modules does not override existing default field in babel module', (t) => {
+  const module = {
+    default: (_fastify, _opts, next) => next()
+  }
+
+  module.default.default = 'Existing default field'
+
+  const plugin = fp(module)
+
+  t.assert.strictEqual(plugin.default, 'Existing default field')
+})
+
+test('support ts named imports', (t) => {
+  const plugin = fp((_fastify, _opts, next) => {
+    next()
+  }, {
+    name: 'hello'
+  })
+
+  t.assert.strictEqual(plugin.hello, plugin)
+})
+
+test('from kebab-case to camelCase', (t) => {
+  const plugin = fp((_fastify, _opts, next) => {
+    next()
+  }, {
+    name: 'hello-world'
+  })
+
+  t.assert.strictEqual(plugin.helloWorld, plugin)
+})
+
+test('from @-prefixed named imports', (t) => {
+  const plugin = fp((_fastify, _opts, next) => {
+    next()
+  }, {
+    name: '@hello/world'
+  })
+
+  t.assert.strictEqual(plugin.helloWorld, plugin)
+})
+
+test('from @-prefixed named kebab-case to camelCase', (t) => {
+  const plugin = fp((_fastify, _opts, next) => {
+    next()
+  }, {
+    name: '@hello/my-world'
+  })
+
+  t.assert.strictEqual(plugin.helloMyWorld, plugin)
+})
+
+test('from kebab-case to camelCase multiple words', (t) => {
+  const plugin = fp((_fastify, _opts, next) => {
+    next()
+  }, {
+    name: 'hello-long-world'
+  })
+
+  t.assert.strictEqual(plugin.helloLongWorld, plugin)
+})
+
+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.assert.strictEqual(plugin.helloLongWorld, foobar)
+})

package/node_modules/@fastify/reply-from/node_modules/fastify-plugin/test/checkVersion.test.js

@@ -0,0 +1,67 @@
+'use strict'
+
+const { test } = require('node:test')
+const fp = require('..')
+
+test('checkVersion having require.main.filename', (t) => {
+  const info = console.info
+  t.assert.ok(require.main.filename)
+  t.after(() => {
+    console.info = info
+  })
+
+  console.info = function (msg) {
+    t.assert.fail('logged: ' + msg)
+  }
+
+  fp((_fastify, _opts, next) => {
+    next()
+  }, {
+    fastify: '^5.0.0'
+  })
+})
+
+test('checkVersion having no require.main.filename but process.argv[1]', (t) => {
+  const filename = require.main.filename
+  const info = console.info
+  t.after(() => {
+    require.main.filename = filename
+    console.info = info
+  })
+
+  require.main.filename = null
+
+  console.info = function (msg) {
+    t.assert.fail('logged: ' + msg)
+  }
+
+  fp((_fastify, _opts, next) => {
+    next()
+  }, {
+    fastify: '^5.0.0'
+  })
+})
+
+test('checkVersion having no require.main.filename and no process.argv[1]', (t) => {
+  const filename = require.main.filename
+  const argv = process.argv
+  const info = console.info
+  t.after(() => {
+    require.main.filename = filename
+    process.argv = argv
+    console.info = info
+  })
+
+  require.main.filename = null
+  process.argv[1] = null
+
+  console.info = function (msg) {
+    t.assert.fail('logged: ' + msg)
+  }
+
+  fp((_fastify, _opts, next) => {
+    next()
+  }, {
+    fastify: '^5.0.0'
+  })
+})

package/node_modules/@fastify/reply-from/node_modules/fastify-plugin/test/composite.test.js

@@ -0,0 +1,14 @@
+'use strict'
+
+const { test } = require('node:test')
+const fp = require('..')
+
+test('anonymous function should be named composite.test0', (t) => {
+  t.plan(2)
+  const fn = fp((_fastify, _opts, next) => {
+    next()
+  })
+
+  t.assert.strictEqual(fn[Symbol.for('plugin-meta')].name, 'composite.test-auto-0')
+  t.assert.strictEqual(fn[Symbol.for('fastify.display-name')], 'composite.test-auto-0')
+})

package/node_modules/@fastify/reply-from/node_modules/fastify-plugin/test/esm/esm.mjs

@@ -0,0 +1,11 @@
+import { test } from 'node:test'
+import fp from '../../index.js'
+
+test('esm base support', (t) => {
+  fp((_fastify, _opts, next) => {
+    next()
+  }, {
+    fastify: '^5.0.0'
+  })
+  t.assert.ok(true, 'fp function called without throwing an error')
+})

package/node_modules/@fastify/reply-from/node_modules/fastify-plugin/test/esm/index.test.js

@@ -0,0 +1,11 @@
+'use strict'
+
+// 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/node_modules/@fastify/reply-from/node_modules/fastify-plugin/test/extractPluginName.test.js

@@ -0,0 +1,49 @@
+'use strict'
+
+const { test } = require('node:test')
+const extractPluginName = require('../lib/getPluginName').extractPluginName
+
+const winStack = `Error: anonymous function
+at checkName (C:\\Users\\leonardo.davinci\\Desktop\\fastify-plugin\\index.js:43:11)
+at plugin (C:\\Users\\leonardo.davinci\\Desktop\\fastify-plugin\\index.js:24:20)
+at Test.test (C:\\Users\\leonardo.davinci\\Desktop\\fastify-plugin\\test\\hello.test.js:9:14)
+at bound (domain.js:396:14)
+at Test.runBound (domain.js:409:12)
+at ret (C:\\Users\\leonardo.davinci\\Desktop\\fastify-plugin\\node_modules\\tap\\lib\\test.js:278:21)
+at Test.main (C:\\Users\\leonardo.davinci\\Desktop\\fastify-plugin\\node_modules\\tap\\lib\\test.js:282:7)
+at writeSubComment (C:\\Users\\leonardo.davinci\\Desktop\\fastify-plugin\\node_modules\\tap\\lib\\test.js:371:13)
+at TAP.writeSubComment (C:\\Users\\leonardo.davinci\\Desktop\\fastify-plugin\\node_modules\\tap\\lib\\test.js:403:5)
+at Test.runBeforeEach (C:\\Users\\leonardo.davinci\\Desktop\\fastify-plugin\\node_modules\\tap\\lib\\test.js:370:14)
+at loop (C:\\Users\\leonardo.davinci\\Desktop\\fastify-plugin\\node_modules\\function-loop\\index.js:35:15)
+at TAP.runBeforeEach (C:\\Users\\leonardo.davinci\\Desktop\\fastify-plugin\\node_modules\\tap\\lib\\test.js:683:7)
+at TAP.processSubtest (C:\\Users\\leonardo.davinci\\Desktop\\fastify-plugin\\node_modules\\tap\\lib\\test.js:369:12)
+at TAP.process (C:\\Users\\leonardo.davinci\\Desktop\\fastify-plugin\\node_modules\\tap\\lib\\test.js:306:14)
+at TAP.sub (C:\\Users\\leonardo.davinci\\Desktop\\fastify-plugin\\node_modules\\tap\\lib\\test.js:185:10)
+at TAP.test (C:\\Users\\leonardo.davinci\\Desktop\\fastify-plugin\\node_modules\\tap\\lib\\test.js:209:17)`
+
+const nixStack = `Error: anonymous function
+at checkName (/home/leonardo/desktop/fastify-plugin/index.js:43:11)
+at plugin (/home/leonardo/desktop/fastify-plugin/index.js:24:20)
+at Test.test (/home/leonardo/desktop/fastify-plugin/test/this.is.a.test.js:9:14)
+at bound (domain.js:396:14)
+at Test.runBound (domain.js:409:12)
+at ret (/home/leonardo/desktop/fastify-plugin/node_modules/tap/lib/test.js:278:21)
+at Test.main (/home/leonardo/desktop/fastify-plugin/node_modules/tap/lib/test.js:282:7)
+at writeSubComment (/home/leonardo/desktop/fastify-plugin/node_modules/tap/lib/test.js:371:13)
+at TAP.writeSubComment (/home/leonardo/desktop/fastify-plugin/node_modules/tap/lib/test.js:403:5)
+at Test.runBeforeEach (/home/leonardo/desktop/fastify-plugin/node_modules/tap/lib/test.js:370:14)
+at loop (/home/leonardo/desktop/fastify-plugin/node_modules/function-loop/index.js:35:15)
+at TAP.runBeforeEach (/home/leonardo/desktop/fastify-plugin/node_modules/tap/lib/test.js:683:7)
+at TAP.processSubtest (/home/leonardo/desktop/fastify-plugin/node_modules/tap/lib/test.js:369:12)
+at TAP.process (/home/leonardo/desktop/fastify-plugin/node_modules/tap/lib/test.js:306:14)
+at TAP.sub (/home/leonardo/desktop/fastify-plugin/node_modules/tap/lib/test.js:185:10)
+at TAP.test (/home/leonardo/desktop/fastify-plugin/node_modules/tap/lib/test.js:209:17)`
+
+const anonymousStack = 'Unable to parse this'
+
+test('extractPluginName tests', (t) => {
+  t.plan(3)
+  t.assert.strictEqual(extractPluginName(winStack), 'hello.test')
+  t.assert.strictEqual(extractPluginName(nixStack), 'this.is.a.test')
+  t.assert.strictEqual(extractPluginName(anonymousStack), 'anonymous')
+})

package/node_modules/@fastify/reply-from/node_modules/fastify-plugin/test/mu1tip1e.composite.test.js

@@ -0,0 +1,15 @@
+'use strict'
+
+const { test } = require('node:test')
+const fp = require('..')
+
+test('anonymous function should be named mu1tip1e.composite.test', (t) => {
+  t.plan(2)
+
+  const fn = fp((_fastify, _opts, next) => {
+    next()
+  })
+
+  t.assert.strictEqual(fn[Symbol.for('plugin-meta')].name, 'mu1tip1e.composite.test-auto-0')
+  t.assert.strictEqual(fn[Symbol.for('fastify.display-name')], 'mu1tip1e.composite.test-auto-0')
+})

package/node_modules/@fastify/reply-from/node_modules/fastify-plugin/test/test.js

@@ -0,0 +1,396 @@
+'use strict'
+
+const { test } = require('node:test')
+const proxyquire = require('proxyquire')
+const fp = require('..')
+const Fastify = require('fastify')
+
+const pkg = require('../package.json')
+
+test('fastify-plugin is a function', (t) => {
+  t.plan(1)
+  t.assert.ok(typeof fp === 'function')
+})
+
+test('should return the function with the skip-override Symbol', (t) => {
+  t.plan(1)
+
+  function plugin (_fastify, _opts, next) {
+    next()
+  }
+
+  fp(plugin)
+  t.assert.ok(plugin[Symbol.for('skip-override')])
+})
+
+test('should support "default" function from babel module', (t) => {
+  t.plan(1)
+
+  const plugin = {
+    default: () => { }
+  }
+
+  try {
+    fp(plugin)
+    t.assert.ok(true)
+  } catch (e) {
+    t.assert.strictEqual(e.message, 'fastify-plugin expects a function, instead got a \'object\'')
+  }
+})
+
+test('should throw if the plugin is not a function', (t) => {
+  t.plan(1)
+
+  try {
+    fp('plugin')
+    t.assert.fail()
+  } catch (e) {
+    t.assert.strictEqual(e.message, 'fastify-plugin expects a function, instead got a \'string\'')
+  }
+})
+
+test('should check the fastify version', (t) => {
+  t.plan(1)
+
+  function plugin (_fastify, _opts, next) {
+    next()
+  }
+
+  try {
+    fp(plugin, { fastify: '>=0.10.0' })
+    t.assert.ok(true)
+  } catch {
+    t.assert.fail()
+  }
+})
+
+test('should check the fastify version', (t) => {
+  t.plan(1)
+
+  function plugin (_fastify, _opts, next) {
+    next()
+  }
+
+  try {
+    fp(plugin, '>=0.10.0')
+    t.assert.ok(true)
+  } catch {
+    t.assert.fail()
+  }
+})
+
+test('the options object should be an object', (t) => {
+  t.plan(2)
+
+  try {
+    fp(() => { }, null)
+    t.assert.fail()
+  } catch (e) {
+    t.assert.strictEqual(e.message, 'The options object should be an object')
+  }
+
+  try {
+    fp(() => { }, [])
+    t.assert.fail()
+  } catch (e) {
+    t.assert.strictEqual(e.message, 'The options object should be an object')
+  }
+})
+
+test('should throw if the version number is not a string', (t) => {
+  t.plan(1)
+
+  try {
+    fp(() => { }, { fastify: 12 })
+    t.assert.fail()
+  } catch (e) {
+    t.assert.strictEqual(e.message, 'fastify-plugin expects a version string, instead got \'number\'')
+  }
+})
+
+test('Should accept an option object', (t) => {
+  t.plan(2)
+
+  const opts = { hello: 'world' }
+
+  function plugin (_fastify, _opts, next) {
+    next()
+  }
+
+  fp(plugin, opts)
+
+  t.assert.ok(plugin[Symbol.for('skip-override')], 'skip-override symbol should be present')
+  t.assert.deepStrictEqual(plugin[Symbol.for('plugin-meta')], opts, 'plugin-meta should match opts')
+})
+
+test('Should accept an option object and checks the version', (t) => {
+  t.plan(2)
+
+  const opts = { hello: 'world', fastify: '>=0.10.0' }
+
+  function plugin (_fastify, _opts, next) {
+    next()
+  }
+
+  fp(plugin, opts)
+  t.assert.ok(plugin[Symbol.for('skip-override')])
+  t.assert.deepStrictEqual(plugin[Symbol.for('plugin-meta')], opts)
+})
+
+test('should set anonymous function name to file it was called from with a counter', (t) => {
+  const fp = proxyquire('../index.js', { stubs: {} })
+
+  const fn = fp((_fastify, _opts, next) => {
+    next()
+  })
+
+  t.assert.strictEqual(fn[Symbol.for('plugin-meta')].name, 'test-auto-0')
+  t.assert.strictEqual(fn[Symbol.for('fastify.display-name')], 'test-auto-0')
+
+  const fn2 = fp((_fastify, _opts, next) => {
+    next()
+  })
+
+  t.assert.strictEqual(fn2[Symbol.for('plugin-meta')].name, 'test-auto-1')
+  t.assert.strictEqual(fn2[Symbol.for('fastify.display-name')], 'test-auto-1')
+})
+
+test('should set function name if Error.stackTraceLimit is set to 0', (t) => {
+  const stackTraceLimit = Error.stackTraceLimit = 0
+
+  const fp = proxyquire('../index.js', { stubs: {} })
+
+  const fn = fp((_fastify, _opts, next) => {
+    next()
+  })
+
+  t.assert.strictEqual(fn[Symbol.for('plugin-meta')].name, 'test-auto-0')
+  t.assert.strictEqual(fn[Symbol.for('fastify.display-name')], 'test-auto-0')
+
+  const fn2 = fp((_fastify, _opts, next) => {
+    next()
+  })
+
+  t.assert.strictEqual(fn2[Symbol.for('plugin-meta')].name, 'test-auto-1')
+  t.assert.strictEqual(fn2[Symbol.for('fastify.display-name')], 'test-auto-1')
+
+  Error.stackTraceLimit = stackTraceLimit
+})
+
+test('should set display-name to meta name', (t) => {
+  t.plan(2)
+
+  const functionName = 'superDuperSpecialFunction'
+
+  const fn = fp((_fastify, _opts, next) => next(), {
+    name: functionName
+  })
+
+  t.assert.strictEqual(fn[Symbol.for('plugin-meta')].name, functionName)
+  t.assert.strictEqual(fn[Symbol.for('fastify.display-name')], functionName)
+})
+
+test('should preserve fastify version in meta', (t) => {
+  t.plan(1)
+
+  const opts = { hello: 'world', fastify: '>=0.10.0' }
+
+  const fn = fp((_fastify, _opts, next) => next(), opts)
+
+  t.assert.strictEqual(fn[Symbol.for('plugin-meta')].fastify, '>=0.10.0')
+})
+
+test('should check fastify dependency graph - plugin', async (t) => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.register(fp((_fastify, _opts, next) => next(), {
+    fastify: '5.x',
+    name: 'plugin1-name'
+  }))
+
+  fastify.register(fp((_fastify, _opts, next) => next(), {
+    fastify: '5.x',
+    name: 'test',
+    dependencies: ['plugin1-name', 'plugin2-name']
+  }))
+
+  await t.assert.rejects(fastify.ready(), { message: "The dependency 'plugin2-name' of plugin 'test' is not registered" })
+})
+
+test('should check fastify dependency graph - decorate', async (t) => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.decorate('plugin1', fp((_fastify, _opts, next) => next(), {
+    fastify: '5.x',
+    name: 'plugin1-name'
+  }))
+
+  fastify.register(fp((_fastify, _opts, next) => next(), {
+    fastify: '5.x',
+    name: 'test',
+    decorators: { fastify: ['plugin1', 'plugin2'] }
+  }))
+
+  await t.assert.rejects(fastify.ready(), { message: "The decorator 'plugin2' required by 'test' is not present in Fastify" })
+})
+
+test('should check fastify dependency graph - decorateReply', async (t) => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.decorateReply('plugin1', fp((_fastify, _opts, next) => next(), {
+    fastify: '5.x',
+    name: 'plugin1-name'
+  }))
+
+  fastify.register(fp((_fastify, _opts, next) => next(), {
+    fastify: '5.x',
+    name: 'test',
+    decorators: { reply: ['plugin1', 'plugin2'] }
+  }))
+
+  await t.assert.rejects(fastify.ready(), { message: "The decorator 'plugin2' required by 'test' is not present in Reply" })
+})
+
+test('should accept an option to encapsulate', async (t) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  fastify.register(fp((fastify, _opts, next) => {
+    fastify.decorate('accessible', true)
+    next()
+  }, {
+    name: 'accessible-plugin'
+  }))
+
+  fastify.register(fp((fastify, _opts, next) => {
+    fastify.decorate('alsoAccessible', true)
+    next()
+  }, {
+    name: 'accessible-plugin2',
+    encapsulate: false
+  }))
+
+  fastify.register(fp((fastify, _opts, next) => {
+    fastify.decorate('encapsulated', true)
+    next()
+  }, {
+    name: 'encapsulated-plugin',
+    encapsulate: true
+  }))
+
+  await fastify.ready()
+
+  t.assert.ok(fastify.hasDecorator('accessible'))
+  t.assert.ok(fastify.hasDecorator('alsoAccessible'))
+  t.assert.ok(!fastify.hasDecorator('encapsulated'))
+})
+
+test('should check dependencies when encapsulated', async (t) => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.register(fp((_fastify, _opts, next) => next(), {
+    name: 'test',
+    dependencies: ['missing-dependency-name'],
+    encapsulate: true
+  }))
+
+  await t.assert.rejects(fastify.ready(), { message: "The dependency 'missing-dependency-name' of plugin 'test' is not registered" })
+})
+
+test(
+  'should check version when encapsulated',
+  { skip: /\d-.+/.test(pkg.devDependencies.fastify) },
+  async (t) => {
+    t.plan(1)
+    const fastify = Fastify()
+
+    fastify.register(fp((_fastify, _opts, next) => next(), {
+      name: 'test',
+      fastify: '<=2.10.0',
+      encapsulate: true
+    }))
+
+    await t.assert.rejects(fastify.ready(), { message: /fastify-plugin: test - expected '<=2.10.0' fastify version, '\d.\d+.\d+' is installed/ })
+  }
+)
+
+test('should check decorators when encapsulated', async (t) => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.decorate('plugin1', 'foo')
+
+  fastify.register(fp((_fastify, _opts, next) => next(), {
+    fastify: '5.x',
+    name: 'test',
+    encapsulate: true,
+    decorators: { fastify: ['plugin1', 'plugin2'] }
+  }))
+
+  await t.assert.rejects(fastify.ready(), { message: "The decorator 'plugin2' required by 'test' is not present in Fastify" })
+})
+
+test('plugin name when encapsulated', async (t) => {
+  t.plan(6)
+  const fastify = Fastify()
+
+  fastify.register(function plugin (_instance, _opts, next) {
+    next()
+  })
+
+  fastify.register(fp(getFn('hello'), {
+    fastify: '5.x',
+    name: 'hello',
+    encapsulate: true
+  }))
+
+  fastify.register(function plugin (fastify, _opts, next) {
+    fastify.register(fp(getFn('deep'), {
+      fastify: '5.x',
+      name: 'deep',
+      encapsulate: true
+    }))
+
+    fastify.register(fp(function genericPlugin (fastify, _opts, next) {
+      t.assert.strictEqual(fastify.pluginName, 'deep-deep', 'should be deep-deep')
+
+      fastify.register(fp(getFn('deep-deep-deep'), {
+        fastify: '5.x',
+        name: 'deep-deep-deep',
+        encapsulate: true
+      }))
+
+      fastify.register(fp(getFn('deep-deep -> not-encapsulated-2'), {
+        fastify: '5.x',
+        name: 'not-encapsulated-2'
+      }))
+
+      next()
+    }, {
+      fastify: '5.x',
+      name: 'deep-deep',
+      encapsulate: true
+    }))
+
+    fastify.register(fp(getFn('plugin -> not-encapsulated'), {
+      fastify: '5.x',
+      name: 'not-encapsulated'
+    }))
+
+    next()
+  })
+
+  await fastify.ready()
+
+  function getFn (expectedName) {
+    return function genericPlugin (fastify, _opts, next) {
+      t.assert.strictEqual(fastify.pluginName, expectedName, `should be ${expectedName}`)
+      next()
+    }
+  }
+})

package/node_modules/@fastify/reply-from/node_modules/fastify-plugin/test/toCamelCase.test.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const { test } = require('node:test')
+const toCamelCase = require('../lib/toCamelCase')
+
+test('from kebab-case to camelCase', (t) => {
+  t.plan(1)
+  t.assert.strictEqual(toCamelCase('hello-world'), 'helloWorld')
+})
+
+test('from @-prefixed named imports', (t) => {
+  t.plan(1)
+  t.assert.strictEqual(toCamelCase('@hello/world'), 'helloWorld')
+})
+
+test('from @-prefixed named kebab-case to camelCase', (t) => {
+  t.plan(1)
+  t.assert.strictEqual(toCamelCase('@hello/my-world'), 'helloMyWorld')
+})
+
+test('from kebab-case to camelCase multiple words', (t) => {
+  t.plan(1)
+  t.assert.strictEqual(toCamelCase('hello-long-world'), 'helloLongWorld')
+})