From e34f413a9d2699f3f6a852736bdcc8e9f7ff34ae Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marcus=20P=C3=B6hls?= Date: Fri, 3 Nov 2023 09:15:16 +0100 Subject: [PATCH] switch error handling params from ctx,error to error,ctx --- packages/contracts/src/core/error-handler.ts | 6 +-- packages/core/src/errors/handler.ts | 42 +++++++++---------- packages/core/test/error-handler.js | 6 +-- packages/http/src/middleware/handle-error.ts | 6 +-- packages/http/test/helpers/error-handler.js | 2 +- .../session/test/helpers/error-handler.js | 4 +- 6 files changed, 33 insertions(+), 33 deletions(-) diff --git a/packages/contracts/src/core/error-handler.ts b/packages/contracts/src/core/error-handler.ts index 62a5fc5a..c686993d 100644 --- a/packages/contracts/src/core/error-handler.ts +++ b/packages/contracts/src/core/error-handler.ts @@ -16,15 +16,15 @@ export interface ErrorHandler { /** * Handle the given error. */ - handle(ctx: HttpContext, error: Error): Promise + handle(error: Error, ctx: HttpContext): Promise /** * Report an error. */ - report(context: HttpContext, error: Error): void | Promise + report(error: Error, ctx: HttpContext): void | Promise /** * Render an error into an HTTP response. */ - render(context: HttpContext, error: Error): Promise + render(error: Error, ctx: HttpContext): Promise } diff --git a/packages/core/src/errors/handler.ts b/packages/core/src/errors/handler.ts index 721d5942..e7356164 100644 --- a/packages/core/src/errors/handler.ts +++ b/packages/core/src/errors/handler.ts @@ -19,7 +19,7 @@ export class ErrorHandler implements ErrorHandlerContract { /** * Stores the list of report callbacks. */ - protected readonly reportCallbacks: Array<(ctx: HttpContext, error: HttpError) => void | Promise> + protected readonly reportCallbacks: Array<(error: HttpError, ctx: HttpContext) => void | Promise> /** * Create a new error handler instance. @@ -85,7 +85,7 @@ export class ErrorHandler implements ErrorHandlerContract { /** * Register a reportable callback. */ - reportable (reportUsing: (ctx: HttpContext, error: any) => void | Promise): ErrorHandler { + reportable (reportUsing: (error: any, ctx: HttpContext) => void | Promise): ErrorHandler { return tap(this, () => { this.reportCallbacks.push(reportUsing) }) @@ -112,25 +112,25 @@ export class ErrorHandler implements ErrorHandlerContract { /** * Handle the given error. */ - async handle (ctx: HttpContext, error: any): Promise { - await this.report(ctx, error) - await this.render(ctx, error) + async handle (error: any, ctx: HttpContext): Promise { + await this.report(error, ctx) + await this.render(error, ctx) } /** * Report an error. */ - async report (ctx: HttpContext, error: any): Promise { + async report (error: any, ctx: HttpContext): Promise { if (this.shouldNotReport(error)) { return } - if (await this.errorReported(ctx, error)) { + if (await this.errorReported(error, ctx)) { return } const handled = await Collect(this.reportCallbacks).any(async reportCallback => { - return await reportCallback(ctx, error) + return await reportCallback(error, ctx) }) if (handled) { @@ -147,54 +147,54 @@ export class ErrorHandler implements ErrorHandlerContract { } /** - * Determine whether the given `error` is implementing a `handle` method and - * that `handle` method returns a truthy value, like a valid HTTP response. + * Determine whether the given `error` is implementing a `report` method and + * that `report` method returns a truthy value, like a valid HTTP response. */ - async errorReported (ctx: HttpContext, error: any): Promise { + async errorReported (error: any, ctx: HttpContext): Promise { if (typeof error.report !== 'function') { return false } - return await error.report(error, ctx) + return !!(await error.report(error, ctx)) } /** * Render the error into an HTTP response. */ - async render (ctx: HttpContext, error: any): Promise { - if (await this.errorRendered(ctx, error)) { + async render (error: any, ctx: HttpContext): Promise { + if (await this.errorRendered(error, ctx)) { return } const httpError = HttpError.wrap(error) if (ctx.request.wantsJson()) { - return this.renderJsonResponse(ctx, httpError) + return this.renderJsonResponse(httpError, ctx) } if (this.app.env().isProduction()) { - return this.renderJsonResponse(ctx, httpError) + return this.renderJsonResponse(httpError, ctx) } - return await this.renderViewResponse(ctx, httpError) + return await this.renderViewResponse(httpError, ctx) } /** * Determine whether the given `error` is implementing a `render` method and * that `render` method returns a truthy value, like a valid HTTP response. */ - async errorRendered (ctx: HttpContext, error: any): Promise { + async errorRendered (error: any, ctx: HttpContext): Promise { if (typeof error.render !== 'function') { return false } - return await error.render(ctx, error) + return await error.render(error, ctx) } /** * Creates a JSON response depending on the app’s environment. */ - protected renderJsonResponse (ctx: HttpContext, error: HttpError): void { + protected renderJsonResponse (error: HttpError, ctx: HttpContext): void { const { message, stack, status: statusCode } = error this.app.env().isProduction() @@ -205,7 +205,7 @@ export class ErrorHandler implements ErrorHandlerContract { /** * Creates an HTML response depending on the app’s environment. */ - protected async renderViewResponse (ctx: HttpContext, error: HttpError): Promise { + protected async renderViewResponse (error: HttpError, ctx: HttpContext): Promise { if (await this.isMissingTemplateFor(error)) { return await this.renderYouchResponse(ctx, error) } diff --git a/packages/core/test/error-handler.js b/packages/core/test/error-handler.js index df88c746..847cf6d3 100644 --- a/packages/core/test/error-handler.js +++ b/packages/core/test/error-handler.js @@ -183,7 +183,7 @@ test('calls report callbacks', async () => { class CustomErrorHandler extends ErrorHandler { register () { - this.reportable((_, error) => { + this.reportable(error => { reportedError = error }) } @@ -215,7 +215,7 @@ test('report callbacks can stop the reportable chain', async () => { .reportable(() => { return true }) - .reportable((_ctx, error) => { + .reportable(error => { reportedError = error }) } @@ -448,7 +448,7 @@ class ReportedError extends ReportingError { } class RenderError extends Error { - render (ctx, error) { + render (error, ctx) { return ctx.response.payload({ message: error.message, foo: 'bar', diff --git a/packages/http/src/middleware/handle-error.ts b/packages/http/src/middleware/handle-error.ts index a9f757d4..8a0c160a 100644 --- a/packages/http/src/middleware/handle-error.ts +++ b/packages/http/src/middleware/handle-error.ts @@ -10,16 +10,16 @@ export class HandleErrorMiddleware extends Middleware { try { await next() } catch (error: any) { - await this.handleError(ctx, error) + await this.handleError(error, ctx) } } /** * Process the given `error` and HTTP `ctx` using the error handler. */ - private async handleError (ctx: HttpContext, error: Error): Promise { + private async handleError (error: Error, ctx: HttpContext): Promise { if (this.app.hasBinding('error.handler')) { - return await this.app.make('error.handler').handle(ctx, error) + return await this.app.make('error.handler').handle(error, ctx) } throw error diff --git a/packages/http/test/helpers/error-handler.js b/packages/http/test/helpers/error-handler.js index 36fc94ab..9facea42 100644 --- a/packages/http/test/helpers/error-handler.js +++ b/packages/http/test/helpers/error-handler.js @@ -1,6 +1,6 @@ export default class ErrorHandler { - handle (ctx, error) { + handle (error, ctx) { // console.log('Received error in testing error handler', { error }) ctx.response.status(error.status || error.statusCode || 500) diff --git a/packages/session/test/helpers/error-handler.js b/packages/session/test/helpers/error-handler.js index 964aac72..e32b0103 100644 --- a/packages/session/test/helpers/error-handler.js +++ b/packages/session/test/helpers/error-handler.js @@ -2,9 +2,9 @@ import { ErrorHandler as Handler } from '@supercharge/core' export default class ErrorHandler extends Handler { - handle (ctx, error) { + handle (error, ctx) { // console.error('Received error in testing error handler', { error }) - return super.handle(ctx, error) + return super.handle(error, ctx) } }