objective-http 1.4.0 → 2.0.2

package/README.md

@@ -1,57 +1,99 @@
+
 # objective-http
-Proxy classes for creating a http server
 
+Proxy classes for creating a http server
 
 ## Server
 
 There are all `Server` classes feature.  
-Your endpoints must implement `Endpoint` class interface (`route()` and `async handle(request)` methods).
+Your endpoints should implement `Endpoint` class interface 
+(`get route()` and `async handle(request)` methods).  
+Also you can add own handlers (`handle(reqestStream, responseStream)`).  
+`Handler` is a top level logic object, who intrreact with IO streams directly.  
+`options` is a `node:http` options, who pass when server starting.  
 
 ```javascript
-const createServerFunction = require('node:http').createServer;
-
+const http = require('node:http');
+const console = require('node:console');
 const {
     Server,
-    LoggedServer,
-    endpoint: {
-        Endpoint,
-        Endpoints
+    handler: {
+        endpoint: {
+            EndpointHandler,
+            EndpointsHandler,
+            EndpointHandlers,
+            EndpointRequiredHandler,
+        },
+        error: {
+            LogErrorHandler,
+            UnexpectedErrorHandler,
+            InvalidRequestErrorHandler,
+            HandlerNotFoundErrorHandler,
+        },
     },
     request: {
-        InputRequest,
-        LoggedInputRequest,
+        chunk: { JsonServerRequest, ChunkServerRequest },
     },
     response: {
-        OutputResponse,
-        LoggedOutputResponse
-    }
+        chunk: { JsonServerResponse, ChunkServerResponse },
+    },
 } = require('objective-http').server;
 
-new LoggedServer(
-    new Server(
-        new Endpoints([
-            new MyFirstEndpoint(),
-            new MySecondEndpoint(),
-            new MyThirdEndpoint()
-        ]),
-        {port: server_port},
-        new LoggedInputRequest(new InputRequest(), console),
-        new LoggedOutputResponse(new OutputResponse(), console),
-        createServerFunction
-    ),
-    console
-).start();
+new Server({
+    handler: new UnexpectedErrorHandler({
+        origin: new LogErrorHandler({
+            origin: new InvalidRequestErrorHandler({
+                origin: new HandlerNotFoundErrorHandler({
+                    origin: new EndpointRequiredHandler({
+                        origin: new EndpointHandlers({
+                            handlers: [
+                                new EndpointHandler({
+                                    endpoint: new MyEndpoint(),
+                                    request: new ChunkServerRequest({}),
+                                    response: new ChunkServerResponse({}),
+                                }),
+                                new EndpointHandler({
+                                    endpoint: new MyEndpoint(),
+                                    request: new ChunkServerRequest({}),
+                                    response: new ChunkServerResponse({})
+                                }),
+                                new EndpointsHandler({
+                                    endpoints: [
+                                       new MyJsonEndpoint(),
+                                       new MyJsonEndpoint(),
+                                       new MyJsonEndpoint(),
+                                    ],
+                                    request: new JsonServerRequest({
+                                        origin: new ChunkServerRequest({}),
+                                    }),
+                                    response: new JsonServerResponse({
+                                        origin: new ChunkServerResponse({}),
+                                    }),
+                                }),
+                            ],
+                        }),
+                    }),
+                    response: new ChunkServerResponse({}),
+                }),
+                response: new ChunkServerResponse({}),
+            }),
+            logger: console,
+        }),
+        response: new ChunkServerResponse({}),
+    }),
+
+    options: { port: 8080 },
+    http,
+});
 ```
 
 `MyEndpoint` class example:
 
 ```javascript
 class MyEndpoint {
-    route() {
-        return {
-            method: 'GET',
-            path: '/test'
-        };
+    route = {
+        method: 'GET',
+        path: '/test'
     }
 
     async handle(request) {
@@ -59,13 +101,13 @@ class MyEndpoint {
             const processResult = await someProcess();
 
             return {
-                statusCode: 200,
+                status: 200,
                 body: processResult.toString()
             };
         
         } catch (e) {
             return {
-                statusCode: 404,
+                status: 404,
                 body: 'process does not found anything'
             };
         }
@@ -76,162 +118,40 @@ class MyEndpoint {
 
 ## Client
 
-```javascript
-const requestFunction = require('node:http').request;
-
-const {
-    request: {
-        OutputRequest
-    },
-    response: {
-        InputResponse
-    }
-} = require('objective-http').client;
-
-
-const response = await new OutputRequest(
-    new InputResponse(),
-    requestFunction,
-    {
-        url: 'https://example.com',
-        method: 'POST',
-        body: 'test body'
-    })
-    .send();
-
-console.log(response.body().toString());
-
-//or
-
-const request = new OutputRequest(new InputResponse(), requestFunction);
-
-const otherResponse = await (request
-    .copy({
-        url: 'https://example.com',
-        method: 'POST',
-        body: 'test body'
-    }))
-    .send();
-
-console.log(response.body().toString());
-```
-
-
-## [Bun](https://bun.sh) support
-
-`server` and `client` packages support Bun by default.  
-But there ara special `bun` package with native [Bun API](https://bun.sh/docs/runtime/bun-apis) implementation (like `Bun.serve()`). 
-And you should replace `node:http` package with `objective-http.bun.bunttp` in your `Server` configuration.
-
-
-### Server Bun usage
-
-It should work with `node` and `bun`:
+Simple wrapper for requests. `options` passing into `http.request(oprions, ...)`
 
 ```javascript
-const createServerFunction = require('node:http').createServer;
-
+const http = require('node:http');
 const {
-    Server,
-    LoggedServer,
-    endpoint: {
-        Endpoint,
-        Endpoints
-    },
     request: {
-        InputRequest,
-        LoggedInputRequest,
+        chunk: { JsonClientRequest, ChunkClientRequest },
     },
     response: {
-        OutputResponse,
-        LoggedOutputResponse
-    }
-} = require('objective-http').server;
-
-new LoggedServer(
-    new Server(
-        new Endpoints([
-            new MyFirstEndpoint(),
-            new MySecondEndpoint(),
-            new MyThirdEndpoint()
-        ]),
-        {port: server_port},
-        new LoggedInputRequest(new InputRequest(), console),
-        new LoggedOutputResponse(new OutputResponse(), console),
-        createServerFunction
-    ),
-    console
-).start()
-```
-
-In order for the code to be executed only by `bun` (with `Bun API` inside), you need to make changes to the import block.  
-`bun` package redeclare only `InputRequest` and `OutputResponse` classes. Other classes taken from `server` package.
-
-```javascript
-const createServerFunction = require('objective-http').bun.bunttp.createServer;
-
-const {
-    Server,
-    LoggedServer,
-    endpoint: {
-        Endpoint,
-        Endpoints
-    },
-    request: {
-        LoggedInputRequest,
-    },
-    response: {
-        LoggedOutputResponse
-    }
-} = require('objective-http').server;
-
-const {
-    request: {
-        InputRequest
-    },
-    response: {
-        OutputResponse
-    }
-} = require('objective-http').bun.server;
-```
-
-
-### Client Bun usage
-
-It should work with `node` and `bun`:
-
-```javascript
-const requestFunction = require('node:http').request;
-
-const {
-    request: {
-        OutputRequest
+        chunk: { JsonClientResponse, ChunkClientResponse },
     },
-    response: {
-        InputResponse
-    }
 } = require('objective-http').client;
 
-await (new OutputRequest(new InputResponse(), requestFunction)
-    .copy({
-        url: 'https://example.com',
-        method: 'POST',
-        body: 'test body'
-    }))
-    .send();
-```
-
-In order for the code to be executed only by `bun`, you need to make changes to the import block.
+const request = new JsonClientRequest({
+    origin: new ChunkClientRequest({
+        http: http,
+        response: new JsonClientResponse({
+            origin: new ChunkClientResponse({})
+        }),
+    }),
+});
+
+const response = await request
+    .with({
+        options: {
+            host: 'localhost',
+            port: 80,
+            method: 'GET',
+            path: '/test',
+        },
+        body: { some: 'body' }
+    })
+    .send()
 
-```javascript
-const requestFunction = require('objective-http').bun.bunttp.request;
+console.log(JSON.stringify(response.body));
+```
 
-const {
-    request: {
-        OutputRequest
-    },
-    response: {
-        InputResponse
-    }
-} = require('objective-http').bun.client;
-```

package/package.json

@@ -1 +1,44 @@
-{"name":"objective-http","version":"1.4.0","description":"Proxy classes for creating a http server","keywords":["web","web-server","http","http-server","oop"],"author":{"name":"volatilization","email":"volatilization@yandex.ru"},"repository":{"url":"git+https://github.com/volatilization/objective-http.git"},"license":"LGPL-3.0-only","main":"src/js/index.js"}
+{
+    "name": "objective-http",
+    "version": "2.0.2",
+    "description": "Proxy classes for creating a http server",
+    "keywords": [
+        "web",
+        "web-server",
+        "http",
+        "http-server",
+        "oop"
+    ],
+    "author": {
+        "name": "volatilization",
+        "email": "volatilization@yandex.ru"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/volatilization/objective-http"
+    },
+    "license": "LGPL-3.0-only",
+    "scripts": {
+        "lint": "eslint",
+        "test": "node --test  --experimental-test-coverage --test-reporter=spec src/test/*.js src/test/**/*.js",
+        "test:coverage": "node scripts/coverage.js",
+        "release": "release-it --config release-it.config.mjs",
+        "release:no-increment": "release-it --config release-it.config.mjs --no-increment",
+        "dist:build": "node scripts/build.js",
+        "dist:cleanup": "node scripts/cleanup.js"
+    },
+    "main": "src/js/index.js",
+    "devDependencies": {
+        "@dotenvx/dotenvx": "^1.57.5",
+        "@eslint/js": "^9.35.0",
+        "@eslint/json": "^0.12.0",
+        "@eslint/markdown": "^6.4.0",
+        "eslint": "^9.35.0",
+        "eslint-config-prettier": "^10.1.5",
+        "eslint-plugin-prettier": "^5.4.0",
+        "globals": "^16.0.0",
+        "prettier": "3.5.3",
+        "prettier-eslint-cli": "^8.0.1",
+        "release-it": "^19.2.4"
+    }
+}

package/src/js/client/index.js

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

package/src/js/client/request/chunk/ChunkClientRequest.js

@@ -0,0 +1,67 @@
+module.exports = class ChunkClientRequest {
+    #http;
+    #options;
+    #body;
+    #response;
+
+    constructor({ http, options, body, response }) {
+        this.#http = http;
+        this.#options = options;
+        this.#body = body;
+        this.#response = response;
+    }
+
+    with({
+        http = this.#http,
+        options = this.#options,
+        body = this.#body,
+        response = this.#response,
+    }) {
+        return new ChunkClientRequest({ http, options, body, response });
+    }
+
+    get http() {
+        return this.#http;
+    }
+
+    get options() {
+        return this.#options;
+    }
+
+    get body() {
+        return this.#body;
+    }
+
+    get response() {
+        return this.#response;
+    }
+
+    send() {
+        return new Promise((resolve, reject) => {
+            const requestStream = this.http.request(
+                this.options,
+                (responseStream) => {
+                    this.response
+                        .with({ responseStream })
+                        .accept()
+                        .then(resolve)
+                        .catch(reject);
+                },
+            );
+
+            requestStream.on('error', (e) => {
+                reject(
+                    new Error('Client request error', {
+                        cause: { error: e, code: 'REQUEST_ERROR' },
+                    }),
+                );
+            });
+
+            if (this.body != null) {
+                requestStream.write(this.body);
+            }
+
+            requestStream.end();
+        });
+    }
+};

package/src/js/client/request/chunk/JsonClientRequest.js

@@ -0,0 +1,55 @@
+module.exports = class JsonClientRequest {
+    #origin;
+
+    constructor({ origin }) {
+        this.#origin = origin;
+    }
+
+    with({
+        http,
+        options,
+        body,
+        response,
+        origin = this.#origin.with({
+            http,
+            options,
+            body,
+            response,
+        }),
+    }) {
+        return new JsonClientRequest({ origin });
+    }
+
+    get http() {
+        return this.#origin.http;
+    }
+
+    get options() {
+        return {
+            ...this.#origin.options,
+            headers: {
+                ...this.#origin.options.headers,
+                'content-type': 'application/json',
+            },
+        };
+    }
+
+    get body() {
+        return this.#origin.body
+            ? JSON.stringify(this.#origin.body)
+            : this.#origin.body;
+    }
+
+    get response() {
+        return this.#origin.response;
+    }
+
+    send() {
+        return this.#origin
+            .with({
+                body: this.body,
+                options: this.options,
+            })
+            .send();
+    }
+};

package/src/js/client/request/chunk/index.js

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

package/src/js/client/request/index.js

@@ -1,3 +1,3 @@
 module.exports = {
-    OutputRequest: require('./OutputRequest')
-};
+    chunk: require('./chunk'),
+};

package/src/js/client/response/chunk/ChunkClientResponse.js

@@ -0,0 +1,75 @@
+module.exports = class ChunkClientResponse {
+    #responseStream;
+    #status;
+    #headers;
+    #body;
+
+    constructor({ responseStream, status, headers, body }) {
+        this.#responseStream = responseStream;
+        this.#status = status;
+        this.#headers = headers;
+        this.#body = body;
+    }
+
+    with({
+        responseStream = this.#responseStream,
+        status = this.#status,
+        headers = this.#headers,
+        body = this.#body,
+    }) {
+        return new ChunkClientResponse({
+            responseStream,
+            status,
+            headers,
+            body,
+        });
+    }
+
+    get status() {
+        return this.#status;
+    }
+
+    get headers() {
+        return this.#headers;
+    }
+
+    get body() {
+        return this.#body;
+    }
+
+    get ok() {
+        return Number(this.status) === 200;
+    }
+
+    accept() {
+        return new Promise((resolve, reject) => {
+            try {
+                this.#responseStream.on('error', (e) => {
+                    reject(
+                        new Error('Client response error', {
+                            cause: { error: e, code: 'RESPONSE_ERROR' },
+                        }),
+                    );
+                });
+
+                var chunks = [];
+                this.#responseStream.on('data', (chunk) => chunks.push(chunk));
+                this.#responseStream.on('end', () => {
+                    resolve(
+                        this.with({
+                            status: this.#responseStream.statusCode,
+                            headers: new Headers(this.#responseStream.headers),
+                            body: Buffer.concat(chunks),
+                        }),
+                    );
+                });
+            } catch (e) {
+                reject(
+                    new Error('Client reponse error', {
+                        cause: { error: e, code: 'RESPONSE_ERROR' },
+                    }),
+                );
+            }
+        });
+    }
+};

package/src/js/client/response/chunk/JsonClientResponse.js

@@ -0,0 +1,62 @@
+module.exports = class JsonClientResponse {
+    #origin;
+
+    constructor({ origin }) {
+        this.#origin = origin;
+    }
+
+    with({
+        responseStream,
+        status,
+        headers,
+        body,
+        origin = this.#origin.with({
+            responseStream,
+            status,
+            headers,
+            body,
+        }),
+    }) {
+        return new JsonClientResponse({ origin });
+    }
+
+    get ok() {
+        return this.#origin.ok;
+    }
+
+    get status() {
+        return this.#origin.status;
+    }
+
+    get headers() {
+        return this.#origin.headers;
+    }
+
+    get body() {
+        return this.#origin.body;
+    }
+
+    async accept() {
+        const accepted = await this.#origin.accept();
+
+        try {
+            return this.with({
+                origin: accepted.with({
+                    body:
+                        accepted.body?.length > 0
+                            ? JSON.parse(accepted.body?.toString())
+                            : accepted.body,
+                    headers: Object.fromEntries(accepted.headers),
+                }),
+            });
+        } catch (e) {
+            if (!(e instanceof SyntaxError)) {
+                throw new Error('JSON client response error', {
+                    cause: { error: e, code: 'RESPONSE_ERROR' },
+                });
+            }
+
+            throw e;
+        }
+    }
+};

package/src/js/client/response/chunk/index.js

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

package/src/js/client/response/index.js

@@ -1,3 +1,3 @@
 module.exports = {
-    InputResponse: require('./InputResponse')
-};
+    chunk: require('./chunk'),
+};

package/src/js/index.js

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