upcore-tcp 0.0.1

package/lib/server.js

@@ -0,0 +1,712 @@
+const crypto = require('crypto');
+const net = require('net');
+const tls = require('tls');
+
+const package = require('../package.json');
+const version = package.version;
+
+const routeContext = require('./routeContext');
+
+const checkHeader = require('./checkHeader');
+
+const headerDecode = require('./headerDecode');
+const cookieDecode = require('./cookieDecode');
+const queryDecode = require('./queryDecode');
+const decodeFrame = require('./decodeFrame');
+const encodeFrame = require('./encodeFrame');
+const checkType = require('./checkType');
+const parameterFile = require('./parameterFile');
+const streamFile = require('./streamFile');
+const payloadDecode = require('./payloadDecode');
+const payloadType = require('./payloadType');
+
+const httpHeader = require('./httpHeader');
+
+const checkPath = require('./checkPath');
+
+const parsePath = require('./parsePath');
+
+module.exports = class{
+    CALLBACK_ID = 0
+    CALLBACK_TREE = {}
+    ROUTE_TREE = {}
+    TYPE_TREE = {}
+
+    constructor(options){
+        this.config = {
+            hostname:'0.0.0.0',
+            port:3000,
+            keepAlive:true,
+            keepAliveInitialDelay:5000,
+            noDelay:true,
+            timeout:30000,
+            dev:false,
+            traffic:()=>{},
+        };
+
+        // ==== Options Config ====
+        // allowHalfOpen
+        // highWaterMark
+        // keepAlive
+        // keepAliveInitialDelay
+        // noDelay
+        // pauseOnConnect
+        // blockList
+        // SNICallback
+
+        if(typeof options == 'object'){
+            for(let x in options){
+                if(options[x] !== undefined){
+                    this.config[x] = options[x];
+                }
+            }
+        }
+
+        if(options.logger){
+            this.config.traffic = ({connection, method, host, search, pathname}) => {
+                const d = new Date()
+                const pad = n => String(n).padStart(2, '0')
+
+                const time =
+                    `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ` +
+                    `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`
+
+                const C = {
+                    reset:      '\x1b[0m',
+                    gray:       '\x1b[90m',
+                    green:      '\x1b[32m',
+                    cyan:       '\x1b[36m',
+                    yellow:     '\x1b[33m',
+                    red:        '\x1b[31m',
+                    magenta:    '\x1b[35m',
+                }
+
+                const methodColor = (
+                    method === 'get'    ?   C.green     :
+                    method === 'post'   ?   C.cyan      :
+                    method === 'put'    ?   C.yellow    :
+                    method === 'delete' ?   C.red       :
+                                            C.magenta
+                )
+
+                console.log(
+                    `${C.gray}${time}${C.reset} ` +
+                    `[${methodColor}${connection === 2 ? 'websocket' : method}${C.reset}] ` +
+                    `${host}${C.reset} ` +
+                    `${C.green}${pathname}${C.reset}` +
+                    (search ? `${C.yellow}?${search}${C.reset}` : '')
+                )
+             }
+        }
+
+        let root = new routeContext(this, '*');
+        for(let x of root.setup){
+            this[x] = (...arr)=>{
+                return root[x](...arr);
+            }
+        }
+
+        this._core = this.config.use === 'https' ? tls : net;
+    }
+    listen(callback){
+        (this.server = this._core.createServer(this.config))
+        .on('connection', (socket)=>{
+            let focus = 1;
+            let payloadLength = 0;
+            let req;
+        
+            try{
+                socket
+                .setTimeout(this.config.timeout)
+                .on('data', (chunk)=>{
+                    if(focus == 1){
+                        req = checkHeader(chunk);
+                        if(req === false){
+                            socket.destroy();
+                            return false;
+                        }
+        
+                        switch(req.connection){
+                            case 2:{
+                                socket.setTimeout(0);
+                                focus = 3;
+                                break;
+                            }
+                            default:{
+                                socket.setKeepAlive(this.config.keepAlive, this.config.keepAliveInitialDelay);
+                            }
+                        }
+        
+                        if(req.success){
+                            payloadLength = 0;
+        
+                            this.handle(req, socket);
+                        }else{
+                            payloadLength = req.payload[0]?.length || 0;
+                            focus = 2;
+                        }
+                    }else if(focus == 2){
+                        payloadLength += chunk.length;
+                        req.payload.push(chunk);
+        
+                        if(req.length == payloadLength){
+                            payloadLength = 0;
+                            focus = 1;
+                            req.success = true;
+        
+                            this.handle(req, socket);
+                        }else if(req.length < payloadLength){
+                            socket.destroy();
+                            return false;
+                        }
+                    }else if(focus == 3){
+                        if(req.frame){
+                            req.frame.decode(chunk);
+                        }
+                    }
+                })
+                .on('close', ()=>{
+                    if(req?.userOut) req.userOut();
+                })
+                .on('error', (err)=>{
+                    if(!socket.destroyed){
+                        socket.destroy();
+                    }
+                })
+                .on('timeout', ()=>{
+                    if(!socket.destroyed){
+                        socket.destroy();
+                    }
+                });
+            }catch(e){
+                console.log(e);
+                socket.destroy();
+            }
+        })
+        .on('error', (e)=>{
+            console.log(e);
+        });
+
+        const cb = typeof callback === 'function' ? () => callback(this.server.address()) : this.config.dev ? ()=>{
+            let {address, port} = this.server.address();
+            console.log(`HTTP/1.1 server(\x1b[32mr938-upcore\x1b[0m/${version}) listening on ${address}:\x1b[36m${port}\x1b[0m`);
+        } : null;
+
+        if(this.config.hostname !== undefined){
+            this.server.listen(this.config.port, this.config.hostname, cb);
+        }else{
+            this.server.listen(this.config.port, cb);
+        }
+    }
+    createTool(req, socket){
+        req.response = {
+            status:200,
+            header:[],
+        };
+        
+        req.get = (key)=>{
+            headerDecode(req);
+    
+            return req.header[key] ? req.header[key][req.header[key].length - 1] : undefined;
+        }
+        req.set = (key, value)=>{
+            req.response.header.push(`${key}: ${value}\r\n`);
+
+            return req;
+        };
+        req.code = (status)=>{
+            req.response.status = status;
+    
+            return req;
+        }
+        req.http = (data)=>{
+            if(data !== undefined){
+                socket.write(httpHeader(req.response.status) + req.response.header.join('') + httpHeader.CONTENT_LENGTH + Buffer.byteLength(data) + httpHeader.CRLF2 + data);
+            }else if(req.connection === 2){
+                socket.write(httpHeader(req.response.status) + req.response.header.join('') + httpHeader.CONNECTION_UPGRADE + httpHeader.CRLF);
+            }else{
+                socket.write(httpHeader(req.response.status) + req.response.header.join('') + httpHeader.CRLF); 
+            }
+        }
+        req.socket = (call)=>{
+            call(socket);
+        }
+        req.write = (data)=>{
+            socket.write(data);
+        }
+        req.error = (status)=>{
+            req.code(status);
+            req.http();
+            socket.destroy();
+        }
+        req.gcookie = (name) => {
+            if(!req.cookie){
+                let cookie = req.get('cookie');
+                req.cookie = cookieDecode(cookie);
+            }
+            
+            return req.cookie[name];
+        }
+        req.scookie = (name, value, option) => {
+            let text = [name + '=' + encodeURI((value || '').toString())];
+            for(let x in option){
+                if(['domain', 'expires', 'httponly', 'max-age', 'partitioned', 'path', 'secure', 'sameSite'].includes(x)){
+                    if(['string','number'].includes(typeof option[x])){
+                        text.push(x + '=' + encodeURI(option[x].toString()));
+                    }else{
+                        text.push(x);
+                    }
+                }
+            }
+            req.set('Set-Cookie', text.join('; '));
+    
+            return req;
+        }
+        req.rcookie = (name, option)=>{
+            if(typeof option != 'object'){
+                option = {};
+            }
+            option['max-age'] = '-1';
+    
+            req.scookie(name, '', option);
+    
+            return req;
+        }
+        req.look = (keys)=>{
+            queryDecode(req);
+
+            for(let x of keys.split(/[\s]*,[\s]*/)){
+                if(req.query[x] === undefined){
+                    return false;
+                }
+            }
+            return true;
+        }
+        req.u = (key)=>{
+            queryDecode(req);
+
+            if(req.query[key] !== undefined){
+                if(Array.isArray(req.query[key])){
+                    return req.query[key][req.query[key].length - 1];
+                }else{
+                    return req.query[key];
+                }
+            }
+            return false;
+        }
+    
+        if(req.connection === 2){
+            req.frame = new decodeFrame((data)=>{
+                req.body = data;
+    
+                if(data.type == 'utf8'){
+                    if((data.payload[0] == '{' && data.payload[data.payload.length - 1] == '}') || (data.payload[0] == '[' && data.payload[data.payload.length - 1] == ']')){
+                        try{
+                            data.json = JSON.parse(data.payload);
+                        }catch(e){
+                            data.json = {};
+                        }
+                    }
+                    req.upgrade('data');
+                }else if(data.type == 'binary'){
+                    req.upgrade('data');
+                }else if(data.type == 'close'){
+                    socket.destroy();
+                }else if(data.type == 'ping'){
+                    req.upgrade('ping');
+                }else if(data.type == 'pong'){
+                    req.upgrade('pong');
+                }else{
+                    req.upgrade('error');
+                }
+            });
+    
+            req.start = async(uid)=>{
+                let seckey = req.get('Sec-WebSocket-Key');
+                let protocol = req.get('Sec-WebSocket-Protocol');
+                let version = parseInt(req.get('Sec-WebSocket-Version'));
+    
+                if(version !== 13){
+                    req.error(400);
+                    return false;
+                }
+    
+                let checkUser = req.userHas(uid);
+                if(checkUser !== false){
+                    checkUser.stop();
+                    await checkUser.userOut();
+                }
+    
+                let acceptKey = crypto.createHash('sha1')
+                .update(seckey + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
+                .digest('base64');
+    
+                req.uid = uid;
+                req.userIn();
+    
+                req.code(101)
+                .set('Sec-WebSocket-Accept', acceptKey);
+    
+                if(protocol){
+                    req.set('Sec-WebSocket-Protocol', protocol);
+                }
+    
+                req.http();
+                return true;
+            }
+            req.userEach = (callback)=>{
+                if(req._client?.users){
+                    for(let x in req._client.users){
+                        callback(req._client.users[x]);
+                    }
+                }
+            };
+            req.userHas = (uid)=>{
+                return req._client?.users && req._client.users[uid] ? req._client.users[uid] : false;
+            };
+            req.userLength = ()=>{
+                return req._client.length;
+            };
+            req.userIn = ()=>{
+                req._client.users[req.uid] = req;
+                req._client.length++;
+                req.userIn = ()=>{};
+            };
+            req.userOut = async()=>{
+                if(req._client?.users && req._client.users[req.uid]){
+                    delete req._client.users[req.uid];
+                    req._client.length--;
+                    await req.upgrade('close');
+                }
+                req.userOut = ()=>{};
+            };
+    
+            req.stop = ()=>{
+                socket.destroy();
+            }
+            req.encode = (text, opcode)=>{
+                return encodeFrame(text, opcode);
+            }
+            req.pong = ()=>{
+                let encode = req.encode('pong', 10);
+                req.write(encode);
+            }
+            req.ping = ()=>{
+                let encode = req.encode('ping', 9);
+                req.write(encode);
+            }
+            req.send = (text, opcode = 1)=>{
+                let encode = req.encode(text, opcode); 
+                req.write(encode);
+            }
+            req.sends = (text, opcode = 1)=>{
+                let encode = req.encode(text, opcode); 
+                req.userEach((user)=>{
+                    user.write(encode);
+                });
+            }
+            req.sendto = (uid, text, opcode = 1)=>{
+                let user = req.userHas(uid);
+                if(user !== false){
+                    user.send(text, opcode);
+                    return true;
+                }
+                return false;
+            }
+            req.sendc = (text, opcode = 1, call)=>{
+                let encode = req.encode(text, opcode); 
+                req.userEach((user)=>{
+                    if(call(user)){
+                        user.write(encode);
+                    }
+                });
+            }
+    
+            req.json = (json)=>{
+                req.send(JSON.stringify(json), 1);
+            }
+            req.jsons = (json)=>{
+                req.sends(JSON.stringify(json), 1);
+            }
+            req.jsonto = (uid, json)=>{
+                let user = req.userHas(uid);
+                if(user !== false){
+                    user.json(json);
+                    return true;
+                }
+                return false;
+            }
+            req.jsonc = (json, call)=>{
+                req.sendc(JSON.stringify(json), 1, call);
+            }
+        }else{
+            const TYPE_TEST = req.type.toString();
+            
+            req.test = ({type, data, core})=>{
+                let parameter = {};
+                if(
+                    (type == 'json' && !TYPE_TEST.startsWith('application/json')) ||
+                    (type == 'formdata' && !TYPE_TEST.startsWith('multipart/form-data')) ||
+                    (type == 'wwwform' && !TYPE_TEST.startsWith('application/x-www-form-urlencoded'))
+                ){
+                    req.code(415).set('Content-Length', 79).set('Content-Type', 'application/json').http('{"status":false,"err":"Request Content-Type does not match the expected type."}');
+                    return false;
+                }
+    
+                if(typeof core == 'object'){
+                    for(let id in core){
+                        if(req[id] !== core[id]){
+                            req.code(400).set('Content-Length', 78).set('Content-Type', 'application/json').http('{"status":false,"err":"The request does not satisfy the required conditions."}');
+                            return false;
+                        }
+                    }
+                }
+    
+                if(typeof data == 'object'){
+                    if(typeof req.body != 'object'){
+                        req.code(415).set('Content-Length', 61).set('Content-Type', 'application/json').http('{"status":false,"err":"Request body must be a valid object."}');
+                        return false;
+                    }
+    
+                    for(let id in data){
+                        let {t, r} = data[id];
+                        if(req.body[id] !== undefined){
+                            let value = type == 'json' ? req.body[id] : req.q(id);
+                            let test = checkType(this.TYPE_TREE[t] || {}, value);
+                            if(!test){
+                                req.code(400).set('Content-Length', 54).set('Content-Type', 'application/json').http('{"status":false,"err":"Invalid format for parameter."}');
+                                return false;
+                            }
+
+                            parameter[id] = value;
+                        }else if(r === true){
+                            req.code(400).set('Content-Length', 54).set('Content-Type', 'application/json').http('{"status":false,"err":"Missing or invalid parameter."}');
+                            return false;
+                        }
+                    }
+                }
+    
+                return parameter;
+            }
+            req.check = (keys)=>{
+                for(let x of keys.split(/[\s]*,[\s]*/)){
+                    if(req.body[x] === undefined){
+                        return false;
+                    }
+                }
+                return true;
+            }
+            req.q = (key)=>{
+                if(req.body && req.body[key] !== undefined){
+                    if(Array.isArray(req.body[key])){
+                        return req.body[key][req.body[key].length - 1];
+                    }else{
+                        return req.body[key];
+                    }
+                }
+    
+                return false;
+            }
+            req.send = (text)=>{
+                req.response.header.push(httpHeader.CONTENT_TYPE_PLAIN);
+                req.http(text);
+            }
+            req.html = (text)=>{
+                req.response.header.push(httpHeader.CONTENT_TYPE_HTML);
+    
+                req.http(text);
+            }
+            req.json = (data)=>{
+                try{
+                    let text = JSON.stringify(data);
+
+                    req.response.header.push(httpHeader.CONTENT_TYPE_JSON);
+    
+                    req.http(text);
+                }catch(e){
+                    req.error(500);
+                }
+            }
+            req.redirect = (a, b)=>{
+                const typeA = typeof a;
+                const typeB = typeof b;
+                let status = false;
+                let location = false;
+    
+                if(typeA == 'number' && typeB == 'string'){
+                    status = a;
+                    location = b;
+                }else if(typeA == 'string'){
+                    status = 301;
+                    location = a;
+                }
+    
+                if(status === false){
+                    req.error(500);
+                    return false;
+                }
+    
+                req.code(status)
+                req.set('Location', location)
+                req.http();
+                socket.destroy();
+            }
+            req.file = (op)=>{
+                if(typeof op == 'string'){
+                    op = {file: op};
+                }
+    
+                if(typeof op.error !== 'function'){
+                    op.error = (code)=>{
+                        req.error(code)
+                    }
+                }
+                if(op.download){
+                    req.set('Content-Disposition', `attachment; filename="${op.download || path.basename(op.file)}"`);
+                }
+    
+                if(op.parameter){
+                    parameterFile(req, op.file, op.parameter, op.error);
+                }else{
+                    streamFile(req, op.file, op.error);
+                }
+            }
+            req.load = (a, b)=>{
+                let callback = ()=>{};
+                let type = payloadType(req);
+
+                if(typeof a == 'string' && typeof b == 'function'){
+                    if(a !== type){
+                        req.error(400);
+                        return false;
+                    }
+                    callback = b;
+                }else if(Array.isArray(a) && typeof b == 'function'){
+                    if(!a.includes(type)){
+                        req.error(400);
+                        return false;
+                    }
+                    callback = b;
+                }else if(typeof a == 'function'){
+                    callback = a;
+                }else{
+                    req.error(400);
+                    return false;
+                }
+
+                let load = payloadDecode(req, type);
+    
+                if(load !== false){
+                    req.body = load;
+                    callback();
+                }else{
+                    req.error(400);
+                }
+            }
+        }
+    }
+    handle(req, socket){
+        const client = checkPath(this.ROUTE_TREE, req, socket);
+
+        if(client !== false){
+
+            this.createTool(req, socket);
+            let i = 0;
+            req._client = client;
+            req.next = async()=>{
+                await this.CALLBACK_TREE[client.core[i++]](req, client.core.length == i ? 'start' : 'next');
+            };
+
+            if(req.connection === 2){
+                let endCore = this.CALLBACK_TREE[client.core[client.core.length - 1]] || (()=>{});
+                req.upgrade = async(a)=>{
+                    await endCore(req, a);
+                };
+            }
+
+            this.config.traffic(req);
+
+            req.next();
+        }else{
+            socket.destroy();
+        }
+    }
+
+    type(id, {type, length, format, list, mime}){
+        this.TYPE_TREE[id] = {type, length, format, list, mime};
+        return this;
+    }
+    types(obj){
+        for(let x in obj){
+            let {type, length, format, list, mime} = obj[x];
+
+            this.TYPE_TREE[x] = {type, length, format, list, mime};
+        }
+        return this;
+    }
+    set(domains, methods, paths, ...cb){
+        domains = Array.isArray(domains) ? domains : [domains];
+        methods = Array.isArray(methods) ? methods : [methods];
+        paths = Array.isArray(paths) ? paths : [paths];
+
+        let handler = {core:[]};
+
+        for(let x of cb){
+            if(typeof x === 'function'){
+                let id = `__cb_${++this.CALLBACK_ID}`;
+
+                this.CALLBACK_TREE[id] = x;
+                handler.core.push(id);
+                
+            }else if(typeof x === 'string'){
+                handler.core.push(x);
+            }
+        }
+
+        for(const domain of domains){
+            this.ROUTE_TREE[domain] ??= {};
+
+            for(const method of methods){
+                this.ROUTE_TREE[domain][method] ??= {};
+
+                if(method == 'websocket'){
+                    handler.users = {};
+                    handler.length = 0;
+                }
+                
+                for(const pathname of paths){
+                    let node = this.ROUTE_TREE[domain][method];
+                    const parts = parsePath(pathname);
+
+                    for(const p of parts){
+                        if(p.type === 'static'){
+                            node.static ??= {};
+                            node.static[p.value] ??= {};
+                            node = node.static[p.value];
+                        }else if(p.type === 'param'){
+                            node.param ??= { id: p.name };
+                            node = node.param;
+                        }else if(p.type === 'wildcard'){
+                            node.wildcard ??= { wildcard: true };
+                            node = node.wildcard;
+                            break;
+                        }
+                    }
+
+                    node.handler = handler;
+                }
+            }
+        }
+
+        return this;
+    }
+    domain(domain){
+        return new routeContext(this, domain);
+    }
+    add(id, cb){
+        if(!this.CALLBACK_TREE[id]){
+            this.CALLBACK_TREE[id] = cb;
+        }
+        return this;
+    }
+}