@zuplo/cli 6.71.22 → 6.71.25

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

@@ -0,0 +1,400 @@
+'use strict'
+
+const { test } = require('node:test')
+const validator = require('is-my-json-valid')
+const build = require('..')
+
+function buildTest (schema, toStringify) {
+  test(`render a ${schema.title} as JSON`, (t) => {
+    t.plan(3)
+
+    const validate = validator(schema)
+    const stringify = build(schema)
+    const output = stringify(toStringify)
+
+    t.assert.deepStrictEqual(JSON.parse(output), toStringify)
+    t.assert.equal(output, JSON.stringify(toStringify))
+    t.assert.ok(validate(JSON.parse(output)), 'valid schema')
+  })
+}
+
+buildTest({
+  title: 'string',
+  type: 'string',
+  format: 'unsafe'
+}, 'hello world')
+
+buildTest({
+  title: 'basic',
+  type: 'object',
+  properties: {
+    firstName: {
+      type: 'string'
+    },
+    lastName: {
+      type: 'string'
+    },
+    age: {
+      description: 'Age in years',
+      type: 'integer',
+      minimum: 0
+    },
+    magic: {
+      type: 'number'
+    }
+  },
+  required: ['firstName', 'lastName']
+}, {
+  firstName: 'Matteo',
+  lastName: 'Collina',
+  age: 32,
+  magic: 42.42
+})
+
+buildTest({
+  title: 'string',
+  type: 'string'
+}, 'hello world')
+
+buildTest({
+  title: 'string',
+  type: 'string'
+}, 'hello\nworld')
+
+buildTest({
+  title: 'string with quotes',
+  type: 'string'
+}, 'hello """" world')
+
+buildTest({
+  title: 'boolean true',
+  type: 'boolean'
+}, true)
+
+buildTest({
+  title: 'boolean false',
+  type: 'boolean'
+}, false)
+
+buildTest({
+  title: 'an integer',
+  type: 'integer'
+}, 42)
+
+buildTest({
+  title: 'a number',
+  type: 'number'
+}, 42.42)
+
+buildTest({
+  title: 'deep',
+  type: 'object',
+  properties: {
+    firstName: {
+      type: 'string'
+    },
+    lastName: {
+      type: 'string'
+    },
+    more: {
+      description: 'more properties',
+      type: 'object',
+      properties: {
+        something: {
+          type: 'string'
+        }
+      }
+    }
+  }
+}, {
+  firstName: 'Matteo',
+  lastName: 'Collina',
+  more: {
+    something: 'else'
+  }
+})
+
+buildTest({
+  title: 'null',
+  type: 'null'
+}, null)
+
+buildTest({
+  title: 'deep object with weird keys',
+  type: 'object',
+  properties: {
+    '@version': {
+      type: 'integer'
+    }
+  }
+}, {
+  '@version': 1
+})
+
+buildTest({
+  title: 'deep object with weird keys of type object',
+  type: 'object',
+  properties: {
+    '@data': {
+      type: 'object',
+      properties: {
+        id: {
+          type: 'string'
+        }
+      }
+    }
+  }
+}, {
+  '@data': {
+    id: 'string'
+  }
+})
+
+buildTest({
+  title: 'deep object with spaces in key',
+  type: 'object',
+  properties: {
+    'spaces in key': {
+      type: 'object',
+      properties: {
+        something: {
+          type: 'integer'
+        }
+      }
+    }
+  }
+}, {
+  'spaces in key': {
+    something: 1
+  }
+})
+
+buildTest({
+  title: 'with null',
+  type: 'object',
+  properties: {
+    firstName: {
+      type: 'null'
+    }
+  }
+}, {
+  firstName: null
+})
+
+buildTest({
+  title: 'array with objects',
+  type: 'array',
+  items: {
+    type: 'object',
+    properties: {
+      name: {
+        type: 'string'
+      }
+    }
+  }
+}, [{
+  name: 'Matteo'
+}, {
+  name: 'Dave'
+}])
+
+buildTest({
+  title: 'array with strings',
+  type: 'array',
+  items: {
+    type: 'string'
+  }
+}, [
+  'Matteo',
+  'Dave'
+])
+
+buildTest({
+  title: 'array with numbers',
+  type: 'array',
+  items: {
+    type: 'number'
+  }
+}, [
+  42.42,
+  24
+])
+
+buildTest({
+  title: 'array with integers',
+  type: 'array',
+  items: {
+    type: 'number'
+  }
+}, [
+  42,
+  24
+])
+
+buildTest({
+  title: 'nested array with objects',
+  type: 'object',
+  properties: {
+    data: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          name: {
+            type: 'string'
+          }
+        }
+      }
+    }
+  }
+}, {
+  data: [{
+    name: 'Matteo'
+  }, {
+    name: 'Dave'
+  }]
+})
+
+buildTest({
+  title: 'object with boolean',
+  type: 'object',
+  properties: {
+    readonly: {
+      type: 'boolean'
+    }
+  }
+}, {
+  readonly: true
+})
+
+test('throw an error or coerce numbers and integers that are not numbers', (t) => {
+  const stringify = build({
+    title: 'basic',
+    type: 'object',
+    properties: {
+      age: {
+        type: 'number'
+      },
+      distance: {
+        type: 'integer'
+      }
+    }
+  })
+
+  t.assert.throws(() => {
+    stringify({ age: 'hello  ', distance: 'long' })
+  }, { message: 'The value "hello  " cannot be converted to a number.' })
+
+  const result = stringify({
+    age: '42',
+    distance: true
+  })
+
+  t.assert.deepStrictEqual(JSON.parse(result), { age: 42, distance: 1 })
+})
+
+test('Should throw on invalid schema', t => {
+  t.plan(1)
+  t.assert.throws(() => {
+    build({
+      type: 'Dinosaur',
+      properties: {
+        claws: { type: 'sharp' }
+      }
+    })
+  }, { message: 'schema is invalid: data/properties/claws/type must be equal to one of the allowed values' })
+})
+
+test('additionalProperties - throw on unknown type', (t) => {
+  t.plan(1)
+
+  t.assert.throws(() => {
+    build({
+      title: 'check array coerce',
+      type: 'object',
+      properties: {},
+      additionalProperties: {
+        type: 'strangetype'
+      }
+    })
+    t.fail('should be an invalid schema')
+  }, { message: 'schema is invalid: data/additionalProperties/type must be equal to one of the allowed values' })
+})
+
+test('patternProperties - throw on unknown type', (t) => {
+  t.plan(1)
+
+  t.assert.throws(() => {
+    build({
+      title: 'check array coerce',
+      type: 'object',
+      properties: {},
+      patternProperties: {
+        foo: {
+          type: 'strangetype'
+        }
+      }
+    })
+  }, { message: 'schema is invalid: data/patternProperties/foo/type must be equal to one of the allowed values' })
+})
+
+test('render a double quote as JSON /1', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string'
+  }
+  const toStringify = '" double quote'
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify(toStringify)
+
+  t.assert.equal(output, JSON.stringify(toStringify))
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
+test('render a double quote as JSON /2', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string'
+  }
+  const toStringify = 'double quote " 2'
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify(toStringify)
+
+  t.assert.equal(output, JSON.stringify(toStringify))
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
+test('render a long string', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string'
+  }
+  const toStringify = 'the Ultimate Question of Life, the Universe, and Everything.'
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify(toStringify)
+
+  t.assert.equal(output, JSON.stringify(toStringify))
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
+test('returns JSON.stringify if schema type is boolean', t => {
+  t.plan(1)
+
+  const schema = {
+    type: 'array',
+    items: true
+  }
+
+  const array = [1, true, 'test']
+  const stringify = build(schema)
+  t.assert.equal(stringify(array), JSON.stringify(array))
+})

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

@@ -0,0 +1,76 @@
+'use strict'
+
+const { test } = require('node:test')
+
+const build = require('..')
+
+test('render a bigint as JSON', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'bigint',
+    type: 'integer'
+  }
+
+  const stringify = build(schema)
+  const output = stringify(1615n)
+
+  t.assert.equal(output, '1615')
+})
+
+test('render an object with a bigint as JSON', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'object with bigint',
+    type: 'object',
+    properties: {
+      id: {
+        type: 'integer'
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  const output = stringify({
+    id: 1615n
+  })
+
+  t.assert.equal(output, '{"id":1615}')
+})
+
+test('render an array with a bigint as JSON', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'array with bigint',
+    type: 'array',
+    items: {
+      type: 'integer'
+    }
+  }
+
+  const stringify = build(schema)
+  const output = stringify([1615n])
+
+  t.assert.equal(output, '[1615]')
+})
+
+test('render an object with an additionalProperty of type bigint as JSON', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'object with bigint',
+    type: 'object',
+    additionalProperties: {
+      type: 'integer'
+    }
+  }
+
+  const stringify = build(schema)
+  const output = stringify({
+    num: 1615n
+  })
+
+  t.assert.equal(output, '{"num":1615}')
+})

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

@@ -0,0 +1,47 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('Should clean the cache', (t) => {
+  t.plan(1)
+
+  const schema = {
+    $id: 'test',
+    type: 'string'
+  }
+
+  t.assert.doesNotThrow(() => {
+    build(schema)
+    build(schema)
+  })
+})
+
+test('Should clean the cache with external schemas', (t) => {
+  t.plan(1)
+
+  const schema = {
+    $id: 'test',
+    definitions: {
+      def: {
+        type: 'object',
+        properties: {
+          str: {
+            type: 'string'
+          }
+        }
+      }
+    },
+    type: 'object',
+    properties: {
+      obj: {
+        $ref: '#/definitions/def'
+      }
+    }
+  }
+
+  t.assert.doesNotThrow(() => {
+    build(schema)
+    build(schema)
+  })
+})