@zuplo/cli 6.71.23 → 6.71.25

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

@@ -0,0 +1,510 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('object with multiple types field', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'object with multiple types field',
+    type: 'object',
+    properties: {
+      str: {
+        oneOf: [{
+          type: 'string'
+        }, {
+          type: 'boolean'
+        }]
+      }
+    }
+  }
+  const stringify = build(schema)
+
+  t.assert.equal(stringify({ str: 'string' }), '{"str":"string"}')
+  t.assert.equal(stringify({ str: true }), '{"str":true}')
+})
+
+test('object with field of type object or null', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'object with field of type object or null',
+    type: 'object',
+    properties: {
+      prop: {
+        oneOf: [{
+          type: 'object',
+          properties: {
+            str: {
+              type: 'string'
+            }
+          }
+        }, {
+          type: 'null'
+        }]
+      }
+    }
+  }
+  const stringify = build(schema)
+
+  t.assert.equal(stringify({ prop: null }), '{"prop":null}')
+
+  t.assert.equal(stringify({
+    prop: {
+      str: 'string', remove: 'this'
+    }
+  }), '{"prop":{"str":"string"}}')
+})
+
+test('object with field of type object or array', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'object with field of type object or array',
+    type: 'object',
+    properties: {
+      prop: {
+        oneOf: [{
+          type: 'object',
+          properties: {},
+          additionalProperties: true
+        }, {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        }]
+      }
+    }
+  }
+  const stringify = build(schema)
+
+  t.assert.equal(stringify({
+    prop: { str: 'string' }
+  }), '{"prop":{"str":"string"}}')
+
+  t.assert.equal(stringify({
+    prop: ['string']
+  }), '{"prop":["string"]}')
+})
+
+test('object with field of type string and coercion disable ', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'object with field of type string',
+    type: 'object',
+    properties: {
+      str: {
+        oneOf: [{
+          type: 'string'
+        }]
+      }
+    }
+  }
+  const stringify = build(schema)
+  t.assert.throws(() => stringify({ str: 1 }))
+})
+
+test('object with field of type string and coercion enable ', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'object with field of type string',
+    type: 'object',
+    properties: {
+      str: {
+        oneOf: [{
+          type: 'string'
+        }]
+      }
+    }
+  }
+
+  const options = {
+    ajv: {
+      coerceTypes: true
+    }
+  }
+  const stringify = build(schema, options)
+
+  const value = stringify({
+    str: 1
+  })
+  t.assert.equal(value, '{"str":"1"}')
+})
+
+test('object with field with type union of multiple objects', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'object with oneOf property value containing objects',
+    type: 'object',
+    properties: {
+      oneOfSchema: {
+        oneOf: [
+          {
+            type: 'object',
+            properties: {
+              baz: { type: 'number' }
+            },
+            required: ['baz']
+          },
+          {
+            type: 'object',
+            properties: {
+              bar: { type: 'string' }
+            },
+            required: ['bar']
+          }
+        ]
+      }
+    },
+    required: ['oneOfSchema']
+  }
+
+  const stringify = build(schema)
+
+  t.assert.equal(stringify({ oneOfSchema: { baz: 5 } }), '{"oneOfSchema":{"baz":5}}')
+
+  t.assert.equal(stringify({ oneOfSchema: { bar: 'foo' } }), '{"oneOfSchema":{"bar":"foo"}}')
+})
+
+test('null value in schema', (t) => {
+  t.plan(0)
+
+  const schema = {
+    title: 'schema with null child',
+    type: 'string',
+    nullable: true,
+    enum: [null]
+  }
+
+  build(schema)
+})
+
+test('oneOf and $ref together', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      cs: {
+        oneOf: [
+          {
+            $ref: '#/definitions/Option'
+          },
+          {
+            type: 'boolean'
+          }
+        ]
+      }
+    },
+    definitions: {
+      Option: {
+        type: 'string'
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  t.assert.equal(stringify({ cs: 'franco' }), '{"cs":"franco"}')
+
+  t.assert.equal(stringify({ cs: true }), '{"cs":true}')
+})
+
+test('oneOf and $ref: 2 levels are fine', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      cs: {
+        oneOf: [
+          {
+            $ref: '#/definitions/Option'
+          },
+          {
+            type: 'boolean'
+          }
+        ]
+      }
+    },
+    definitions: {
+      Option: {
+        oneOf: [
+          {
+            type: 'number'
+          },
+          {
+            type: 'boolean'
+          }
+        ]
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  const value = stringify({
+    cs: 3
+  })
+  t.assert.equal(value, '{"cs":3}')
+})
+
+test('oneOf and $ref: multiple levels should throw at build.', (t) => {
+  t.plan(3)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      cs: {
+        oneOf: [
+          {
+            $ref: '#/definitions/Option'
+          },
+          {
+            type: 'boolean'
+          }
+        ]
+      }
+    },
+    definitions: {
+      Option: {
+        oneOf: [
+          {
+            $ref: '#/definitions/Option2'
+          },
+          {
+            type: 'string'
+          }
+        ]
+      },
+      Option2: {
+        type: 'number'
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  t.assert.equal(stringify({ cs: 3 }), '{"cs":3}')
+  t.assert.equal(stringify({ cs: true }), '{"cs":true}')
+  t.assert.equal(stringify({ cs: 'pippo' }), '{"cs":"pippo"}')
+})
+
+test('oneOf and $ref - multiple external $ref', (t) => {
+  t.plan(2)
+
+  const externalSchema = {
+    external: {
+      definitions: {
+        def: {
+          type: 'object',
+          properties: {
+            prop: { oneOf: [{ $ref: 'external2#/definitions/other' }] }
+          }
+        }
+      }
+    },
+    external2: {
+      definitions: {
+        internal: {
+          type: 'string'
+        },
+        other: {
+          type: 'object',
+          properties: {
+            prop2: { $ref: '#/definitions/internal' }
+          }
+        }
+      }
+    }
+  }
+
+  const schema = {
+    title: 'object with $ref',
+    type: 'object',
+    properties: {
+      obj: {
+        $ref: 'external#/definitions/def'
+      }
+    }
+  }
+
+  const object = {
+    obj: {
+      prop: {
+        prop2: 'test'
+      }
+    }
+  }
+
+  const stringify = build(schema, { schema: externalSchema })
+  const output = stringify(object)
+
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, '{"obj":{"prop":{"prop2":"test"}}}')
+})
+
+test('oneOf with enum with more than 100 entries', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'type array that may have one of declared items',
+    type: 'array',
+    items: {
+      oneOf: [
+        {
+          type: 'string',
+          enum: ['EUR', 'USD', ...(new Set([...new Array(200)].map(() => Math.random().toString(36).substr(2, 3)))).values()]
+        },
+        { type: 'null' }
+      ]
+    }
+  }
+  const stringify = build(schema)
+
+  const value = stringify(['EUR', 'USD', null])
+  t.assert.equal(value, '["EUR","USD",null]')
+})
+
+test('oneOf object with field of type string with format or null', (t) => {
+  t.plan(1)
+
+  const toStringify = new Date()
+
+  const withOneOfSchema = {
+    type: 'object',
+    properties: {
+      prop: {
+        oneOf: [{
+          type: 'string',
+          format: 'date-time'
+        }, {
+          type: 'null'
+        }]
+      }
+    }
+  }
+
+  const withOneOfStringify = build(withOneOfSchema)
+
+  t.assert.equal(withOneOfStringify({
+    prop: toStringify
+  }), `{"prop":"${toStringify.toISOString()}"}`)
+})
+
+test('one array item match oneOf types', (t) => {
+  t.plan(3)
+
+  const schema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['data'],
+    properties: {
+      data: {
+        type: 'array',
+        minItems: 1,
+        items: {
+          oneOf: [
+            {
+              type: 'string'
+            },
+            {
+              type: 'number'
+            }
+          ]
+        }
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  t.assert.equal(stringify({ data: ['foo'] }), '{"data":["foo"]}')
+  t.assert.equal(stringify({ data: [1] }), '{"data":[1]}')
+  t.assert.throws(() => stringify({ data: [false, 'foo'] }))
+})
+
+test('some array items match oneOf types', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['data'],
+    properties: {
+      data: {
+        type: 'array',
+        minItems: 1,
+        items: {
+          oneOf: [
+            {
+              type: 'string'
+            },
+            {
+              type: 'number'
+            }
+          ]
+        }
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  t.assert.equal(stringify({ data: ['foo', 5] }), '{"data":["foo",5]}')
+  t.assert.throws(() => stringify({ data: [false, 'foo', true, 5] }))
+})
+
+test('all array items does not match oneOf types', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['data'],
+    properties: {
+      data: {
+        type: 'array',
+        minItems: 1,
+        items: {
+          oneOf: [
+            {
+              type: 'string'
+            },
+            {
+              type: 'number'
+            }
+          ]
+        }
+      }
+    }
+  }
+
+  const stringify = build(schema)
+
+  t.assert.throws(() => stringify({ data: [null, false, true, undefined, [], {}] }))
+})
+
+test('invalid oneOf schema', (t) => {
+  t.plan(1)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      prop: {
+        oneOf: 'not array'  // invalid, oneOf must be array
+      }
+    }
+  }
+
+  try {
+    build(schema)
+    t.assert.fail('Should throw')
+  } catch (err) {
+    t.assert.ok(err.message.includes('schema is invalid'))
+  }
+})

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

@@ -0,0 +1,168 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('patternProperties', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'patternProperties',
+    type: 'object',
+    properties: {
+      str: {
+        type: 'string'
+      }
+    },
+    patternProperties: {
+      foo: {
+        type: 'string'
+      }
+    }
+  })
+
+  const obj = { str: 'test', foo: 42, ofoo: true, foof: 'string', objfoo: { a: true }, notMe: false }
+  t.assert.equal(stringify(obj), '{"str":"test","foo":"42","ofoo":"true","foof":"string","objfoo":"[object Object]"}')
+})
+
+test('patternProperties should not change properties', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'patternProperties should not change properties',
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      }
+    },
+    patternProperties: {
+      foo: {
+        type: 'number'
+      }
+    }
+  })
+
+  const obj = { foo: '42', ofoo: 42 }
+  t.assert.equal(stringify(obj), '{"foo":"42","ofoo":42}')
+})
+
+test('patternProperties - string coerce', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'check string coerce',
+    type: 'object',
+    properties: {},
+    patternProperties: {
+      foo: {
+        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('patternProperties - number coerce', (t) => {
+  t.plan(2)
+  const stringify = build({
+    title: 'check number coerce',
+    type: 'object',
+    properties: {},
+    patternProperties: {
+      foo: {
+        type: 'number'
+      }
+    }
+  })
+
+  const coercibleValues = { foo: true, ofoo: '42' }
+  t.assert.equal(stringify(coercibleValues), '{"foo":1,"ofoo":42}')
+
+  const incoercibleValues = { xfoo: 'string', arrfoo: [1, 2], objfoo: { num: 42 } }
+  try {
+    stringify(incoercibleValues)
+    t.fail('should throw an error')
+  } catch (err) {
+    t.assert.ok(err)
+  }
+})
+
+test('patternProperties - boolean coerce', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'check boolean coerce',
+    type: 'object',
+    properties: {},
+    patternProperties: {
+      foo: {
+        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('patternProperties - object coerce', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'check object coerce',
+    type: 'object',
+    properties: {},
+    patternProperties: {
+      foo: {
+        type: 'object',
+        properties: {
+          answer: {
+            type: 'number'
+          }
+        }
+      }
+    }
+  })
+
+  const obj = { objfoo: { answer: 42 } }
+  t.assert.equal(stringify(obj), '{"objfoo":{"answer":42}}')
+})
+
+test('patternProperties - array coerce', (t) => {
+  t.plan(2)
+  const stringify = build({
+    title: 'check array coerce',
+    type: 'object',
+    properties: {},
+    patternProperties: {
+      foo: {
+        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('patternProperties - fail on invalid regex, handled by ajv', (t) => {
+  t.plan(1)
+
+  t.assert.throws(() => build({
+    title: 'check array coerce',
+    type: 'object',
+    properties: {},
+    patternProperties: {
+      'foo/\\': {
+        type: 'array',
+        items: {
+          type: 'string'
+        }
+      }
+    }
+  }), new Error('schema is invalid: data/patternProperties must match format "regex"'))
+})