objective-http 1.4.0 → 2.0.2

package/src/js/server/Server.js

@@ -1,83 +1,61 @@
 module.exports = class Server {
-    #endpoints;
+    #handler;
     #options;
-    #request;
-    #response;
-    #createServerFunction;
+    #http;
     #server;
 
-    constructor(endpoints, options, request, response, createServerFunction, server) {
-        this.#endpoints = endpoints;
+    constructor({ handler, options, http, server }) {
+        this.#handler = handler;
         this.#options = options;
-        this.#request = request;
-        this.#response = response;
-        this.#createServerFunction = createServerFunction;
+        this.#http = http;
         this.#server = server;
     }
 
-    options() {
+    with({
+        handler = this.#handler,
+        options = this.#options,
+        http = this.#http,
+        server = this.#server,
+    }) {
+        return new Server({
+            handler,
+            options,
+            http,
+            server,
+        });
+    }
+
+    get options() {
         return this.#options;
     }
 
     start() {
-        const server = this.#createServerFunction(async (requestStream, responseStream) => {
+        return new Promise((resolve, reject) => {
             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) =>
+                        await this.#handler.handle(
+                            requestStream,
+                            responseStream,
+                        ),
+                );
+
+                server.listen(this.options, () =>
+                    resolve(this.with({ server })),
+                );
             } catch (e) {
-                if (e.cause === 'INVALID_REQUEST') {
-                    return this.#response
-                        .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(responseStream,
-                        {statusCode: 500, body: 'Unexpected server error.'})
-                    .flush();
+                reject(
+                    new Error('Init server fail', {
+                        cause: { error: e, code: 'INITIAL_SERVER_FAIL' },
+                    }),
+                );
             }
         });
-
-        return new Promise(resolve => {
-            server.listen(
-                this.#options,
-                () => 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,
-                    this.#options,
-                    this.#request,
-                    this.#response,
-                    this.#createServerFunction))
-            );
+        return new Promise((resolve) => {
+            this.#server.close(() => resolve(this.with({ server: null })));
         });
     }
-};
+};

package/src/js/server/handler/endpoint/EndpointHandler.js

@@ -0,0 +1,35 @@
+module.exports = class EndpointHandler {
+    #endpoint;
+    #request;
+    #response;
+
+    constructor({ endpoint, request, response }) {
+        this.#endpoint = endpoint;
+        this.#request = request;
+        this.#response = response;
+    }
+
+    async handle(requestStream, responseStream) {
+        const requestRoute = JSON.stringify({
+            method: requestStream.method,
+            path: new URL(`http://localhost${requestStream.url}`).pathname,
+        });
+
+        if (requestRoute !== JSON.stringify(this.#endpoint.route)) {
+            return;
+        }
+
+        const request = await this.#request
+            .with({
+                requestStream,
+            })
+            .accept();
+
+        return this.#response
+            .with({
+                responseStream,
+                ...(await this.#endpoint.handle(request)),
+            })
+            .send();
+    }
+};

package/src/js/server/handler/endpoint/EndpointHandlers.js

@@ -0,0 +1,22 @@
+module.exports = class EndpointHandlers {
+    #handlers;
+
+    constructor({ handlers }) {
+        this.#handlers = handlers;
+    }
+
+    async handle(requestStream, responseStream) {
+        for (let i = 0; i < this.#handlers.length; i++) {
+            const response = await this.#handlers[i].handle(
+                requestStream,
+                responseStream,
+            );
+
+            if (response != null) {
+                return response;
+            }
+        }
+
+        return;
+    }
+};

package/src/js/server/handler/endpoint/EndpointsHandler.js

@@ -0,0 +1,42 @@
+module.exports = class EndpointsHandler {
+    #routeToEndpointMap;
+    #request;
+    #response;
+
+    constructor({ endpoints, request, response }) {
+        this.#request = request;
+        this.#response = response;
+        this.#routeToEndpointMap = new Map(
+            endpoints.map((endpoint) => [
+                JSON.stringify(endpoint.route),
+                endpoint,
+            ]),
+        );
+    }
+
+    async handle(requestStream, responseStream) {
+        const requestRoute = JSON.stringify({
+            method: requestStream.method,
+            path: new URL(`http://localhost${requestStream.url}`).pathname,
+        });
+
+        if (!this.#routeToEndpointMap.has(requestRoute)) {
+            return;
+        }
+
+        const request = await this.#request
+            .with({
+                requestStream,
+            })
+            .accept();
+
+        return this.#response
+            .with({
+                responseStream,
+                ...(await this.#routeToEndpointMap
+                    .get(JSON.stringify(request.route))
+                    .handle(request)),
+            })
+            .send();
+    }
+};

package/src/js/server/handler/endpoint/EndpontRequiredHandler.js

@@ -0,0 +1,22 @@
+module.exports = class EndpontRequiredHandler {
+    #origin;
+
+    constructor({ origin }) {
+        this.#origin = origin;
+    }
+
+    async handle(requestStream, responseStream) {
+        const response = await this.#origin.handle(
+            requestStream,
+            responseStream,
+        );
+
+        if (response == null) {
+            throw new Error(`Handler for ${requestStream.url} not found`, {
+                cause: { code: 'HANDLER_NOT_FOUND' },
+            });
+        }
+
+        return response;
+    }
+};

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

@@ -0,0 +1,6 @@
+module.exports = {
+    EndpointHandler: require('./EndpointHandler'),
+    EndpointsHandler: require('./EndpointsHandler'),
+    EndpointHandlers: require('./EndpointHandlers'),
+    EndpointRequiredHandler: require('./EndpontRequiredHandler'),
+};

package/src/js/server/handler/error/HandlerNotFoundErrorHandler.js

@@ -0,0 +1,27 @@
+module.exports = class HandlerNotFoundErrorHandler {
+    #origin;
+    #response;
+
+    constructor({ origin, response }) {
+        this.#origin = origin;
+        this.#response = response;
+    }
+
+    async handle(requestStream, responseStream) {
+        try {
+            return await this.#origin.handle(requestStream, responseStream);
+        } catch (e) {
+            if (e.cause?.code !== 'HANDLER_NOT_FOUND') {
+                throw e;
+            }
+
+            return this.#response
+                .with({
+                    responseStream,
+                    status: 501,
+                    body: e.message,
+                })
+                .send();
+        }
+    }
+};

package/src/js/server/handler/error/InvalidRequestErrorHandler.js

@@ -0,0 +1,27 @@
+module.exports = class InvalidRequestErrorHandler {
+    #origin;
+    #response;
+
+    constructor({ origin, response }) {
+        this.#origin = origin;
+        this.#response = response;
+    }
+
+    async handle(requestStream, responseStream) {
+        try {
+            return await this.#origin.handle(requestStream, responseStream);
+        } catch (e) {
+            if (e.cause?.code !== 'INVALID_REQUEST') {
+                throw e;
+            }
+
+            return this.#response
+                .with({
+                    responseStream,
+                    status: 400,
+                    body: e.message,
+                })
+                .send();
+        }
+    }
+};

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

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

package/src/js/server/handler/error/UnexpectedErrorHandler.js

@@ -0,0 +1,23 @@
+module.exports = class UnexpectedErrorHandler {
+    #origin;
+    #response;
+
+    constructor({ origin, response }) {
+        this.#origin = origin;
+        this.#response = response;
+    }
+
+    async handle(requestStream, responseStream) {
+        try {
+            return await this.#origin.handle(requestStream, responseStream);
+        } catch {
+            return this.#response
+                .with({
+                    responseStream,
+                    status: 500,
+                    body: 'Application unexpected error',
+                })
+                .send();
+        }
+    }
+};

package/src/js/server/handler/error/index.js

@@ -0,0 +1,6 @@
+module.exports = {
+    UnexpectedErrorHandler: require('./UnexpectedErrorHandler'),
+    InvalidRequestErrorHandler: require('./InvalidRequestErrorHandler'),
+    HandlerNotFoundErrorHandler: require('./HandlerNotFoundErrorHandler'),
+    LogErrorHandler: require('./LogErrorHandler'),
+};

package/src/js/server/handler/index.js

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

package/src/js/server/index.js

@@ -1,7 +1,6 @@
 module.exports = {
     Server: require('./Server'),
-    LoggedServer: require('./LoggedServer'),
-    endpoint: require('./endpoint'),
+    handler: require('./handler'),
     request: require('./request'),
-    response: require('./response')
-}
+    response: require('./response'),
+};

package/src/js/server/request/chunk/ChunkServerRequest.js

@@ -0,0 +1,87 @@
+module.exports = class ChunkServerRequest {
+    #requestStream;
+    #route;
+    #query;
+    #headers;
+    #body;
+
+    constructor({ requestStream, route, query, headers, body }) {
+        this.#requestStream = requestStream;
+        this.#route = route;
+        this.#query = query;
+        this.#headers = headers;
+        this.#body = body;
+    }
+
+    with({
+        requestStream = this.#requestStream,
+        route = this.#route,
+        query = this.#query,
+        headers = this.#headers,
+        body = this.#body,
+    }) {
+        return new ChunkServerRequest({
+            requestStream,
+            route,
+            query,
+            headers,
+            body,
+        });
+    }
+
+    get route() {
+        return this.#route;
+    }
+
+    get query() {
+        return this.#query;
+    }
+
+    get body() {
+        return this.#body;
+    }
+
+    get headers() {
+        return this.#headers;
+    }
+
+    accept() {
+        return new Promise((resolve, reject) => {
+            try {
+                this.#requestStream.on('error', (e) => {
+                    reject(
+                        new Error('Server request error', {
+                            cause: { error: e, code: 'REQUEST_ERROR' },
+                        }),
+                    );
+                });
+
+                let chunks = [];
+                this.#requestStream.on('data', (chunk) => chunks.push(chunk));
+                this.#requestStream.on('end', () => {
+                    resolve(
+                        this.with({
+                            route: {
+                                method: this.#requestStream.method,
+                                path: new URL(
+                                    `http://${process.env.HOST ?? 'localhost'}${this.#requestStream.url}`,
+                                ).pathname,
+                            },
+                            query: new URL(
+                                `http://${process.env.HOST ?? 'localhost'}${this.#requestStream.url}`,
+                            ).searchParams,
+                            headers: new Headers(this.#requestStream.headers),
+                            body: Buffer.concat(chunks),
+                        }),
+                    );
+                });
+            } catch (e) {
+                reject(
+                    new Error('Server request error', {
+                        cause: { error: e, code: 'REQUEST_ERROR' },
+                    }),
+                );
+            }
+        });
+    }
+};

package/src/js/server/request/chunk/JsonServerRequest.js

@@ -0,0 +1,67 @@
+module.exports = class JsonServerRequest {
+    #origin;
+
+    constructor({ origin }) {
+        this.#origin = origin;
+    }
+
+    with({
+        requestStream,
+        route,
+        query,
+        headers,
+        body,
+        origin = this.#origin.with({
+            requestStream,
+            route,
+            query,
+            headers,
+            body,
+        }),
+    }) {
+        return new JsonServerRequest({
+            origin,
+        });
+    }
+
+    get route() {
+        return this.#origin.route;
+    }
+
+    get query() {
+        return this.#origin.query;
+    }
+
+    get body() {
+        return this.#origin.body;
+    }
+
+    get headers() {
+        return this.#origin.headers;
+    }
+
+    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),
+                    query: Object.fromEntries(accepted.query),
+                }),
+            });
+        } catch (e) {
+            if (e instanceof SyntaxError) {
+                throw new Error('Invalid server json request', {
+                    cause: { error: e, code: 'INVALID_REQUEST' },
+                });
+            }
+
+            throw e;
+        }
+    }
+};

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

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

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

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

package/src/js/server/response/chunk/ChunkServerResponse.js

@@ -0,0 +1,53 @@
+module.exports = class ChunkServerResponse {
+    #responseStream;
+    #status;
+    #headers;
+    #body;
+
+    constructor({ responseStream, status = 200, 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 ChunkServerResponse({
+            responseStream,
+            status,
+            headers,
+            body,
+        });
+    }
+
+    get status() {
+        return this.#status;
+    }
+
+    get headers() {
+        return this.#headers;
+    }
+
+    get body() {
+        return this.#body;
+    }
+
+    send() {
+        try {
+            this.#responseStream.writeHead(this.status, this.headers);
+
+            if (this.body != null) {
+                this.#responseStream.write(this.body);
+            }
+
+            return this;
+        } finally {
+            this.#responseStream.end();
+        }
+    }
+};

package/src/js/server/response/chunk/JsonServerResponse.js

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

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

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

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

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