Release/v2.1.2

eslint.config.mjs

@@ -8,12 +8,16 @@ import eslintConfigPrettier from 'eslint-config-prettier/flat';
 export default defineConfig([
     eslintConfigPrettier,
     globalIgnores(['dist/']),
+    globalIgnores(['scratch.js']),
     { files: ['**/*.js'], languageOptions: { sourceType: 'commonjs' } },
     {
         files: ['**/*.{js,mjs,cjs}'],
         languageOptions: { globals: globals.node },
         plugins: { js },
         extends: ['js/recommended'],
+        rules: {
+            'preserve-caught-error': 'off',
+        },
     },
     {
         files: ['**/*.json'],

package.json

@@ -1,6 +1,6 @@
 {
     "name": "objective-http",
-    "version": "2.1.1",
+    "version": "2.1.2",
     "description": "Proxy classes for creating a http server",
     "keywords": [
         "web",
@@ -27,23 +27,23 @@
         "dist:build": "webpack --config webpack.config.mjs",
         "dist:cleanup": "node scripts/cleanup.js"
     },
-    "main": "src/js/index.js",
     "publishConfig": {
         "access": "public"
     },
     "devDependencies": {
-        "@dotenvx/dotenvx": "^1.57.5",
-        "@eslint/js": "^9.35.0",
-        "@eslint/json": "^0.12.0",
-        "@eslint/markdown": "^6.4.0",
+        "@dotenvx/dotenvx": "^1.60.2",
+        "@eslint/js": "^10.0.1",
+        "@eslint/json": "^1.2.0",
+        "@eslint/markdown": "^8.0.1",
         "copy-webpack-plugin": "^14.0.0",
-        "eslint": "^9.35.0",
+        "eslint": "^10.2.0",
         "eslint-config-prettier": "^10.1.5",
         "eslint-plugin-prettier": "^5.4.0",
-        "globals": "^16.0.0",
-        "prettier": "3.5.3",
+        "globals": "^17.4.0",
+        "prettier": "^3.8.1",
         "prettier-eslint-cli": "^8.0.1",
         "release-it": "^19.2.4",
+        "terser-webpack-plugin": "^5.4.0",
         "webpack": "^5.105.4",
         "webpack-cli": "^7.0.2"
     }

release-it.config.mjs

@@ -9,7 +9,7 @@ dotenv.config({
 
 export default {
     git: {
-        requireBranch: ['master', 'release/*'],
+        requireBranch: ['master', 'release/v*'],
         commitMessage: 'release v${version}',
         requireCleanWorkingDir: false,
         requireUpstream: false,

src/js/server/autoconfig/handler.js

@@ -0,0 +1,99 @@
+function collectionEndpointHandler({ endpoints }) {
+    const { EndpointHandlers } = require('../index').handler.endpoint;
+
+    return new EndpointHandlers({
+        handlers: endpoints.map((endpoint) => endpointHandler({ endpoint })),
+    });
+}
+
+function endpointHandler({ endpoint }) {
+    const {
+        request: {
+            chunk: { JsonServerRequest, ChunkServerRequest },
+        },
+        response: {
+            chunk: { JsonServerResponse, ChunkServerResponse },
+        },
+    } = require('../index');
+
+    const request = new JsonServerRequest({
+        origin: new ChunkServerRequest({}),
+    });
+
+    const response = new JsonServerResponse({
+        origin: new ChunkServerResponse({}),
+    });
+
+    if (
+        endpoint instanceof Array &&
+        endpoint?.some((innerEndpoint) => innerEndpoint instanceof Array)
+    ) {
+        return collectionEndpointHandler({ endpoints: endpoint });
+    }
+
+    if (endpoint instanceof Array) {
+        const { EndpointsHandler } = require('../index').handler.endpoint;
+
+        return new EndpointsHandler({
+            endpoints: endpoint,
+            request,
+            response,
+        });
+    }
+
+    const { EndpointHandler } = require('../index').handler.endpoint;
+
+    return new EndpointHandler({
+        endpoint,
+        request,
+        response,
+    });
+}
+
+function loggHandler({ env, handler }) {
+    if ([undefined, null, 'disable', 'off'].includes(env?.SERVER_ERROR_LOG)) {
+        return handler;
+    }
+
+    const { LogErrorHandler } = require('../index').handler.error;
+    const console = require('node:console');
+
+    return new LogErrorHandler({
+        origin: handler,
+        logger: console,
+    });
+}
+
+module.exports = function handler({ env, endpoints }) {
+    const {
+        handler: {
+            endpoint: { EndpointRequiredHandler },
+            error: {
+                UnexpectedErrorHandler,
+                InvalidRequestErrorHandler,
+                HandlerNotFoundErrorHandler,
+            },
+        },
+        response: {
+            chunk: { ChunkServerResponse },
+        },
+    } = require('../index');
+
+    return new UnexpectedErrorHandler({
+        origin: loggHandler({
+            handler: new InvalidRequestErrorHandler({
+                origin: new HandlerNotFoundErrorHandler({
+                    origin: new EndpointRequiredHandler({
+                        origin: endpointHandler({
+                            endpoint: endpoints,
+                        }),
+                    }),
+                    response: new ChunkServerResponse({}),
+                }),
+                response: new ChunkServerResponse({}),
+            }),
+            env,
+        }),
+        response: new ChunkServerResponse({}),
+    });
+};

src/js/server/autoconfig/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+    server: require('./server'),
+    handler: require('./handler'),
+};

src/js/server/autoconfig/server.js

@@ -0,0 +1,17 @@
+module.exports = function server({ env, endpoints }) {
+    if (!env?.SERVER_PORT) {
+        throw new Error('Server port is empty', {
+            cause: { code: 'INVALID_CONFIG' },
+        });
+    }
+
+    const { Server } = require('../index');
+    const handler = require('./handler');
+    const http = require('node:http');
+
+    return new Server({
+        handler: handler({ env, endpoints }),
+        options: { port: Number(env.SERVER_PORT) },
+        http,
+    });
+};

src/js/server/handler/error/LogErrorHandler.js

@@ -11,9 +11,10 @@ module.exports = class LogErrorHandler {
         try {
             return await this.#origin.handle(reqestStream, responseStream);
         } catch (e) {
-            this.#logger.error(`Error while handling ${reqestStream.url}`, {
-                cause: { error: e },
-            });
+            this.#logger.error(
+                `Error while handling ${reqestStream.method}:${reqestStream.url}`,
+                e,
+            );
 
             throw e;
         }

src/js/server/index.js

@@ -3,4 +3,5 @@ module.exports = {
     handler: require('./handler'),
     request: require('./request'),
     response: require('./response'),
+    autoconfig: require('./autoconfig'),
 };

src/test/e2e/server/server.js

@@ -45,7 +45,25 @@ const serverConfig = new Server({
                                         },
 
                                         handle() {
-                                            throw new Error('WTF');
+                                            throw new Error('WTF', {
+                                                cause: {
+                                                    error: new Error('1', {
+                                                        cause: {
+                                                            error: new Error(
+                                                                '2',
+                                                                {
+                                                                    cause: {
+                                                                        error: new TypeError(),
+                                                                        code: '2',
+                                                                    },
+                                                                },
+                                                            ),
+                                                            code: '1',
+                                                        },
+                                                    }),
+                                                    code: 'MAIN',
+                                                },
+                                            });
                                         },
                                     },
                                     request: new ChunkServerRequest({}),

webpack.config.mjs

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import CopyPlugin from 'copy-webpack-plugin';
+import TerserPlugin from 'terser-webpack-plugin';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -23,6 +24,15 @@ export default {
             ],
         }),
     ],
+    optimization: {
+        minimizer: [
+            new TerserPlugin({
+                terserOptions: {
+                    keep_classnames: true,
+                },
+            }),
+        ],
+    },
     mode: 'production',
     target: 'node',
 };