fast-json-stringify 5.8.0 → 5.9.1

package/.gitattributes

@@ -0,0 +1,2 @@
+# Set default behavior to automatically convert line endings
+* text=auto eol=lf

package/.github/workflows/benchmark.yml

@@ -14,13 +14,13 @@ jobs:
       PR-BENCH: ${{ steps.benchmark-pr.outputs.BENCH_RESULT }}
       MASTER-BENCH: ${{ steps.benchmark-master.outputs.BENCH_RESULT }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           persist-credentials: false
           ref: ${{github.event.pull_request.head.sha}}
           repository: ${{github.event.pull_request.head.repo.full_name}}
 
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v4
         with:
           node-version: 18
 
@@ -39,7 +39,7 @@ jobs:
           echo "::set-output name=BENCH_RESULT::$content"
 
       # master benchmark
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           ref: 'master'
 

package/examples/example.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const fastJson = require('..')
 const stringify = fastJson({
   title: 'Example Schema',

package/index.js

@@ -5,13 +5,15 @@
 const merge = require('@fastify/deepmerge')()
 const clone = require('rfdc')({ proto: true })
 const { randomUUID } = require('crypto')
+const { RefResolver } = require('json-schema-ref-resolver')
 
 const validate = require('./lib/schema-validator')
 const Serializer = require('./lib/serializer')
 const Validator = require('./lib/validator')
-const RefResolver = require('./lib/ref-resolver')
 const Location = require('./lib/location')
 
+const SINGLE_TICK = /'/g
+
 let largeArraySize = 2e4
 let largeArrayMechanism = 'default'
 
@@ -53,8 +55,7 @@ function resolveRef (context, location, ref) {
   const jsonPointer = ref.slice(hashIndex) || '#'
 
   const schema = context.refResolver.getSchema(schemaId, jsonPointer)
-
-  if (schema === undefined) {
+  if (schema === null) {
     throw new Error(`Cannot find reference "${ref}"`)
   }
 
@@ -66,6 +67,13 @@ function resolveRef (context, location, ref) {
   return newLocation
 }
 
+function getSchemaId (schema, rootSchemaId) {
+  if (schema.$id && schema.$id.charAt(0) !== '#') {
+    return schema.$id
+  }
+  return rootSchemaId
+}
+
 function build (schema, options) {
   isValidSchema(schema)
 
@@ -82,12 +90,19 @@ function build (schema, options) {
     validatorSchemasIds: new Set()
   }
 
-  context.refResolver.addSchema(schema, context.rootSchemaId)
+  const schemaId = getSchemaId(schema, context.rootSchemaId)
+  if (!context.refResolver.hasSchema(schemaId)) {
+    context.refResolver.addSchema(schema, context.rootSchemaId)
+  }
 
   if (options.schema) {
-    for (const key of Object.keys(options.schema)) {
-      isValidSchema(options.schema[key], key)
-      context.refResolver.addSchema(options.schema[key], key)
+    for (const key in options.schema) {
+      const schema = options.schema[key]
+      const schemaId = getSchemaId(schema, key)
+      if (!context.refResolver.hasSchema(schemaId)) {
+        isValidSchema(schema, key)
+        context.refResolver.addSchema(schema, key)
+      }
     }
   }
 
@@ -821,7 +836,7 @@ function buildConstSerializer (location, input) {
     `
   }
 
-  code += `json += '${JSON.stringify(schema.const)}'`
+  code += `json += '${JSON.stringify(schema.const).replace(SINGLE_TICK, "\\'")}'`
 
   if (hasNullType) {
     code += `

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "fast-json-stringify",
-  "version": "5.8.0",
+  "version": "5.9.1",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
+  "type": "commonjs",
   "types": "types/index.d.ts",
   "scripts": {
     "bench": "node ./benchmark/bench.js",
@@ -34,7 +35,7 @@
   "homepage": "https://github.com/fastify/fast-json-stringify#readme",
   "devDependencies": {
     "@fastify/pre-commit": "^2.0.2",
-    "@sinclair/typebox": "^0.29.1",
+    "@sinclair/typebox": "^0.31.1",
     "benchmark": "^2.1.4",
     "cli-select": "^1.1.2",
     "compile-json-stringify": "^0.1.2",
@@ -42,7 +43,7 @@
     "simple-git": "^3.7.1",
     "standard": "^17.0.0",
     "tap": "^16.0.1",
-    "tsd": "^0.28.0",
+    "tsd": "^0.29.0",
     "webpack": "^5.40.0",
     "fast-json-stringify": "."
   },
@@ -52,7 +53,8 @@
     "ajv-formats": "^2.1.1",
     "fast-deep-equal": "^3.1.3",
     "fast-uri": "^2.1.0",
-    "rfdc": "^1.2.0"
+    "rfdc": "^1.2.0",
+    "json-schema-ref-resolver": "^1.0.1"
   },
   "standard": {
     "ignore": [

package/test/const.test.js

@@ -82,6 +82,26 @@ test('schema with const string and no input', (t) => {
   t.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
+test('schema with const string that contains \'', (t) => {
+  t.plan(2)
+
+  const schema = {
+    type: 'object',
+    properties: {
+      foo: { const: "'bar'" }
+    }
+  }
+
+  const validate = validator(schema)
+  const stringify = build(schema)
+  const output = stringify({
+    foo: "'bar'"
+  })
+
+  t.equal(output, '{"foo":"\'bar\'"}')
+  t.ok(validate(JSON.parse(output)), 'valid schema')
+})
+
 test('schema with const number', (t) => {
   t.plan(2)
 

package/test/ref.test.js

@@ -1377,7 +1377,10 @@ test('Bad key', t => {
       })
       t.fail('Should throw')
     } catch (err) {
-      t.equal(err.message, 'Cannot find reference "extrenal#/definitions/projectId"')
+      t.equal(
+        err.message,
+        'Cannot resolve ref "extrenal#/definitions/projectId". Schema with id "extrenal" is not found.'
+      )
     }
   })
 
@@ -2076,7 +2079,11 @@ test('should throw an Error if two non-identical schemas with same id are provid
     ]
   }
 
-  t.throws(() => build(schema), new Error('There is already another schema with id inner_schema'))
+  try {
+    build(schema)
+  } catch (err) {
+    t.equal(err.message, 'There is already another schema with id "inner_schema".')
+  }
 })
 
 test('ref internal - throw if schema has definition twice with different shape', (t) => {
@@ -2115,5 +2122,9 @@ test('ref internal - throw if schema has definition twice with different shape',
     }
   }
 
-  t.throws(() => build(schema), Error('There is already another schema with id test##uri'))
+  try {
+    build(schema)
+  } catch (err) {
+    t.equal(err.message, 'There is already another anchor "#uri" in a schema "test".')
+  }
 })

package/lib/ref-resolver.js

@@ -1,104 +0,0 @@
-'use strict'
-
-const deepEqual = require('fast-deep-equal')
-
-class RefResolver {
-  constructor () {
-    this.schemas = {}
-  }
-
-  addSchema (schema, schemaId) {
-    if (schema.$id !== undefined && schema.$id.charAt(0) !== '#') {
-      schemaId = schema.$id
-    }
-    if (this.getSchema(schemaId) === undefined) {
-      this.insertSchemaBySchemaId(schema, schemaId)
-      this.insertSchemaSubschemas(schema, schemaId)
-    }
-  }
-
-  getSchema (schemaId, jsonPointer = '#') {
-    const schema = this.schemas[schemaId]
-    if (schema === undefined) {
-      return undefined
-    }
-    if (schema.anchors[jsonPointer] !== undefined) {
-      return schema.anchors[jsonPointer]
-    }
-    return getDataByJSONPointer(schema.schema, jsonPointer)
-  }
-
-  getSchemaDependencies (schemaId, dependencies = {}) {
-    const schema = this.schemas[schemaId]
-
-    for (const dependencySchemaId of schema.dependencies) {
-      if (dependencies[dependencySchemaId] !== undefined) continue
-      dependencies[dependencySchemaId] = this.getSchema(dependencySchemaId)
-      this.getSchemaDependencies(dependencySchemaId, dependencies)
-    }
-
-    return dependencies
-  }
-
-  insertSchemaBySchemaId (schema, schemaId) {
-    if (
-      this.schemas[schemaId] !== undefined &&
-      !deepEqual(schema, this.schemas[schemaId].schema)
-    ) {
-      throw new Error(`There is already another schema with id ${schemaId}`)
-    }
-    this.schemas[schemaId] = { schema, anchors: {}, dependencies: [] }
-  }
-
-  insertSchemaByAnchor (schema, schemaId, anchor) {
-    const { anchors } = this.schemas[schemaId]
-    if (
-      anchors[anchor] !== undefined &&
-      !deepEqual(schema, anchors[anchor])
-    ) {
-      throw new Error(`There is already another schema with id ${schemaId}#${anchor}`)
-    }
-    anchors[anchor] = schema
-  }
-
-  insertSchemaSubschemas (schema, rootSchemaId) {
-    const schemaId = schema.$id
-    if (schemaId !== undefined && typeof schemaId === 'string') {
-      if (schemaId.charAt(0) === '#') {
-        this.insertSchemaByAnchor(schema, rootSchemaId, schemaId)
-      } else {
-        this.insertSchemaBySchemaId(schema, schemaId)
-        rootSchemaId = schemaId
-      }
-    }
-
-    const ref = schema.$ref
-    if (ref !== undefined && typeof ref === 'string') {
-      if (ref.charAt(0) !== '#') {
-        const dependencySchemaId = ref.split('#')[0]
-        this.schemas[rootSchemaId].dependencies.push(dependencySchemaId)
-      }
-    }
-
-    for (const key in schema) {
-      if (typeof schema[key] === 'object' && schema[key] !== null) {
-        this.insertSchemaSubschemas(schema[key], rootSchemaId)
-      }
-    }
-  }
-}
-
-function getDataByJSONPointer (data, jsonPointer) {
-  const parts = jsonPointer.split('/')
-  let current = data
-  for (const part of parts) {
-    if (part === '' || part === '#') continue
-    if (typeof current !== 'object' || current === null) {
-      return undefined
-    }
-    current = current[part]
-  }
-  return current
-}
-
-module.exports = RefResolver