objective-http 1.0.3 → 1.1.0

package/README.md

@@ -1,7 +1,10 @@
 # objective-http
 Proxy classes for creating a http server
 
-## Using
+## Server
+
+There are all ```Server``` classes feature. 
+Your endpoints must implement ```Endpoint``` class interface (```route``` and ```handle``` functions).
 
 ``` javascript
 const http = require('node:http');
@@ -40,4 +43,40 @@ new ClusteredServer(
     cluster,
     {workers: workers_count}
 ).start();
+```
+
+## Client
+
+``` javascript
+const https = require('node:https');
+const {
+    OutputRequest,
+    InputResponse
+} = require('objective-http').client;
+
+
+const response = await new OutputRequest(
+    https,
+    new InputResponse(),
+    {
+        url: 'https://example.com',
+        method: 'POST',
+        body: 'test body'
+    })
+    .send();
+
+console.log(response.body().toString());
+
+//or
+
+const request = new OutputRequest(https, new InputResponse());
+
+const otherResponse = await (request
+    .copy({
+        url: 'https://example.com',
+        method: 'POST',
+        body: 'test body'
+    }))
+    .send()
+
 ```

package/package.json

@@ -1 +1 @@
-{"name":"objective-http","version":"1.0.3","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":"1.1.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"}

package/src/js/client/request/OutputRequest.js

@@ -0,0 +1,69 @@
+module.exports = class OutputRequest {
+    #http;
+    #response;
+    #options;
+
+    constructor(http, response, options) {
+        this.#http = http;
+        this.#response = response;
+        this.#options = {method: 'GET', ...options};
+    }
+
+    copy(options = this.#options, response = this.#response, http = this.#http) {
+        return new OutputRequest(http, response, {method: 'GET', ...options});
+    }
+
+    send() {
+        return new Promise((resolve, reject) => {
+            try {
+                this.#sendRequestOutputStream(
+                    this.#configureRequestOutputStream(this.#http, this.#response, this.#options, resolve, reject),
+                    this.#options);
+
+            } catch (e) {
+                throw new Error(e.message, {cause: 'INVALID_REQUEST'});
+            }
+        });
+    }
+
+    #configureRequestOutputStream(http, response, options, resolve, reject) {
+        if (options.url != null) {
+            return http.request(
+                options.url,
+                options,
+                async (responseInputStream) => {
+                    await this.#flushResponseInputStream(responseInputStream, response, resolve, reject);
+                });
+        }
+
+        return http.request(
+            options,
+            async (responseInputStream) => {
+                await this.#flushResponseInputStream(responseInputStream, response, resolve, reject);
+            });
+    }
+
+    async #flushResponseInputStream(responseInputStream, response, resolve, reject) {
+        try {
+            resolve(await response
+                .copy(responseInputStream)
+                .flush());
+
+        } catch (e) {
+            reject(e);
+        }
+    }
+
+    #sendRequestOutputStream(requestOutputStream, options) {
+        if (this.#needToByWritten(options)) {
+            requestOutputStream.write(options.body);
+        }
+
+        requestOutputStream.end();
+    }
+
+    #needToByWritten(options) {
+        return ['POST', 'PUT'].some(method => method === options.method.toString().toUpperCase())
+            && (options.body != null && typeof options.body === 'string');
+    }
+};

package/src/js/client/response/InputResponse.js

@@ -0,0 +1,43 @@
+module.exports = class InputResponse {
+    #inputStream;
+    #options;
+
+    constructor(inputStream, options) {
+        this.#inputStream = inputStream;
+        this.#options = options;
+    }
+
+    copy(inputStream = this.#inputStream, options = this.#options) {
+        return new InputResponse(inputStream, options);
+    }
+
+    flush() {
+        return new Promise((resolve, reject) => {
+            this.#inputStream.once('error', (e) =>
+                reject(new Error(e.message, {cause: 'INVALID_RESPONSE'}))
+            );
+
+            let chunks = [];
+            this.#inputStream.on('data', (chunk) => chunks.push(chunk));
+            this.#inputStream.on('end', () => resolve(new InputResponse(this.#inputStream,
+                {
+                    statusCode: this.#inputStream.statusCode,
+                    headers: new Headers(this.#inputStream.headers),
+                    body: Buffer.concat(chunks)
+                }
+            )));
+        });
+    }
+
+    statusCode() {
+        return this.#options.statusCode;
+    }
+
+    headers() {
+        return this.#options.headers;
+    }
+
+    body() {
+        return this.#options.body;
+    }
+};

package/src/js/index.js

@@ -12,5 +12,9 @@ module.exports = {
         OutputResponse: require('./server/response/OutputResponse'),
         JsonOutputResponse: require('./server/response/JsonOutputResponse'),
         LoggedOutputResponse: require('./server/response/LoggedOutputResponse')
+    },
+    client: {
+        OutputRequest: require('./client/request/OutputRequest'),
+        InputResponse: require('./client/response/InputResponse')
     }
 }

package/src/js/server/ClusteredServer.js

@@ -16,10 +16,8 @@ module.exports = class ClusteredServer {
             }
 
         } else {
-            await this.#origin.start();
+            return new ClusteredServer(await this.#origin.start(), this.#cluster, this.#options);
         }
-
-        return this;
     }
 
     options() {

package/src/js/server/LoggedServer.js

@@ -8,13 +8,22 @@ module.exports = class LoggedServer {
     }
 
     async start() {
-        await this.#origin.start();
+        const server = await this.#origin.start();
 
         this.#logger.debug(`HttpServer is running at port: ${this.#origin.options().port}`);
 
-        return this;
+        return new LoggedServer(server, this.#logger);
     }
 
+    async stop() {
+        const server = await this.#origin.stop();
+
+        this.#logger.debug(`HttpServer at port: ${this.#origin.options().port} is stopped`);
+
+        return new LoggedServer(server, this.#logger);
+    }
+
+
     options() {
         return this.#origin.options();
     }

package/src/js/server/Server.js

@@ -4,53 +4,74 @@ module.exports = class HttpServer {
     #response;
     #endpoints;
     #options;
+    #server;
 
-    constructor(http, request, response, endpoints, options) {
+    constructor(http, request, response, endpoints, options, server) {
         this.#http = http;
         this.#request = request;
         this.#response = response;
         this.#endpoints = endpoints;
         this.#options = options;
+        this.#server = server;
     }
 
     start() {
-        return new Promise(resolve => {
-            this.#http
-                .createServer(async (requestStream, responseStream) => {
-                    try {
-                        return await (this.#response
-                            .copy(responseStream, await this.#endpoints
-                                .handle(await (this.#request
-                                    .copy(requestStream))
-                                    .flush())))
-                            .flush();
+        const server = this.#http.createServer(async (requestStream, responseStream) => {
+            try {
+                return await (this.#response
+                    .copy(responseStream, await this.#endpoints
+                        .handle(await (this.#request
+                            .copy(requestStream))
+                            .flush())))
+                    .flush();
+
+            } catch (e) {
+                if (e.cause === 'INVALID_REQUEST') {
+                    return await (this.#response
+                        .copy(responseStream, {
+                            statusCode: 400,
+                            body: e.message
+                        }))
+                        .flush();
+                }
+
+                return await (this.#response
+                    .copy(responseStream, {
+                        statusCode: 500,
+                        body: 'Unexpected server error.'
+                    }))
+                    .flush();
+            }
+        });
 
-                    } catch (e) {
-                        if (e.cause === 'INVALID_REQUEST') {
-                            return this.#response
-                                .copy(responseStream, {
-                                    statusCode: 400,
-                                    body: e.message
-                                })
-                                .flush();
-                        }
+        return new Promise(resolve => {
+            server.listen(
+                this.#options,
+                () => resolve(new HttpServer(
+                    this.#http,
+                    this.#request,
+                    this.#response,
+                    this.#endpoints,
+                    this.#options,
+                    server))
+            );
+        });
+    }
 
-                        return this.#response
-                            .copy(responseStream, {
-                                statusCode: 500,
-                                body: 'Unexpected server error.'
-                            })
-                            .flush();
-                    }
-                })
-                .listen(
-                    {port: this.#options.port},
-                    () => resolve(this)
-                );
+    stop() {
+        return new Promise(resolve => {
+            this.#server.close(
+                () => resolve(new HttpServer(
+                    this.#http,
+                    this.#request,
+                    this.#response,
+                    this.#endpoints,
+                    this.#options))
+            );
         });
     }
 
     options() {
         return this.#options;
     }
-}
+};

package/src/js/server/request/InputRequest.js

@@ -13,26 +13,22 @@ module.exports = class InputRequest {
 
     flush() {
         return new Promise((resolve, reject) => {
-            try {
-                this.#inputStream.on('error', (e) => reject(e));
-
-                if (!this.#isChunkedInputStream(this.#inputStream)) {
-                    resolve(new InputRequest(
-                        this.#inputStream,
-                        this.#extractOptionsFromInputStream(this.#inputStream)
-                    ));
+            this.#inputStream.once('error', (e) =>
+                reject(new Error(e.message, {cause: 'INVALID_REQUEST'}))
+            );
+
+            let chunks = [];
+            this.#inputStream.on('data', (chunk) => chunks.push(chunk));
+            this.#inputStream.on('end', () => resolve(new InputRequest(
+                this.#inputStream,
+                {
+                    method: this.#inputStream.method,
+                    path: new URL(this.#inputStream.url, 'http://dummy').pathname,
+                    query: new URL(this.#inputStream.url, 'http://dummy').searchParams,
+                    headers: new Headers(this.#inputStream.headers),
+                    body: Buffer.concat(chunks)
                 }
-
-                let chunks = [];
-                this.#inputStream.on('data', (chunk) => chunks.push(chunk));
-                this.#inputStream.on('end', () => resolve(new InputRequest(
-                    this.#inputStream,
-                    {... this.#extractOptionsFromInputStream(this.#inputStream), body: Buffer.concat(chunks)}
-                )));
-
-            } catch (e) {
-                reject(e);
-            }
+            )));
         });
     }
 
@@ -40,7 +36,7 @@ module.exports = class InputRequest {
         return {
             method: this.#options.method.toString().toUpperCase(),
             path: this.#options.path.toString().toLowerCase()
-        }
+        };
     }
 
     query() {
@@ -51,16 +47,7 @@ module.exports = class InputRequest {
         return this.#options.body;
     }
 
-    #isChunkedInputStream(inputStream) {
-        return ['POST', 'PUT'].some(method => method === inputStream.method.toString().toUpperCase());
-    }
-
-    #extractOptionsFromInputStream(inputStream) {
-        return {
-            method: inputStream.method,
-            path: new URL(inputStream.url, 'http://dummy').pathname,
-            query: new URL(inputStream.url, 'http://dummy').searchParams,
-            headers: inputStream.headers
-        };
+    headers() {
+        return this.#options.headers;
     }
-}
+};

package/src/js/server/request/JsonInputRequest.js

@@ -28,11 +28,16 @@ module.exports = class JsonInputRequest {
     }
 
     body() {
-        if (this.#origin.body() == null) {
-            return null;
+        try {
+            return JSON.parse(this.#origin.body().toString());
+
+        } catch (e) {
+            throw new Error('Wrong body format. Only JSON accepted.', {cause: 'INVALID_REQUEST'});
         }
+    }
 
-        return JSON.parse(this.#origin.body().toString());
+    headers() {
+        return this.#origin.headers();
     }
 
     #useChunkMethod(requestMethod) {

package/src/js/server/request/LoggedInputRequest.js

@@ -30,4 +30,8 @@ module.exports = class LoggedInputRequest {
     body() {
         return this.#origin.body();
     }
+
+    headers() {
+        return this.#origin.headers();
+    }
 }

package/src/js/server/response/OutputResponse.js

@@ -31,6 +31,10 @@ module.exports = class OutputResponse {
     }
 
     #mergeOptions(existedOptions, newOptions) {
+        if (newOptions == null) {
+            return existedOptions;
+        }
+
         if (newOptions.statusCode != null) {
             existedOptions.statusCode = newOptions.statusCode;
         }

package/.github/workflows/npm-publish.yml

@@ -1,21 +0,0 @@
-name: Publish release
-
-on:
-  release:
-    types: [published]
-
-jobs:
-  publish-npm:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 21
-          registry-url: https://registry.npmjs.org/
-      - run: npm run prepareToPublish
-        env:
-          RELEASE: ${{github.event.release.name}}
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}