@zuplo/cli 6.71.23 → 6.71.26

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

@@ -0,0 +1,183 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('external $ref schema should be reused, not inlined at every reference', (t) => {
+  t.plan(3)
+
+  const contactSchema = {
+    $id: 'contact.json',
+    type: 'object',
+    properties: {
+      firstName: { type: 'string' },
+      lastName: { type: 'string' },
+      email: { type: 'string' }
+    }
+  }
+
+  // Schema referencing the same external $ref multiple times
+  const parentSchema = {
+    type: 'object',
+    properties: {
+      owner: { $ref: 'contact.json' },
+      assignee: { $ref: 'contact.json' },
+      reporter: { $ref: 'contact.json' }
+    }
+  }
+
+  const serializer = build(parentSchema, { schema: { 'contact.json': contactSchema } })
+  const code = serializer.toString()
+
+  // The serialized function should contain extracted anonymous functions
+  // rather than inlining the full contact schema at every reference.
+  // With the fix, `firstName` appears 0 times in the main serializer body
+  // (it is inside the extracted function, which is not included in .toString())
+  // or at most 1 time if in a single extracted function.
+  const firstNameMatches = code.match(/firstName/g)
+  t.assert.ok(firstNameMatches === null || firstNameMatches.length <= 1,
+    `firstName should appear at most once (extracted function), got ${firstNameMatches ? firstNameMatches.length : 0}`)
+
+  // Verify correct serialization
+  const data = {
+    owner: { firstName: 'John', lastName: 'Doe', email: 'john@example.com' },
+    assignee: { firstName: 'Jane', lastName: 'Smith', email: 'jane@example.com' },
+    reporter: { firstName: 'Bob', lastName: 'Jones', email: 'bob@example.com' }
+  }
+
+  const output = serializer(data)
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, JSON.stringify(data))
+})
+
+test('external $ref schema reused with anyOf wrapping', (t) => {
+  t.plan(2)
+
+  const contactSchema = {
+    $id: 'contact.json',
+    type: 'object',
+    properties: {
+      firstName: { type: 'string' },
+      lastName: { type: 'string' },
+      email: { type: 'string' }
+    }
+  }
+
+  // Common pattern: anyOf wrapping $ref for polymorphic fields (populated object OR string ID OR null)
+  const parentSchema = {
+    type: 'object',
+    properties: {
+      owner: {
+        anyOf: [{ type: ['string', 'null'] }, { $ref: 'contact.json' }]
+      },
+      assignee: {
+        anyOf: [{ type: ['string', 'null'] }, { $ref: 'contact.json' }]
+      },
+      reporter: {
+        anyOf: [{ type: ['string', 'null'] }, { $ref: 'contact.json' }]
+      }
+    }
+  }
+
+  const serializer = build(parentSchema, { schema: { 'contact.json': contactSchema } })
+
+  // Serialize with populated objects
+  const data = {
+    owner: { firstName: 'John', lastName: 'Doe', email: 'john@example.com' },
+    assignee: { firstName: 'Jane', lastName: 'Smith', email: 'jane@example.com' },
+    reporter: { firstName: 'Bob', lastName: 'Jones', email: 'bob@example.com' }
+  }
+
+  const output = serializer(data)
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, JSON.stringify(data))
+})
+
+test('external $ref schema reused in array items', (t) => {
+  t.plan(2)
+
+  const contactSchema = {
+    $id: 'contact.json',
+    type: 'object',
+    properties: {
+      firstName: { type: 'string' },
+      lastName: { type: 'string' }
+    }
+  }
+
+  const parentSchema = {
+    type: 'object',
+    properties: {
+      contacts: {
+        type: 'array',
+        items: { $ref: 'contact.json' }
+      },
+      primary: { $ref: 'contact.json' },
+      secondary: { $ref: 'contact.json' }
+    }
+  }
+
+  const serializer = build(parentSchema, { schema: { 'contact.json': contactSchema } })
+
+  const data = {
+    contacts: [
+      { firstName: 'Alice', lastName: 'Wonder' },
+      { firstName: 'Bob', lastName: 'Builder' }
+    ],
+    primary: { firstName: 'Charlie', lastName: 'Charm' },
+    secondary: { firstName: 'Diana', lastName: 'Prince' }
+  }
+
+  const output = serializer(data)
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, JSON.stringify(data))
+})
+
+test('external array $ref schema should be reused, not inlined at every reference', (t) => {
+  t.plan(2)
+
+  const tagsSchema = {
+    $id: 'tags.json',
+    type: 'array',
+    items: { type: 'string' }
+  }
+
+  const parentSchema = {
+    type: 'object',
+    properties: {
+      a: { $ref: 'tags.json' },
+      b: { $ref: 'tags.json' },
+      c: { $ref: 'tags.json' }
+    }
+  }
+
+  const serializer = build(parentSchema, { schema: { 'tags.json': tagsSchema } })
+
+  const data = {
+    a: ['x', 'y'],
+    b: ['z'],
+    c: []
+  }
+
+  const output = serializer(data)
+  t.assert.doesNotThrow(() => JSON.parse(output))
+  t.assert.equal(output, JSON.stringify(data))
+})
+
+test('inline anonymous schemas should still be inlined (not extracted)', (t) => {
+  t.plan(1)
+
+  // Inline schemas (no external $ref) should continue to work normally
+  const schema = {
+    type: 'object',
+    properties: {
+      a: { type: 'object', properties: { x: { type: 'string' } } },
+      b: { type: 'object', properties: { x: { type: 'string' } } }
+    }
+  }
+
+  const serializer = build(schema)
+  const output = serializer({ a: { x: 'hello' }, b: { x: 'world' } })
+
+  t.assert.equal(output, '{"a":{"x":"hello"},"b":{"x":"world"}}')
+})

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

@@ -0,0 +1,57 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('additionalProperties: false', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'additionalProperties',
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      }
+    },
+    additionalProperties: false
+  })
+
+  const obj = { foo: 'a', bar: 'b', baz: 'c' }
+  t.assert.equal(stringify(obj), '{"foo":"a"}')
+})
+
+test('additionalProperties: {}', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'additionalProperties',
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      }
+    },
+    additionalProperties: {}
+  })
+
+  const obj = { foo: 'a', bar: 'b', baz: 'c' }
+  t.assert.equal(stringify(obj), '{"foo":"a","bar":"b","baz":"c"}')
+})
+
+test('additionalProperties: {type: string}', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'additionalProperties',
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      }
+    },
+    additionalProperties: {
+      type: 'string'
+    }
+  })
+
+  const obj = { foo: 'a', bar: 'b', baz: 'c' }
+  t.assert.equal(stringify(obj), '{"foo":"a","bar":"b","baz":"c"}')
+})

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/test/json-schema-test-suite/README.md

@@ -0,0 +1,10 @@
+# JSON-Schema-Test-Suite
+
+You can find all test cases [here](https://github.com/json-schema-org/JSON-Schema-Test-Suite).
+It contains a set of JSON objects that implementors of JSON Schema validation libraries can use to test their validators.
+
+# How to add another test case?
+
+1. Navigate to [JSON-Schema-Test-Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests)
+2. Choose a draft `draft4`, `draft6` or `draft7`
+3. Copy & paste the `test-case.json` to the project and add a test like in the `draft4.test.js`

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/test/json-schema-test-suite/draft4/required.json

@@ -0,0 +1,54 @@
+[
+    {
+        "description": "required validation",
+        "schema": {
+            "properties": {
+                "foo": {},
+                "bar": {}
+            },
+            "required": ["foo"]
+        },
+        "tests": [
+            {
+                "description": "present required property is valid",
+                "data": {"foo": 1},
+                "valid": true
+            },
+            {
+                "description": "non-present required property is invalid",
+                "data": {"bar": 1},
+                "valid": false
+            },
+            {
+                "description": "ignores arrays",
+                "data": [],
+                "valid": true
+            },
+            {
+                "description": "ignores strings",
+                "data": "",
+                "valid": true
+            },
+            {
+                "description": "ignores other non-objects",
+                "data": 12,
+                "valid": true
+            }
+        ]
+    },
+    {
+        "description": "required default validation",
+        "schema": {
+            "properties": {
+                "foo": {}
+            }
+        },
+        "tests": [
+            {
+                "description": "not required by default",
+                "data": {},
+                "valid": true
+            }
+        ]
+    }
+]

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/test/json-schema-test-suite/draft4.test.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const { test } = require('node:test')
+const { counTests, runTests } = require('./util')
+
+const requiredTestSuite = require('./draft4/required.json')
+
+test('required', async (t) => {
+  const skippedTests = ['ignores arrays', 'ignores strings', 'ignores other non-objects']
+  t.plan(counTests(requiredTestSuite, skippedTests))
+  await runTests(t, requiredTestSuite, skippedTests)
+})

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/test/json-schema-test-suite/draft6/required.json

@@ -0,0 +1,70 @@
+[
+    {
+        "description": "required validation",
+        "schema": {
+            "properties": {
+                "foo": {},
+                "bar": {}
+            },
+            "required": ["foo"]
+        },
+        "tests": [
+            {
+                "description": "present required property is valid",
+                "data": {"foo": 1},
+                "valid": true
+            },
+            {
+                "description": "non-present required property is invalid",
+                "data": {"bar": 1},
+                "valid": false
+            },
+            {
+                "description": "ignores arrays",
+                "data": [],
+                "valid": true
+            },
+            {
+                "description": "ignores strings",
+                "data": "",
+                "valid": true
+            },
+            {
+                "description": "ignores other non-objects",
+                "data": 12,
+                "valid": true
+            }
+        ]
+    },
+    {
+        "description": "required default validation",
+        "schema": {
+            "properties": {
+                "foo": {}
+            }
+        },
+        "tests": [
+            {
+                "description": "not required by default",
+                "data": {},
+                "valid": true
+            }
+        ]
+    },
+    {
+        "description": "required with empty array",
+        "schema": {
+            "properties": {
+                "foo": {}
+            },
+            "required": []
+        },
+        "tests": [
+            {
+                "description": "property not required",
+                "data": {},
+                "valid": true
+            }
+        ]
+    }
+]

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/test/json-schema-test-suite/draft6.test.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const { test } = require('node:test')
+const { counTests, runTests } = require('./util')
+
+const requiredTestSuite = require('./draft6/required.json')
+
+test('required', async (t) => {
+  const skippedTests = ['ignores arrays', 'ignores strings', 'ignores other non-objects']
+  t.plan(counTests(requiredTestSuite, skippedTests))
+  await runTests(t, requiredTestSuite, skippedTests)
+})

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/test/json-schema-test-suite/draft7/required.json

@@ -0,0 +1,70 @@
+[
+    {
+        "description": "required validation",
+        "schema": {
+            "properties": {
+                "foo": {},
+                "bar": {}
+            },
+            "required": ["foo"]
+        },
+        "tests": [
+            {
+                "description": "present required property is valid",
+                "data": {"foo": 1},
+                "valid": true
+            },
+            {
+                "description": "non-present required property is invalid",
+                "data": {"bar": 1},
+                "valid": false
+            },
+            {
+                "description": "ignores arrays",
+                "data": [],
+                "valid": true
+            },
+            {
+                "description": "ignores strings",
+                "data": "",
+                "valid": true
+            },
+            {
+                "description": "ignores other non-objects",
+                "data": 12,
+                "valid": true
+            }
+        ]
+    },
+    {
+        "description": "required default validation",
+        "schema": {
+            "properties": {
+                "foo": {}
+            }
+        },
+        "tests": [
+            {
+                "description": "not required by default",
+                "data": {},
+                "valid": true
+            }
+        ]
+    },
+    {
+        "description": "required with empty array",
+        "schema": {
+            "properties": {
+                "foo": {}
+            },
+            "required": []
+        },
+        "tests": [
+            {
+                "description": "property not required",
+                "data": {},
+                "valid": true
+            }
+        ]
+    }
+]

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/test/json-schema-test-suite/draft7.test.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const { test } = require('node:test')
+const { counTests, runTests } = require('./util')
+
+const requiredTestSuite = require('./draft7/required.json')
+
+test('required', async (t) => {
+  const skippedTests = ['ignores arrays', 'ignores strings', 'ignores other non-objects']
+  t.plan(counTests(requiredTestSuite, skippedTests))
+  await runTests(t, requiredTestSuite, skippedTests)
+})

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/test/json-schema-test-suite/util.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const build = require('../..')
+
+async function runTests (t, testsuite, skippedTests) {
+  for (const scenario of testsuite) {
+    const stringify = build(scenario.schema)
+    for (const test of scenario.tests) {
+      if (skippedTests.indexOf(test.description) !== -1) {
+        console.log(`skip ${test.description}`)
+        continue
+      }
+
+      await t.test(test.description, (t) => {
+        t.plan(1)
+        try {
+          const output = stringify(test.data)
+          t.assert.equal(output, JSON.stringify(test.data), 'compare payloads')
+        } catch (err) {
+          t.assert.ok(test.valid === false, 'payload should be valid: ' + err.message)
+        }
+      })
+    }
+  }
+}
+
+function counTests (ts, skippedTests) {
+  return ts.reduce((a, b) => a + b.tests.length, 0) - skippedTests.length
+}
+
+module.exports = { runTests, counTests }

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

@@ -0,0 +1,88 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('missing values', (t) => {
+  t.plan(3)
+
+  const stringify = build({
+    title: 'object with missing values',
+    type: 'object',
+    properties: {
+      str: {
+        type: 'string'
+      },
+      num: {
+        type: 'number'
+      },
+      val: {
+        type: 'string'
+      }
+    }
+  })
+
+  t.assert.equal('{"val":"value"}', stringify({ val: 'value' }))
+  t.assert.equal('{"str":"string","val":"value"}', stringify({ str: 'string', val: 'value' }))
+  t.assert.equal('{"str":"string","num":42,"val":"value"}', stringify({ str: 'string', num: 42, val: 'value' }))
+})
+
+test('handle null when value should be string', (t) => {
+  t.plan(1)
+
+  const stringify = build({
+    type: 'object',
+    properties: {
+      str: {
+        type: 'string'
+      }
+    }
+  })
+
+  t.assert.equal('{"str":""}', stringify({ str: null }))
+})
+
+test('handle null when value should be integer', (t) => {
+  t.plan(1)
+
+  const stringify = build({
+    type: 'object',
+    properties: {
+      int: {
+        type: 'integer'
+      }
+    }
+  })
+
+  t.assert.equal('{"int":0}', stringify({ int: null }))
+})
+
+test('handle null when value should be number', (t) => {
+  t.plan(1)
+
+  const stringify = build({
+    type: 'object',
+    properties: {
+      num: {
+        type: 'number'
+      }
+    }
+  })
+
+  t.assert.equal('{"num":0}', stringify({ num: null }))
+})
+
+test('handle null when value should be boolean', (t) => {
+  t.plan(1)
+
+  const stringify = build({
+    type: 'object',
+    properties: {
+      bool: {
+        type: 'boolean'
+      }
+    }
+  })
+
+  t.assert.equal('{"bool":false}', stringify({ bool: null }))
+})

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/test/multi-type-serializer.test.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('should throw a TypeError with the path to the key of the invalid value', (t) => {
+  t.plan(1)
+  const schema = {
+    type: 'object',
+    properties: {
+      num: {
+        type: ['number']
+      }
+    }
+  }
+
+  const stringify = build(schema)
+  t.assert.throws(() => stringify({ num: { bla: 123 } }), new TypeError('The value of \'#/properties/num\' does not match schema definition.'))
+})

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

@@ -0,0 +1,63 @@
+'use strict'
+
+const { test } = require('node:test')
+const build = require('..')
+
+test('nested objects with same properties', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'nested objects with same properties',
+    type: 'object',
+    properties: {
+      stringProperty: {
+        type: 'string'
+      },
+      objectProperty: {
+        type: 'object',
+        additionalProperties: true
+      }
+    }
+  }
+  const stringify = build(schema)
+
+  const value = stringify({
+    stringProperty: 'string1',
+    objectProperty: {
+      stringProperty: 'string2',
+      numberProperty: 42
+    }
+  })
+  t.assert.equal(value, '{"stringProperty":"string1","objectProperty":{"stringProperty":"string2","numberProperty":42}}')
+})
+
+test('names collision', (t) => {
+  t.plan(1)
+
+  const schema = {
+    title: 'nested objects with same properties',
+    type: 'object',
+    properties: {
+      test: {
+        type: 'object',
+        properties: {
+          a: { type: 'string' }
+        }
+      },
+      tes: {
+        type: 'object',
+        properties: {
+          b: { type: 'string' },
+          t: { type: 'object' }
+        }
+      }
+    }
+  }
+  const stringify = build(schema)
+  const data = {
+    test: { a: 'a' },
+    tes: { b: 'b', t: {} }
+  }
+
+  t.assert.equal(stringify(data), JSON.stringify(data))
+})