fastify 5.8.5 → 5.10.0

package/fastify.d.ts

@@ -6,7 +6,7 @@ import { Socket } from 'node:net'
 import { BuildCompilerFromPool, ValidatorFactory } from '@fastify/ajv-compiler'
 import { FastifyError } from '@fastify/error'
 import { Options as FJSOptions, SerializerFactory } from '@fastify/fast-json-stringify-compiler'
-import { Config as FindMyWayConfig, ConstraintStrategy, HTTPVersion } from 'find-my-way'
+import { ConstraintStrategy, Config as FindMyWayConfig, HTTPVersion } from 'find-my-way'
 import { InjectOptions, CallbackFunc as LightMyRequestCallback, Chain as LightMyRequestChain, Response as LightMyRequestResponse } from 'light-my-request'
 
 import { AddContentTypeParser, ConstructorAction, FastifyBodyParser, FastifyContentTypeParser, getDefaultJsonParser, hasContentTypeParser, ProtoAction } from './types/content-type-parser'
@@ -17,6 +17,7 @@ import { FastifyInstance, FastifyListenOptions, PrintRoutesOptions } from './typ
 import {
   FastifyBaseLogger,
   FastifyChildLoggerFactory,
+  LogController as LogControllerClass,
   FastifyLogFn,
   FastifyLoggerInstance,
   FastifyLoggerOptions,
@@ -28,7 +29,7 @@ import { FastifyRegister, FastifyRegisterOptions, RegisterOptions } from './type
 import { FastifyReply } from './types/reply'
 import { FastifyRequest, RequestGenericInterface } from './types/request'
 import { RouteGenericInterface, RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler } from './types/route'
-import { FastifySchema, FastifySchemaValidationError, FastifySchemaCompiler, FastifySerializerCompiler, SchemaErrorDataVar, SchemaErrorFormatter } from './types/schema'
+import { FastifySchema, FastifySchemaCompiler, FastifySchemaValidationError, FastifySerializerCompiler, SchemaErrorDataVar, SchemaErrorFormatter } from './types/schema'
 import { FastifyServerFactory, FastifyServerFactoryHandler } from './types/server-factory'
 import { FastifyTypeProvider, FastifyTypeProviderDefault, SafePromiseLike } from './types/type-provider'
 import { ContextConfigDefault, HTTPMethods, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault, RequestBodyDefault, RequestHeadersDefault, RequestParamsDefault, RequestQuerystringDefault } from './types/utils'
@@ -44,6 +45,7 @@ type Fastify = typeof fastify
 
 declare namespace fastify {
   export const errorCodes: FastifyErrorCodes
+  export { LogControllerClass as LogController }
 
   export type FastifyHttp2SecureOptions<
     Server extends http2.Http2SecureServer,
@@ -90,7 +92,7 @@ declare namespace fastify {
 
   type TrustProxyFunction = (address: string, hop: number) => boolean
 
-  export type FastifyRouterOptions<RawServer extends RawServerBase> = Omit<FindMyWayConfigForServer<RawServer>, 'defaultRoute' | 'onBadUrl' | 'querystringParser'> & {
+  export type FastifyRouterOptions<RawServer extends RawServerBase> = Omit<FindMyWayConfigForServer<RawServer>, 'defaultRoute' | 'onBadUrl' | 'onMaxParamLength' | 'querystringParser'> & {
     defaultRoute?: (
       req: RawRequestDefaultExpression<RawServer>,
       res: RawReplyDefaultExpression<RawServer>
@@ -100,6 +102,11 @@ declare namespace fastify {
       req: RawRequestDefaultExpression<RawServer>,
       res: RawReplyDefaultExpression<RawServer>
     ) => void,
+    onMaxParamLength?: (
+      path: string,
+      req: RawRequestDefaultExpression<RawServer>,
+      res: RawReplyDefaultExpression<RawServer>
+    ) => void,
     querystringParser?: (str: string) => { [key: string]: unknown }
   }
 
@@ -121,7 +128,9 @@ declare namespace fastify {
     bodyLimit?: number,
     handlerTimeout?: number,
     maxParamLength?: number,
+    /** @deprecated Use the `logController` option with `disableRequestLogging` or `isLogDisabled` override instead. Will be removed in `fastify@6`. */
     disableRequestLogging?: boolean | ((req: FastifyRequest) => boolean),
+    logController?: LogControllerClass,
     exposeHeadRoutes?: boolean,
     onProtoPoisoning?: ProtoAction,
     onConstructorPoisoning?: ConstructorAction,
@@ -132,6 +141,7 @@ declare namespace fastify {
     caseSensitive?: boolean,
     allowUnsafeRegex?: boolean,
     requestIdHeader?: string | false,
+    /** @deprecated Use the `logController` option with `requestIdLogLabel` instead. Will be removed in `fastify@6`. */
     requestIdLogLabel?: string;
     useSemicolonDelimiter?: boolean,
     genReqId?: (req: RawRequestDefaultExpression<RawServer>) => string,

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '5.8.5'
+const VERSION = '5.10.0'
 
 const Avvio = require('avvio')
 const http = require('node:http')
@@ -33,7 +33,8 @@ const {
   kChildLoggerFactory,
   kGenReqId,
   kErrorHandlerAlreadySet,
-  kHandlerTimeout
+  kHandlerTimeout,
+  kLogController
 } = require('./lib/symbols.js')
 
 const { createServer } = require('./lib/server')
@@ -44,7 +45,7 @@ const decorator = require('./lib/decorate')
 const ContentTypeParser = require('./lib/content-type-parser.js')
 const SchemaController = require('./lib/schema-controller')
 const { Hooks, hookRunnerApplication, supportedHooks } = require('./lib/hooks')
-const { createChildLogger, defaultChildLoggerFactory, createLogger } = require('./lib/logger-factory')
+const { createChildLogger, defaultChildLoggerFactory, createLogger, createLogController, LogController } = require('./lib/logger-factory')
 const pluginUtils = require('./lib/plugin-utils.js')
 const { getGenReqId, reqIdGenFactory } = require('./lib/req-id-gen-factory.js')
 const { buildRouting, validateBodyLimitOption, buildRouterOptions } = require('./lib/route')
@@ -63,6 +64,7 @@ const { defaultInitOptions } = getSecuredInitialConfig
 const {
   FST_ERR_ASYNC_CONSTRAINT,
   FST_ERR_BAD_URL,
+  FST_ERR_MAX_PARAM_LENGTH,
   FST_ERR_OPTIONS_NOT_OBJ,
   FST_ERR_QSP_NOT_FN,
   FST_ERR_SCHEMA_CONTROLLER_BUCKET_OPT_NOT_FN,
@@ -78,7 +80,7 @@ const {
 } = errorCodes
 
 const { buildErrorHandler } = require('./lib/error-handler.js')
-const { FSTWRN004 } = require('./lib/warnings.js')
+const { FSTWRN004, FSTDEP023, FSTDEP024 } = require('./lib/warnings.js')
 
 const initChannel = diagnostics.channel('fastify.initialization')
 
@@ -89,10 +91,10 @@ function fastify (serverOptions) {
   const {
     options,
     genReqId,
-    disableRequestLogging,
+    logController,
     hasLogger,
     initialConfig
-  } = processOptions(serverOptions, defaultRoute, onBadUrl)
+  } = processOptions(serverOptions, defaultRoute, onBadUrl, onMaxParamLength)
 
   // Default router
   const router = buildRouting(options.routerOptions)
@@ -215,6 +217,7 @@ function fastify (serverOptions) {
     },
     // expose logger instance
     log: options.logger,
+    [kLogController]: logController,
     // type provider
     withTypeProvider,
     // hooks
@@ -381,8 +384,7 @@ function fastify (serverOptions) {
       hookRunnerApplication('preClose', fastify[kAvvioBoot], fastify, function () {
         if (fastify[kState].listening) {
           /* istanbul ignore next: Cannot test this without Node.js core support */
-          if (forceCloseConnections === 'idle') {
-            // Not needed in Node 19
+          if (forceCloseConnections === 'idle' && options.serverFactory) {
             instance.server.closeIdleConnections()
             /* istanbul ignore next: Cannot test this without Node.js core support */
           } else if (serverHasCloseAllConnections && forceCloseConnections) {
@@ -423,8 +425,8 @@ function fastify (serverOptions) {
     })
   })
 
-  // Create bad URL context
-  const onBadUrlContext = new Context({
+  // Create route event (bad URL, max param length, etc) context
+  const routeEventContext = new Context({
     server: fastify,
     config: {}
   })
@@ -637,16 +639,13 @@ function fastify (serverOptions) {
 
   function onBadUrl (path, req, res) {
     if (options.frameworkErrors) {
-      const id = getGenReqId(onBadUrlContext.server, req)
-      const childLogger = createChildLogger(onBadUrlContext, options.logger, req, id)
+      const id = getGenReqId(routeEventContext.server, req)
+      const childLogger = createChildLogger(routeEventContext, options.logger, req, id)
 
-      const request = new Request(id, null, req, null, childLogger, onBadUrlContext)
+      const request = new Request(id, null, req, null, childLogger, routeEventContext)
       const reply = new Reply(res, request, childLogger)
 
-      const resolvedDisableRequestLogging = typeof disableRequestLogging === 'function' ? disableRequestLogging(req) : disableRequestLogging
-      if (resolvedDisableRequestLogging === false) {
-        childLogger.info({ req: request }, 'incoming request')
-      }
+      routeEventContext.server[kLogController].incomingRequest(request, reply)
 
       return options.frameworkErrors(new FST_ERR_BAD_URL(path), request, reply)
     }
@@ -663,21 +662,43 @@ function fastify (serverOptions) {
     res.end(body)
   }
 
+  function onMaxParamLength (path, req, res) {
+    if (options.frameworkErrors) {
+      const id = getGenReqId(routeEventContext.server, req)
+      const childLogger = createChildLogger(routeEventContext, options.logger, req, id)
+
+      const request = new Request(id, null, req, null, childLogger, routeEventContext)
+      const reply = new Reply(res, request, childLogger)
+
+      routeEventContext.server[kLogController].incomingRequest(request, reply)
+
+      return options.frameworkErrors(new FST_ERR_MAX_PARAM_LENGTH(path), request, reply)
+    }
+    const body = JSON.stringify({
+      error: 'Bad Request',
+      code: 'FST_ERR_MAX_PARAM_LENGTH',
+      message: `'${path}' is exceeding the max param length`,
+      statusCode: 414
+    })
+    res.writeHead(414, {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(body)
+    })
+    res.end(body)
+  }
+
   function buildAsyncConstraintCallback (isAsync, req, res) {
     if (isAsync === false) return undefined
     return function onAsyncConstraintError (err) {
       if (err) {
         if (options.frameworkErrors) {
-          const id = getGenReqId(onBadUrlContext.server, req)
-          const childLogger = createChildLogger(onBadUrlContext, options.logger, req, id)
+          const id = getGenReqId(routeEventContext.server, req)
+          const childLogger = createChildLogger(routeEventContext, options.logger, req, id)
 
-          const request = new Request(id, null, req, null, childLogger, onBadUrlContext)
+          const request = new Request(id, null, req, null, childLogger, routeEventContext)
           const reply = new Reply(res, request, childLogger)
 
-          const resolvedDisableRequestLogging = typeof disableRequestLogging === 'function' ? disableRequestLogging(req) : disableRequestLogging
-          if (resolvedDisableRequestLogging === false) {
-            childLogger.info({ req: request }, 'incoming request')
-          }
+          routeEventContext.server[kLogController].incomingRequest(request, reply)
 
           return options.frameworkErrors(new FST_ERR_ASYNC_CONSTRAINT(), request, reply)
         }
@@ -748,7 +769,7 @@ function fastify (serverOptions) {
     if (!options.allowErrorHandlerOverride && this[kErrorHandlerAlreadySet]) {
       throw new FST_ERR_ERROR_HANDLER_ALREADY_SET()
     } else if (this[kErrorHandlerAlreadySet]) {
-      FSTWRN004("To disable this behavior, set 'allowErrorHandlerOverride' to false or ignore this message. For more information, visit: https://fastify.dev/docs/latest/Reference/Server/#allowerrorhandleroverride")
+      FSTWRN004()
     }
 
     this[kErrorHandlerAlreadySet] = true
@@ -821,7 +842,7 @@ function fastify (serverOptions) {
   }
 }
 
-function processOptions (options, defaultRoute, onBadUrl) {
+function processOptions (options, defaultRoute, onBadUrl, onMaxParamLength) {
   // Options validations
   if (options && typeof options !== 'object') {
     throw new FST_ERR_OPTIONS_NOT_OBJ()
@@ -848,9 +869,13 @@ function processOptions (options, defaultRoute, onBadUrl) {
 
   const requestIdHeader = typeof options.requestIdHeader === 'string' && options.requestIdHeader.length !== 0 ? options.requestIdHeader.toLowerCase() : (options.requestIdHeader === true && 'request-id')
   const genReqId = reqIdGenFactory(requestIdHeader, options.genReqId)
-  const requestIdLogLabel = options.requestIdLogLabel || 'reqId'
+  if (options.requestIdLogLabel !== undefined) {
+    FSTDEP024()
+  }
   options.bodyLimit = options.bodyLimit || defaultInitOptions.bodyLimit
-  const disableRequestLogging = options.disableRequestLogging || false
+  if (options.disableRequestLogging !== undefined) {
+    FSTDEP023()
+  }
 
   const ajvOptions = Object.assign({
     customOptions: {},
@@ -866,6 +891,10 @@ function processOptions (options, defaultRoute, onBadUrl) {
 
   const { logger, hasLogger } = createLogger(options)
 
+  // the internal logger uses the input logger to execute the logging. This allows the user
+  // to customize every internal log line
+  const logController = createLogController(options)
+
   // Update the options with the fixed values
   options.connectionTimeout = options.connectionTimeout || defaultInitOptions.connectionTimeout
   options.keepAliveTimeout = options.keepAliveTimeout || defaultInitOptions.keepAliveTimeout
@@ -873,8 +902,6 @@ function processOptions (options, defaultRoute, onBadUrl) {
   options.requestTimeout = options.requestTimeout || defaultInitOptions.requestTimeout
   options.logger = logger
   options.requestIdHeader = requestIdHeader
-  options.requestIdLogLabel = requestIdLogLabel
-  options.disableRequestLogging = disableRequestLogging
   options.ajv = ajvOptions
   options.clientErrorHandler = options.clientErrorHandler || defaultClientErrorHandler
   options.allowErrorHandlerOverride = options.allowErrorHandlerOverride ?? defaultInitOptions.allowErrorHandlerOverride
@@ -890,6 +917,7 @@ function processOptions (options, defaultRoute, onBadUrl) {
   options.routerOptions = buildRouterOptions(options, {
     defaultRoute,
     onBadUrl,
+    onMaxParamLength,
     ignoreTrailingSlash: defaultInitOptions.ignoreTrailingSlash,
     ignoreDuplicateSlashes: defaultInitOptions.ignoreDuplicateSlashes,
     maxParamLength: defaultInitOptions.maxParamLength,
@@ -901,7 +929,7 @@ function processOptions (options, defaultRoute, onBadUrl) {
   return {
     options,
     genReqId,
-    disableRequestLogging,
+    logController,
     hasLogger,
     initialConfig
   }
@@ -981,5 +1009,6 @@ function validateSchemaErrorFormatter (schemaErrorFormatter) {
  */
 module.exports = fastify
 module.exports.errorCodes = errorCodes
+module.exports.LogController = LogController
 module.exports.fastify = fastify
 module.exports.default = fastify

package/lib/content-type-parser.js

@@ -118,6 +118,8 @@ ContentTypeParser.prototype.existingParser = function (contentType) {
 
 ContentTypeParser.prototype.getParser = function (contentType) {
   if (typeof contentType === 'string') {
+    const cached = this.cache.get(contentType)
+    if (cached !== undefined) return cached
     contentType = new ContentType(contentType)
   }
   const ct = contentType.toString()

package/lib/content-type.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const { LruMap: Lru } = require('toad-cache')
+
 /**
  * keyValuePairsReg is used to split the parameters list into associated
  * key value pairings. The leading `(?:^|;)\s*` anchor ensures the regex
@@ -35,6 +37,12 @@ const typeNameReg = /^[\w!#$%&'*+.^`|~-]+$/
  */
 const subtypeNameReg = /^[\w!#$%&'*+.^`|~-]+\s*$/
 
+/**
+ * Content-Type internal shared cache
+ * @type {Lru<ContentType>}
+ */
+const cache = new Lru(100)
+
 /**
  * ContentType parses and represents the value of the content-type header.
  *
@@ -49,6 +57,27 @@ class ContentType {
   #parameters = new Map()
   #string
 
+  /**
+   * The shared cache of ContentType instances. The cache is used to avoid
+   * creating multiple instances of ContentType for the same header value.
+   * @type {Lru<ContentType>}
+   */
+  static get cache () { return cache }
+
+  /**
+   * Create a ContentType instance from a header value. If the value has been
+   * previously parsed, the cached instance will be returned.
+   * @param {string} headerValue
+   * @returns {ContentType | undefined}
+   */
+  static from (headerValue) {
+    let contentType = cache.get(headerValue)
+    if (contentType !== undefined) return contentType
+    contentType = new ContentType(headerValue)
+    cache.set(headerValue, contentType)
+    return contentType
+  }
+
   constructor (headerValue) {
     if (headerValue == null || headerValue === '' || headerValue === 'undefined') {
       return
@@ -106,7 +135,11 @@ class ContentType {
 
     let matches = keyValuePairsReg.exec(paramsList)
     while (matches) {
-      const key = matches[1]
+      // https://httpwg.org/specs/rfc9110.html#parameter
+      // Parameter names are case-insensitive.
+      const key = matches[1].toLowerCase()
+      // Parameter values might or might not be case-sensitive,
+      // depending on the semantics of the parameter name.
       const value = matches[2]
       if (value[0] === '"') {
         if (value.at(-1) !== '"') {

package/lib/context.js

@@ -6,7 +6,6 @@ const {
   kSchemaErrorFormatter,
   kErrorHandler,
   kChildLoggerFactory,
-  kOptions,
   kReply,
   kRequest,
   kBodyLimit,
@@ -24,7 +23,6 @@ function Context ({
   schema,
   handler,
   config,
-  requestIdLogLabel,
   childLoggerFactory,
   errorHandler,
   bodyLimit,
@@ -56,7 +54,6 @@ function Context ({
   this.onRequestAbort = null
   this.config = config
   this.errorHandler = errorHandler || server[kErrorHandler]
-  this.requestIdLogLabel = requestIdLogLabel || server[kOptions].requestIdLogLabel
   this.childLoggerFactory = childLoggerFactory || server[kChildLoggerFactory]
   this._middie = null
   this._parserOptions = {

package/lib/decorate.js

@@ -47,7 +47,7 @@ function getInstanceDecorator (name) {
 
 function decorateConstructor (konstructor, name, fn, dependencies) {
   const instance = konstructor.prototype
-  if (Object.hasOwn(instance, name) || hasKey(konstructor, name)) {
+  if (Object.hasOwn(instance, name) || hasKey(konstructor, name) || hasInstanceProperty(konstructor, name)) {
     throw new FST_ERR_DEC_ALREADY_PRESENT(name)
   }
 
@@ -87,19 +87,27 @@ function checkExistence (instance, name) {
 }
 
 function hasKey (fn, name) {
-  if (fn.props) {
-    return fn.props.find(({ key }) => key === name)
+  return fn.props ? fn.props.some(p => p.key === name) : false
+}
+
+function hasInstanceProperty (konstructor, name) {
+  let k = konstructor
+  while (k) {
+    if (k.instanceProperties && k.instanceProperties.has(name)) return true
+    k = k.parent
   }
   return false
 }
 
 function checkRequestExistence (name) {
   if (name && hasKey(this[kRequest], name)) return true
+  if (name && hasInstanceProperty(this[kRequest], name)) return true
   return checkExistence(this[kRequest].prototype, name)
 }
 
 function checkReplyExistence (name) {
   if (name && hasKey(this[kReply], name)) return true
+  if (name && hasInstanceProperty(this[kReply], name)) return true
   return checkExistence(this[kReply].prototype, name)
 }
 

package/lib/error-handler.js

@@ -8,7 +8,8 @@ const {
   kReplyNextErrorHandler,
   kReplyIsRunningOnErrorHook,
   kRouteContext,
-  kDisableRequestLogging
+  kLogController,
+  kDiagnosticsStore
 } = require('./symbols.js')
 
 const {
@@ -19,7 +20,6 @@ const {
 const { getSchemaSerializer } = require('./schemas')
 
 const serializeError = require('./error-serializer')
-
 const rootErrorHandler = {
   func: defaultErrorHandler,
   toJSON () {
@@ -36,12 +36,7 @@ function handleError (reply, error, cb) {
       try {
         reply.raw.writeHead(reply.raw.statusCode, reply[kReplyHeaders])
       } catch (error) {
-        if (!reply.log[kDisableRequestLogging]) {
-          reply.log.warn(
-            { req: reply.request, res: reply, err: error },
-            error?.message
-          )
-        }
+        reply.server[kLogController].writeHeadError(error, reply.request, reply)
         reply.raw.writeHead(reply.raw.statusCode)
       }
       reply.raw.end(payload)
@@ -69,7 +64,8 @@ function handleError (reply, error, cb) {
     const result = func(error, reply.request, reply)
     if (result !== undefined) {
       if (result !== null && typeof result.then === 'function') {
-        wrapThenable(result, reply)
+        const store = reply[kDiagnosticsStore] || null
+        wrapThenable(result, reply, store)
       } else {
         reply.send(result)
       }
@@ -82,21 +78,7 @@ function handleError (reply, error, cb) {
 function defaultErrorHandler (error, request, reply) {
   setErrorHeaders(error, reply)
   setErrorStatusCode(reply, error)
-  if (reply.statusCode < 500) {
-    if (!reply.log[kDisableRequestLogging]) {
-      reply.log.info(
-        { res: reply, err: error },
-        error?.message
-      )
-    }
-  } else {
-    if (!reply.log[kDisableRequestLogging]) {
-      reply.log.error(
-        { req: request, res: reply, err: error },
-        error?.message
-      )
-    }
-  }
+  request.server[kLogController].defaultErrorLog(error, request, reply)
   reply.send(error)
 }
 
@@ -122,10 +104,10 @@ function fallbackErrorHandler (error, reply, cb) {
       }))
     }
   } catch (err) {
-    if (!reply.log[kDisableRequestLogging]) {
-      // error is always FST_ERR_SCH_SERIALIZATION_BUILD because this is called from route/compileSchemasForSerialization
-      reply.log.error({ err, statusCode: res.statusCode }, 'The serializer for the given status code failed')
-    }
+    // error is always FST_ERR_SCH_SERIALIZATION_BUILD
+    // because this is called from route/compileSchemasForSerialization
+    reply.server[kLogController].serializerError(err, reply.request, reply, { statusCode: res.statusCode })
+
     reply.code(500)
     payload = serializeError(new FST_ERR_FAILED_ERROR_SERIALIZATION(err.message, error.message))
   }

package/lib/error-serializer.js

@@ -40,93 +40,93 @@ const asInteger = serializer.asInteger.bind(serializer)
     const JSON_STR_NULL = 'null'
   
     
-  
-    // #
-    function anonymous0 (input) {
-      const obj = (input && typeof input.toJSON === 'function')
+      // #
+      function anonymous0 (input) {
+        const obj = (input && typeof input.toJSON === 'function')
     ? input.toJSON()
     : input
   
-      if (obj === null) return JSON_STR_EMPTY_OBJECT
+        if (obj === null) return JSON_STR_EMPTY_OBJECT
+        let json = ''
 
-      let value
-let json = JSON_STR_BEGIN_OBJECT
-let addComma = false
+        json += JSON_STR_BEGIN_OBJECT
+let addComma_0 = false
 
-      value = obj["statusCode"]
-      if (value !== undefined) {
-        !addComma && (addComma = true) || (json += JSON_STR_COMMA)
-        json += "\"statusCode\":"
-        json += asNumber(value)
-      }
+          const value_statusCode_1 = obj["statusCode"]
+          if (value_statusCode_1 !== undefined) {
+            !addComma_0 && (addComma_0 = true) || (json += JSON_STR_COMMA)
+            json += "\"statusCode\":"
+            json += asNumber(value_statusCode_1)
+          }
 
-      value = obj["code"]
-      if (value !== undefined) {
-        !addComma && (addComma = true) || (json += JSON_STR_COMMA)
-        json += "\"code\":"
-        
-        if (typeof value !== 'string') {
-          if (value === null) {
+          const value_code_2 = obj["code"]
+          if (value_code_2 !== undefined) {
+            !addComma_0 && (addComma_0 = true) || (json += JSON_STR_COMMA)
+            json += "\"code\":"
+            
+        if (typeof value_code_2 !== 'string') {
+          if (value_code_2 === null) {
             json += JSON_STR_EMPTY_STRING
-          } else if (value instanceof Date) {
-            json += JSON_STR_QUOTE + value.toISOString() + JSON_STR_QUOTE
-          } else if (value instanceof RegExp) {
-            json += asString(value.source)
+          } else if (value_code_2 instanceof Date) {
+            json += JSON_STR_QUOTE + value_code_2.toISOString() + JSON_STR_QUOTE
+          } else if (value_code_2 instanceof RegExp) {
+            json += asString(value_code_2.source)
           } else {
-            json += asString(value.toString())
+            json += asString(value_code_2.toString())
           }
         } else {
-          json += asString(value)
+          json += asString(value_code_2)
         }
         
-      }
+          }
 
-      value = obj["error"]
-      if (value !== undefined) {
-        !addComma && (addComma = true) || (json += JSON_STR_COMMA)
-        json += "\"error\":"
-        
-        if (typeof value !== 'string') {
-          if (value === null) {
+          const value_error_3 = obj["error"]
+          if (value_error_3 !== undefined) {
+            !addComma_0 && (addComma_0 = true) || (json += JSON_STR_COMMA)
+            json += "\"error\":"
+            
+        if (typeof value_error_3 !== 'string') {
+          if (value_error_3 === null) {
             json += JSON_STR_EMPTY_STRING
-          } else if (value instanceof Date) {
-            json += JSON_STR_QUOTE + value.toISOString() + JSON_STR_QUOTE
-          } else if (value instanceof RegExp) {
-            json += asString(value.source)
+          } else if (value_error_3 instanceof Date) {
+            json += JSON_STR_QUOTE + value_error_3.toISOString() + JSON_STR_QUOTE
+          } else if (value_error_3 instanceof RegExp) {
+            json += asString(value_error_3.source)
           } else {
-            json += asString(value.toString())
+            json += asString(value_error_3.toString())
           }
         } else {
-          json += asString(value)
+          json += asString(value_error_3)
         }
         
-      }
+          }
 
-      value = obj["message"]
-      if (value !== undefined) {
-        !addComma && (addComma = true) || (json += JSON_STR_COMMA)
-        json += "\"message\":"
-        
-        if (typeof value !== 'string') {
-          if (value === null) {
+          const value_message_4 = obj["message"]
+          if (value_message_4 !== undefined) {
+            !addComma_0 && (addComma_0 = true) || (json += JSON_STR_COMMA)
+            json += "\"message\":"
+            
+        if (typeof value_message_4 !== 'string') {
+          if (value_message_4 === null) {
             json += JSON_STR_EMPTY_STRING
-          } else if (value instanceof Date) {
-            json += JSON_STR_QUOTE + value.toISOString() + JSON_STR_QUOTE
-          } else if (value instanceof RegExp) {
-            json += asString(value.source)
+          } else if (value_message_4 instanceof Date) {
+            json += JSON_STR_QUOTE + value_message_4.toISOString() + JSON_STR_QUOTE
+          } else if (value_message_4 instanceof RegExp) {
+            json += asString(value_message_4.source)
           } else {
-            json += asString(value.toString())
+            json += asString(value_message_4.toString())
           }
         } else {
-          json += asString(value)
+          json += asString(value_message_4)
         }
         
-      }
+          }
 
-    return json + JSON_STR_END_OBJECT
-  
-    }
+    json += JSON_STR_END_OBJECT
   
+        return json
+      }
+    
     const main = anonymous0
     return main