@zuplo/cli 6.71.23 → 6.71.26

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

@@ -0,0 +1,32 @@
+'use strict'
+
+const { test } = require('node:test')
+const validator = require('is-my-json-valid')
+const build = require('..')
+
+test('object with RexExp', (t) => {
+  t.plan(3)
+
+  const schema = {
+    title: 'object with RegExp',
+    type: 'object',
+    properties: {
+      reg: {
+        type: 'string'
+      }
+    }
+  }
+
+  const obj = {
+    reg: /"([^"]|\\")*"/
+  }
+
+  const stringify = build(schema)
+  const validate = validator(schema)
+  const output = stringify(obj)
+
+  t.assert.doesNotThrow(() => JSON.parse(output))
+
+  t.assert.equal(obj.reg.source, new RegExp(JSON.parse(output).reg).source)
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
+})

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

@@ -0,0 +1,204 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('object with required field', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'object with required field',
+    type: 'object',
+    properties: {
+      str: {
+        type: 'string'
+      },
+      num: {
+        type: 'integer'
+      }
+    },
+    required: ['str']
+  }
+  const stringify = build(schema)
+
+  t.assert.doesNotThrow(() => {
+    stringify({
+      str: 'string'
+    })
+  })
+
+  t.assert.throws(() => {
+    stringify({
+      num: 42
+    })
+  }, { message: '"str" is required!' })
+})
+
+test('object with required field not in properties schema', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'object with required field',
+    type: 'object',
+    properties: {
+      num: {
+        type: 'integer'
+      }
+    },
+    required: ['str']
+  }
+  const stringify = build(schema)
+
+  t.assert.throws(() => {
+    stringify({})
+  }, { message: '"str" is required!' })
+
+  t.assert.throws(() => {
+    stringify({
+      num: 42
+    })
+  }, { message: '"str" is required!' })
+})
+
+test('object with required field not in properties schema with additional properties true', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'object with required field',
+    type: 'object',
+    properties: {
+      num: {
+        type: 'integer'
+      }
+    },
+    additionalProperties: true,
+    required: ['str']
+  }
+  const stringify = build(schema)
+
+  t.assert.throws(() => {
+    stringify({})
+  }, { message: '"str" is required!' })
+
+  t.assert.throws(() => {
+    stringify({
+      num: 42
+    })
+  }, { message: '"str" is required!' })
+})
+
+test('object with multiple required field not in properties schema', (t) => {
+  t.plan(3)
+
+  const schema = {
+    title: 'object with required field',
+    type: 'object',
+    properties: {
+      num: {
+        type: 'integer'
+      }
+    },
+    additionalProperties: true,
+    required: ['num', 'key1', 'key2']
+  }
+  const stringify = build(schema)
+
+  t.assert.throws(() => {
+    stringify({})
+  }, { message: '"key1" is required!' })
+
+  t.assert.throws(() => {
+    stringify({
+      key1: 42,
+      key2: 42
+    })
+  }, { message: '"num" is required!' })
+
+  t.assert.throws(() => {
+    stringify({
+      num: 42,
+      key1: 'some'
+    })
+  }, { message: '"key2" is required!' })
+})
+
+test('object with required bool', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'object with required field',
+    type: 'object',
+    properties: {
+      num: {
+        type: 'integer'
+      }
+    },
+    additionalProperties: true,
+    required: ['bool']
+  }
+  const stringify = build(schema)
+
+  t.assert.throws(() => {
+    stringify({})
+  }, { message: '"bool" is required!' })
+
+  t.assert.doesNotThrow(() => {
+    stringify({
+      bool: false
+    })
+  })
+})
+
+test('required nullable', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'object with required field',
+    type: 'object',
+    properties: {
+      num: {
+        type: ['integer']
+      }
+    },
+    additionalProperties: true,
+    required: ['null']
+  }
+  const stringify = build(schema)
+
+  t.assert.doesNotThrow(() => {
+    stringify({
+      null: null
+    })
+  })
+})
+
+test('required numbers', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'object with required field',
+    type: 'object',
+    properties: {
+      str: {
+        type: 'string'
+      },
+      num: {
+        type: 'integer'
+      }
+    },
+    required: ['num']
+  }
+  const stringify = build(schema)
+
+  t.assert.doesNotThrow(() => {
+    stringify({
+      num: 42
+    })
+  })
+
+  t.assert.throws(() => {
+    stringify({
+      num: 'aaa'
+    })
+  }, { message: 'The value "aaa" cannot be converted to an integer.' })
+})

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

@@ -0,0 +1,50 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('nested ref requires ajv', async t => {
+  t.test('nested ref requires ajv', async t => {
+    const schemaA = {
+      $id: 'urn:schema:a',
+      definitions: {
+        foo: { anyOf: [{ type: 'string' }, { type: 'null' }] }
+      }
+    }
+
+    const schemaB = {
+      $id: 'urn:schema:b',
+      type: 'object',
+      properties: {
+        results: {
+          type: 'object',
+          properties: {
+            items: {
+              type: 'object',
+              properties: {
+                bar: {
+                  type: 'array',
+                  items: { $ref: 'urn:schema:a#/definitions/foo' }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    const stringify = build(schemaB, {
+      schema: {
+        [schemaA.$id]: schemaA
+      }
+    })
+    const result = stringify({
+      results: {
+        items: {
+          bar: ['baz']
+        }
+      }
+    })
+    t.assert.equal(result, '{"results":{"items":{"bar":["baz"]}}}')
+  })
+})

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

@@ -0,0 +1,141 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+const stringify = build({
+  title: 'Example Schema',
+  type: 'object',
+  properties: {
+    firstName: {
+      type: 'string'
+    },
+    lastName: {
+      type: 'string'
+    },
+    age: {
+      description: 'Age in years"',
+      type: 'integer'
+    },
+    [(() => "phra'&& process.exit(1) ||'phra")()]: {},
+    now: {
+      type: 'string'
+    },
+    reg: {
+      type: 'string',
+      default: 'a\'&& process.exit(1) ||\''
+    },
+    obj: {
+      type: 'object',
+      properties: {
+        bool: {
+          type: 'boolean'
+        }
+      }
+    },
+    '"\'w00t': {
+      type: 'string',
+      default: '"\'w00t'
+    },
+    arr: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          'phra\' && process.exit(1)//': {
+            type: 'number'
+          },
+          str: {
+            type: 'string'
+          }
+        }
+      }
+    }
+  },
+  required: ['now'],
+  patternProperties: {
+    '.*foo$': {
+      type: 'string'
+    },
+    test: {
+      type: 'number'
+    },
+    'phra\'/ && process.exit(1) && /\'': {
+      type: 'number'
+    },
+    '"\'w00t.*////': {
+      type: 'number'
+    }
+  },
+  additionalProperties: {
+    type: 'string'
+  }
+})
+
+const obj = {
+  firstName: 'Matteo',
+  lastName: 'Collina',
+  age: 32,
+  now: new Date(),
+  foo: 'hello"',
+  bar: "world'",
+  'fuzz"': 42,
+  "me'": 42,
+  numfoo: 42,
+  test: 42,
+  strtest: '23',
+  arr: [{ 'phra\' && process.exit(1)//': 42 }],
+  obj: { bool: true },
+  notmatch: 'valar morghulis',
+  notmatchobj: { a: true },
+  notmatchnum: 42
+}
+
+test('sanitize', t => {
+  const json = stringify(obj)
+  t.assert.doesNotThrow(() => JSON.parse(json))
+
+  const stringify2 = build({
+    title: 'Example Schema',
+    type: 'object',
+    patternProperties: {
+      '"\'w00t.*////': {
+        type: 'number'
+      }
+    }
+  })
+
+  t.assert.deepStrictEqual(JSON.parse(stringify2({
+    '"\'phra////': 42,
+    asd: 42
+  })), {
+  })
+
+  const stringify3 = build({
+    title: 'Example Schema',
+    type: 'object',
+    properties: {
+      "\"phra\\'&&(console.log(42))//||'phra": {}
+    }
+  })
+
+  // this verifies the escaping
+  JSON.parse(stringify3({
+    '"phra\'&&(console.log(42))//||\'phra': 42
+  }))
+
+  const stringify4 = build({
+    title: 'Example Schema',
+    type: 'object',
+    properties: {
+      '"\\\\\\\\\'w00t': {
+        type: 'string',
+        default: '"\'w00t'
+      }
+    }
+  })
+
+  t.assert.deepStrictEqual(JSON.parse(stringify4({})), {
+    '"\\\\\\\\\'w00t': '"\'w00t'
+  })
+})

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

@@ -0,0 +1,18 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('sanitize 2', t => {
+  const payload = '(throw "pwoned")'
+
+  const stringify = build({
+    properties: {
+      [`*///\\\\\\']);${payload};{/*`]: {
+        type: 'number'
+      }
+    }
+  })
+
+  t.assert.doesNotThrow(() => stringify({}))
+})

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

@@ -0,0 +1,17 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('sanitize 3', t => {
+  t.assert.throws(() => {
+    build({
+      $defs: {
+        type: 'foooo"bar'
+      },
+      patternProperties: {
+        x: { $ref: '#/$defs' }
+      }
+    })
+  }, { message: 'foooo"bar unsupported' })
+})

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

@@ -0,0 +1,16 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('sanitize 4', t => {
+  const payload = '(throw "pwoned")'
+
+  const stringify = build({
+    required: [`"];${payload}//`]
+  })
+
+  t.assert.throws(() => {
+    stringify({})
+  }, { message: '""];(throw "pwoned")//" is required!' })
+})

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

@@ -0,0 +1,16 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('sanitize 5', t => {
+  const payload = '(throw "pwoned")'
+
+  t.assert.throws(() => {
+    build({
+      patternProperties: {
+        '*': { type: `*/${payload}){//` }
+      }
+    })
+  }, { message: 'schema is invalid: data/patternProperties must match format "regex"' })
+})

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

@@ -0,0 +1,22 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('sanitize 6', t => {
+  const payload = '(throw "pwoned")'
+
+  const stringify = build({
+    type: 'object',
+    properties: {
+      '/*': { type: 'object' },
+      x: {
+        type: 'object',
+        properties: {
+          a: { type: 'string', default: `*/}${payload};{//` }
+        }
+      }
+    }
+  })
+  t.assert.doesNotThrow(() => { stringify({}) })
+})

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

@@ -0,0 +1,68 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('required property containing single quote, contains property', (t) => {
+  t.plan(1)
+
+  const stringify = build({
+    type: 'object',
+    properties: {
+      '\'': { type: 'string' }
+    },
+    required: [
+      '\''
+    ]
+  })
+
+  t.assert.throws(() => stringify({}), new Error('"\'" is required!'))
+})
+
+test('required property containing double quote, contains property', (t) => {
+  t.plan(1)
+
+  const stringify = build({
+    type: 'object',
+    properties: {
+      '"': { type: 'string' }
+    },
+    required: [
+      '"'
+    ]
+  })
+
+  t.assert.throws(() => stringify({}), new Error('""" is required!'))
+})
+
+test('required property containing single quote, does not contain property', (t) => {
+  t.plan(1)
+
+  const stringify = build({
+    type: 'object',
+    properties: {
+      a: { type: 'string' }
+    },
+    required: [
+      '\''
+    ]
+  })
+
+  t.assert.throws(() => stringify({}), new Error('"\'" is required!'))
+})
+
+test('required property containing double quote, does not contain property', (t) => {
+  t.plan(1)
+
+  const stringify = build({
+    type: 'object',
+    properties: {
+      a: { type: 'string' }
+    },
+    required: [
+      '"'
+    ]
+  })
+
+  t.assert.throws(() => stringify({}), new Error('""" is required!'))
+})