objective-http 1.3.0 → 1.4.0

package/README.md

@@ -15,17 +15,14 @@ const {
     LoggedServer,
     endpoint: {
         Endpoint,
-        LoggedEndpoint,
         Endpoints
     },
     request: {
         InputRequest,
-        JsonInputRequest,
         LoggedInputRequest,
     },
     response: {
         OutputResponse,
-        JsonOutputResponse,
         LoggedOutputResponse
     }
 } = require('objective-http').server;
@@ -33,13 +30,13 @@ const {
 new LoggedServer(
     new Server(
         new Endpoints([
-            new LoggedEndpoint(new MyFirstEndpoint(), console),
-            new LoggedEndpoint(new MySecondEndpoint(), console),
-            new LoggedEndpoint(new MyThirdEndpoint(), console)
+            new MyFirstEndpoint(),
+            new MySecondEndpoint(),
+            new MyThirdEndpoint()
         ]),
         {port: server_port},
-        new LoggedInputRequest(new JsonInputRequest(new InputRequest()), console),
-        new LoggedOutputResponse(new JsonOutputResponse(new OutputResponse()), console),
+        new LoggedInputRequest(new InputRequest(), console),
+        new LoggedOutputResponse(new OutputResponse(), console),
         createServerFunction
     ),
     console
@@ -139,17 +136,14 @@ const {
     LoggedServer,
     endpoint: {
         Endpoint,
-        LoggedEndpoint,
         Endpoints
     },
     request: {
         InputRequest,
-        JsonInputRequest,
         LoggedInputRequest,
     },
     response: {
         OutputResponse,
-        JsonOutputResponse,
         LoggedOutputResponse
     }
 } = require('objective-http').server;
@@ -157,13 +151,13 @@ const {
 new LoggedServer(
     new Server(
         new Endpoints([
-            new LoggedEndpoint(new MyFirstEndpoint(), console),
-            new LoggedEndpoint(new MySecondEndpoint(), console),
-            new LoggedEndpoint(new MyThirdEndpoint(), console)
+            new MyFirstEndpoint(),
+            new MySecondEndpoint(),
+            new MyThirdEndpoint()
         ]),
         {port: server_port},
-        new LoggedInputRequest(new JsonInputRequest(new InputRequest()), console),
-        new LoggedOutputResponse(new JsonOutputResponse(new OutputResponse()), console),
+        new LoggedInputRequest(new InputRequest(), console),
+        new LoggedOutputResponse(new OutputResponse(), console),
         createServerFunction
     ),
     console
@@ -181,15 +175,12 @@ const {
     LoggedServer,
     endpoint: {
         Endpoint,
-        LoggedEndpoint,
         Endpoints
     },
     request: {
-        JsonInputRequest,
         LoggedInputRequest,
     },
     response: {
-        JsonOutputResponse,
         LoggedOutputResponse
     }
 } = require('objective-http').server;

package/package.json

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

package/src/js/bun/Bunttp.js

@@ -12,16 +12,13 @@ module.exports = class Bunttp {
     }
 
     listen(options, cb) {
-        const config = {...this.#serverConfig, port: options.port};
-        const server = Bun.serve(config);
+        this.#server = Bun.serve({...this.#serverConfig, port: options.port});
         cb();
-        return new Bunttp(config, server);
     }
 
     close(cb) {
-        const server = this.#server.stop();
+        this.#server.stop();
         cb();
-        return new Bunttp(this.#serverConfig, server);
     }
 
     request = fetch;

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

@@ -16,8 +16,10 @@ module.exports = class InputRequest {
             return new InputRequest(
                 this.#inputStream,
                 {
-                    method: this.#inputStream.method,
-                    path: new URL(this.#inputStream.url).pathname,
+                    route: {
+                        method: this.#inputStream.method,
+                        path: new URL(this.#inputStream.url).pathname
+                    },
                     query: new URL(this.#inputStream.url).searchParams,
                     headers: this.#inputStream.headers,
                     body: Buffer.from(await (await this.#inputStream.blob()).arrayBuffer())
@@ -30,10 +32,7 @@ module.exports = class InputRequest {
     }
 
     route() {
-        return {
-            method: this.#options.method.toString().toUpperCase(),
-            path: this.#options.path.toString().toLowerCase()
-        }
+        return this.#options.route;
     }
 
     query() {

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

@@ -7,14 +7,10 @@ module.exports = class OutputResponse {
         this.#outputStream = outputStream;
     }
 
-    copy(options = this.#options, outputStream = this.#outputStream) {
+    copy(outputStream = this.#outputStream, options = this.#options) {
         return new OutputResponse({...{statusCode: 200, headers: {}}, ...options}, outputStream);
     }
 
-    update(options) {
-        return new OutputResponse(this.#mergeOptions(this.#options, options), this.#outputStream);
-    }
-
     flush() {
         try {
             return new Response(this.#options.body, {
@@ -26,24 +22,4 @@ module.exports = class OutputResponse {
             throw new Error(e.message, {cause: 'INVALID_RESPONSE'});
         }
     }
-
-    #mergeOptions(existedOptions, newOptions) {
-        if (newOptions == null) {
-            return existedOptions;
-        }
-
-        if (newOptions.statusCode != null) {
-            existedOptions.statusCode = newOptions.statusCode;
-        }
-
-        if (newOptions.body != null) {
-            existedOptions.body = newOptions.body;
-        }
-
-        if (newOptions.headers != null) {
-            existedOptions.headers = {...existedOptions.headers, ...newOptions.headers};
-        }
-
-        return existedOptions;
-    }
 }

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

@@ -10,72 +10,44 @@ module.exports = class OutputRequest {
     }
 
     copy(options = this.#options, response = this.#response, http = this.#requestFunction) {
-        return new OutputRequest(response, http,  {method: 'GET', ...options});
+        return new OutputRequest(response, http, {method: 'GET', ...options});
     }
 
-    async send() {
-        try {
-            return await new Promise((resolve, reject) => {
-                this.#sendRequestOutputStream(
-                    this.#configureRequestOutputStream(this.#requestFunction, this.#response, this.#options, resolve, reject),
+    send() {
+        return new Promise((resolve, reject) => {
+            try {
+                const requestOutputStream = this.#requestFunction(
+                    this.#options.url,
                     this.#options,
-                    reject);
-            });
-
-        } catch (e) {
-            if (e.cause == null) {
-                throw new Error(e.message, {cause: 'INVALID_REQUEST'});
-            }
+                    async (responseInputStream) => {
+                        try {
+                            resolve(await this.#response
+                                .copy(responseInputStream)
+                                .flush());
+
+                        } catch (e) {
+                            reject(new Error(e.message, {cause: 'INVALID_REQUEST'}));
+                        }
+                    });
+
+                requestOutputStream.once('error', e => {
+                    reject(new Error(e.message, {cause: 'INVALID_REQUEST'}));
+                });
 
-            throw e;
-        }
-    }
+                if (this.#needToByWritten(this.#options)) {
+                    requestOutputStream.write(this.#options.body);
+                }
 
-    #sendRequestOutputStream(requestOutputStream, options, reject) {
-        try {
-            requestOutputStream.once('error', e => reject(e));
+                requestOutputStream.end();
 
-            if (this.#needToByWritten(options)) {
-                requestOutputStream.write(options.body);
+            } catch (e) {
+                reject(new Error(e.message, {cause: 'INVALID_REQUEST'}));
             }
-
-            requestOutputStream.end();
-
-        } catch (e) {
-            reject(e);
-        }
+        });
     }
 
     #needToByWritten(options) {
         return ['POST', 'PUT'].some(method => method === options.method.toString().toUpperCase())
             && (options.body != null && typeof options.body === 'string');
     }
-
-    #configureRequestOutputStream(requestFunction, response, options, resolve, reject) {
-        if (options.url != null) {
-            return requestFunction(
-                options.url,
-                options,
-                async (responseInputStream) => {
-                    await this.#flushResponseInputStream(responseInputStream, response, resolve, reject);
-                });
-        }
-
-        return requestFunction(
-            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);
-        }
-    }
 };

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

@@ -24,35 +24,25 @@ module.exports = class InputResponse {
     }
 
     async flush() {
-        try {
-            return await new Promise((resolve, reject) => {
-                this.#flushResponseInputStream(this.#inputStream, resolve, reject);
-            });
-
-        } catch (e) {
-            throw new Error(e.message, {cause: 'INVALID_RESPONSE'});
-        }
-    }
-
-    #flushResponseInputStream(inputStream, resolve, reject) {
-        try {
-            inputStream.once('error', (e) => reject(e));
-
-            let chunks = [];
-            inputStream.on('data', (chunk) => chunks.push(chunk));
-            inputStream.on('end', () => resolve(
-                new InputResponse(
-                    inputStream,
-                    {
-                        statusCode: inputStream.statusCode,
-                        headers: new Headers(inputStream.headers),
-                        body: Buffer.concat(chunks)
-                    }
-                )
-            ));
-
-        } catch (e) {
-            reject(e);
-        }
+        return await new Promise((resolve, reject) => {
+            try {
+                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)
+                        }
+                    )
+                ));
+            } catch (e) {
+                throw new Error(e.message, {cause: 'INVALID_RESPONSE'});
+            }
+        });
     }
 };

package/src/js/index.js

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

package/src/js/server/LoggedServer.js

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

@@ -15,31 +15,39 @@ module.exports = class Server {
         this.#server = server;
     }
 
+    options() {
+        return this.#options;
+    }
+
     start() {
         const server = this.#createServerFunction(async (requestStream, responseStream) => {
             try {
-                return await (this.#response
-                    .copy(await this.#endpoints
-                        .handle(await (this.#request
-                            .copy(requestStream))
-                            .flush()), responseStream))
+                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 this.#response
-                        .copy({
-                            statusCode: 400,
-                            body: e.message
-                        }, responseStream)
+                        .copy(responseStream,
+                            {statusCode: 400, body: e.message})
+                        .flush();
+                }
+
+                if (e.cause === 'HANDLER_NOT_FOUND') {
+                    return this.#response
+                        .copy(responseStream,
+                            {statusCode: 501, body: e.message})
                         .flush();
                 }
 
                 return this.#response
-                    .copy({
-                        statusCode: 500,
-                        body: 'Unexpected server error.'
-                    }, responseStream)
+                    .copy(responseStream,
+                        {statusCode: 500, body: 'Unexpected server error.'})
                     .flush();
             }
         });
@@ -47,21 +55,21 @@ module.exports = class Server {
         return new Promise(resolve => {
             server.listen(
                 this.#options,
-                () => {
-                    resolve(new Server(
-                        this.#endpoints,
-                        this.#options,
-                        this.#request,
-                        this.#response,
-                        this.#createServerFunction,
-                        server));
-                }
+                () => resolve(new Server(
+                    this.#endpoints,
+                    this.#options,
+                    this.#request,
+                    this.#response,
+                    this.#createServerFunction,
+                    server))
             );
         });
     }
 
     stop() {
         return new Promise(resolve => {
+            console.log('stop ', this.#server);
+
             this.#server.close(
                 () => resolve(new Server(
                     this.#endpoints,
@@ -72,8 +80,4 @@ module.exports = class Server {
             );
         });
     }
-
-    options() {
-        return this.#options;
-    }
 };

package/src/js/server/endpoint/Endpoint.js

@@ -1,24 +1,17 @@
 module.exports = class Endpoint {
-    #method;
-    #path;
+    #route;
 
-    constructor(method, path) {
-        this.#method = method;
-        this.#path = path;
+    constructor(route) {
+        this.#route = route;
     }
 
-    copy(method = this.#method, path = this.#path) {
-        return new Endpoint(method, path);
+    route() {
+        return this.#route;
     }
 
-    route() {
+    async handle() {
         return {
-            method: this.#method.toString().toUpperCase(),
-            path: this.#path.toString().toLowerCase()
+            statusCode: 200
         };
     }
-
-    async handle(request) {
-        return {};
-    }
 }

package/src/js/server/endpoint/Endpoints.js

@@ -1,26 +1,36 @@
 module.exports = class Endpoints {
-    #collection;
+    #map;
 
-    constructor(collection = []) {
-        this.#collection = collection;
+    constructor(collection = [], map = new Map()) {
+        this.#map = map;
+        collection.forEach((endpoint) => {
+            if (!this.#map.has(endpoint.route().path.toString().toLowerCase())) {
+                this.#map.set(endpoint.route().path.toString().toLowerCase(), new Map());
+            }
+
+            this.#map
+                .get(endpoint.route().path.toString().toLowerCase())
+                .set(endpoint.route().method.toString().toUpperCase(),
+                    endpoint);
+        });
     }
 
-    copy(collection = this.#collection) {
-        return new Endpoints(collection);
+    copy(collection, map = this.#map) {
+        return new Endpoints(collection, map);
     }
 
     async handle(request) {
-        const endpoint = this.#collection
-            .find(endpoint => endpoint.route().method === request.route().method
-                && endpoint.route().path === request.route().path);
-
-        if (endpoint == null) {
-            return {
-                statusCode: 501,
-                body: 'There are no handler for request.'
-            }
+        if (!this.#map.has(request.route().path.toString().toLowerCase())
+            || !this.#map
+                .get(request.route().path.toString().toLowerCase())
+                .has(request.route().method.toString().toUpperCase())
+        ) {
+            throw new Error('There are no handler for request.', {cause: 'HANDLER_NOT_FOUND'});
         }
 
-        return await endpoint.handle(request);
+        return await this.#map
+            .get(request.route().path.toString().toLowerCase())
+            .get(request.route().method.toString().toUpperCase())
+            .handle(request);
     }
 }

package/src/js/server/endpoint/index.js

@@ -1,5 +1,4 @@
 module.exports = {
     Endpoint: require('./Endpoint'),
-    LoggedEndpoint: require('./LoggedEndpoint'),
     Endpoints: require('./Endpoints'),
 };

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

@@ -11,6 +11,22 @@ module.exports = class InputRequest {
         return new InputRequest(inputStream, options);
     }
 
+    route() {
+        return this.#options.route;
+    }
+
+    query() {
+        return this.#options.query;
+    }
+
+    body() {
+        return this.#options.body;
+    }
+
+    headers() {
+        return this.#options.headers;
+    }
+
     flush() {
         return new Promise((resolve, reject) => {
             try {
@@ -23,36 +39,19 @@ module.exports = class InputRequest {
                 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,
+                        route: {
+                            method: this.#inputStream.method,
+                            path: new URL(this.#inputStream.url, 'http://url').pathname
+                        },
+                        query: new URL(this.#inputStream.url, 'http://url').searchParams,
                         headers: new Headers(this.#inputStream.headers),
-                        body: Buffer.concat(chunks)
+                        body: Buffer.concat(chunks),
                     }
                 )));
 
             } catch (e) {
-                throw new Error(e.message, {cause: 'INVALID_REQUEST'});
+                reject(new Error(e.message, {cause: 'INVALID_REQUEST'}));
             }
         });
     }
-
-    route() {
-        return {
-            method: this.#options.method.toString().toUpperCase(),
-            path: this.#options.path.toString().toLowerCase()
-        };
-    }
-
-    query() {
-        return this.#options.query;
-    }
-
-    body() {
-        return this.#options.body;
-    }
-
-    headers() {
-        return this.#options.headers;
-    }
 };

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

@@ -13,19 +13,6 @@ module.exports = class LoggedInputRequest {
         return new LoggedInputRequest(origin, logger, inputStream);
     }
 
-    async flush() {
-        this.#logger.debug(`HttpRequest: [${this.#inputStream.method}] ${this.#inputStream.url} ${JSON.stringify(this.#inputStream.headers)}`);
-
-        try {
-            return new LoggedInputRequest(await this.#origin.flush(), this.#logger);
-
-        } catch (e) {
-            this.#logger.error(`HttpRequest: [${this.#inputStream.method}] ${this.#inputStream.url} error: ${e.message}`, e);
-
-            throw e;
-        }
-    }
-
     route() {
         return this.#origin.route();
     }
@@ -41,4 +28,17 @@ module.exports = class LoggedInputRequest {
     headers() {
         return this.#origin.headers();
     }
+
+    async flush() {
+        this.#logger.debug(`HttpRequest: [${this.#inputStream.method}] ${this.#inputStream.url} ${JSON.stringify(this.#inputStream.headers)}`);
+
+        try {
+            return new LoggedInputRequest(await this.#origin.flush(), this.#logger);
+
+        } catch (e) {
+            this.#logger.error(`HttpRequest: [${this.#inputStream.method}] ${this.#inputStream.url} error: ${e.message}`, e);
+
+            throw e;
+        }
+    }
 }

package/src/js/server/request/index.js

@@ -1,5 +1,4 @@
 module.exports = {
     InputRequest: require('./InputRequest'),
-    JsonInputRequest: require('./JsonInputRequest'),
     LoggedInputRequest: require('./LoggedInputRequest')
 };

package/src/js/server/response/LoggedOutputResponse.js

@@ -11,10 +11,6 @@ module.exports = class LoggedOutputResponse {
         return new LoggedOutputResponse(origin, logger);
     }
 
-    update(options) {
-        return new LoggedOutputResponse(this.#origin.update(options), this.#logger);
-    }
-
     flush() {
         const outputStream = this.#loggedFlush();
 

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

@@ -7,14 +7,10 @@ module.exports = class OutputResponse {
         this.#outputStream = outputStream;
     }
 
-    copy(options = this.#options, outputStream = this.#outputStream) {
+    copy(outputStream = this.#outputStream, options = this.#options) {
         return new OutputResponse({...{statusCode: 200, headers: {}}, ...options}, outputStream);
     }
 
-    update(options) {
-        return new OutputResponse(this.#mergeOptions(this.#options, options), this.#outputStream);
-    }
-
     flush() {
         try {
             this.#outputStream.writeHead(this.#options.statusCode, this.#options.headers)
@@ -29,24 +25,4 @@ module.exports = class OutputResponse {
             this.#outputStream.end();
         }
     }
-
-    #mergeOptions(existedOptions, newOptions) {
-        if (newOptions == null) {
-            return existedOptions;
-        }
-
-        if (newOptions.statusCode != null) {
-            existedOptions.statusCode = newOptions.statusCode;
-        }
-
-        if (newOptions.body != null) {
-            existedOptions.body = newOptions.body;
-        }
-
-        if (newOptions.headers != null) {
-            existedOptions.headers = {...existedOptions.headers, ...newOptions.headers};
-        }
-
-        return existedOptions;
-    }
 }

package/src/js/server/response/index.js

@@ -1,5 +1,4 @@
 module.exports = {
     OutputResponse: require('./OutputResponse'),
-    JsonOutputResponse: require('./JsonOutputResponse'),
     LoggedOutputResponse: require('./LoggedOutputResponse')
 };

package/src/js/server/endpoint/LoggedEndpoint.js

@@ -1,30 +0,0 @@
-module.exports = class LoggedEndpoint {
-    #origin;
-    #logger;
-
-    constructor(origin, logger) {
-        this.#origin = origin;
-        this.#logger = logger;
-    }
-
-    copy(method, path, logger = this.#logger, origin = this.#origin.copy(method, path)) {
-        return new LoggedEndpoint(origin, logger);
-    }
-
-    route() {
-        return this.#origin.route();
-    }
-
-    async handle(request) {
-        this.#logger.debug(`HttpEndpoint's handling [${request.route().method}] ${request.route().path}`);
-
-        try {
-            return await this.#origin.handle(request);
-
-        } catch (e) {
-            this.#logger.error(`HttpEndpoint's handling [${request.route().method}] ${request.route().path} error: ${e.message}`, e);
-
-            throw e;
-        }
-    }
-}

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

@@ -1,51 +0,0 @@
-module.exports = class JsonInputRequest {
-    #origin;
-    #inputStream;
-
-    constructor(origin, inputStream) {
-        this.#origin = origin;
-        this.#inputStream = inputStream;
-    }
-
-    copy(inputStream, options, origin = this.#origin.copy(inputStream, options)) {
-        return new JsonInputRequest(origin, inputStream);
-    }
-
-    async flush() {
-        if (this.#useChunkMethod(this.#inputStream.method) && !this.#validHeaders(new Headers(this.#inputStream.headers))) {
-            throw new Error('Wrong content-type. Only application/json accepted.', {cause: 'INVALID_REQUEST'});
-        }
-
-        return new JsonInputRequest(await this.#origin.flush(), this.#inputStream);
-    }
-
-    route() {
-        return this.#origin.route();
-    }
-
-    query() {
-        return this.#origin.query();
-    }
-
-    body() {
-        try {
-            return JSON.parse(this.#origin.body().toString());
-
-        } catch (e) {
-            throw new Error('Wrong body format. Only JSON accepted.', {cause: 'INVALID_REQUEST'});
-        }
-    }
-
-    headers() {
-        return this.#origin.headers();
-    }
-
-    #useChunkMethod(requestMethod) {
-        return ['POST', 'PUT'].some(method => method === requestMethod.toString().toUpperCase())
-    }
-
-    #validHeaders(requestHeaders) {
-        return new Headers(requestHeaders).has('content-type')
-            && new RegExp('^application\/json').test(new Headers(requestHeaders).get('content-type'));
-    }
-}

package/src/js/server/response/JsonOutputResponse.js

@@ -1,45 +0,0 @@
-module.exports = class JsonOutputResponse {
-    #origin;
-    #options;
-
-    constructor(origin, options) {
-        this.#origin = origin;
-        this.#options = options;
-    }
-
-    copy(options, outputStream, origin = this.#origin.copy(options, outputStream)) {
-        return new JsonOutputResponse(origin, options);
-    }
-
-    update(options) {
-        return new JsonOutputResponse(this.#origin.update(options));
-    }
-
-    flush() {
-        const body = this.#options.body;
-
-        if (body == null) {
-            return this.#origin.flush();
-        }
-
-        if (typeof body === 'string') {
-            try {
-                JSON.parse(body);
-
-                return this.#origin
-                    .update({headers: {'Content-Type': 'application/json; charset=utf-8'}})
-                    .flush();
-
-            } catch (e) {
-                return this.#origin.flush();
-            }
-        }
-
-        return this.#origin
-            .update({
-                headers: {'Content-Type': 'application/json; charset=utf-8'},
-                body: JSON.stringify(body)
-            })
-            .flush();
-    }
-};