Implement function scoped Warning

benchmarks/warn.js

@@ -8,8 +8,8 @@ const err2 = createWarning('FastifyWarning', 'FST_ERROR_CODE_2', 'message')
 
 new Suite()
   .add('warn', function () {
-    err1.emit()
-    err2.emit()
+    err1()
+    err2()
   })
   .on('cycle', function (event) {
     console.log(String(event.target))

examples/example.js

@@ -4,4 +4,4 @@ const { createWarning } = require('..')
 
 const CUSTDEP001 = createWarning('DeprecationWarning', 'CUSTDEP001', 'This is a deprecation warning')
 
-CUSTDEP001.emit()
+CUSTDEP001()

index.js

@@ -62,41 +62,33 @@ function createWarning (name, code, message, { unlimited = false } = {}) {
 
   code = code.toUpperCase()
 
-  return new WarningItem(name, code, message, unlimited)
-}
+  let warning
 
-/**
- * Represents a warning item with details.
- * @class
- * @memberof processWarning
- * @param {string} name - The name of the warning.
- * @param {string} code - The code associated with the warning.
- * @param {string} message - The warning message.
- * @param {boolean} unlimited - If true, allows unlimited emissions of the warning.
- */
-class WarningItem {
-  constructor (name, code, message, unlimited) {
-    this.name = name
-    this.code = code
-    this.message = message
-    this.unlimited = unlimited
-    this.emitted = false
-  }
+  const warningContainer = unlimited
+    ? {
+        [name]: function (a, b, c) {
+          warning.emitted = true
 
-  /**
-   * Emits the warning.
-   * @param {*} [a] Possible message interpolation value.
-   * @param {*} [b] Possible message interpolation value.
-   * @param {*} [c] Possible message interpolation value.
-   */
-  emit (a, b, c) {
-    if (this.emitted === true && this.unlimited === false) {
-      return
-    }
-    this.emitted = true
+          process.emitWarning(warning.format(a, b, c), warning.name, warning.code)
+        }
 
-    process.emitWarning(this.format(a, b, c), this.name, this.code)
-  }
+      }
+    : {
+        [name]: function (a, b, c) {
+          if (warning.emitted === true && warning.unlimited !== true) {
+            return
+          }
+          warning.emitted = true
+
+          process.emitWarning(warning.format(a, b, c), warning.name, warning.code)
+        }
+      }
+  warning = warningContainer[name]
+
+  warning.emitted = false
+  warning.message = message
+  warning.unlimited = unlimited
+  warning.code = code
 
   /**
    * Formats the warning message.
@@ -105,19 +97,21 @@ class WarningItem {
    * @param {*} [c] Possible message interpolation value.
    * @returns {string} The formatted warning message.
    */
-  format (a, b, c) {
+  warning.format = function (a, b, c) {
     let formatted
     if (a && b && c) {
-      formatted = format(this.message, a, b, c)
+      formatted = format(message, a, b, c)
     } else if (a && b) {
-      formatted = format(this.message, a, b)
+      formatted = format(message, a, b)
     } else if (a) {
-      formatted = format(this.message, a)
+      formatted = format(message, a)
     } else {
-      formatted = this.message
+      formatted = message
     }
     return formatted
   }
+
+  return warning
 }
 
 /**

test/emit-interpolated-string.test.js

@@ -15,8 +15,8 @@ test('emit with interpolated string', t => {
   }
 
   const codeWarning = createWarning('FastifyDeprecation', 'CODE', 'Hello %s')
-  codeWarning.emit('world')
-  codeWarning.emit('world')
+  codeWarning('world')
+  codeWarning('world')
 
   setImmediate(() => {
     process.removeListener('warning', onWarning)

test/emit-once-only.test.js

@@ -15,8 +15,8 @@ test('emit should emit a given code only once', t => {
   }
 
   const warn = createWarning('FastifyDeprecation', 'CODE', 'Hello world')
-  warn.emit()
-  warn.emit()
+  warn()
+  warn()
   setImmediate(() => {
     process.removeListener('warning', onWarning)
     t.end()

test/emit-set.test.js

@@ -16,7 +16,7 @@ test('emit should set the emitted state', t => {
   warn.emitted = true
   t.ok(warn.emitted)
 
-  warn.emit()
+  warn()
   t.ok(warn.emitted)
 
   setImmediate(() => {

test/emit-unlimited.test.js

@@ -23,7 +23,7 @@ test('emit should emit a given code unlimited times', t => {
 
   for (let i = 0; i < times; i++) {
     expectedRun.push(i)
-    warn.emit()
+    warn()
   }
   setImmediate(() => {
     process.removeListener('warning', onWarning)

test/issue-88.test.js

@@ -14,8 +14,8 @@ test('Must not overwrite config', t => {
   createWarning('FastifyWarning', 'CODE_2', 'Msg', { unlimited: true })
 
   process.on('warning', onWarning)
-  a.emit('CODE_1')
-  a.emit('CODE_1')
+  a('CODE_1')
+  a('CODE_1')
 
   setImmediate(() => {
     process.removeListener('warning', onWarning)

test/jest.test.js

@@ -5,7 +5,7 @@ const { createWarning } = require('..')
 
 test('works with jest', done => {
   const code = createWarning('FastifyDeprecation', 'CODE', 'Hello %s')
-  code.emit('world')
+  code('world')
 
   // we cannot actually listen to process warning event
   // because jest messes with it (that's the point of this test)