@zuplo/cli 6.71.23 → 6.71.26

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

@@ -0,0 +1,196 @@
+'use strict'
+
+const { test } = require('node:test')
+const clone = require('rfdc/default')
+const build = require('..')
+
+test('oneOf with $ref should not change the input schema', t => {
+  t.plan(2)
+
+  const referenceSchema = {
+    $id: 'externalId',
+    type: 'object',
+    properties: {
+      name: { type: 'string' }
+    }
+  }
+
+  const schema = {
+    $id: 'mainSchema',
+    type: 'object',
+    properties: {
+      people: {
+        oneOf: [{ $ref: 'externalId' }]
+      }
+    }
+  }
+  const clonedSchema = clone(schema)
+  const stringify = build(schema, {
+    schema: {
+      [referenceSchema.$id]: referenceSchema
+    }
+  })
+
+  const value = stringify({ people: { name: 'hello', foo: 'bar' } })
+  t.assert.equal(value, '{"people":{"name":"hello"}}')
+  t.assert.deepStrictEqual(schema, clonedSchema)
+})
+
+test('oneOf and anyOf with $ref should not change the input schema', t => {
+  t.plan(3)
+
+  const referenceSchema = {
+    $id: 'externalSchema',
+    type: 'object',
+    properties: {
+      name: { type: 'string' }
+    }
+  }
+
+  const schema = {
+    $id: 'rootSchema',
+    type: 'object',
+    properties: {
+      people: {
+        oneOf: [{ $ref: 'externalSchema' }]
+      },
+      love: {
+        anyOf: [
+          { $ref: '#/definitions/foo' },
+          { type: 'boolean' }
+        ]
+      }
+    },
+    definitions: {
+      foo: { type: 'string' }
+    }
+  }
+  const clonedSchema = clone(schema)
+  const stringify = build(schema, {
+    schema: {
+      [referenceSchema.$id]: referenceSchema
+    }
+  })
+
+  const valueAny1 = stringify({ people: { name: 'hello', foo: 'bar' }, love: 'music' })
+  const valueAny2 = stringify({ people: { name: 'hello', foo: 'bar' }, love: true })
+
+  t.assert.equal(valueAny1, '{"people":{"name":"hello"},"love":"music"}')
+  t.assert.equal(valueAny2, '{"people":{"name":"hello"},"love":true}')
+  t.assert.deepStrictEqual(schema, clonedSchema)
+})
+
+test('multiple $ref tree', t => {
+  t.plan(2)
+
+  const referenceDeepSchema = {
+    $id: 'deepId',
+    type: 'number'
+  }
+
+  const referenceSchema = {
+    $id: 'externalId',
+    type: 'object',
+    properties: {
+      name: { $ref: '#/definitions/foo' },
+      age: { $ref: 'deepId' }
+    },
+    definitions: {
+      foo: { type: 'string' }
+    }
+  }
+
+  const schema = {
+    $id: 'mainSchema',
+    type: 'object',
+    properties: {
+      people: {
+        oneOf: [{ $ref: 'externalId' }]
+      }
+    }
+  }
+  const clonedSchema = clone(schema)
+  const stringify = build(schema, {
+    schema: {
+      [referenceDeepSchema.$id]: referenceDeepSchema,
+      [referenceSchema.$id]: referenceSchema
+    }
+  })
+
+  const value = stringify({ people: { name: 'hello', foo: 'bar', age: 42 } })
+  t.assert.equal(value, '{"people":{"name":"hello","age":42}}')
+  t.assert.deepStrictEqual(schema, clonedSchema)
+})
+
+test('must not mutate items $ref', t => {
+  t.plan(2)
+
+  const referenceSchema = {
+    $id: 'ShowSchema',
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    type: 'object',
+    properties: {
+      name: {
+        type: 'string'
+      }
+    }
+  }
+
+  const schema = {
+    $id: 'ListSchema',
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    type: 'array',
+    items: {
+      $ref: 'ShowSchema#'
+    }
+  }
+  const clonedSchema = clone(schema)
+  const stringify = build(schema, {
+    schema: {
+      [referenceSchema.$id]: referenceSchema
+    }
+  })
+
+  const value = stringify([{ name: 'foo' }])
+  t.assert.equal(value, '[{"name":"foo"}]')
+  t.assert.deepStrictEqual(schema, clonedSchema)
+})
+
+test('must not mutate items referred by $ref', t => {
+  t.plan(2)
+
+  const firstSchema = {
+    $id: 'example1',
+    type: 'object',
+    properties: {
+      name: {
+        type: 'string'
+      }
+    }
+  }
+
+  const reusedSchema = {
+    $id: 'example2',
+    type: 'object',
+    properties: {
+      name: {
+        oneOf: [
+          {
+            $ref: 'example1'
+          }
+        ]
+      }
+    }
+  }
+
+  const clonedSchema = clone(firstSchema)
+  const stringify = build(reusedSchema, {
+    schema: {
+      [firstSchema.$id]: firstSchema
+    }
+  })
+
+  const value = stringify({ name: { name: 'foo' } })
+  t.assert.equal(value, '{"name":{"name":"foo"}}')
+  t.assert.deepStrictEqual(firstSchema, clonedSchema)
+})

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

@@ -0,0 +1,219 @@
+'use strict'
+
+const { test, after } = require('node:test')
+const fjs = require('..')
+const fs = require('fs')
+const path = require('path')
+
+function build (opts, schema) {
+  return fjs(schema || {
+    title: 'default string',
+    type: 'object',
+    properties: {
+      firstName: {
+        type: 'string'
+      }
+    },
+    required: ['firstName']
+  }, opts)
+}
+
+const tmpDir = 'test/fixtures'
+
+test('activate standalone mode', async (t) => {
+  t.plan(3)
+
+  after(async () => {
+    await fs.promises.rm(destination, { force: true })
+  })
+
+  const code = build({ mode: 'standalone' })
+  t.assert.ok(typeof code === 'string')
+  t.assert.equal(code.indexOf('ajv'), -1)
+
+  const destination = path.resolve(tmpDir, 'standalone.js')
+
+  await fs.promises.writeFile(destination, code)
+  const standalone = require(destination)
+  t.assert.equal(standalone({ firstName: 'Foo', surname: 'bar' }), JSON.stringify({ firstName: 'Foo' }), 'surname evicted')
+})
+
+test('test ajv schema', async (t) => {
+  t.plan(3)
+
+  after(async () => {
+    await fs.promises.rm(destination, { force: true })
+  })
+
+  const code = build({ mode: 'standalone' }, {
+    type: 'object',
+    properties: {
+    },
+    if: {
+      type: 'object',
+      properties: {
+        kind: { type: 'string', enum: ['foobar'] }
+      }
+    },
+    then: {
+      type: 'object',
+      properties: {
+        kind: { type: 'string', enum: ['foobar'] },
+        foo: { type: 'string' },
+        bar: { type: 'number' },
+        list: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              value: { type: 'string' }
+            }
+          }
+        }
+      }
+    },
+    else: {
+      type: 'object',
+      properties: {
+        kind: { type: 'string', enum: ['greeting'] },
+        hi: { type: 'string' },
+        hello: { type: 'number' },
+        list: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              value: { type: 'string' }
+            }
+          }
+        }
+      }
+    }
+  })
+  t.assert.ok(typeof code === 'string')
+  t.assert.equal(code.indexOf('ajv') > 0, true)
+
+  const destination = path.resolve(tmpDir, 'standalone2.js')
+
+  await fs.promises.writeFile(destination, code)
+  const standalone = require(destination)
+  t.assert.equal(standalone({
+    kind: 'foobar',
+    foo: 'FOO',
+    list: [{
+      name: 'name',
+      value: 'foo'
+    }],
+    bar: 42,
+    hi: 'HI',
+    hello: 45,
+    a: 'A',
+    b: 35
+  }), JSON.stringify({
+    kind: 'foobar',
+    foo: 'FOO',
+    bar: 42,
+    list: [{
+      name: 'name',
+      value: 'foo'
+    }]
+  }))
+})
+
+test('no need to keep external schemas once compiled', async (t) => {
+  t.plan(1)
+
+  after(async () => {
+    await fs.promises.rm(destination, { force: true })
+  })
+
+  const externalSchema = {
+    first: {
+      definitions: {
+        id1: {
+          type: 'object',
+          properties: {
+            id1: {
+              type: 'integer'
+            }
+          }
+        }
+      }
+    }
+  }
+  const code = fjs({
+    $ref: 'first#/definitions/id1'
+  }, {
+    mode: 'standalone',
+    schema: externalSchema
+  })
+
+  const destination = path.resolve(tmpDir, 'standalone3.js')
+
+  await fs.promises.writeFile(destination, code)
+  const standalone = require(destination)
+
+  t.assert.equal(standalone({ id1: 5 }), JSON.stringify({ id1: 5 }), 'serialization works with external schemas')
+})
+
+test('no need to keep external schemas once compiled - with oneOf validator', async (t) => {
+  t.plan(2)
+
+  after(async () => {
+    await fs.promises.rm(destination, { force: true })
+  })
+
+  const externalSchema = {
+    ext: {
+      definitions: {
+        oBaz: {
+          type: 'object',
+          properties: {
+            baz: { type: 'number' }
+          },
+          required: ['baz']
+        },
+        oBar: {
+          type: 'object',
+          properties: {
+            bar: { type: 'string' }
+          },
+          required: ['bar']
+        },
+        other: {
+          type: 'string',
+          const: 'other'
+        }
+      }
+    }
+  }
+
+  const schema = {
+    title: 'object with oneOf property value containing refs to external schema',
+    type: 'object',
+    properties: {
+      oneOfSchema: {
+        oneOf: [
+          { $ref: 'ext#/definitions/oBaz' },
+          { $ref: 'ext#/definitions/oBar' }
+        ]
+      }
+    },
+    required: ['oneOfSchema']
+  }
+
+  const code = fjs(schema, {
+    mode: 'standalone',
+    schema: externalSchema
+  })
+
+  const destination = path.resolve(tmpDir, 'standalone-oneOf-ref.js')
+
+  await fs.promises.writeFile(destination, code)
+  const stringify = require(destination)
+
+  t.assert.equal(stringify({ oneOfSchema: { baz: 5 } }), '{"oneOfSchema":{"baz":5}}')
+  t.assert.equal(stringify({ oneOfSchema: { bar: 'foo' } }), '{"oneOfSchema":{"bar":"foo"}}')
+})

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

@@ -0,0 +1,84 @@
+'use strict'
+
+const { test } = require('node:test')
+
+const build = require('..')
+
+test('serialize short string', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string'
+  }
+
+  const input = 'abcd'
+  const stringify = build(schema)
+  const output = stringify(input)
+
+  t.assert.equal(output, '"abcd"')
+  t.assert.equal(JSON.parse(output), input)
+})
+
+test('serialize short string', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string'
+  }
+
+  const input = '\x00'
+  const stringify = build(schema)
+  const output = stringify(input)
+
+  t.assert.equal(output, '"\\u0000"')
+  t.assert.equal(JSON.parse(output), input)
+})
+
+test('serialize long string', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string'
+  }
+
+  const input = new Array(2e4).fill('\x00').join('')
+  const stringify = build(schema)
+  const output = stringify(input)
+
+  t.assert.equal(output, `"${new Array(2e4).fill('\\u0000').join('')}"`)
+  t.assert.equal(JSON.parse(output), input)
+})
+
+test('unsafe string', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string',
+    format: 'unsafe'
+  }
+
+  const input = 'abcd'
+  const stringify = build(schema)
+  const output = stringify(input)
+
+  t.assert.equal(output, `"${input}"`)
+  t.assert.equal(JSON.parse(output), input)
+})
+
+test('unsafe unescaped string', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'string',
+    format: 'unsafe'
+  }
+
+  const input = 'abcd "abcd"'
+  const stringify = build(schema)
+  const output = stringify(input)
+
+  t.assert.equal(output, `"${input}"`)
+  t.assert.throws(function () {
+    JSON.parse(output)
+  })
+})

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

@@ -0,0 +1,67 @@
+'use strict'
+
+const { test } = require('node:test')
+const validator = require('is-my-json-valid')
+const build = require('..')
+
+test('render a string with surrogate pairs as JSON:test 1', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'surrogate',
+    type: 'string'
+  }
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify('𝌆')
+
+  t.assert.equal(output, '"𝌆"')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
+test('render a string with surrogate pairs as JSON: test 2', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'long',
+    type: 'string'
+  }
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify('\uD834\uDF06')
+
+  t.assert.equal(output, '"𝌆"')
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
+test('render a string with Unpaired surrogate code as JSON', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'surrogate',
+    type: 'string'
+  }
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify('\uDF06\uD834')
+  t.assert.equal(output, JSON.stringify('\uDF06\uD834'))
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
+test('render a string with lone surrogate code as JSON', (t) => {
+  t.plan(2)
+
+  const schema = {
+    title: 'surrogate',
+    type: 'string'
+  }
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify('\uDEAD')
+  t.assert.equal(output, JSON.stringify('\uDEAD'))
+  t.assert.ok(validate(JSON.parse(output)), 'valid schema')
+})