Add BaseError.httpResponse()

Author: ehmicky

CHANGELOG.md

@@ -1,3 +1,11 @@
+# 2.2.0
+
+## Features
+
+- `error.httpResponse()` has been renamed to
+  [`BaseError.httpResponse(error)`](README.md#baseerrorhttpresponseerror).
+  `error.httpResponse()` is deprecated but still supported.
+
 # 2.1.0
 
 ## Features

README.md

@@ -15,9 +15,10 @@
 [plugin](https://github.com/ehmicky/modern-errors#-plugins) to create HTTP error
 responses.
 
-This adds [`error.httpResponse()`](#errorhttpresponse) which converts `error` to
-a plain object ([RFC 7807](https://www.rfc-editor.org/rfc/rfc7807), "problem
-details") to use in an HTTP response.
+This adds [`BaseError.httpResponse(error)`](#baseerrorhttpresponseerror) which
+converts `error` to a plain object
+([RFC 7807](https://www.rfc-editor.org/rfc/rfc7807), "problem details") to use
+in an HTTP response.
 
 # Example
 
@@ -44,7 +45,7 @@ export const AuthError = BaseError.subclass('AuthError', {
 })
 ```
 
-[Creating](#errorhttpresponse) an HTTP error response.
+[Creating](#baseerrorhttpresponseerror) an HTTP error response.
 
 ```js
 const error = new AuthError('Could not authenticate.', {
@@ -53,7 +54,7 @@ const error = new AuthError('Could not authenticate.', {
     extra: { userId: 62 },
   },
 })
-const object = error.httpResponse()
+const object = BaseError.httpResponse(error)
 // {
 //   type: 'https://example.com/probs/auth',
 //   status: 401,
@@ -88,7 +89,9 @@ Plugin object to pass to the
 [`plugins` option](https://github.com/ehmicky/modern-errors#adding-plugins) of
 `ErrorClass.subclass()`.
 
-## error.httpResponse()
+## BaseError.httpResponse(error)
+
+`error`: `Error`
 
 _Return value_: `HttpResponse`
 
@@ -181,10 +184,10 @@ export const AuthError = BaseError.subclass('AuthError', {
 throw new AuthError('...', { http: { ...options } })
 ```
 
-- A specific [`error.httpResponse()`](#errorhttpresponse) call
+- A specific [`BaseError.httpResponse(error)`](#baseerrorhttpresponseerror) call
 
 ```js
-error.httpResponse(...args, { ...options })
+BaseError.httpResponse(error, ...args, { ...options })
 ```
 
 # Related projects

test/main.js

@@ -21,7 +21,9 @@ each(
   ],
   ({ title }, [propName, propValue]) => {
     test(`Valid options are kept | ${title}`, (t) => {
-      const httpResponse = baseError.httpResponse({ [propName]: propValue })
+      const httpResponse = BaseError.httpResponse(baseError, {
+        [propName]: propValue,
+      })
       t.deepEqual(httpResponse[propName], propValue)
     })
   },
@@ -35,30 +37,36 @@ each(
       (optName) => ({ [optName]: undefined }),
     ),
   ],
-  ({ title }, http) => {
+  ({ title }, options) => {
     test(`Assign default options | ${title}`, (t) => {
       const { name, message, stack } = baseError
-      const httpResponse = baseError.httpResponse(http)
+      const httpResponse = BaseError.httpResponse(baseError, options)
       t.deepEqual(httpResponse, { title: name, detail: message, stack })
     })
   },
 )
 
+test('Can be called as error.httpResponse()', (t) => {
+  t.is(BaseError.httpResponse(baseError).title, baseError.name)
+})
+
 test('Assign default extra', (t) => {
   const props = { prop: true }
-  t.deepEqual(new BaseError('test', { props }).httpResponse().extra, props)
+  const error = new BaseError('test', { props })
+  t.deepEqual(BaseError.httpResponse(error).extra, props)
 })
 
 test('Keep extra JSON-safe', (t) => {
-  t.deepEqual(baseError.httpResponse({ extra: { one: true, two: 0n } }).extra, {
-    one: true,
-  })
+  t.deepEqual(
+    BaseError.httpResponse(baseError, { extra: { one: true, two: 0n } }).extra,
+    { one: true },
+  )
 })
 
 test('Keep object keys order', (t) => {
   t.deepEqual(
     Object.keys(
-      baseError.httpResponse({
+      BaseError.httpResponse(baseError, {
         extra: {},
         stack: '',
         instance: '',

test/options.js

@@ -1,7 +1,7 @@
 import test from 'ava'
 import { each } from 'test-each'
 
-import { baseError } from './helpers/main.js'
+import { BaseError, baseError } from './helpers/main.js'
 
 each(
   [
@@ -18,9 +18,9 @@ each(
     ]),
     { extra: true },
   ],
-  ({ title }, http) => {
+  ({ title }, options) => {
     test(`Options are validated | ${title}`, (t) => {
-      t.throws(baseError.httpResponse.bind(baseError, http))
+      t.throws(BaseError.httpResponse.bind(undefined, baseError, options))
     })
   },
 )

types/main.d.ts

@@ -58,7 +58,7 @@ export interface Options {
 }
 
 /**
- * `error.httpResponse()`'s return value
+ * `BaseError.httpResponse(error)`'s return value
  */
 export interface HttpResponse extends Options {
   readonly title: string
@@ -80,7 +80,7 @@ declare const plugin: {
      *
      * @example
      * ```js
-     * const object = error.httpResponse()
+     * const object = BaseError.httpResponse(error)
      * // {
      * //   type: 'https://example.com/probs/auth',
      * //   status: 401,

types/main.test-d.ts

@@ -9,115 +9,115 @@ import {
 
 const BaseError = ModernError.subclass('BaseError', { plugins: [plugin] })
 const error = new BaseError('')
-const httpResponse = error.httpResponse()
+const httpResponse = BaseError.httpResponse(error)
 
 ModernError.subclass('TestError', { plugins: [plugin], http: {} })
-error.httpResponse({})
+BaseError.httpResponse(error, {})
 expectAssignable<Options>({})
-expectError(error.httpResponse(undefined))
+expectError(BaseError.httpResponse(error, undefined))
 expectNotAssignable<Options>(undefined)
 expectError(
   ModernError.subclass('TestError', { plugins: [plugin], http: true }),
 )
-expectError(error.httpResponse(true))
+expectError(BaseError.httpResponse(error, true))
 expectNotAssignable<Options>(true)
 expectError(
   ModernError.subclass('TestError', {
     plugins: [plugin],
     http: { unknown: true },
   }),
 )
-expectError(error.httpResponse({ unknown: true }))
+expectError(BaseError.httpResponse(error, { unknown: true }))
 expectNotAssignable<Options>({ unknown: true })
 
 ModernError.subclass('TestError', { plugins: [plugin], http: { type: '' } })
-error.httpResponse({ type: '' })
+BaseError.httpResponse(error, { type: '' })
 expectAssignable<Options>({ type: '' })
 expectError(
   ModernError.subclass('TestError', {
     plugins: [plugin],
     http: { type: true },
   }),
 )
-expectError(error.httpResponse({ type: true }))
+expectError(BaseError.httpResponse(error, { type: true }))
 expectNotAssignable<Options>({ type: true })
 
 ModernError.subclass('TestError', { plugins: [plugin], http: { status: 200 } })
-error.httpResponse({ status: 200 })
+BaseError.httpResponse(error, { status: 200 })
 expectAssignable<Options>({ status: 200 })
 expectError(
   ModernError.subclass('TestError', {
     plugins: [plugin],
     http: { status: true },
   }),
 )
-expectError(error.httpResponse({ status: true }))
+expectError(BaseError.httpResponse(error, { status: true }))
 expectNotAssignable<Options>({ status: true })
 
 ModernError.subclass('TestError', { plugins: [plugin], http: { title: '' } })
-error.httpResponse({ title: '' })
+BaseError.httpResponse(error, { title: '' })
 expectAssignable<Options>({ title: '' })
 expectError(
   ModernError.subclass('TestError', {
     plugins: [plugin],
     http: { title: true },
   }),
 )
-expectError(error.httpResponse({ title: true }))
+expectError(BaseError.httpResponse(error, { title: true }))
 expectNotAssignable<Options>({ title: true })
 
 ModernError.subclass('TestError', { plugins: [plugin], http: { detail: '' } })
-error.httpResponse({ detail: '' })
+BaseError.httpResponse(error, { detail: '' })
 expectAssignable<Options>({ detail: '' })
 expectError(
   ModernError.subclass('TestError', {
     plugins: [plugin],
     http: { detail: true },
   }),
 )
-expectError(error.httpResponse({ detail: true }))
+expectError(BaseError.httpResponse(error, { detail: true }))
 expectNotAssignable<Options>({ detail: true })
 
 ModernError.subclass('TestError', { plugins: [plugin], http: { instance: '' } })
-error.httpResponse({ instance: '' })
+BaseError.httpResponse(error, { instance: '' })
 expectAssignable<Options>({ instance: '' })
 expectError(
   ModernError.subclass('TestError', {
     plugins: [plugin],
     http: { instance: true },
   }),
 )
-expectError(error.httpResponse({ instance: true }))
+expectError(BaseError.httpResponse(error, { instance: true }))
 expectNotAssignable<Options>({ instance: true })
 
 ModernError.subclass('TestError', { plugins: [plugin], http: { stack: '' } })
-error.httpResponse({ stack: '' })
+BaseError.httpResponse(error, { stack: '' })
 expectAssignable<Options>({ stack: '' })
 expectError(
   ModernError.subclass('TestError', {
     plugins: [plugin],
     http: { stack: true },
   }),
 )
-expectError(error.httpResponse({ stack: true }))
+expectError(BaseError.httpResponse(error, { stack: true }))
 expectNotAssignable<Options>({ stack: true })
 
 ModernError.subclass('TestError', { plugins: [plugin], http: { extra: {} } })
-error.httpResponse({ extra: {} })
+BaseError.httpResponse(error, { extra: {} })
 expectAssignable<Options>({ extra: {} })
 ModernError.subclass('TestError', {
   plugins: [plugin],
   http: { extra: { prop: true } },
 })
-error.httpResponse({ extra: { prop: true } })
+BaseError.httpResponse(error, { extra: { prop: true } })
 expectAssignable<Options>({ extra: { prop: true } })
 expectError(
   ModernError.subclass('TestError', {
     plugins: [plugin],
     http: { extra: true },
   }),
 )
-expectError(error.httpResponse({ extra: true }))
+expectError(BaseError.httpResponse(error, { extra: true }))
 expectNotAssignable<Options>({ extra: true })
 
 expectType<HttpResponse>(httpResponse)
@@ -129,3 +129,6 @@ expectType<string | undefined>(httpResponse.instance)
 expectType<string>(httpResponse.stack)
 expectType<object | undefined>(httpResponse.extra)
 expectError(httpResponse.extra?.prop)
+
+expectType<HttpResponse>(error.httpResponse())
+expectError(error.httpResponse(true))