[2.1.0] Post-Execution-Functions will now be executed, even if the handler failed

.eslintignore

@@ -1,3 +1,2 @@
 node_modules
 dist
-*.test.ts

.eslintrc.js

@@ -1,17 +1,11 @@
 module.exports = {
-    parser: "@typescript-eslint/parser", // Specifies the ESLint parser
+    parser: '@typescript-eslint/parser', // Specifies the ESLint parser
     parserOptions: {
         ecmaVersion: 2020, // Allows for the parsing of modern ECMAScript features
-        sourceType: "module", // Allows for the use of imports
-        ecmaFeatures: {
-        }
-    },
-    settings: {
-    },
-    extends: [
-        "plugin:@typescript-eslint/recommended",
-        "plugin:prettier/recommended"
-    ],
-    rules: {
+        sourceType: 'module', // Allows for the use of imports
+        ecmaFeatures: {},
     },
+    settings: {},
+    extends: ['plugin:@typescript-eslint/recommended', 'plugin:prettier/recommended'],
+    rules: {},
 };

.github/workflows/ci.yml

@@ -10,7 +10,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [ 15.x, 16.x ]
+        node-version: [ 16.x, 18.x ]
 
     steps:
       - uses: actions/checkout@v4

.prettierignore

@@ -4,5 +4,4 @@ package-lock.json
 *.ejs
 dist
 coverage
-dist/
 config/*

.prettierrc.js

@@ -3,5 +3,8 @@ module.exports = {
     trailingComma: "all",
     singleQuote: true,
     printWidth: 120,
-    tabWidth: 4
+    tabWidth: 4,
+    importOrder: ["^[./]"],
+    importOrderSeparation: true,
+    importOrderSortSpecifiers: true
 };

CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+## 2.1.0 (19.09.2023)
++ Post-Execution-Functions will now be executed, even if the handler failed
+- The middlewareWithErrorHandling was removed. To regain the same functionality you can now pass an option-flag, called disableErrorHandling
+
 ## 2.0.0 (01.04.2023)
 - Added auto-logging functionality to the library that enhances searchability of saved log statements in Azure AppInsights by storing context properties in commonProperties. 
 - Removed the MiddlewareFunction-Type in favor for the azure-built-in one 

example/test-header-authentication-function/test-header-authentication-function.ts

@@ -1,5 +1,6 @@
 import { Context } from '@azure/functions';
-import middleware from '../../src/middleware';
+
+import { middleware } from '../../src';
 import headerAuthentication from '../../src/headerAuthentication';
 
 const functionHandler = async (context: Context): Promise<void> => {

example/test-jwt-authorization-function/test-jwt-authorization-function.ts

@@ -1,5 +1,6 @@
 import { Context, ContextBindingData } from '@azure/functions';
-import middleware from '../../src/middleware';
+
+import { middleware } from '../../src';
 import authorization from '../../src/jwtAuthorization';
 
 const functionHandler = async (context: Context): Promise<void> => {

example/test-validation-function/test-validation-function.ts

@@ -1,9 +1,10 @@
 import { Context, HttpRequest } from '@azure/functions';
-import middleware from '../../src/middleware';
 import * as Joi from 'joi';
-import validation from '../../src/validation';
 import { ObjectSchema } from 'joi';
 
+import { middleware } from '../../src';
+import validation from '../../src/validation';
+
 const schema: ObjectSchema = Joi.object({
     name: Joi.string().min(3).max(30).required(),
 }).required();

integration-test/header-authentication-test.integration.ts

@@ -1,4 +1,5 @@
 import axios from 'axios';
+
 import waitTillFunctionReady from './waitTillFunctionReady';
 
 describe('The example azure function is started and the header authentication should execute the request', () => {

integration-test/jwt-authorization-test.integration.ts

@@ -1,4 +1,5 @@
 import axios from 'axios';
+
 import waitTillFunctionReady from './waitTillFunctionReady';
 
 // Token generated with https://jwt.io/ containing the "userId" "c8e65ca7-a008-4b1c-b52a-4ad0ee417017"

integration-test/validation-test.integration.ts

@@ -1,4 +1,5 @@
 import axios from 'axios';
+
 import waitTillFunctionReady from './waitTillFunctionReady';
 
 describe('The example azure function is started and the JOI validation should', () => {

package.json

@@ -1,6 +1,6 @@
 {
     "name": "@senacor/azure-function-middleware",
-    "version": "2.0.1",
+    "version": "2.1.0",
     "description": "Middleware for azure functions to handle authentication, authorization, error handling and logging",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -25,6 +25,7 @@
     "author": "[email protected]",
     "license": "MIT",
     "devDependencies": {
+        "@trivago/prettier-plugin-sort-imports": "^4.2.0",
         "@types/jest": "^27.0.3",
         "@typescript-eslint/eslint-plugin": "^5.10.2",
         "@typescript-eslint/parser": "^5.10.2",

src/appInsights/Logger.ts

@@ -1,6 +1,6 @@
-import { SeverityLevel } from 'applicationinsights/out/Declarations/Contracts';
-import { TelemetryClient } from 'applicationinsights';
 import { Logger } from '@azure/functions';
+import { TelemetryClient } from 'applicationinsights';
+import { SeverityLevel } from 'applicationinsights/out/Declarations/Contracts';
 
 const consoleDefaultLog = (message: string): void => {
     console.log(message);

src/appInsights/appInsightsWrapper.ts

@@ -1,8 +1,9 @@
 import { Context, HttpRequest } from '@azure/functions';
 import * as appInsights from 'applicationinsights';
-import { createAppInsightsLogger, consoleLogger } from './Logger';
 import { TelemetryClient } from 'applicationinsights';
 
+import { consoleLogger, createAppInsightsLogger } from './Logger';
+
 const telemetryClients: { [key: string]: TelemetryClient } = {};
 
 const isDisabled =
@@ -49,7 +50,7 @@
     context.log = createAppInsightsLogger(telemetryClient);
 
     // excluding headers because it contains sensible data
     const { headers, ...includedProperties } = context.bindingData;
 
     telemetryClient.commonProperties = {
         ...includedProperties,

src/error/errorHandler.test.ts

@@ -0,0 +1,39 @@
+import { Context } from '@azure/functions';
+import { mock } from 'jest-mock-extended';
+
+import { ApplicationError } from './ApplicationError';
+import { errorHandler as sut } from './errorHandler';
+
+describe('Error-Handler should', () => {
+    const contextMock = mock<Context>();
+
+    beforeEach(() => {
+        jest.restoreAllMocks();
+
+        contextMock.log.error = jest.fn();
+    });
+
+    test('return an provided ApplicationError', () => {
+        const res = sut(new ApplicationError('', 400, { error: 'critical' }), contextMock);
+        expect(res.status).toStrictEqual(400);
+        expect(res.body).toStrictEqual({ error: 'critical' });
+    });
+
+    test('return an default error-message, if no errorResponseHandler was provided', () => {
+        const res = sut('Error!', contextMock);
+        expect(res.status).toStrictEqual(500);
+        expect(res.body).toStrictEqual({ message: 'Internal server error' });
+    });
+
+    test('use the errorResponseHandler, if an errorResponseHandler was provided', () => {
+        const errorResponseHandler = () => ({
+            status: 409,
+            body: {
+                message: 'conflict!',
+            },
+        });
+        const res = sut('Error!', contextMock, { errorResponseHandler });
+        expect(res.status).toStrictEqual(409);
+        expect(res.body).toStrictEqual({ message: 'conflict!' });
+    });
+});

src/error/errorHandler.ts

@@ -0,0 +1,79 @@
+import { Context } from '@azure/functions';
+
+import { Options } from '../middleware';
+import { ApplicationError } from './ApplicationError';
+
+type ErrorWithMessage = {
+    message: string;
+    stack?: string;
+};
+
+const isErrorWithMessage = (error: unknown): error is ErrorWithMessage => {
+    return (
+        typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        typeof (error as Record<string, unknown>).message === 'string'
+    );
+};
+
+const logErrorObject = (error: object | null, context: Context) => {
+    if (error === null) {
+        context.log.error('The provided error was eq to null - unable to log a specific error-message');
+        return;
+    }
+
+    if (isErrorWithMessage(error)) {
+        context.log.error({ message: error.message, stack: error.stack });
+    } else {
+        try {
+            const errorAsJson = JSON.stringify(error);
+            if (errorAsJson === '{}') {
+                context.log.error(error.toString());
+            } else {
+                context.log.error(errorAsJson); // Log the JSON string of the error object
+            }
+        } catch (_) {
+            //Fallback in case there's an error stringify
+            context.log.error(error.toString());
+        }
+    }
+};
+
+export const errorHandler = (
+    error: unknown,
+    context: Context,
+    opts?: Options,
+): {
+    [key: string]: unknown;
+} => {
+    if (error instanceof ApplicationError) {
+        context.log.error(`Received application error with message ${error.message}`);
+        return {
+            status: error.status,
+            body: error.body,
+        };
+    }
+
+    switch (typeof error) {
+        case 'string':
+            context.log.error(error);
+            break;
+        case 'object':
+            logErrorObject(error, context);
+            break;
+        default:
+            context.log(`The error object has a type, that is not suitable for logging: ${typeof error}`);
+    }
+
+    if (opts?.errorResponseHandler === undefined) {
+        return {
+            status: 500,
+            body: {
+                message: 'Internal server error',
+            },
+        };
+    } else {
+        return opts.errorResponseHandler(error);
+    }
+};