@vorplex/api 0.0.4 → 0.0.9

package/dist/server/server/http/response-codes.enum.js

@@ -0,0 +1,15 @@
+export const HttpResponseCodes = {
+    OK: 200,
+    NoContent: 204,
+    PartialContent: 206,
+    Redirect: 302,
+    BadRequest: 400,
+    Unauthorized: 401,
+    Forbidden: 403,
+    NotFound: 404,
+    MethodNotAllowed: 405,
+    UnsupportedMediaType: 415,
+    Locked: 423,
+    InternalServerError: 500,
+    NotImplemented: 501
+};

package/dist/server/server/http/response.interface.d.ts

@@ -0,0 +1,23 @@
+import { MimeType } from '@vorplex/core';
+import { HttpResponseCodes } from './response-codes.enum';
+export interface HttpResponse {
+    type?: string;
+    code?: HttpResponseCodes;
+    status?: string;
+    headers?: Record<string, string>;
+}
+export interface HttpJsonResponse<T = any> extends HttpResponse {
+    type: 'json';
+    value: T;
+}
+export interface HttpFileResponse extends HttpResponse {
+    type: 'file';
+    file: string;
+    mimeType: MimeType;
+}
+export interface HttpRedirectResponse extends HttpResponse {
+    type: 'redirect';
+    url: string;
+    code?: HttpResponseCodes;
+}
+export type HttpResponses = HttpJsonResponse | HttpFileResponse | HttpRedirectResponse;

package/dist/server/server/hub/action.interface.d.ts

@@ -0,0 +1,15 @@
+import { Awaitable, Injector, Task, TsonObjectDefinition, WebClient } from '@vorplex/core';
+export interface ActionParams<T = any> {
+    injector: Injector;
+    client: WebClient;
+    task: Task;
+    packet: {
+        id: string;
+        data: T;
+    };
+}
+export interface Action<T = any> {
+    name: string;
+    schema?: TsonObjectDefinition<T>;
+    callback: (params: ActionParams<T>) => Awaitable<void>;
+}

package/dist/server/server/hub/hub.interface.d.ts

@@ -0,0 +1,5 @@
+import { Action } from './action.interface';
+export interface Hub {
+    name: string;
+    actions: Action[];
+}

package/dist/server/server/server.model.d.ts

@@ -0,0 +1,78 @@
+import { Awaitable, Injector, Logger, Subscribable, WebClient } from '@vorplex/core';
+import { IncomingMessage, Server as NodeHttpServer, ServerResponse } from 'http';
+import { Server as NodeHttpsServer } from 'https';
+import { WebSocketServer } from 'ws';
+import { Controller } from './controller/controller.interface';
+import { Handler } from './controller/handler.interface';
+import { Action } from './hub/action.interface';
+import { Hub } from './hub/hub.interface';
+export declare class Api {
+    static controller(controller: Controller): Controller;
+    static hub(hub: Hub): Hub;
+    static action<T>(action: Action<T>): Action<T>;
+    static actionResult(result: {
+        id: string;
+        data: any;
+    }): {
+        id: string;
+        data: any;
+    };
+    static actionError(result: {
+        id: string;
+        error: {
+            message: string;
+            data?: any;
+        };
+    }): {
+        id: string;
+        error: {
+            message: string;
+            data?: any;
+        };
+    };
+    static handler<TRoute extends string, TParameters extends string[]>(handler: Handler<TRoute, TParameters>): Handler<TRoute, TParameters>;
+}
+export interface HttpServerOptions {
+    port: number;
+    injector?: Injector;
+    hostname?: string;
+    logger?: Logger;
+    certificate?: {
+        crt: string;
+        key: string;
+    };
+}
+export declare class Server {
+    private _disposables;
+    private _clients;
+    private readonly _connection;
+    private readonly _disconnection;
+    private readonly _requests;
+    private readonly _packets;
+    injector: Injector;
+    options: HttpServerOptions;
+    httpServer: NodeHttpServer | NodeHttpsServer;
+    webServer: WebSocketServer;
+    controllers: Controller[];
+    hubs: Hub[];
+    get connection(): Subscribable<{
+        client: WebClient;
+        request: IncomingMessage;
+    }>;
+    get disconnection(): Subscribable<WebClient>;
+    get clients(): ReadonlyArray<WebClient>;
+    get requests(): Subscribable<{
+        request: IncomingMessage;
+        response: ServerResponse;
+    }>;
+    get packets(): Subscribable<{
+        client: WebClient;
+        packet: any;
+    }>;
+    constructor(options: HttpServerOptions);
+    route(routes: string | string[], callback: (request: IncomingMessage, response: ServerResponse) => Awaitable<void>): void;
+    start(): void;
+    private initHttpServer;
+    private initWebServer;
+    stop(): void;
+}

package/dist/server/server/server.model.js

@@ -0,0 +1,313 @@
+import { $Array, $Router, $String, $Tson, Emitter, Injector, MimeType, Task, TsonError, WebClient } from '@vorplex/core';
+import * as fs from 'fs';
+import { Server as NodeHttpServer } from 'http';
+import { Server as NodeHttpsServer } from 'https';
+import { WebSocketServer } from 'ws';
+import { HttpError, WebError } from './http/error.model';
+import { $HttpResponder } from './http/responder.util';
+import { HttpResponseCodes } from './http/response-codes.enum';
+export class Api {
+    static controller(controller) {
+        return controller;
+    }
+    static hub(hub) {
+        return hub;
+    }
+    static action(action) {
+        return action;
+    }
+    static actionResult(result) {
+        return result;
+    }
+    static actionError(result) {
+        return result;
+    }
+    static handler(handler) {
+        return handler;
+    }
+}
+export class Server {
+    _disposables = [];
+    _clients = [];
+    _connection = new Emitter();
+    _disconnection = new Emitter();
+    _requests = new Emitter();
+    _packets = new Emitter();
+    injector;
+    options;
+    httpServer;
+    webServer;
+    controllers = [];
+    hubs = [];
+    get connection() { return this._connection; }
+    get disconnection() { return this._disconnection; }
+    get clients() { return this._clients; }
+    get requests() { return this._requests; }
+    get packets() { return this._packets; }
+    constructor(options) {
+        this.options = options;
+        this.injector = options.injector ?? new Injector();
+        this.injector.addInstance(this);
+    }
+    route(routes, callback) {
+        routes = Array.isArray(routes) ? routes : [routes];
+        this.requests.subscribe(async ({ request, response }) => {
+            for (const route of routes) {
+                const match = $Router.match(route, request.url);
+                if (match) {
+                    await callback(request, response);
+                }
+            }
+        });
+    }
+    start() {
+        this.options.logger?.log('Starting Server');
+        this.stop();
+        this.initHttpServer();
+        this.initWebServer();
+    }
+    initHttpServer() {
+        const listener = (request, response) => {
+            response.setHeader('Access-Control-Allow-Origin', '*');
+            response.setHeader('Access-Control-Allow-Methods', '*');
+            response.setHeader('Access-Control-Allow-Headers', '*');
+            if (request.method === 'OPTIONS') {
+                response.end();
+                return;
+            }
+            this._requests.emit({ request, response });
+        };
+        const subscription = this.requests.subscribe(async ({ request, response }) => {
+            const task = new Task(`Request: ${request.method} ${request.url}`);
+            try {
+                task.log('Routing request');
+                for (const controller of this.controllers) {
+                    for (const handler of controller.handlers) {
+                        if (handler.method === request.method) {
+                            const match = $Router.match(`${controller.route}${handler.route}`, request.url);
+                            if (match) {
+                                const query = $Router.getQueryParameters(request.url);
+                                task.log(`Forwarding request to controller (${controller.route}) handler (${handler.route})`);
+                                for (const guard of controller.guards ?? []) {
+                                    const authorized = await guard({
+                                        injector: this.injector,
+                                        server: this,
+                                        request,
+                                        response
+                                    });
+                                    if (!authorized)
+                                        throw new HttpError(HttpResponseCodes.Unauthorized);
+                                }
+                                task.log(`${request.method} ${request.url}`, {
+                                    attachments: {
+                                        parameters: { type: 'json', value: JSON.stringify(query, null, 4) },
+                                        headers: { type: 'json', value: JSON.stringify(request.headers, null, 4) }
+                                    }
+                                });
+                                for (const parameter of handler.parameters ?? []) {
+                                    if (!parameter.endsWith('?') && $String.isNullOrEmpty(query[parameter]))
+                                        throw new HttpError(HttpResponseCodes.BadRequest, `Missing required query parameter (${parameter})`);
+                                }
+                                const result = await handler.callback({
+                                    injector: this.injector,
+                                    server: this,
+                                    task,
+                                    parameters: {
+                                        route: match,
+                                        query
+                                    },
+                                    request,
+                                    response
+                                });
+                                if (result) {
+                                    if (response.writable) {
+                                        if (result.code)
+                                            response.statusCode = result.code;
+                                        if (result.status)
+                                            response.statusMessage = result.status;
+                                        if (result.headers)
+                                            response.setHeaders(new Map(Object.entries(result.headers)));
+                                        switch (result.type) {
+                                            case 'json':
+                                                response
+                                                    .setHeader('Content-Type', MimeType.json)
+                                                    .write(result.value === undefined ? undefined : JSON.stringify(result.value));
+                                                break;
+                                            case 'file':
+                                                await new Promise((resolve, reject) => {
+                                                    response.setHeader('Content-Type', result.mimeType);
+                                                    response.once('finish', () => resolve());
+                                                    response.once('error', (error) => reject(error));
+                                                    fs.createReadStream(result.file).pipe(response, { end: true });
+                                                });
+                                                break;
+                                            case 'redirect':
+                                                response.statusCode = 302;
+                                                response.setHeader('Location', result.url);
+                                                break;
+                                        }
+                                    }
+                                }
+                                if (!response.writableEnded)
+                                    response.end();
+                                return;
+                            }
+                        }
+                    }
+                }
+                task.fail(`No route matches URL`);
+                if (response.writable) {
+                    response.writeHead(HttpResponseCodes.BadRequest, 'Route Not Found');
+                    response.end();
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.stack : String(error);
+                task.fail(message);
+                if (error instanceof HttpError) {
+                    response.statusCode = error.code;
+                    if (error.message)
+                        response.statusMessage = error.message;
+                    response.end();
+                }
+                else
+                    $HttpResponder.internalServerError(response);
+            }
+            finally {
+                task.complete();
+                this.options.logger?.log(task.toConsoleLog());
+            }
+        });
+        this.httpServer = this.options.certificate ? new NodeHttpsServer({ key: this.options.certificate.key, cert: this.options.certificate.crt, rejectUnauthorized: false }, listener) : new NodeHttpServer(listener);
+        this.httpServer.listen(this.options.port, this.options.hostname);
+        this.options.logger?.log(`HTTP server started listening on ${this.httpServer instanceof NodeHttpServer ? 'http' : 'https'}://${this.options.hostname ?? '0.0.0.0'}:${this.options.port}`);
+        this._disposables.push(() => {
+            subscription.unsubscribe();
+            this.httpServer.close();
+        });
+    }
+    initWebServer() {
+        this.webServer = new WebSocketServer({ server: this.httpServer });
+        this.options.logger?.log(`WS server started listening on ${this.httpServer instanceof NodeHttpServer ? 'ws' : 'wss'}://${this.options.hostname ?? '0.0.0.0'}:${this.options.port}`);
+        this.webServer.on('connection', (ws, request) => {
+            const forwarded = request.headers['x-forwarded-for'];
+            const client = new WebClient(ws, forwarded ? forwarded.split(',')[0] : request.socket.remoteAddress.replace('::ffff:', ''));
+            this._clients.push(client);
+            this._connection.emit({ client, request });
+            ws.on('message', packet => {
+                try {
+                    const json = packet.toString();
+                    packet = JSON.parse(json);
+                    this._packets.emit({ client, packet });
+                }
+                catch (error) { }
+            });
+            ws.on('close', () => {
+                this._clients = $Array.remove(this._clients, client);
+                this._disconnection.emit(client);
+            });
+        });
+        const subscription = this.packets.subscribe(async ({ client, packet }) => {
+            const definition = $Tson.object({
+                properties: {
+                    id: $Tson.string(),
+                    hub: $Tson.string(),
+                    action: $Tson.string(),
+                    data: $Tson.any({ default: null })
+                }
+            });
+            const schema = $Tson.parse(definition);
+            let parsedPacket;
+            try {
+                parsedPacket = schema.parse(packet);
+            }
+            catch (error) {
+                if (error instanceof TsonError) {
+                    client.send({
+                        error: {
+                            message: error.message,
+                            path: error.path,
+                            schema: error.schema
+                        },
+                        schema
+                    });
+                    return;
+                }
+                throw error;
+            }
+            const task = new Task(`[${parsedPacket.id}] Packet`);
+            try {
+                for (const hub of this.hubs) {
+                    if (hub.name === parsedPacket.hub) {
+                        for (const action of hub.actions) {
+                            if (action.name === parsedPacket.action) {
+                                task.log(`Forwarding packet to hub (${hub.name}) with action (${action.name})`, {
+                                    attachments: { packet: { type: 'json', value: JSON.stringify(packet, null, 4) } }
+                                });
+                                let data = parsedPacket.data;
+                                if (action.schema) {
+                                    try {
+                                        data = $Tson.parse(action.schema).parse(parsedPacket.data);
+                                    }
+                                    catch (error) {
+                                        if (error instanceof TsonError) {
+                                            throw new WebError(`Failed to parse packet data for hub (${hub.name}) with action (${action.name})`, {
+                                                message: error.message,
+                                                path: error.path,
+                                                schema: error.schema,
+                                                value: error.value
+                                            });
+                                        }
+                                        else
+                                            throw error;
+                                    }
+                                }
+                                await action.callback({
+                                    injector: this.injector,
+                                    client,
+                                    task,
+                                    packet: {
+                                        id: parsedPacket.id,
+                                        data
+                                    }
+                                });
+                                return;
+                            }
+                        }
+                    }
+                }
+                throw new WebError(`No hub (${parsedPacket.hub}) was found with action (${parsedPacket.action})`);
+            }
+            catch (error) {
+                task.fail(error);
+                if (error instanceof WebError) {
+                    client.send(Api.actionError({
+                        id: parsedPacket.id,
+                        error: {
+                            message: error.message,
+                            data: error.data
+                        }
+                    }));
+                }
+                throw error;
+            }
+            finally {
+                task.complete();
+                this.options.logger?.log(task.toConsoleLog());
+            }
+            ;
+        });
+        this._disposables.push(() => {
+            subscription.unsubscribe();
+            this.webServer.close();
+        });
+    }
+    stop() {
+        for (const dispose of this._disposables) {
+            dispose();
+        }
+        this._disposables = [];
+        this.httpServer = null;
+        this.webServer = null;
+    }
+}