@zuplo/cli 6.71.22 → 6.71.25

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/lib/serializer.js

@@ -0,0 +1,141 @@
+'use strict'
+
+// eslint-disable-next-line
+const STR_ESCAPE = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/
+
+module.exports = class Serializer {
+  constructor (options) {
+    switch (options && options.rounding) {
+      case 'floor':
+        this.parseInteger = Math.floor
+        break
+      case 'ceil':
+        this.parseInteger = Math.ceil
+        break
+      case 'round':
+        this.parseInteger = Math.round
+        break
+      case 'trunc':
+      default:
+        this.parseInteger = Math.trunc
+        break
+    }
+    this._options = options
+  }
+
+  asInteger (i) {
+    if (Number.isInteger(i)) {
+      return '' + i
+    } else if (typeof i === 'bigint') {
+      return i.toString()
+    }
+    /* eslint no-undef: "off" */
+    const integer = this.parseInteger(i)
+    // check if number is Infinity or NaN
+    // eslint-disable-next-line no-self-compare
+    if (integer === Infinity || integer === -Infinity || integer !== integer) {
+      throw new Error(`The value "${i}" cannot be converted to an integer.`)
+    }
+    return '' + integer
+  }
+
+  asNumber (i) {
+    // fast cast to number
+    const num = Number(i)
+    // check if number is NaN
+    // eslint-disable-next-line no-self-compare
+    if (num !== num) {
+      throw new Error(`The value "${i}" cannot be converted to a number.`)
+    } else if (num === Infinity || num === -Infinity) {
+      return 'null'
+    } else {
+      return '' + num
+    }
+  }
+
+  asBoolean (bool) {
+    return bool && 'true' || 'false' // eslint-disable-line
+  }
+
+  asDateTime (date) {
+    if (date === null) return '""'
+    if (date instanceof Date) {
+      return '"' + date.toISOString() + '"'
+    }
+    if (typeof date === 'string') {
+      return '"' + date + '"'
+    }
+    throw new Error(`The value "${date}" cannot be converted to a date-time.`)
+  }
+
+  asDate (date) {
+    if (date === null) return '""'
+    if (date instanceof Date) {
+      return '"' + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(0, 10) + '"'
+    }
+    if (typeof date === 'string') {
+      return '"' + date + '"'
+    }
+    throw new Error(`The value "${date}" cannot be converted to a date.`)
+  }
+
+  asTime (date) {
+    if (date === null) return '""'
+    if (date instanceof Date) {
+      return '"' + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(11, 19) + '"'
+    }
+    if (typeof date === 'string') {
+      return '"' + date + '"'
+    }
+    throw new Error(`The value "${date}" cannot be converted to a time.`)
+  }
+
+  asString (str) {
+    const len = str.length
+    if (len === 0) {
+      return '""'
+    } else if (len < 42) {
+      // magically escape strings for json
+      // relying on their charCodeAt
+      // everything below 32 needs JSON.stringify()
+      // every string that contain surrogate needs JSON.stringify()
+      // 34 and 92 happens all the time, so we
+      // have a fast case for them
+      let result = ''
+      let last = -1
+      let point = 255
+      for (let i = 0; i < len; i++) {
+        point = str.charCodeAt(i)
+        if (
+          point === 0x22 || // '"'
+          point === 0x5c // '\'
+        ) {
+          last === -1 && (last = 0)
+          result += str.slice(last, i) + '\\'
+          last = i
+        } else if (point < 32 || (point >= 0xD800 && point <= 0xDFFF)) {
+          // The current character is non-printable characters or a surrogate.
+          return JSON.stringify(str)
+        }
+      }
+      return (last === -1 && ('"' + str + '"')) || ('"' + result + str.slice(last) + '"')
+    } else if (len < 5000 && STR_ESCAPE.test(str) === false) {
+      // Only use the regular expression for shorter input. The overhead is otherwise too much.
+      return '"' + str + '"'
+    } else {
+      return JSON.stringify(str)
+    }
+  }
+
+  asUnsafeString (str) {
+    return '"' + str + '"'
+  }
+
+  getState () {
+    return this._options
+  }
+
+  static restoreFromState (state) {
+    return new Serializer(state)
+  }
+}

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/lib/standalone.js

@@ -0,0 +1,34 @@
+'use strict'
+
+function buildStandaloneCode (contextFunc, context, serializer, validator) {
+  let ajvDependencyCode = ''
+  if (context.validatorSchemasIds.size > 0) {
+    ajvDependencyCode += 'const Validator = require(\'fast-json-stringify/lib/validator\')\n'
+    ajvDependencyCode += `const validatorState = ${JSON.stringify(validator.getState())}\n`
+    ajvDependencyCode += 'const validator = Validator.restoreFromState(validatorState)\n'
+  } else {
+    ajvDependencyCode += 'const validator = null\n'
+  }
+
+  // Don't need to keep external schemas once compiled
+  // validatorState will hold external schemas if it needs them
+  const { schema, ...serializerState } = serializer.getState()
+
+  return `
+  'use strict'
+
+  const Serializer = require('fast-json-stringify/lib/serializer')
+  const serializerState = ${JSON.stringify(serializerState)}
+  const serializer = Serializer.restoreFromState(serializerState)
+
+  ${ajvDependencyCode}
+
+  module.exports = ${contextFunc.toString()}(validator, serializer)`
+}
+
+module.exports = buildStandaloneCode
+
+module.exports.dependencies = {
+  Serializer: require('./serializer'),
+  Validator: require('./validator')
+}

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/lib/validator.js

@@ -0,0 +1,96 @@
+'use strict'
+
+const Ajv = require('ajv')
+const fastUri = require('fast-uri')
+const ajvFormats = require('ajv-formats')
+const clone = require('rfdc')({ proto: true })
+
+class Validator {
+  constructor (ajvOptions) {
+    this.ajv = new Ajv({
+      ...ajvOptions,
+      strictSchema: false,
+      validateSchema: false,
+      allowUnionTypes: true,
+      uriResolver: fastUri
+    })
+
+    ajvFormats(this.ajv)
+
+    this.ajv.addKeyword({
+      keyword: 'fjs_type',
+      type: 'object',
+      errors: false,
+      validate: (_type, data) => {
+        return data && typeof data.toJSON === 'function'
+      }
+    })
+
+    this._ajvSchemas = {}
+    this._ajvOptions = ajvOptions || {}
+  }
+
+  addSchema (schema, schemaName) {
+    let schemaKey = schema.$id || schemaName
+    if (schema.$id !== undefined && schema.$id[0] === '#') {
+      schemaKey = schemaName + schema.$id // relative URI
+    }
+
+    if (
+      this.ajv.refs[schemaKey] === undefined &&
+      this.ajv.schemas[schemaKey] === undefined
+    ) {
+      const ajvSchema = clone(schema)
+      this.convertSchemaToAjvFormat(ajvSchema)
+      this.ajv.addSchema(ajvSchema, schemaKey)
+      this._ajvSchemas[schemaKey] = schema
+    }
+  }
+
+  validate (schemaRef, data) {
+    return this.ajv.validate(schemaRef, data)
+  }
+
+  // Ajv does not natively support JavaScript objects like Date or other types
+  // that rely on a custom .toJSON() representation. To properly validate schemas
+  // that may contain such objects (e.g. Date, ObjectId, etc.), we replace all
+  // occurrences of the string type with a custom keyword fjs_type
+  // (see https://github.com/fastify/fast-json-stringify/pull/441)
+  convertSchemaToAjvFormat (schema) {
+    if (schema === null) return
+
+    if (schema.type === 'string') {
+      schema.fjs_type = 'string'
+      schema.type = ['string', 'object']
+    } else if (
+      Array.isArray(schema.type) &&
+      schema.type.includes('string') &&
+      !schema.type.includes('object')
+    ) {
+      schema.fjs_type = 'string'
+      schema.type.push('object')
+    }
+    for (const property in schema) {
+      if (typeof schema[property] === 'object') {
+        this.convertSchemaToAjvFormat(schema[property])
+      }
+    }
+  }
+
+  getState () {
+    return {
+      ajvOptions: this._ajvOptions,
+      ajvSchemas: this._ajvSchemas
+    }
+  }
+
+  static restoreFromState (state) {
+    const validator = new Validator(state.ajvOptions)
+    for (const [id, ajvSchema] of Object.entries(state.ajvSchemas)) {
+      validator.ajv.addSchema(ajvSchema, id)
+    }
+    return validator
+  }
+}
+
+module.exports = Validator

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "fast-json-stringify",
+  "version": "7.0.0",
+  "description": "Stringify your JSON at max speed",
+  "main": "index.js",
+  "type": "commonjs",
+  "types": "types/index.d.ts",
+  "scripts": {
+    "bench": "node --expose-gc ./benchmark/bench.js",
+    "bench:cmp": "node ./benchmark/bench-cmp-branch.js",
+    "bench:cmp:ci": "node ./benchmark/bench-cmp-branch.js --ci",
+    "benchmark": "node --expose-gc ./benchmark/bench-cmp-lib.js",
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "test:typescript": "tstyche",
+    "test:unit": "c8 node --test",
+    "test": "npm run test:unit && npm run test:typescript"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fastify/fast-json-stringify.git"
+  },
+  "keywords": [
+    "json",
+    "stringify",
+    "schema",
+    "fast"
+  ],
+  "author": "Matteo Collina <hello@matteocollina.com>",
+  "contributors": [
+    {
+      "name": "Tomas Della Vedova",
+      "url": "http://delved.org"
+    },
+    {
+      "name": "Aras Abbasi",
+      "email": "aras.abbasi@gmail.com"
+    },
+    {
+      "name": "Manuel Spigolon",
+      "email": "behemoth89@gmail.com"
+    },
+    {
+      "name": "Frazer Smith",
+      "email": "frazer.dev@icloud.com",
+      "url": "https://github.com/fdawgs"
+    }
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/fastify/fast-json-stringify/issues"
+  },
+  "homepage": "https://github.com/fastify/fast-json-stringify#readme",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/fastify"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/fastify"
+    }
+  ],
+  "devDependencies": {
+    "c8": "^11.0.0",
+    "cli-select": "^1.1.2",
+    "compile-json-stringify": "^0.1.2",
+    "eslint": "^9.39.2",
+    "fast-json-stringify": ".",
+    "is-my-json-valid": "^2.20.6",
+    "json-accelerator": "^0.1.7",
+    "neostandard": "^0.13.0",
+    "simple-git": "^3.30.0",
+    "tinybench": "^6.0.0",
+    "tstyche": "^7.1.0",
+    "typebox": "^1.0.81",
+    "typescript": "~6.0.2",
+    "webpack": "^5.104.1"
+  },
+  "dependencies": {
+    "@fastify/merge-json-schemas": "^0.2.0",
+    "ajv": "^8.12.0",
+    "ajv-formats": "^3.0.1",
+    "fast-uri": "^3.0.0",
+    "json-schema-ref-resolver": "^3.0.0",
+    "rfdc": "^1.2.0"
+  },
+  "runkitExampleFilename": "./examples/example.js"
+}

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/test/additionalProperties.test.js

@@ -0,0 +1,332 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('additionalProperties', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'additionalProperties',
+    type: 'object',
+    properties: {
+      str: {
+        type: 'string'
+      }
+    },
+    additionalProperties: {
+      type: 'string'
+    }
+  })
+
+  const obj = { str: 'test', foo: 42, ofoo: true, foof: 'string', objfoo: { a: true } }
+  t.assert.equal(stringify(obj), '{"str":"test","foo":"42","ofoo":"true","foof":"string","objfoo":"[object Object]"}')
+})
+
+test('additionalProperties should not change properties', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'patternProperties should not change properties',
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      }
+    },
+    additionalProperties: {
+      type: 'number'
+    }
+  })
+
+  const obj = { foo: '42', ofoo: 42 }
+  t.assert.equal(stringify(obj), '{"foo":"42","ofoo":42}')
+})
+
+test('additionalProperties should not change properties and patternProperties', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'patternProperties should not change properties',
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      }
+    },
+    patternProperties: {
+      foo: {
+        type: 'string'
+      }
+    },
+    additionalProperties: {
+      type: 'number'
+    }
+  })
+
+  const obj = { foo: '42', ofoo: 42, test: '42' }
+  t.assert.equal(stringify(obj), '{"foo":"42","ofoo":"42","test":42}')
+})
+
+test('additionalProperties set to true, use of fast-safe-stringify', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'check string coerce',
+    type: 'object',
+    properties: {},
+    additionalProperties: true
+  })
+
+  const obj = { foo: true, ofoo: 42, arrfoo: ['array', 'test'], objfoo: { a: 'world' } }
+  t.assert.equal(stringify(obj), '{"foo":true,"ofoo":42,"arrfoo":["array","test"],"objfoo":{"a":"world"}}')
+})
+
+test('additionalProperties - string coerce', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'check string coerce',
+    type: 'object',
+    properties: {},
+    additionalProperties: {
+      type: 'string'
+    }
+  })
+
+  const obj = { foo: true, ofoo: 42, arrfoo: ['array', 'test'], objfoo: { a: 'world' } }
+  t.assert.equal(stringify(obj), '{"foo":"true","ofoo":"42","arrfoo":"array,test","objfoo":"[object Object]"}')
+})
+
+test('additionalProperties - number skip', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'check number coerce',
+    type: 'object',
+    properties: {},
+    additionalProperties: {
+      type: 'number'
+    }
+  })
+
+  // const obj = { foo: true, ofoo: '42', xfoo: 'string', arrfoo: [1, 2], objfoo: { num: 42 } }
+  const obj = { foo: true, ofoo: '42' }
+  t.assert.equal(stringify(obj), '{"foo":1,"ofoo":42}')
+})
+
+test('additionalProperties - boolean coerce', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'check boolean coerce',
+    type: 'object',
+    properties: {},
+    additionalProperties: {
+      type: 'boolean'
+    }
+  })
+
+  const obj = { foo: 'true', ofoo: 0, arrfoo: [1, 2], objfoo: { a: true } }
+  t.assert.equal(stringify(obj), '{"foo":true,"ofoo":false,"arrfoo":true,"objfoo":true}')
+})
+
+test('additionalProperties - object coerce', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'check object coerce',
+    type: 'object',
+    properties: {},
+    additionalProperties: {
+      type: 'object',
+      properties: {
+        answer: {
+          type: 'number'
+        }
+      }
+    }
+  })
+
+  const obj = { objfoo: { answer: 42 } }
+  t.assert.equal(stringify(obj), '{"objfoo":{"answer":42}}')
+})
+
+test('additionalProperties - array coerce', (t) => {
+  t.plan(2)
+  const stringify = build({
+    title: 'check array coerce',
+    type: 'object',
+    properties: {},
+    additionalProperties: {
+      type: 'array',
+      items: {
+        type: 'string'
+      }
+    }
+  })
+
+  const coercibleValues = { arrfoo: [1, 2] }
+  t.assert.equal(stringify(coercibleValues), '{"arrfoo":["1","2"]}')
+
+  const incoercibleValues = { foo: 'true', ofoo: 0, objfoo: { tyrion: 'lannister' } }
+  t.assert.throws(() => stringify(incoercibleValues))
+})
+
+test('additionalProperties with empty schema', (t) => {
+  t.plan(1)
+  const stringify = build({
+    type: 'object',
+    additionalProperties: {}
+  })
+
+  const obj = { a: 1, b: true, c: null }
+  t.assert.equal(stringify(obj), '{"a":1,"b":true,"c":null}')
+})
+
+test('additionalProperties with nested empty schema', (t) => {
+  t.plan(1)
+  const stringify = build({
+    type: 'object',
+    properties: {
+      data: { type: 'object', additionalProperties: {} }
+    },
+    required: ['data']
+  })
+
+  const obj = { data: { a: 1, b: true, c: null } }
+  t.assert.equal(stringify(obj), '{"data":{"a":1,"b":true,"c":null}}')
+})
+
+test('nested additionalProperties', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'additionalProperties',
+    type: 'array',
+    items: {
+      type: 'object',
+      properties: {
+        ap: {
+          type: 'object',
+          additionalProperties: { type: 'string' }
+        }
+      }
+    }
+  })
+
+  const obj = [{ ap: { value: 'string' } }]
+  t.assert.equal(stringify(obj), '[{"ap":{"value":"string"}}]')
+})
+
+test('very nested additionalProperties', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'additionalProperties',
+    type: 'array',
+    items: {
+      type: 'object',
+      properties: {
+        ap: {
+          type: 'object',
+          properties: {
+            nested: {
+              type: 'object',
+              properties: {
+                moarNested: {
+                  type: 'object',
+                  properties: {
+                    finally: {
+                      type: 'object',
+                      additionalProperties: {
+                        type: 'string'
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  })
+
+  const obj = [{ ap: { nested: { moarNested: { finally: { value: 'str' } } } } }]
+  t.assert.equal(stringify(obj), '[{"ap":{"nested":{"moarNested":{"finally":{"value":"str"}}}}}]')
+})
+
+test('nested additionalProperties set to true', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'nested additionalProperties=true',
+    type: 'object',
+    properties: {
+      ap: {
+        type: 'object',
+        additionalProperties: true
+      }
+    }
+  })
+
+  const obj = { ap: { value: 'string', someNumber: 42 } }
+  t.assert.equal(stringify(obj), '{"ap":{"value":"string","someNumber":42}}')
+})
+
+test('field passed to fastSafeStringify as undefined should be removed', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'nested additionalProperties=true',
+    type: 'object',
+    properties: {
+      ap: {
+        type: 'object',
+        additionalProperties: true
+      }
+    }
+  })
+
+  const obj = { ap: { value: 'string', someNumber: undefined } }
+  t.assert.equal(stringify(obj), '{"ap":{"value":"string"}}')
+})
+
+test('property without type but with enum, will acts as additionalProperties', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'automatic additionalProperties',
+    type: 'object',
+    properties: {
+      ap: {
+        enum: ['foobar', 42, ['foo', 'bar'], {}]
+      }
+    }
+  })
+
+  const obj = { ap: { additional: 'field' } }
+  t.assert.equal(stringify(obj), '{"ap":{"additional":"field"}}')
+})
+
+test('property without type but with enum, will acts as additionalProperties without overwriting', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'automatic additionalProperties',
+    type: 'object',
+    properties: {
+      ap: {
+        additionalProperties: false,
+        enum: ['foobar', 42, ['foo', 'bar'], {}]
+      }
+    }
+  })
+
+  const obj = { ap: { additional: 'field' } }
+  t.assert.equal(stringify(obj), '{"ap":{}}')
+})
+
+test('function and symbol references are not serialized as undefined', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'additionalProperties',
+    type: 'object',
+    additionalProperties: true,
+    properties: {
+      str: {
+        type: 'string'
+      }
+    }
+  })
+
+  const obj = { str: 'x', test: 'test', meth: () => 'x', sym: Symbol('x') }
+  t.assert.equal(stringify(obj), '{"str":"x","test":"test"}')
+})