fast-json-stringify 6.4.0 → 7.0.1

package/.github/dependabot.yml

@@ -2,12 +2,52 @@ version: 2
 updates:
   - package-ecosystem: "github-actions"
     directory: "/"
+    commit-message:
+      # Prefix all commit messages with "chore: "
+      prefix: "chore"
     schedule:
-      interval: "monthly"
+      interval: "weekly"
+    cooldown:
+      default-days: 7
+    allow:
+      - dependency-name: "*"
+        update-types:
+          - "version-update:semver-major"
     open-pull-requests-limit: 10
 
   - package-ecosystem: "npm"
     directory: "/"
+    commit-message:
+      # Prefix all commit messages with "chore: "
+      prefix: "chore"
     schedule:
-      interval: "monthly"
+      interval: "weekly"
+    cooldown:
+      default-days: 7
+    versioning-strategy: "increase-if-necessary"
+    allow:
+      - dependency-name: "*"
+        update-types:
+          - "version-update:semver-major"
+    ignore:
+      # TODO: remove ignore until neostandard support ESLint 10
+      - dependency-name: "eslint"
+      - dependency-name: "neostandard"
+      - dependency-name: "@stylistic/*"
     open-pull-requests-limit: 10
+    groups:
+      # Production dependencies with breaking changes
+      dependencies:
+        dependency-type: "production"
+      # ESLint related dependencies
+      dev-dependencies-eslint:
+        patterns:
+          - "eslint"
+          - "neostandard"
+          - "@stylistic/*"
+      # TypeScript related dependencies
+      dev-dependencies-typescript:
+        patterns:
+          - "@types/*"
+          - "tstyche"
+          - "typescript"

package/README.md

@@ -11,7 +11,7 @@ Its performance advantage shrinks as your payload grows.
 
 ### How it works
 
-fast-json-stringify requires a [JSON Schema Draft 7](https://json-schema.org/specification-links.html#draft-7) input to generate a fast `stringify` function.
+fast-json-stringify requires a [JSON Schema Draft 7](https://json-schema.org/specification-links#draft-7) input to generate a fast `stringify` function.
 
 ##### Benchmarks
 
@@ -137,7 +137,7 @@ const stringify = fastJson(mySchema, {
 <a name="fastJsonStringify"></a>
 ### fastJsonStringify(schema)
 
-Build a `stringify()` function based on [jsonschema draft 7 spec](https://json-schema.org/specification-links.html#draft-7).
+Build a `stringify()` function based on [jsonschema draft 7 spec](https://json-schema.org/specification-links#draft-7).
 
 Supported types:
 
@@ -160,7 +160,7 @@ And nested ones, too.
 | `RegExp` | `string`                     |
 | `BigInt` | `integer` via `toString`     |
 
-[JSON Schema built-in formats](https://json-schema.org/understanding-json-schema/reference/string.html#built-in-formats) for dates are supported and will be serialized as:
+[JSON Schema built-in formats](https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-00#rfc.section.7.3.1) for dates are supported and will be serialized as:
 
 | Format      | Serialized format example  |
 | ----------- | -------------------------- |
@@ -436,7 +436,7 @@ console.log(stringify({
 <a name="ref"></a>
 #### Reuse - $ref
 If you want to reuse a definition of a value, you can use the property `$ref`.
-The value of `$ref` must be a string in [JSON Pointer](https://tools.ietf.org/html/rfc6901) format.
+The value of `$ref` must be a string in [JSON Pointer](https://datatracker.ietf.org/doc/html/rfc6901) format.
 Example:
 ```javascript
 const schema = {
@@ -561,7 +561,7 @@ const stringify = fastJson(schema, { rounding: 'ceil' })
 <a name="nullable"></a>
 #### Nullable
 
-According to the [Open API 3.0 specification](https://swagger.io/docs/specification/data-models/data-types/#null), a value that can be null must be declared `nullable`.
+According to the [Open API 3.0 specification](https://swagger.io/docs/specification/v3_0/data-models/data-types/#null), a value that can be null must be declared `nullable`.
 
 ##### Nullable object
 ```javascript

package/index.js

@@ -10,8 +10,6 @@ const Location = require('./lib/location')
 const validate = require('./lib/schema-validator')
 const mergeSchemas = require('./lib/merge-schemas')
 
-const SINGLE_TICK = /'/g
-
 let largeArraySize = 2e4
 let largeArrayMechanism = 'default'
 
@@ -222,10 +220,6 @@ function build (schema, options) {
     }
   }
 
-  if (options.debugMode) {
-    options.mode = 'debug'
-  }
-
   if (options.mode === 'debug') {
     return {
       validator,
@@ -386,10 +380,9 @@ function buildInnerObject (context, location, objVar) {
   const localUid = context.uid++
   let addComma = ''
 
-  if (requiredProperties.length > 0) {
-    // If we have required properties, we know that at least one property will be serialized.
-    // We can avoid the runtime check for the comma.
-
+  // propertiesKeys is sorted required-first; the guard checks [0] is required because
+  // otherwise additionalProperties/patternProperties would emit a stray `{ ,"k":v }`.
+  if (propertiesKeys.length > 0 && requiredProperties.includes(propertiesKeys[0])) {
     // The first property is required, so we don't need a comma.
     // For the subsequent properties, we can blindly add a comma.
 
@@ -1078,7 +1071,7 @@ function buildConstSerializer (location, input) {
     `
   }
 
-  code += `json += '${JSON.stringify(schema.const).replace(SINGLE_TICK, "\\'")}'`
+  code += `json += ${JSON.stringify(JSON.stringify(schema.const))}`
 
   if (hasNullType) {
     code += `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-json-stringify",
-  "version": "6.4.0",
+  "version": "7.0.1",
   "description": "Stringify your JSON at max speed",
   "main": "index.js",
   "type": "commonjs",
@@ -30,7 +30,7 @@
   "contributors": [
     {
       "name": "Tomas Della Vedova",
-      "url": "http://delved.org"
+      "url": "https://delvedor.dev"
     },
     {
       "name": "Aras Abbasi",
@@ -81,7 +81,7 @@
     "@fastify/merge-json-schemas": "^0.2.0",
     "ajv": "^8.12.0",
     "ajv-formats": "^3.0.1",
-    "fast-uri": "^3.0.0",
+    "fast-uri": "^4.0.0",
     "json-schema-ref-resolver": "^3.0.0",
     "rfdc": "^1.2.0"
   },

package/test/additionalProperties.test.js

@@ -330,3 +330,50 @@ test('function and symbol references are not serialized as undefined', (t) => {
   const obj = { str: 'x', test: 'test', meth: () => 'x', sym: Symbol('x') }
   t.assert.equal(stringify(obj), '{"str":"x","test":"test"}')
 })
+
+test('required + additionalProperties without declared properties produces valid JSON', (t) => {
+  // Regression: when `required` is non-empty but `properties` is absent
+  // (e.g. a record-style schema with only `additionalProperties`), the
+  // serializer used to emit a stray leading comma:
+  //   {"obj":{,"a":1,"b":2}}
+  // because the "skip first comma" optimization assumed a declared
+  // property would anchor it. With no `properties`, the additionalProperties
+  // branch would write the separator before its first entry.
+  t.plan(2)
+  const stringify = build({
+    type: 'object',
+    properties: {
+      obj: {
+        type: 'object',
+        propertyNames: { type: 'string', enum: ['a', 'b'] },
+        additionalProperties: { type: 'number' },
+        required: ['a', 'b']
+      }
+    }
+  })
+
+  const out = stringify({ obj: { a: 1, b: 2 } })
+  t.assert.equal(out, '{"obj":{"a":1,"b":2}}')
+  t.assert.deepStrictEqual(JSON.parse(out), { obj: { a: 1, b: 2 } })
+})
+
+test('required key not in properties + additionalProperties produces valid JSON', (t) => {
+  // Regression: declared `properties` is non-empty but `required` only lists
+  // keys that are not in `properties`. After sorting, propertiesKeys[0] is
+  // not required, so the "first declared property anchors the comma" premise
+  // does not hold. The serializer used to emit '{,"str":"x"}' for input
+  // missing the (non-required) declared `num`.
+  t.plan(2)
+  const stringify = build({
+    type: 'object',
+    properties: {
+      num: { type: 'number' }
+    },
+    additionalProperties: true,
+    required: ['str']
+  })
+
+  const out = stringify({ str: 'x' })
+  t.assert.equal(out, '{"str":"x"}')
+  t.assert.deepStrictEqual(JSON.parse(out), { str: 'x' })
+})

package/test/const.test.js

@@ -24,6 +24,26 @@ test('schema with const string', (t) => {
   t.assert.ok(validate(JSON.parse(output)), 'valid schema')
 })
 
+test('schema with const string containing characters that need escaping', (t) => {
+  const values = ['back\\slash', 'tab\there', 'quote"here', 'new\nline', "tick's"]
+  t.plan(values.length * 2)
+
+  for (const value of values) {
+    const schema = {
+      type: 'object',
+      properties: {
+        foo: { const: value }
+      }
+    }
+
+    const stringify = build(schema)
+    const output = stringify({ foo: value })
+
+    t.assert.equal(output, JSON.stringify({ foo: value }))
+    t.assert.deepStrictEqual(JSON.parse(output), { foo: value })
+  }
+})
+
 test('schema with const string and different input', (t) => {
   t.plan(2)
 

package/test/debug-mode.test.js

@@ -22,7 +22,7 @@ function build (opts) {
 
 test('activate debug mode', t => {
   t.plan(5)
-  const debugMode = build({ debugMode: true })
+  const debugMode = build({ mode: 'debug' })
 
   t.assert.ok(typeof debugMode === 'object')
   t.assert.ok(debugMode.ajv instanceof Ajv)
@@ -31,21 +31,9 @@ test('activate debug mode', t => {
   t.assert.ok(typeof debugMode.code === 'string')
 })
 
-test('activate debug mode truthy', t => {
-  t.plan(5)
-
-  const debugMode = build({ debugMode: 'yes' })
-
-  t.assert.ok(typeof debugMode === 'object')
-  t.assert.ok(typeof debugMode.code === 'string')
-  t.assert.ok(debugMode.ajv instanceof Ajv)
-  t.assert.ok(debugMode.validator instanceof Validator)
-  t.assert.ok(debugMode.serializer instanceof Serializer)
-})
-
 test('to string auto-consistent', t => {
   t.plan(6)
-  const debugMode = build({ debugMode: 1 })
+  const debugMode = build({ mode: 'debug' })
 
   t.assert.ok(typeof debugMode === 'object')
   t.assert.ok(typeof debugMode.code === 'string')
@@ -73,7 +61,7 @@ test('to string auto-consistent with ajv', t => {
         }]
       }
     }
-  }, { debugMode: 1 })
+  }, { mode: 'debug' })
 
   t.assert.ok(typeof debugMode === 'object')
   t.assert.ok(typeof debugMode.code === 'string')
@@ -102,7 +90,7 @@ test('to string auto-consistent with ajv-formats', t => {
         }]
       }
     }
-  }, { debugMode: 1 })
+  }, { mode: 'debug' })
 
   t.assert.ok(typeof debugMode === 'object')
 
@@ -115,7 +103,7 @@ test('to string auto-consistent with ajv-formats', t => {
 test('debug should restore the same serializer instance', t => {
   t.plan(1)
 
-  const debugMode = fjs({ type: 'integer' }, { debugMode: 1, rounding: 'ceil' })
+  const debugMode = fjs({ type: 'integer' }, { mode: 'debug', rounding: 'ceil' })
   const compiled = fjs.restore(debugMode)
   t.assert.equal(compiled(3.95), 4)
 })

package/test/patternProperties.test.js

@@ -166,3 +166,27 @@ test('patternProperties - fail on invalid regex, handled by ajv', (t) => {
     }
   }), new Error('schema is invalid: data/patternProperties must match format "regex"'))
 })
+
+test('required key not in properties + patternProperties produces valid JSON', (t) => {
+  // Regression: symmetric case to the additionalProperties variant. `required`
+  // names a key not in `properties`, so after sorting propertiesKeys[0] is not
+  // required and the "first declared property anchors the comma" premise does
+  // not hold. The patternProperties branch shares the same code path, so the
+  // same stray-leading-comma bug would surface here without the tightened
+  // guard in `index.js`.
+  t.plan(2)
+  const stringify = build({
+    type: 'object',
+    properties: {
+      num: { type: 'number' }
+    },
+    patternProperties: {
+      '^s_': { type: 'string' }
+    },
+    required: ['s_x']
+  })
+
+  const out = stringify({ s_x: 'x' })
+  t.assert.equal(out, '{"s_x":"x"}')
+  t.assert.deepStrictEqual(JSON.parse(out), { s_x: 'x' })
+})

package/types/index.d.ts

@@ -162,16 +162,10 @@ declare namespace build {
      * @default 'trunc'
      */
     rounding?: 'ceil' | 'floor' | 'round' | 'trunc'
-    /**
-     * @deprecated
-     * Enable debug mode. Please use `mode: "debug"` instead
-     */
-    debugMode?: boolean
     /**
      * Running mode of fast-json-stringify
      */
     mode?: 'debug' | 'standalone'
-
     /**
      * Large arrays are defined as arrays containing, by default, `20000`
      * elements or more. That value can be adjusted via the option parameter
@@ -180,7 +174,6 @@ declare namespace build {
      * @default 20000
      */
     largeArraySize?: number | string | BigInt
-
     /**
      * Specify the function on how large Arrays should be stringified.
      *
@@ -200,10 +193,6 @@ interface DebugOption extends build.Options {
   mode: 'debug'
 }
 
-interface DeprecateDebugOption extends build.Options {
-  debugMode: true
-}
-
 interface StandaloneOption extends build.Options {
   mode: 'standalone'
 }
@@ -217,7 +206,6 @@ type IntegerCoercible = number | BigInt
  * @param options The options to use (optional)
  */
 declare function build (schema: build.AnySchema, options: DebugOption): { code: string, ajv: Ajv }
-declare function build (schema: build.AnySchema, options: DeprecateDebugOption): { code: string, ajv: Ajv }
 declare function build (schema: build.AnySchema, options: StandaloneOption): string
 declare function build (schema: build.AnySchema, options?: build.Options): <TDoc = any>(doc: TDoc) => any
 declare function build (schema: build.StringSchema, options?: build.Options): <TDoc extends StringCoercible = StringCoercible>(doc: TDoc) => string