fast-json-stringify 5.4.0 → 5.5.0

package/README.md

@@ -18,31 +18,37 @@ fast-json-stringify requires a [JSON Schema Draft 7](https://json-schema.org/spe
 ##### Benchmarks
 
 - Machine: `EX41S-SSD, Intel Core i7, 4Ghz, 64GB RAM, 4C/8T, SSD`.
-- Node.js `v16.9.1`
+- Node.js `v18.12.1`
 
 ```
-FJS creation x 8,443 ops/sec ±1.01% (90 runs sampled)
-CJS creation x 183,219 ops/sec ±0.13% (96 runs sampled)
-AJV Serialize creation x 83,541,848 ops/sec ±0.24% (98 runs sampled)
-JSON.stringify array x 5,363 ops/sec ±0.11% (100 runs sampled)
-fast-json-stringify array x 6,747 ops/sec ±0.13% (98 runs sampled)
-compile-json-stringify array x 7,121 ops/sec ±0.42% (98 runs sampled)
-AJV Serialize array x 7,533 ops/sec ±0.13% (98 runs sampled)
-JSON.stringify long string x 16,461 ops/sec ±0.12% (98 runs sampled)
-fast-json-stringify long string x 16,443 ops/sec ±0.37% (99 runs sampled)
-compile-json-stringify long string x 16,458 ops/sec ±0.09% (98 runs sampled)
-AJV Serialize long string x 21,433 ops/sec ±0.08% (95 runs sampled)
-JSON.stringify short string x 12,035,664 ops/sec ±0.62% (96 runs sampled)
-fast-json-stringify short string x 38,281,060 ops/sec ±0.24% (98 runs sampled)
-compile-json-stringify short string x 32,388,037 ops/sec ±0.27% (97 runs sampled)
-AJV Serialize short string x 32,288,612 ops/sec ±0.32% (95 runs sampled)
-JSON.stringify obj x 3,068,185 ops/sec ±0.16% (98 runs sampled)
-fast-json-stringify obj x 10,082,694 ops/sec ±0.10% (97 runs sampled)
-compile-json-stringify obj x 17,037,963 ops/sec ±1.17% (97 runs sampled)
-AJV Serialize obj x 9,660,041 ops/sec ±0.11% (97 runs sampled)
-JSON stringify date x 1,084,008 ops/sec ±0.16% (98 runs sampled)
-fast-json-stringify date format x 1,781,044 ops/sec ±0.48% (99 runs sampled)
-compile-json-stringify date format x 1,086,187 ops/sec ±0.16% (99 runs sampled)
+FJS creation x 4,129 ops/sec ±0.82% (92 runs sampled)
+CJS creation x 184,196 ops/sec ±0.12% (97 runs sampled)
+AJV Serialize creation x 61,130,591 ops/sec ±0.40% (92 runs sampled)
+JSON.stringify array x 5,057 ops/sec ±0.10% (100 runs sampled)
+fast-json-stringify array default x 6,243 ops/sec ±0.14% (98 runs sampled)
+fast-json-stringify array json-stringify x 6,261 ops/sec ±0.30% (99 runs sampled)
+compile-json-stringify array x 6,842 ops/sec ±0.18% (96 runs sampled)
+AJV Serialize array x 6,964 ops/sec ±0.11% (95 runs sampled)
+JSON.stringify large array x 248 ops/sec ±0.07% (90 runs sampled)
+fast-json-stringify large array default x 99.96 ops/sec ±0.22% (74 runs sampled)
+fast-json-stringify large array json-stringify x 248 ops/sec ±0.07% (90 runs sampled)
+compile-json-stringify large array x 317 ops/sec ±0.09% (89 runs sampled)
+AJV Serialize large array x 111 ops/sec ±0.07% (33 runs sampled)
+JSON.stringify long string x 16,002 ops/sec ±0.09% (98 runs sampled)
+fast-json-stringify long string x 15,979 ops/sec ±0.09% (96 runs sampled)
+compile-json-stringify long string x 15,952 ops/sec ±0.31% (97 runs sampled)
+AJV Serialize long string x 21,416 ops/sec ±0.08% (98 runs sampled)
+JSON.stringify short string x 12,944,272 ops/sec ±0.09% (96 runs sampled)
+fast-json-stringify short string x 30,585,790 ops/sec ±0.27% (97 runs sampled)
+compile-json-stringify short string x 30,656,406 ops/sec ±0.12% (96 runs sampled)
+AJV Serialize short string x 30,406,785 ops/sec ±0.37% (96 runs sampled)
+JSON.stringify obj x 3,153,043 ops/sec ±0.33% (99 runs sampled)
+fast-json-stringify obj x 6,866,434 ops/sec ±0.11% (100 runs sampled)
+compile-json-stringify obj x 15,886,723 ops/sec ±0.15% (98 runs sampled)
+AJV Serialize obj x 8,969,043 ops/sec ±0.36% (97 runs sampled)
+JSON stringify date x 1,126,547 ops/sec ±0.09% (97 runs sampled)
+fast-json-stringify date format x 1,836,188 ops/sec ±0.12% (99 runs sampled)
+compile-json-stringify date format x 1,125,735 ops/sec ±0.19% (98 runs sampled)
 ```
 
 #### Table of contents:
@@ -644,12 +650,16 @@ AJV Serialize large array x 58.76 ops/sec ±4.59% (60 runs sampled)
 Treat the schema definition as application code, it
 is not safe to use user-provided schemas.
 
-In order to achieve lowest cost/highest performance redaction `fast-json-stringify`
+To achieve low cost and high performance redaction `fast-json-stringify`
 creates and compiles a function (using the `Function` constructor) on initialization.
 While the `schema` is currently validated for any developer errors,
 there is no guarantee that supplying user-generated schema could not
 expose your application to remote attacks.
 
+Users are responsible for sending trusted data. `fast-json-stringify` guarantees that you will get
+a valid output only if your input matches the schema or can be coerced to the schema. If your input
+doesn't match the schema, you will get undefined behavior. 
+
 <a name="debug"></a>
 ### Debug Mode
 

package/index.js

@@ -56,11 +56,7 @@ function resolveRef (location, ref) {
     throw new Error(`Cannot find reference "${ref}"`)
   }
 
-  if (location.isValidated) {
-    validatorSchemasIds.add(schemaId)
-  }
-
-  const newLocation = new Location(schema, schemaId, jsonPointer, location.isValidated)
+  const newLocation = new Location(schema, schemaId, jsonPointer)
   if (schema.$ref !== undefined) {
     return resolveRef(newLocation, schema.$ref)
   }
@@ -137,6 +133,11 @@ function build (schema, options) {
   for (const schemaId of validatorSchemasIds) {
     const schema = refResolver.getSchema(schemaId)
     validator.addSchema(schema, schemaId)
+
+    const dependencies = refResolver.getSchemaDependencies(schemaId)
+    for (const [schemaId, schema] of Object.entries(dependencies)) {
+      validator.addSchema(schema, schemaId)
+    }
   }
 
   const dependenciesName = ['validator', 'serializer', contextFunctionCode]
@@ -454,7 +455,6 @@ function mergeAllOfSchema (location, schema, mergedSchema) {
 }
 
 function addIfThenElse (location, input) {
-  location.isValidated = true
   validatorSchemasIds.add(location.getSchemaId())
 
   const schema = merge({}, location.schema)
@@ -840,7 +840,6 @@ function buildValue (location, input) {
   let code = ''
 
   if (type === undefined && (schema.anyOf || schema.oneOf)) {
-    location.isValidated = true
     validatorSchemasIds.add(location.getSchemaId())
 
     const type = schema.anyOf ? 'anyOf' : 'oneOf'
@@ -889,6 +888,8 @@ function buildValue (location, input) {
 }
 
 module.exports = build
+module.exports.default = build
+module.exports.build = build
 
 module.exports.validLargeArrayMechanisms = validLargeArrayMechanisms
 

package/lib/location.js

@@ -1,11 +1,10 @@
 'use strict'
 
 class Location {
-  constructor (schema, schemaId, jsonPointer = '#', isValidated = false) {
+  constructor (schema, schemaId, jsonPointer = '#') {
     this.schema = schema
     this.schemaId = schemaId
     this.jsonPointer = jsonPointer
-    this.isValidated = isValidated
     this.mergedSchemaId = null
   }
 
@@ -13,8 +12,7 @@ class Location {
     const propertyLocation = new Location(
       this.schema[propertyName],
       this.schemaId,
-      this.jsonPointer + '/' + propertyName,
-      this.isValidated
+      this.jsonPointer + '/' + propertyName
     )
 
     if (this.mergedSchemaId !== null) {

package/lib/ref-resolver.js

@@ -28,6 +28,18 @@ class RefResolver {
     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 &&
@@ -35,7 +47,7 @@ class RefResolver {
     ) {
       throw new Error(`There is already another schema with id ${schemaId}`)
     }
-    this.schemas[schemaId] = { schema, anchors: {} }
+    this.schemas[schemaId] = { schema, anchors: {}, dependencies: [] }
   }
 
   insertSchemaByAnchor (schema, schemaId, anchor) {
@@ -60,6 +72,14 @@ class RefResolver {
       }
     }
 
+    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)

package/lib/serializer.js

@@ -1,5 +1,8 @@
 'use strict'
 
+// eslint-disable-next-line
+const STR_ESCAPE = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]|[\ud800-\udbff](?![\udc00-\udfff])|(?:[^\ud800-\udbff]|^)[\udc00-\udfff]/
+
 module.exports = class Serializer {
   constructor (options = {}) {
     switch (options.rounding) {
@@ -94,6 +97,11 @@ module.exports = class Serializer {
       str = str.toString()
     }
 
+    // Fast escape chars check
+    if (!STR_ESCAPE.test(str)) {
+      return quotes + str + quotes
+    }
+
     if (str.length < 42) {
       return this.asStringSmall(str)
     } else {

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "fast-json-stringify",
-  "version": "5.4.0",
+  "version": "5.5.0",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
-  "types": "index.d.ts",
+  "types": "types/index.d.ts",
   "scripts": {
     "bench": "node ./benchmark/bench.js",
     "bench:cmp": "node ./benchmark/bench-cmp-branch.js",
@@ -11,7 +11,7 @@
     "benchmark": "node ./benchmark/bench-cmp-lib.js",
     "lint": "standard",
     "lint:fix": "standard --fix",
-    "test:typescript": "tsc --project ./test/types/tsconfig.json && tsd",
+    "test:typescript": "tsd",
     "test:unit": "tap -J test/*.test.js test/**/*.test.js",
     "test": "npm run test:unit && npm run test:typescript"
   },
@@ -34,7 +34,7 @@
   "homepage": "https://github.com/fastify/fast-json-stringify#readme",
   "devDependencies": {
     "@fastify/pre-commit": "^2.0.2",
-    "@sinclair/typebox": "^0.24.9",
+    "@sinclair/typebox": "^0.25.2",
     "benchmark": "^2.1.4",
     "cli-select": "^1.1.2",
     "compile-json-stringify": "^0.1.2",
@@ -46,7 +46,6 @@
     "standard": "^17.0.0",
     "tap": "^16.0.1",
     "tsd": "^0.24.1",
-    "typescript": "^4.0.2",
     "webpack": "^5.40.0"
   },
   "dependencies": {
@@ -62,8 +61,5 @@
       "schema-validator.js"
     ]
   },
-  "runkitExampleFilename": "./examples/example.js",
-  "tsd": {
-    "directory": "test/types"
-  }
+  "runkitExampleFilename": "./examples/example.js"
 }

package/test/anyof.test.js

@@ -616,3 +616,31 @@ test('anyOf with a nested external schema', (t) => {
   const stringify = build(schema, { schema: externalSchemas })
   t.equal(stringify('foo'), '"foo"')
 })
+
+test('object with ref and validated properties', (t) => {
+  t.plan(1)
+
+  const externalSchemas = {
+    RefSchema: {
+      $id: 'RefSchema',
+      type: 'string'
+    }
+  }
+
+  const schema = {
+    $id: 'root',
+    type: 'object',
+    properties: {
+      id: {
+        anyOf: [
+          { type: 'string' },
+          { type: 'number' }
+        ]
+      },
+      reference: { $ref: 'RefSchema' }
+    }
+  }
+
+  const stringify = build(schema, { schema: externalSchemas })
+  t.equal(stringify({ id: 1, reference: 'hi' }), '{"id":1,"reference":"hi"}')
+})

package/{index.d.ts → types/index.d.ts}

@@ -1,5 +1,7 @@
 import Ajv, { Options as AjvOptions } from "ajv"
 
+type Build = typeof build
+
 declare namespace build {
   interface BaseSchema {
     /**
@@ -168,6 +170,12 @@ declare namespace build {
      */
     mode?: 'debug' | 'standalone'
   }
+
+  export const validLargeArrayMechanisms: string[]
+  export function restore (value: <TDoc extends object = object>(doc: TDoc) => string): ReturnType<Build> 
+
+  export const build: Build
+  export { build as default }
 }
 
 interface DebugOption extends build.Options {

package/{test/types/test.ts → types/index.test-d.ts}

@@ -1,5 +1,6 @@
 import Ajv from 'ajv'
-import build, { Schema } from '../..'
+import build, { restore, Schema, validLargeArrayMechanisms } from '..'
+import { expectError, expectType } from 'tsd'
 
 // Number schemas
 const schema1: Schema = {
@@ -150,4 +151,69 @@ str = build(schema1, { debugMode: true }).code
 ajv = build(schema1, { debugMode: true }).ajv
 str = build(schema1, { mode: 'debug' }).code
 ajv = build(schema1, { mode: 'debug' }).ajv
-str = build(schema1, { mode: 'standalone' })
+str = build(schema1, { mode: 'standalone' })
+
+const debugCompiled = build({
+  title: 'default string',
+  type: 'object',
+  properties: {
+    firstName: {
+      type: 'string'
+    }
+  }
+}, { mode: 'debug' })
+expectType<ReturnType<typeof build>>(build.restore(debugCompiled))
+expectType<ReturnType<typeof build>>(restore(debugCompiled))
+
+expectType<string[]>(build.validLargeArrayMechanisms)
+expectType<string[]>(validLargeArrayMechanisms)
+
+/**
+ * Schema inference
+ */
+
+// With inference
+interface InferenceSchema {
+  id: string;
+  a?: number;
+}
+
+const stringify3 = build({
+  type: "object",
+  properties: { a: { type: "string" } },
+});
+stringify3<InferenceSchema>({ id: "123" });
+stringify3<InferenceSchema>({ a: 123, id: "123" });
+expectError(stringify3<InferenceSchema>({ anotherOne: "bar" }));
+expectError(stringify3<Schema>({ a: "bar" }));
+
+// Without inference
+const stringify4 = build({
+  type: "object",
+  properties: { a: { type: "string" } },
+});
+stringify4({ id: "123" });
+stringify4({ a: 123, id: "123" });
+stringify4({ anotherOne: "bar" });
+stringify4({ a: "bar" });
+
+// Without inference - string type
+const stringify5 = build({
+  type: "string",
+});
+stringify5("foo");
+expectError(stringify5({ id: "123" }));
+
+// Without inference - null type
+const stringify6 = build({
+  type: "null",
+});
+stringify6(null);
+expectError(stringify6("a string"));
+
+// Without inference - boolean type
+const stringify7 = build({
+  type: "boolean",
+});
+stringify7(true);
+expectError(stringify7("a string"));

package/test/types/schema-inference.test-d.ts

@@ -1,48 +0,0 @@
-import { expectError } from "tsd";
-import build from "../..";
-
-// With inference
-interface Schema {
-  id: string;
-  a?: number;
-}
-
-const stringify3 = build({
-  type: "object",
-  properties: { a: { type: "string" } },
-});
-stringify3<Schema>({ id: "123" });
-stringify3<Schema>({ a: 123, id: "123" });
-expectError(stringify3<Schema>({ anotherOne: "bar" }));
-expectError(stringify3<Schema>({ a: "bar" }));
-
-// Without inference
-const stringify4 = build({
-  type: "object",
-  properties: { a: { type: "string" } },
-});
-stringify4({ id: "123" });
-stringify4({ a: 123, id: "123" });
-stringify4({ anotherOne: "bar" });
-stringify4({ a: "bar" });
-
-// Without inference - string type
-const stringify5 = build({
-  type: "string",
-});
-stringify5("foo");
-expectError(stringify5({ id: "123" }));
-
-// Without inference - null type
-const stringify6 = build({
-  type: "null",
-});
-stringify6(null);
-expectError(stringify6("a string"));
-
-// Without inference - boolean type
-const stringify7 = build({
-  type: "boolean",
-});
-stringify7(true);
-expectError(stringify7("a string"));

package/test/types/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "esModuleInterop": true,
-    "noEmit": true,
-    "rootDir": "../..",
-    "strict": true,
-    "target": "ES2015",
-    "moduleResolution": "node"
-  },
-  "include": [
-    "./test.ts"
-  ]
-}