@zuplo/cli 6.71.23 → 6.71.25

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/benchmark/bench-cmp-branch.js

@@ -0,0 +1,116 @@
+'use strict'
+
+const { spawn } = require('child_process')
+
+const cliSelect = require('cli-select')
+const simpleGit = require('simple-git')
+
+const git = simpleGit(process.cwd())
+
+const COMMAND = 'npm run bench'
+const DEFAULT_BRANCH = 'main'
+const PERCENT_THRESHOLD = 5
+const greyColor = '\x1b[30m'
+const redColor = '\x1b[31m'
+const greenColor = '\x1b[32m'
+const resetColor = '\x1b[0m'
+
+async function selectBranchName (message, branches) {
+  console.log(message)
+  const result = await cliSelect({
+    type: 'list',
+    name: 'branch',
+    values: branches
+  })
+  console.log(result.value)
+  return result.value
+}
+
+async function executeCommandOnBranch (command, branch) {
+  console.log(`${greyColor}Checking out "${branch}"${resetColor}`)
+  await git.checkout(branch)
+
+  console.log(`${greyColor}Execute "${command}"${resetColor}`)
+  const childProcess = spawn(command, { stdio: 'pipe', shell: true })
+
+  let result = ''
+  childProcess.stdout.on('data', (data) => {
+    process.stdout.write(data.toString())
+    result += data.toString()
+  })
+
+  await new Promise(resolve => childProcess.on('close', resolve))
+
+  console.log()
+
+  return parseBenchmarksStdout(result)
+}
+
+function parseBenchmarksStdout (text) {
+  const results = []
+
+  const lines = text.split('\n')
+  for (const line of lines) {
+    const match = /^(.+?)(\.*) x (.+) ops\/sec .*$/.exec(line)
+    if (match !== null) {
+      results.push({
+        name: match[1],
+        alignedName: match[1] + match[2],
+        result: parseInt(match[3].split(',').join(''))
+      })
+    }
+  }
+
+  return results
+}
+
+function compareResults (featureBranch, mainBranch) {
+  for (const { name, alignedName, result: mainBranchResult } of mainBranch) {
+    const featureBranchBenchmark = featureBranch.find(result => result.name === name)
+    if (featureBranchBenchmark) {
+      const featureBranchResult = featureBranchBenchmark.result
+      const percent = (featureBranchResult - mainBranchResult) * 100 / mainBranchResult
+      const roundedPercent = Math.round(percent * 100) / 100
+
+      const percentString = roundedPercent > 0 ? `+${roundedPercent}%` : `${roundedPercent}%`
+      const message = alignedName + percentString.padStart(7, '.')
+
+      if (roundedPercent > PERCENT_THRESHOLD) {
+        console.log(`${greenColor}${message}${resetColor}`)
+      } else if (roundedPercent < -PERCENT_THRESHOLD) {
+        console.log(`${redColor}${message}${resetColor}`)
+      } else {
+        console.log(message)
+      }
+    }
+  }
+}
+
+(async function () {
+  const branches = await git.branch()
+  const currentBranch = branches.branches[branches.current]
+
+  let featureBranch = null
+  let mainBranch = null
+
+  if (process.argv[2] === '--ci') {
+    featureBranch = currentBranch.name
+    mainBranch = DEFAULT_BRANCH
+  } else {
+    featureBranch = await selectBranchName('Select the branch you want to compare (feature branch):', branches.all)
+    mainBranch = await selectBranchName('Select the branch you want to compare with (main branch):', branches.all)
+  }
+
+  try {
+    const featureBranchResult = await executeCommandOnBranch(COMMAND, featureBranch)
+    const mainBranchResult = await executeCommandOnBranch(COMMAND, mainBranch)
+    compareResults(featureBranchResult, mainBranchResult)
+  } catch (error) {
+    console.error('Switch to origin branch due to an error', error.message)
+  }
+
+  await git.checkout(currentBranch.commit)
+  await git.checkout(currentBranch.name)
+
+  console.log(`${greyColor}Back to ${currentBranch.name} ${currentBranch.commit}${resetColor}`)
+})()

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/benchmark/bench-cmp-lib.js

@@ -0,0 +1,339 @@
+'use strict'
+
+const { Bench } = require('tinybench')
+const suite = new Bench({
+  name: 'Library Comparison Benchmarks',
+  setup: (_task, mode) => {
+    // Run the garbage collector before warmup at each cycle
+    if (mode === 'warmup' && typeof globalThis.gc === 'function') {
+      globalThis.gc()
+    }
+  }
+})
+
+const STR_LEN = 1e4
+const LARGE_ARRAY_SIZE = 2e4
+const MULTI_ARRAY_LENGTH = 1e3
+
+const schema = {
+  title: 'Example Schema',
+  type: 'object',
+  properties: {
+    firstName: {
+      type: 'string'
+    },
+    lastName: {
+      type: ['string', 'null']
+    },
+    age: {
+      description: 'Age in years',
+      type: 'integer',
+      minimum: 0
+    }
+  }
+}
+const schemaCJS = {
+  title: 'Example Schema',
+  type: 'object',
+  properties: {
+    firstName: {
+      type: 'string'
+    },
+    lastName: {
+      type: ['string', 'null']
+    },
+    age: {
+      description: 'Age in years',
+      type: 'number',
+      minimum: 0
+    }
+  }
+}
+
+const schemaAJVJTD = {
+  properties: {
+    firstName: {
+      type: 'string'
+    },
+    lastName: {
+      type: 'string',
+      nullable: true
+    },
+    age: {
+      type: 'uint8'
+    }
+  }
+}
+
+const arraySchema = {
+  title: 'array schema',
+  type: 'array',
+  items: schema
+}
+
+const arraySchemaCJS = {
+  title: 'array schema',
+  type: 'array',
+  items: schemaCJS
+}
+
+const arraySchemaAJVJTD = {
+  elements: schemaAJVJTD
+}
+
+const dateFormatSchema = {
+  description: 'Date of birth',
+  type: 'string',
+  format: 'datetime'
+}
+
+const dateFormatSchemaCJS = {
+  description: 'Date of birth',
+  type: 'string',
+  format: 'datetime'
+}
+
+const obj = {
+  firstName: 'Matteo',
+  lastName: 'Collina',
+  age: 32
+}
+
+const date = new Date()
+
+const multiArray = new Array(MULTI_ARRAY_LENGTH)
+const largeArray = new Array(LARGE_ARRAY_SIZE)
+
+const CJS = require('compile-json-stringify')
+const CJSStringify = CJS(schemaCJS)
+const CJSStringifyArray = CJS(arraySchemaCJS)
+const CJSStringifyDate = CJS(dateFormatSchemaCJS)
+const CJSStringifyString = CJS({ type: 'string' })
+
+const FJS = require('..')
+const stringify = FJS(schema)
+const stringifyArrayDefault = FJS(arraySchema)
+const stringifyArrayJSONStringify = FJS(arraySchema, {
+  largeArrayMechanism: 'json-stringify'
+})
+const stringifyDate = FJS(dateFormatSchema)
+const stringifyString = FJS({ type: 'string' })
+let str = ''
+
+const Ajv = require('ajv/dist/jtd')
+const ajv = new Ajv()
+const ajvSerialize = ajv.compileSerializer(schemaAJVJTD)
+const ajvSerializeArray = ajv.compileSerializer(arraySchemaAJVJTD)
+const ajvSerializeString = ajv.compileSerializer({ type: 'string' })
+
+const { createAccelerator } = require('json-accelerator')
+const accelStringify = createAccelerator(schema)
+const accelArray = createAccelerator(arraySchema)
+const accelDate = FJS(dateFormatSchema)
+const accelString = FJS({ type: 'string' })
+
+const getRandomString = (length) => {
+  if (!Number.isInteger(length)) {
+    throw new Error('Expected integer length')
+  }
+
+  const validCharacters = 'abcdefghijklmnopqrstuvwxyz'
+  const nValidCharacters = 26
+
+  let result = ''
+  for (let i = 0; i < length; ++i) {
+    result += validCharacters[Math.floor(Math.random() * nValidCharacters)]
+  }
+
+  return result[0].toUpperCase() + result.slice(1)
+}
+
+for (let i = 0; i < STR_LEN; i++) {
+  largeArray[i] = {
+    firstName: getRandomString(8),
+    lastName: getRandomString(6),
+    age: Math.ceil(Math.random() * 99)
+  }
+
+  str += i
+  if (i % 100 === 0) {
+    str += '"'
+  }
+}
+
+for (let i = STR_LEN; i < LARGE_ARRAY_SIZE; ++i) {
+  largeArray[i] = {
+    firstName: getRandomString(10),
+    lastName: getRandomString(4),
+    age: Math.ceil(Math.random() * 99)
+  }
+}
+
+for (let i = 0; i < MULTI_ARRAY_LENGTH; i++) {
+  multiArray[i] = obj
+}
+
+suite.add('fast-json-stringify: creation', function () {
+  FJS(schema)
+})
+suite.add('compile-json-stringify: creation', function () {
+  CJS(schemaCJS)
+})
+suite.add('AJV: creation', function () {
+  ajv.compileSerializer(schemaAJVJTD)
+})
+suite.add('json-accelerator: creation', function () {
+  createAccelerator(schema)
+})
+
+suite.add('JSON.stringify: array', function () {
+  JSON.stringify(multiArray)
+})
+
+suite.add('fast-json-stringify [default]: array', function () {
+  stringifyArrayDefault(multiArray)
+})
+
+suite.add('json-accelerator: array', function () {
+  accelArray(multiArray)
+})
+
+suite.add('fast-json-stringify [json-stringify]: array', function () {
+  stringifyArrayJSONStringify(multiArray)
+})
+
+suite.add('compile-json-stringify: array', function () {
+  CJSStringifyArray(multiArray)
+})
+
+suite.add('AJV: array', function () {
+  ajvSerializeArray(multiArray)
+})
+
+suite.add('JSON.stringify: large array', function () {
+  JSON.stringify(largeArray)
+})
+
+suite.add('fast-json-stringify [default]: large array', function () {
+  stringifyArrayDefault(largeArray)
+})
+
+suite.add('fast-json-stringify [json-stringify]: large array', function () {
+  stringifyArrayJSONStringify(largeArray)
+})
+
+suite.add('compile-json-stringify: large array', function () {
+  CJSStringifyArray(largeArray)
+})
+
+suite.add('AJV: large array', function () {
+  ajvSerializeArray(largeArray)
+})
+
+suite.add('JSON.stringify: long string', function () {
+  JSON.stringify(str)
+})
+
+suite.add('fast-json-stringify: long string', function () {
+  stringifyString(str)
+})
+
+suite.add('json-accelerator: long string', function () {
+  stringifyString(str)
+})
+
+suite.add('compile-json-stringify: long string', function () {
+  CJSStringifyString(str)
+})
+
+suite.add('AJV: long string', function () {
+  ajvSerializeString(str)
+})
+
+suite.add('JSON.stringify: short string', function () {
+  JSON.stringify('hello world')
+})
+
+suite.add('fast-json-stringify: short string', function () {
+  stringifyString('hello world')
+})
+
+suite.add('json-accelerator: short string', function () {
+  accelString('hello world')
+})
+
+suite.add('compile-json-stringify: short string', function () {
+  CJSStringifyString('hello world')
+})
+
+suite.add('AJV: short string', function () {
+  ajvSerializeString('hello world')
+})
+
+suite.add('JSON.stringify: obj', function () {
+  JSON.stringify(obj)
+})
+
+suite.add('fast-json-stringify: obj', function () {
+  stringify(obj)
+})
+
+suite.add('json-accelerator: obj', function () {
+  accelStringify(obj)
+})
+
+suite.add('compile-json-stringify: obj', function () {
+  CJSStringify(obj)
+})
+
+suite.add('AJV: obj', function () {
+  ajvSerialize(obj)
+})
+
+suite.add('JSON.stringify: date', function () {
+  JSON.stringify(date)
+})
+
+suite.add('fast-json-stringify: date', function () {
+  stringifyDate(date)
+})
+
+suite.add('json-accelerate: date', function () {
+  accelDate(date)
+})
+
+suite.add('compile-json-stringify: date', function () {
+  CJSStringifyDate(date)
+})
+
+suite.run().then(() => {
+  const results = suite.tasks.map(task => ({
+    name: task.name,
+    hz: task.result.throughput.mean,
+    rme: task.result.latency.rme,
+    samples: task.result.latency.df + 1
+  }))
+
+  const scenarios = {}
+  for (const result of results) {
+    const [library, scenario] = result.name.split(':').map(s => s.trim())
+
+    if (!scenarios[scenario]) scenarios[scenario] = []
+    scenarios[scenario].push({ ...result, library })
+  }
+
+  for (const [scenario, tasks] of Object.entries(scenarios)) {
+    console.log(`\n--- ${scenario} ---`)
+    const sorted = tasks.sort((a, b) => b.hz - a.hz)
+    const winner = sorted[0]
+
+    for (const task of sorted) {
+      const formattedHz = task.hz.toLocaleString('en-US', { maximumFractionDigits: 0 })
+      const formattedRme = task.rme.toFixed(2)
+      const isWinner = task === winner
+      const prefix = isWinner ? '🏆 ' : '   '
+
+      console.log(`${prefix}${task.library.padEnd(40)} x ${formattedHz.padStart(15)} ops/sec ±${formattedRme}% (${task.samples} runs sampled)`)
+    }
+  }
+}).catch(err => console.error(`Error: ${err.message}`))

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/benchmark/bench-thread.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const { workerData: benchmark, parentPort } = require('worker_threads')
+
+const { Bench } = require('tinybench')
+
+const bench = new Bench({
+  name: benchmark.name,
+  setup: (_task, mode) => {
+    // Run the garbage collector before warmup at each cycle
+    if (mode === 'warmup' && typeof globalThis.gc === 'function') {
+      globalThis.gc()
+    }
+  }
+})
+
+const FJS = require('..')
+const stringify = FJS(benchmark.schema)
+
+bench.add(benchmark.name, () => {
+  stringify(benchmark.input)
+}).run().then(() => {
+  const task = bench.tasks[0]
+  const hz = task.result.throughput.mean // ops/sec
+  const rme = task.result.latency.rme // relative margin of error (%)
+  const samples = task.result.latency.df + 1 // degrees of freedom + 1 = sample count
+
+  const formattedHz = hz.toLocaleString('en-US', { maximumFractionDigits: 0 })
+  const formattedRme = rme.toFixed(2)
+
+  const output = `${task.name} x ${formattedHz} ops/sec ±${formattedRme}% (${samples} runs sampled)`
+  parentPort.postMessage(output)
+}).catch(err => parentPort.postMessage(`Error: ${err.message}`))