fast-json-stringify 7.0.0 → 7.1.0

package/test/standalone-mode.test.js

@@ -39,13 +39,13 @@ test('activate standalone mode', async (t) => {
 })
 
 test('test ajv schema', async (t) => {
-  t.plan(3)
+  t.plan(4)
 
   after(async () => {
     await fs.promises.rm(destination, { force: true })
   })
 
-  const code = build({ mode: 'standalone' }, {
+  const code = build({ mode: 'standalone', inlineValidators: false }, {
     type: 'object',
     properties: {
     },
@@ -94,6 +94,7 @@ test('test ajv schema', async (t) => {
   })
   t.assert.ok(typeof code === 'string')
   t.assert.equal(code.indexOf('ajv') > 0, true)
+  t.assert.match(code, /fast-json-stringify\/lib\/validator/)
 
   const destination = path.resolve(tmpDir, 'standalone2.js')
 
@@ -217,3 +218,109 @@ test('no need to keep external schemas once compiled - with oneOf validator', as
   t.assert.equal(stringify({ oneOfSchema: { baz: 5 } }), '{"oneOfSchema":{"baz":5}}')
   t.assert.equal(stringify({ oneOfSchema: { bar: 'foo' } }), '{"oneOfSchema":{"bar":"foo"}}')
 })
+
+test('inline validators with if/then/else', async (t) => {
+  t.plan(6)
+
+  after(async () => {
+    await fs.promises.rm(destination, { force: true })
+  })
+
+  const ajvOptions = {
+    code: { source: false, esm: true, lines: true }
+  }
+  const code = fjs({
+    type: 'object',
+    properties: {},
+    if: {
+      type: 'object',
+      properties: {
+        kind: { const: 'foo' }
+      },
+      required: ['kind']
+    },
+    then: {
+      properties: {
+        kind: { type: 'string' },
+        foo: { type: 'string' }
+      }
+    },
+    else: {
+      properties: {
+        kind: { type: 'string' },
+        bar: { type: 'integer' }
+      }
+    }
+  }, {
+    mode: 'standalone',
+    inlineValidators: true,
+    ajv: ajvOptions
+  })
+
+  t.assert.ok(typeof code === 'string')
+  t.assert.doesNotMatch(code, /fast-json-stringify\/lib\/validator/)
+  t.assert.match(code, /function validate\d/)
+  t.assert.deepEqual(ajvOptions, {
+    code: { source: false, esm: true, lines: true }
+  })
+
+  const destination = path.resolve(tmpDir, 'standalone-inline-if.js')
+
+  await fs.promises.writeFile(destination, code)
+  const stringify = require(destination)
+
+  t.assert.equal(stringify({ kind: 'foo', foo: 'FOO', bar: 42 }), '{"kind":"foo","foo":"FOO"}')
+  t.assert.equal(stringify({ kind: 'bar', foo: 'FOO', bar: 42 }), '{"kind":"bar","bar":42}')
+})
+
+test('inline validators with external oneOf refs and toJSON values', async (t) => {
+  t.plan(4)
+
+  after(async () => {
+    await fs.promises.rm(destination, { force: true })
+  })
+
+  const code = fjs({
+    type: 'object',
+    properties: {
+      value: {
+        oneOf: [
+          { $ref: 'values#/definitions/timestamp' },
+          { $ref: 'values#/definitions/count' }
+        ]
+      }
+    }
+  }, {
+    mode: 'standalone',
+    inlineValidators: true,
+    schema: {
+      values: {
+        definitions: {
+          timestamp: { type: 'string', format: 'date-time' },
+          count: { type: 'integer' }
+        }
+      }
+    }
+  })
+
+  t.assert.doesNotMatch(code, /fast-json-stringify\/lib\/validator/)
+
+  const destination = path.resolve(tmpDir, 'standalone-inline-oneOf.js')
+
+  await fs.promises.writeFile(destination, code)
+  const stringify = require(destination)
+
+  t.assert.equal(
+    stringify({ value: new Date('2020-01-02T03:04:05.000Z') }),
+    '{"value":"2020-01-02T03:04:05.000Z"}'
+  )
+  t.assert.equal(stringify({ value: 42 }), '{"value":42}')
+  t.assert.throws(() => stringify({ value: true }), /does not match schema definition/)
+})
+
+test('does not emit unused inline validators', (t) => {
+  const code = build({ mode: 'standalone', inlineValidators: true })
+
+  t.assert.doesNotMatch(code, /function validate\d/)
+  t.assert.match(code, /const validator = null/)
+})

package/test/string.test.js

@@ -4,6 +4,14 @@ const { test } = require('node:test')
 
 const build = require('..')
 
+test('serialize an empty string', (t) => {
+  t.plan(1)
+
+  const stringify = build({ type: 'string' })
+
+  t.assert.equal(stringify(''), '""')
+})
+
 test('serialize short string', (t) => {
   t.plan(2)
 

package/test/surrogate.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { test } = require('node:test')
-const validator = require('is-my-json-valid')
+const validator = require('./utils/validator')
 const build = require('..')
 
 test('render a string with surrogate pairs as JSON:test 1', (t) => {

package/test/typesArray.test.js

@@ -548,3 +548,62 @@ test('throw an error if none of types matches', (t) => {
   const stringify = build(schema)
   t.assert.throws(() => stringify({ data: 'string' }), 'The value "string" does not match schema definition.')
 })
+
+test('multi-type object listed before array serializes array input as an array', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: ['object', 'array'],
+    properties: {
+      a: { type: 'integer' }
+    },
+    items: { type: 'integer' }
+  }
+
+  const stringify = build(schema, { ajv: { allowUnionTypes: true } })
+
+  // Array input must match the `array` member, not be captured by `object`.
+  t.assert.equal(stringify([1, 2, 3]), '[1,2,3]')
+
+  // Object input for the same schema still serializes as an object.
+  t.assert.equal(stringify({ a: 4 }), '{"a":4}')
+})
+
+test('multi-type [object, array] round-trips an array of objects (JSON:API data)', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      data: {
+        type: ['object', 'array'],
+        properties: {
+          id: { type: 'string' },
+          type: { type: 'string' }
+        },
+        items: {
+          type: 'object',
+          properties: {
+            id: { type: 'string' },
+            type: { type: 'string' }
+          }
+        }
+      }
+    }
+  }
+
+  const stringify = build(schema, { ajv: { allowUnionTypes: true } })
+
+  const arrayInput = {
+    data: [
+      { id: '1', type: 'article' },
+      { id: '2', type: 'article' }
+    ]
+  }
+  t.assert.deepEqual(JSON.parse(stringify(arrayInput)), arrayInput)
+
+  const objectInput = {
+    data: { id: '1', type: 'article' }
+  }
+  t.assert.deepEqual(JSON.parse(stringify(objectInput)), objectInput)
+})

package/test/utils/validator.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const Ajv = require('ajv')
+const ajvFormats = require('ajv-formats')
+
+// Compiles a JSON Schema into a `validate(data) => boolean` function with
+// ajv, the validator the library itself uses, so tests check serialized
+// output against the same rules. A fresh instance is created per schema so
+// tests that reuse an `$id` do not collide.
+module.exports = function validator (schema) {
+  const ajv = new Ajv({ strictSchema: false, allowUnionTypes: true })
+  ajvFormats(ajv)
+  // `unsafe` is a fast-json-stringify format that only disables escaping.
+  ajv.addFormat('unsafe', true)
+  // The serializer renders `format: time` as `HH:mm:ss` with no timezone
+  // (see `asTime` in lib/serializer.js), which ajv-formats rejects because
+  // RFC 3339 requires one. Validate the shape the library documents.
+  ajv.addFormat('time', /^(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d$/)
+  return ajv.compile(schema)
+}

package/types/index.d.ts

@@ -162,10 +162,22 @@ declare namespace build {
      * @default 'trunc'
      */
     rounding?: 'ceil' | 'floor' | 'round' | 'trunc'
+    /**
+     * Maximum number of nested schema levels allowed during compilation (0–100)
+     *
+     * @default 100
+     */
+    maxDepth?: number
     /**
      * Running mode of fast-json-stringify
      */
     mode?: 'debug' | 'standalone'
+    /**
+     * Embed Ajv-generated validators in standalone output instead of compiling schemas at runtime
+     *
+     * @default false
+     */
+    inlineValidators?: boolean
     /**
      * Large arrays are defined as arrays containing, by default, `20000`
      * elements or more. That value can be adjusted via the option parameter
@@ -180,6 +192,14 @@ declare namespace build {
      * @default 'default'
      */
     largeArrayMechanism?: 'default' | 'json-stringify'
+    /**
+     * Eagerly compile the Ajv validators used by `anyOf`, `oneOf` and
+     * `if/then/else` at build time instead of on the first serialization
+     * that reaches them.
+     *
+     * @default false
+     */
+    compileValidators?: boolean
   }
 
   export const validLargeArrayMechanisms: string[]

package/types/index.tst.ts

@@ -31,6 +31,10 @@ expect(build).type.not.toBeCallableWith({
   type: 'number'
 }, { rounding: 'invalid' })
 
+build({} as Schema, { inlineValidators: true })
+build({} as Schema, { inlineValidators: false })
+expect(build).type.not.toBeCallableWith({} as Schema, { inlineValidators: 'true' })
+
 // String schema
 build({
   type: 'string'
@@ -257,3 +261,12 @@ build({}, { largeArraySize: 2000 })
 build({}, { largeArraySize: '2e4' })
 build({}, { largeArraySize: 2n })
 expect(build).type.not.toBeCallableWith({} as Schema, { largeArraySize: ['asdf'] })
+
+// maxDepth
+build({}, { maxDepth: 100 })
+expect(build).type.not.toBeCallableWith({} as Schema, { maxDepth: '500' })
+
+// compileValidators
+build({}, { compileValidators: true })
+build({}, { compileValidators: false })
+expect(build).type.not.toBeCallableWith({} as Schema, { compileValidators: 'yes' })