proteum 1.0.0-1

package/server/services/schema/service.json

@@ -0,0 +1,6 @@
+{
+    "id": "Core/Schema",
+    "name": "Schema",
+    "parent": "app",
+    "dependences": []
+}

package/server/services/security/encrypt/aes/index.ts

@@ -0,0 +1,85 @@
+/*----------------------------------
+-  DEPS
+----------------------------------*/
+
+// Nodejs
+import crypto, { Encoding } from 'crypto';
+
+// Core
+import type { Application } from '@server/app';
+import Service from '@server/app/service';
+import { Forbidden } from '@common/errors';
+
+/*----------------------------------
+- SERVICE CONFIG
+----------------------------------*/
+
+export type Config = {
+    debug?: boolean,
+    // Initialisation vector
+    // Generate one here: https://www.allkeysgenerator.com/Random/Security-Encryption-Key-Generator.aspx
+    iv: string,
+    // Define usage-specific keys
+    // You can also generate one via the link upper
+    keys: {[keyName: string]: string}
+}
+
+export type Hooks = {
+
+}
+
+export type Services = {
+    
+}
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+type TEncryptOptions = {
+    encoding: Encoding
+}
+
+type TDecryptOptions = {
+    encoding: Encoding
+}
+
+/*----------------------------------
+- SERVICE
+----------------------------------*/
+export default class AES<TConfig extends Config = Config> extends Service<TConfig, Hooks, Application, Application> {
+
+    public encrypt( keyName: keyof TConfig["keys"], data: any, options: TEncryptOptions = {
+        encoding: 'base64url'
+    }) {
+
+        const encKey = this.config.keys[ keyName as keyof typeof this.config.keys ];
+
+        data = JSON.stringify(data);
+
+        let cipher = crypto.createCipheriv('aes-256-cbc', encKey, this.config.iv);
+        let encrypted = cipher.update(data, 'utf8', options.encoding);
+        encrypted += cipher.final(options.encoding);
+        return encrypted;
+        
+    }
+
+    public decrypt( keyName: keyof TConfig["keys"], data: string, options: TDecryptOptions = {
+        encoding: 'base64url'
+    }) {
+
+        const encKey = this.config.keys[ keyName as keyof typeof this.config.keys ];
+
+        try {
+
+            let decipher = crypto.createDecipheriv('aes-256-cbc', encKey, this.config.iv);
+            let decrypted = decipher.update(data, options.encoding, 'utf8');
+            return JSON.parse(decrypted + decipher.final('utf8'));
+
+        } catch (error) {
+
+            throw new Forbidden("Invalid token.");
+            
+        }
+    }
+}

package/server/services/security/encrypt/aes/service.json

@@ -0,0 +1,6 @@
+{
+    "id": "Core/Encryption/AES",
+    "name": "AES",
+    "parent": "app",
+    "dependences": []
+}

package/server/services/socket/index.ts

@@ -0,0 +1,162 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import { Server as WebSocketServer, ServerOptions } from 'ws';
+import { v4 as uuidv4 } from 'uuid';
+import { IncomingMessage } from 'http';
+import cookie from 'cookie';
+
+// Core
+import type { Application } from '@server/app';
+import Service, { AnyService, TRegisteredService } from '@server/app/service';
+import SocketScope, { WebSocket } from './scope';
+import type Router from '@server/services/router';
+export type { WebSocket, default as SocketScope } from './scope';
+import type UsersManagementService from '../auth';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+
+export type Config<TUser extends {}> = {
+    debug?: boolean,
+    //server: ServerOptions["server"],
+    //users: UsersManagementService<TUser>,
+    port: number,
+
+    users: UsersManagementService<TUser, Application>,
+    router: Router
+}
+
+export type Hooks = {
+
+}
+
+/*----------------------------------
+- MANAGER
+----------------------------------*/
+export default class WebSocketCommander<
+    TUser extends {},
+    TConfig extends Config<TUser>= Config<TUser>
+> extends Service<TConfig, Hooks, Application> {
+
+    // Services
+    public ws!: WebSocketServer;
+    public users!: TConfig["users"];
+    public router!: TConfig["router"];
+
+    // Context
+    public scopes: {[path: string]: SocketScope<TUser>} = {}
+
+    public constructor(
+        parent: AnyService, 
+        config: TConfig,
+        app: TApplication, 
+    ) {
+        super(parent, config, app);
+        
+        this.users = this.config.users;
+        this.router = this.config.router;
+        
+    }
+    
+    /*----------------------------------
+    - LIFECYCLE
+    ----------------------------------*/
+
+    public loading: Promise<void> | undefined = undefined;
+    protected async ready() {
+
+        this.users.on('disconnect', async (userId: string) => {
+            this.disconnect(userId, 'Logout');
+        });
+
+        console.info(`Loading socket commander`);
+        this.ws = new WebSocketServer({ server: this.router.http.http })
+            .on('connection', (socket: WebSocket, req: IncomingMessage) => {
+
+                // Resolve scope
+                const path = req.url;
+                let scope: SocketScope<TUser> | undefined;
+                for (const scopePath in this.scopes)
+                    if (path === scopePath) {
+                        scope = this.scopes[path];
+                        break;
+                    }
+
+                if (scope === undefined) {
+                    console.warn("Unknown scope path:", path);
+                    socket.close();
+                    return;
+                }
+
+                socket.id = uuidv4();
+
+                // req.headers['x-forwarded-for'] = IP réelle du client quand on passe par un porxy apache
+                const ip = req.headers['x-forwarded-for'] || req.socket.remoteAddress;
+                if (typeof ip !== 'string') {
+                    console.warn("Invalid IP address", ip);
+                    socket.close();
+                    return;
+                }
+                socket.ip = ip;
+
+                // Cookies
+                if (req.headers.cookie) {
+                    req.cookies = cookie.parse(req.headers.cookie);
+                }
+
+                scope.newClient(socket, req);
+
+            })
+
+        console.info(`Socket commander bound to http server.`);
+    }
+
+    public async shutdown() {
+        this.closeAll();
+    }
+
+	/*----------------------------------
+    - ACTIONS
+    ----------------------------------*/
+
+    public open(path: string) {
+
+        if (!(path in this.scopes)) {
+
+            console.info("Registering socket scope:", path);
+            this.scopes[path] = new SocketScope(path, this);
+
+        }
+
+        return this.scopes[path];
+
+    }
+
+
+    public send(scopename: string, usernames: string | string[], command: string, data?: any) {
+
+        const scope = this.scopes[scopename];
+        if (scope === undefined)
+            return console.warn("No scope with name", scopename);
+
+        scope.send(usernames, command, data);
+
+    }
+
+    public disconnect( usernames: string | string[], reason: string, data?: any ) {
+        console.log(`Disconnecting ${usernames} from all scopes`);
+        for (const path in this.scopes)
+            this.scopes[path].disconnect( usernames, reason );
+    }
+
+    public closeAll() {
+        console.log("Closing All connections");
+        for (const path in this.scopes)
+            this.scopes[path].close();
+    }
+}

package/server/services/socket/scope.ts

@@ -0,0 +1,226 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import ws from 'ws';
+import type { IncomingMessage } from 'http';
+
+// Core
+import type SocketService from '.';
+import context from '@server/context';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+export type WebSocket = ws & {
+    ip: string,
+    id: string,
+    username: string,
+    activity: number | false,
+    disconnect: (reason: string) => void
+}
+
+type TConnectCallback = (client: WebSocket, req: IncomingMessage) => Promise<void | false>;
+
+type TEventCallback = (data: any, socket: WebSocket) => Promise<void>
+
+type TCommands = { [command: string]: TEventCallback }
+
+const activityDelay = 10 * 1000; // Clearn broken connections veery 10s
+
+/*----------------------------------
+- SCOPE
+----------------------------------*/
+export default class SocketScope<TUser extends {}> {
+
+    private connectEvent?: TConnectCallback;
+    private disconnectEvent?: TConnectCallback;
+    public commands: TCommands = {};
+    public users: { [username: string]: WebSocket[] } = {}
+
+    public constructor(
+        public path: string,
+        private socket: SocketService<TUser>,
+        private app = socket.app
+    ) {
+
+    }
+
+    private cleaner = setInterval(() => {
+        const now = Date.now();
+        for (const username in this.users) {
+            for (const socket of this.users[username]) {
+                
+                // If the client did not sent any rsponse to the ping
+                if (socket.activity === false) {
+                    
+                    // We consider it as a dead connection (discnnected, but no terminate packet was sent. Ex: internet disabled)
+                    console.log(this.path + ':', username, socket.ip, socket.id, "is dead");
+                    socket.terminate();
+
+                // If user has not been active since x seconds
+                } else if (socket.activity < now - activityDelay) {
+
+                    // We consider hil a dead, until he responds to a ping
+                    socket.activity = false;
+                    socket.ping();
+
+                }
+            }
+        }
+    }, activityDelay);
+
+    public newClient(socket: WebSocket, req: IncomingMessage) {
+        context.run({ channelType: 'socket', channelId: this.path }, async () => {
+
+        // Auth
+        const username = await this.socket.config.users.decode(req);
+        if (!username) {
+            console.log(`Rejecting connection on ${this.path} for client ${socket.ip} (${socket.id})}: Not authenticated`);
+            socket.close(4004, "auth");
+            return;
+        }
+
+        socket.username = username;
+        socket.disconnect = (reason: string) => socket.close(4004, reason);
+
+        // On connect event
+        if (this.connectEvent && await this.connectEvent(socket, req) === false) {
+            return;
+        }
+
+        // Indexage
+        if (this.users[username] === undefined) {
+            this.users[username] = [socket];
+        } else {
+            this.users[username].push(socket);
+        }
+
+        console.log(`Client ${socket.username} (${socket.ip}) connected on ${this.path}. Connections number for this user: ` + this.users[username].length);
+        // Indique au cient que sa connexion a bien été acceptée
+        socket.send("ok>ok")
+
+        // Détection déconnexion
+        socket.activity = Date.now();
+        socket.on('pong', () => {
+            socket.activity = Date.now();
+        });
+
+        // Ecoute résolution des challenges
+        socket.on('message', (m: ws.Data) => {
+
+            const response = m.toString();
+            var i = response.indexOf('>');
+            if (i === -1) {
+                return console.warn(`Bad data structure:`, response.substring(0, 100) + '...');
+            }
+
+            const command = response.slice(0, i);
+            const strData = response.slice(i + 1);
+
+            let data;
+            try {
+                data = JSON.parse(strData);
+            } catch (error) {
+                console.warn(`Error decoding data`, error);
+                this.send(socket.username, 'log', `Invalid data format.`);
+                return;
+            }
+
+            const handler = this.commands[command];
+            if (handler === undefined)
+                return console.error('Command « ' + command + ' » does not exists.');
+
+            socket.activity = Date.now();
+
+            handler(data, socket);
+
+
+        });
+
+        socket.on('close', () => {
+
+            if (this.users[username].length > 1)
+                this.users[username] = this.users[username].filter(s => s.id !== socket.id);
+            else
+                this.users[username] = [];
+
+            console.log(`Client ${socket.ip} (${socket.id}) disconnected from ${this.path}. Connections number for this user: ` + this.users[username].length);
+
+            if (this.disconnectEvent !== undefined)
+                this.disconnectEvent(socket, req);
+
+        });
+    });
+    }
+
+    public isConnected(username: string) {
+        return this.users[username] !== undefined && this.users[username].length !== 0;
+    }
+
+    public send(usernames: string | string[], command: string, data: any = true) {
+
+        if (usernames === '*')
+            usernames = Object.keys(this.users);
+        else if (!Array.isArray(usernames))
+            usernames = [usernames];
+
+        for (const username of usernames) {
+
+            const user = this.users[username];
+            if (user === undefined)
+                return console.warn("User", username, "is not connected to", this.path);
+
+            for (const client of user) {
+                client.send(command + '>' + JSON.stringify(data));
+            }
+
+            console.log("Sent event " + command + " to " + username + " on " + this.path)
+
+        }
+    }
+
+    public disconnect(usernames: string | string[], reason: string, data?: any) {
+
+        if (usernames === '*')
+            usernames = Object.keys(this.users);
+        else if (!Array.isArray(usernames))
+            usernames = [usernames];
+
+        for (const username of usernames) {
+
+            const user = this.users[username];
+            if (user === undefined)
+                return console.warn("User", username, "is not connected to", this.path);
+
+            for (const client of user) {
+                client.disconnect(reason);
+            }
+
+            console.log("Disconnected " + username + " from " + this.path + " fo the following reason: " + reason)
+
+        }
+    }
+
+    public onConnect(cb: TConnectCallback) {
+        this.connectEvent = cb;
+        return this;
+    }
+
+    public on(event: string, cb: TEventCallback) {
+        this.commands[event] = cb;
+        return this;
+    }
+
+    public onDisconnect(cb: TConnectCallback) {
+        this.disconnectEvent = cb;
+        return this;
+    }
+
+    public close() {
+        clearInterval(this.cleaner);
+    }
+
+}

package/server/services/socket/service.json

@@ -0,0 +1,6 @@
+{
+    "id": "Core/Socket",
+    "name": "Socket",
+    "parent": "app",
+    "dependences": []
+}

package/server/services_old/SocketClient.ts

@@ -0,0 +1,92 @@
+// Source: https://github.com/binance-exchange/binance-websocket-examples/blob/master/src/lib/socketClient.js
+// Exmeple utilisation: https://github.com/binance-exchange/binance-websocket-examples/blob/master/src/monitor-spot.js
+
+import WebSocket from 'ws';
+
+type THandler = (message: any) => void;
+
+class SocketClient {
+
+    private url: string;
+
+    private ws!: WebSocket;
+    private handlers: THandler[] = [];
+
+    constructor(url: string) {
+        this.url = url;
+    }
+
+    private log = (...args: any[]) => console.log('[socket][client]['+ this.url +']', ...args);
+
+    public connecter(): Promise<this> {
+        return new Promise((resolve, reject) => {
+
+            this.log('Connexion');
+
+            this.ws = new WebSocket(this.url);
+
+            this.ws.onopen = () => {
+                this.log('Connecté.');
+
+                resolve(this);
+            };
+
+            this.ws.onmessage = (msg) => {
+                try {
+                    const message = JSON.parse(msg.data);
+                    for (const handler of this.handlers)
+                        handler(message);
+                } catch (e) {
+                    this.log('Parse message failed', e);
+                }
+            };
+
+            this.ws.onerror = (err) => {
+                this.log('Erreur', err);
+
+                reject(err);
+            };
+
+            this.ws.onclose = (e) => {
+                this.log('Fermé', e.reason);
+            };
+
+            this.ws.on('pong', () => {
+                this.log('Le serveur a envoyé pong');
+            });
+
+            this.ws.on('ping', () => {
+                if (this.ws.readyState === WebSocket.OPEN)
+                    this.ws.pong();
+            });
+
+            //this.heartBeat();
+            
+        })
+    }
+
+    /*public heartBeat() {
+        setInterval(() => {
+            if (this.ws.readyState === WebSocket.OPEN) {
+                this.ws.ping();
+                this.log("Ping serveur");
+            }
+        }, 5000);
+    }*/
+
+    public send(data: object) {
+        this.ws.send( JSON.stringify(data) );
+        return this;
+    }
+
+    public handle(handler: THandler) {
+        this.handlers.push(handler);
+        return this;
+    }
+
+    public close() {
+        this.ws.close();
+    }
+}
+
+export default SocketClient;

package/server/services_old/Token.old.ts

@@ -0,0 +1,97 @@
+
+
+/*
+    NOTE: Replaced by AES
+*/
+
+
+/*----------------------------------
+-  DEPS
+----------------------------------*/
+
+// NPM
+import { v4 as uuid } from 'uuid';
+import hInterval from 'human-interval';
+
+// Core
+import Cron, { CronTask } from '@server/services/cron';
+import { Forbidden } from '@common/errors';
+
+const debug = true;
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+type TokenOptions = {
+    expires?: number, // Timestamp
+    data?: any
+};
+
+/*----------------------------------
+- SERVICE
+----------------------------------*/
+class Tokens {
+
+    private tokens: {[token: string]: TokenOptions} = {};
+
+    public constructor() {
+        Cron.task("tokens.expiration", '*/5 * * * *', async () => {
+            this.cleanExpired()
+        })
+    }
+
+    private cleanExpired() {
+        debug && console.log("Cleaning expired tokens ...");
+        const now = Date.now();
+        for (const token in this.tokens) {
+            const expires = this.tokens[token].expires;
+            if (expires !== undefined && expires < now) {
+                debug && console.log("Expired: " + token);
+                delete this.tokens[token];
+            }
+        }
+    }
+
+    public create( duration?: string, data?: any ) {
+
+        const now = Date.now();
+        const token = uuid();
+        const options: TokenOptions = {
+            data
+        }
+
+        if (duration !== undefined) {
+
+            const interval = hInterval(duration);
+            if (!interval)
+                throw new Error(`Invalid interval expression: ${duration}`);
+
+            options.expires = now + interval;
+        }
+        
+        this.tokens[ token ] = options;
+
+        return token;
+
+    }
+
+    public get<TData extends any>( token: string, critical: boolean = true ): TData | undefined {
+
+        const options = this.tokens[token];
+        debug && console.log("Get token", token, options);
+        if (options === undefined) {
+            if (critical)
+                throw new Forbidden(`Invalid token.`);
+            else
+                return undefined;
+        }
+
+        delete this.tokens[token];
+
+        return options.data;
+    }
+
+}
+
+export default new Tokens;