birdpack 1.0.0

package/lib/server.js

@@ -0,0 +1,426 @@
+const core = require('./core');
+const websocket = require('./websocket');
+const R938_METHOD = ['get','post','put','patch','delete','head','options'];
+
+module.exports = class{
+    mapws = {}
+    maps = {}
+    calls = []
+    constructor(opt){
+        this.opt = opt || {};
+
+        console.log(this.powered());
+
+        this.argv();
+        this.setupMethod();
+        this.setupSSL();
+    }
+    argv(){
+        let cmd = {
+            '-u':'use',
+            '-p':'port',
+        };
+        let data = false;
+        for(let x of process.argv){
+            if(data !== false){
+                this.opt[data] = x;
+                data = false;
+            }else if(cmd[x]){
+                data = cmd[x];
+                this.opt[data] = true;
+            }
+        }
+    }
+    setupMethod(){
+        for(let x of R938_METHOD){
+            this[x] = (url, callback)=>{
+                this.set({
+                    domain:'*',
+                    method:x,
+                    url,
+                    callback:this.setCall(callback)
+                });
+                return this;
+            }
+        }
+    }
+    setupSSL(){
+        const tls = require('tls');
+        const sslSecure = [];
+        const sslDomain = {};
+
+        if(Array.isArray(this.opt.ssl) && this.opt.ssl.length > 0){
+            for(const x of this.opt.ssl){                
+                const typeDomain = typeof x.domain;
+                if(typeDomain == 'string'){
+                    sslDomain[x.domain] = sslSecure.length;
+                }else if(typeDomain == 'object' && Array.isArray(x.domain)){
+                    for(let d of x.domain){
+                        sslDomain[d] = sslSecure.length;
+                    }
+                }
+                sslSecure.push(tls.createSecureContext(x));
+            }
+
+            this.opt.SNICallback = function(servername, callback){
+                let data = this._SNICallback.prototype.data;
+                if(data.domain.hasOwnProperty(servername)){
+                    callback(null, data.secure[data.domain[servername]]);
+                }else{
+                    callback();
+                }
+            };
+            this.opt.SNICallback.prototype.data = {
+                secure:sslSecure,
+                domain:sslDomain
+            };
+        }
+    }
+    create(){
+        let use = '';
+        if(this.opt.use == 'http'){
+            use = 'http';
+        }else if(this.opt.use == 'https'){
+            use = 'https';
+        }else{
+            return false;
+        }
+
+        let options = {};
+
+        for(let x in this.opt){
+            if(['SNICallback','connectionsCheckingInterval','headersTimeout','keepAlive','keepAliveInitialDelay','keepAliveTimeout','maxHeaderSize','noDelay','requestTimeout','requireHostHeader'].includes(x)){
+                options[x] = this.opt[x];
+            }
+        }
+
+        const {createServer} = require(use);
+        this.server = createServer(options, (req, res)=>{
+            let cc = new core({req, res});
+
+            cc.router(()=>{
+                let call = this.maps[cc.host];
+                if(!call && this.maps['*']){
+                    call = this.maps['*']
+                }
+
+                if(call && call[cc.method]){
+                    call = call[cc.method];
+                }
+            
+                if(call){
+                    if(call.fixed && call.fixed.hasOwnProperty(cc.path)){
+                        call = call.fixed[cc.path];
+                    }else if(call.params){
+                        let path = cc.path.split('/').slice(1);
+
+                        let mode = true;
+                        for(const modes of call.params){
+                            let status = false;
+                            for(const route of modes){
+                                if(!route.url || (mode && route.url.length !== path.length)) continue;
+
+                                let matched = true;
+
+                                for(let i = 0; i < path.length; i++){
+                                    const routeSegment = route.url[i];
+                                    const pathSegment = path[i];
+
+                                    if(routeSegment == undefined){
+                                        matched = false;
+                                        break;
+                                    }
+
+                                    if(routeSegment === pathSegment){
+                                        continue;
+                                    }else if (routeSegment[0] === ':'){
+                                        cc.param(routeSegment.slice(1), pathSegment);
+                                    }else if(routeSegment === '*'){
+                                        cc.param('*', path.slice(i).join('/'));
+                                        break;
+                                    }else{
+                                        matched = false;
+                                        break;
+                                    }
+                                }
+
+                                if(matched){
+                                    status = true;
+                                    call = route;
+                                    break;
+                                }
+                            }
+
+                            if(status){
+                                break;
+                            }
+                            mode = false;
+                        }
+                    }
+
+                    if(call){
+                        if(call.next !== false){
+                            return this.getCall(call.next)(cc, (data)=>{
+                                this.getCall(call.callback)(cc, data);
+                            });
+                        }else{
+                            return this.getCall(call.callback)(cc);
+                        }
+                    }
+                }
+
+                cc.error(404, 'This page isn\'t working');
+            });
+        });
+        this.server.on('upgrade', (req, socket, head) => {
+            const ws = new websocket({req, socket, head});
+            let call = this.mapws[ws.host];
+            if(!call && this.mapws['*']){
+                call = this.mapws['*']
+            }
+
+            if(call && call.hasOwnProperty(ws.path)){
+                call = call[ws.path].callback;
+                
+                const run = this.getCall(call);
+
+                ws.update(run);
+                run(ws, 'start');
+            }else{
+                ws.error(404);
+            }
+        });
+        return true;
+    }
+    listen(port, host){
+        if(this.create()){
+            let domain = {};
+            for(let x in this.maps){
+                domain[x] = 1;
+            }
+            for(let x in this.mapws){
+                domain[x] = 1;
+            }
+            for(let x in domain){
+                this.log('domain', `${x}`);
+            }
+
+            this.server.listen(port || this.opt.port || process.env.PORT || 3000, host, ()=>{
+                this.log('server', `Started on server(${this.opt.use}) port(${this.server._connectionKey.split(':').pop()})`);
+            });
+        }
+    }
+
+    log(status, text){
+        let out = `[${status}] - ${text}`;
+        console.log(out);
+    }
+    powered(){
+        return [
+            `\x1b[32m`,
+            `   __   _________`,
+            `  |__| |_______  \\`,
+            `   __          \\  \\`,
+            `  |  |          \\  \\`,
+            `  |  |__________/  /`,
+            `  |   ______    __/`,
+            `  |  |      |  |     \x1b[33m | \x1b[36mBirdPack Framework\x1b[33m | \x1b[32m`,
+            `  |  |      |  |     \x1b[33m | \x1b[0mR938 Service\x1b[33m       | \x1b[32m`,
+            `  |__|      |__|     \x1b[33m | \x1b[0mVersion: 1.0.0\x1b[33m     | \x1b[0m`,
+            `____________________________________________`,
+            '',
+        ].join('\n');
+    }
+
+    domain(domain){
+        if(domain == undefined){
+            domain = '*';
+        }
+
+        let config = {
+            websocket:(url, a, b, c)=>{
+                let typeA = typeof a == 'function';
+                let typeB = typeof b == 'function';
+                let typeC = typeof c == 'function';
+                let callback;
+
+                if(typeA && typeB && typeC){
+                    callback = async(core, code) => {
+                        if(code == 'start'){
+                            let check = await a(core, core.body);
+                            
+                            if(check !== true){
+                                core.stop();
+                            }
+                        }else if(code == 'data'){
+                            await b(core, core.body);
+                        }else if(code == 'close'){
+                            await c(core, core.body);
+                        }
+                    };
+                }else if(typeA){
+                    callback = a;
+                }
+
+                callback.users = {
+                    member:{},
+                    length:0,
+                };
+
+                this.setUpgrade({
+                    domain, 
+                    url, 
+                    callback: this.setCall(callback)
+                });
+                return config;
+            },
+            next:(n)=>{
+               let next = {}; 
+                for(let x of R938_METHOD){
+                    next[x] = (url, callback)=>{
+                        this.set({
+                            domain,
+                            method:x,
+                            url,
+                            next:this.setCall(n),
+                            callback:this.setCall(callback)
+                        });
+                        return next;
+                    }
+                }
+
+                return next;
+            }
+        }
+
+        for(let x of R938_METHOD){
+            config[x] = (url, callback)=>{
+                this.set({
+                    domain,
+                    method:x,
+                    url,
+                    callback:this.setCall(callback)
+                });
+                return config;
+            }
+        }
+        
+        return config;
+    }
+    set({domain, method, url, next, callback}){
+        if(typeof domain != 'string'){
+            domain = '*';
+        }
+
+        if(typeof method != 'string' || !R938_METHOD.includes(method)){
+            method = 'get';
+        }
+        method = method.toLowerCase();
+
+        if(typeof url != 'string' && !Array.isArray(url)){
+            return false;
+        }
+
+        if(typeof next != 'number'){
+            next = false;
+        }
+
+        if(typeof callback != 'number'){
+            return false;
+        }
+
+        if(!this.maps.hasOwnProperty(domain)){
+            this.maps[domain] = {};
+        }
+
+        if(!this.maps[domain].hasOwnProperty(method)){
+            this.maps[domain][method] = {
+                fixed:{},
+                params:[[], []]
+            };
+        }
+
+        const urlCache = url.split('/').slice(1);
+        const mode = url.includes('*') ? 'flexible' : (url.includes(':') ? 'params' : 'fixed');
+
+        
+        let route = {
+            url:urlCache,
+            next: next,
+            callback: callback,
+        };
+
+        if(mode == 'fixed'){
+            this.maps[domain][method].fixed[url] = route;
+        }else{
+            this.maps[domain][method].params[mode == 'params' ? 0 : 1].push(route);
+        }
+    }
+    setUpgrade({domain, url, callback}){
+        if(typeof domain != 'string'){
+            domain = '*';
+        }
+
+        if(typeof url != 'string' && !Array.isArray(url)){
+            return false;
+        }
+
+        if(typeof callback != 'number'){
+            return false;
+        }
+
+        if(!this.mapws.hasOwnProperty(domain)){
+            this.mapws[domain] = {};
+        }
+
+        this.mapws[domain][url] = {
+            callback:callback
+        };
+    }
+    setCall(callback){
+        this.calls.push(callback);
+        return this.calls.length - 1;
+    }
+    getCall(id){
+        if(this.calls[id]){
+            return this.calls[id];
+        }
+        return ()=>{};
+    }    
+    websocket(url, a, b, c){
+        let typeA = typeof a == 'function';
+        let typeB = typeof b == 'function';
+        let typeC = typeof c == 'function';
+        let callback;
+
+        if(typeA && typeB && typeC){
+            callback = async(core, code) => {
+                if(code == 'start'){
+                    let check = await a(core, core.body);
+                    
+                    if(check !== true){
+                        core.stop();
+                    }
+                }else if(code == 'data'){
+                    await b(core, core.body);
+                }else if(code == 'close'){
+                    await c(core, core.body);
+                }
+            };
+        }else if(typeA){
+            callback = a;
+        }
+
+        callback.users = {
+            member:{},
+            length:0,
+        };
+
+        this.setUpgrade({
+            domain: '*', 
+            url, 
+            callback: this.setCall(callback)
+        });
+        return this;
+    }
+}