birdpack 1.0.10 → 1.0.12

package/lib/method.js

@@ -1,19 +1,28 @@
+const { errorMonitor } = require('events');
 const tools = require('./tools');
-const METHOD = ['get','post','put','patch','delete','head','options'];
+const METHOD = ['get','post','put','patch','delete','options'];
 const fs = require('fs');
+let crypto = require('crypto');
 
-module.exports = {
+const serviceMethod = {
     METHOD,
     basic:(app, use, {domain, next})=>{
         for(let x of METHOD){
             use[x] = (url, callback)=>{
-                app.set({
-                    domain,
-                    method:x,
-                    url,
-                    next,
-                    callback:app.setCall(callback)
-                });
+                let idCallback = app.setCall(callback);
+                if(!Array.isArray(url)){
+                    url = [url];
+                }
+
+                for(let y of url){
+                    app.set({
+                        domain,
+                        method:x,
+                        url:y,
+                        next,
+                        callback:idCallback
+                    });
+                }
                 return use;
             }
         }
@@ -64,7 +73,7 @@ module.exports = {
             return this;
         }
     },
-    websocket:(app, use, domain)=>{
+    websocket:(app, use, {domain, next})=>{
         return (url, a, b, c)=>{
             let typeA = typeof a == 'function';
             let typeB = typeof b == 'function';
@@ -95,7 +104,8 @@ module.exports = {
             };
 
             app.setUpgrade({
-                domain, 
+                domain,
+                next,
                 url, 
                 callback: app.setCall(callback)
             });
@@ -151,4 +161,97 @@ module.exports = {
             return use;
         };
     },
-};
+
+    apply:(app, use, {domain, next})=>{
+        use.apply = (pack)=>{
+            if(pack.name == 'R938_PACK' && pack.data && Array.isArray(pack.data.upgrade) && Array.isArray(pack.data.method) && Array.isArray(pack.data.callback)){
+                for(let x of pack.data.callback){
+                    app.setCall(x);
+                }
+
+                for(let x of pack.data.upgrade){
+                    app.setUpgrade({
+                        domain,
+                        next,
+                        url:x.url,
+                        callback:x.callback
+                    });
+                }
+                for(let x of pack.data.method){
+                    app.set({
+                        domain,
+                        next,
+                        method:x.method,
+                        url:x.url,
+                        callback:x.callback
+                    });
+                }
+                return use;
+            }
+            return false;
+        };
+    },
+    pack:()=>{
+        let idcal = 0;
+        let pack = {
+            id:crypto.randomBytes(16).toString('hex'),
+            name:'R938_PACK',
+            data:{
+                upgrade:[],
+                method:[],
+                callback:[],
+            }
+        };
+
+        let vmApp = {
+            setCall:(call)=>{
+                let id = `r938_${pack.id}_${idcal}`;
+                pack.data.callback.push({
+                    id, 
+                    callback:call
+                });
+                idcal++;
+                return id;
+            },
+            setUpgrade:({url, callback})=>{
+                pack.data.upgrade.push({url, callback});
+            },
+            set:({method, url, callback})=>{
+                pack.data.method.push({method, url, callback});
+            },
+        };
+
+        serviceMethod.maps(vmApp, pack);
+
+        return pack;
+    },
+    maps:(app, use, domain)=>{
+        serviceMethod.basic(app, use, {domain});
+        use.routes = serviceMethod.routes(use);
+        use.directory = serviceMethod.directory(use);
+        use.websocket = serviceMethod.websocket(app, use, {domain});
+
+        if(use.name !== 'R938_PACK'){
+            use.next = (n)=>{
+                if(typeof n !== 'function'){
+                    return false;
+                }
+
+                let next = {
+                    id:app.setCall(n)
+                };
+
+                serviceMethod.basic(app, next, {domain, next:next.id});
+                next.routes = serviceMethod.routes(next);
+                next.directory = serviceMethod.directory(next);
+                next.websocket = serviceMethod.websocket(app, next, {domain, next:next.id});
+                serviceMethod.apply(app, next, {domain, next:next.id});
+
+                return next;
+            }
+            serviceMethod.apply(app, use, {domain});
+        }
+    }
+};
+
+module.exports = serviceMethod;

package/lib/pack.js

@@ -0,0 +1,4 @@
+const methodPlugin = require('./method');
+module.exports = ()=>{
+    return methodPlugin.pack();
+}

package/lib/server.js

@@ -3,13 +3,16 @@ const core = require('./core');
 const websocket = require('./websocket');
 const powered = require('./powered');
 const methodPlugin = require('./method');
+const packPlugin = require('./pack');
 
 module.exports = class{
     mapws = {}
     maps = {}
-    calls = []
+    calls = {}
+    idcalls = 0;
     constructor(opt){
         this.opt = opt || {};
+        this.params = {};
 
         this.powered();
         this.dev();
@@ -19,10 +22,6 @@ module.exports = class{
         this.setupSSL();
     }
     dev(){
-        if(typeof this.opt.log !== 'string'){
-            this.opt.log = 'console';
-        }
-
         if(this.opt.log == 'console'){
             this.log = (status, text)=>{
                 let out = `[${status}] - ${text}`;
@@ -35,12 +34,13 @@ module.exports = class{
                 file.write(`${out}\n`);
             }
         }else{
+            this.opt.log = 'false';
             this.log = ()=>{};
         }
 
         let traffic = this.opt.traffic;
         if(typeof traffic !== 'string'){
-            traffic = '$time $status $method $path $ip $head(user-agent)';
+            traffic = '$time $status $host $method $path $ip';
         }
 
         let useTraffic = traffic.replace(/\$[a-zA-Z0-9\(\)\-]*/g, (a)=>{
@@ -48,6 +48,8 @@ module.exports = class{
                 return '${time}';
             }else if(a == '$status'){
                 return '${c.status}';
+            }else if(a == '$host'){
+                return '${c.host}';
             }else if(a == '$method'){
                 return '${c.method}';
             }else if(a == '$path'){
@@ -73,21 +75,31 @@ module.exports = class{
             '-p':'port',
         };
         let data = false;
+        let id = false;
         for(let x of process.argv){
-            if(data !== false){
-                this.opt[data] = x;
+            if(data !== false && id !== false){
+                if(data === 'parameter'){
+                    this.params[id] = x;
+                }else if(data === 'server'){
+                    if(id == 'port'){
+                        x = parseInt(x);
+                    }
+                    this.opt[id] = x;
+                }
+
+                id = false;
                 data = false;
             }else if(cmd[x]){
-                data = cmd[x];
-                this.opt[data] = true;
+                id = cmd[x];
+                data = 'server';
+            }else if(x[0] === '-' && x[1] === '-'){
+                id = x.slice(2);
+                data = 'parameter';
             }
         }
     }
     setupMethod(){
-        methodPlugin.basic(this, this, {domain:'*'});
-        this.routes = methodPlugin.routes(this);
-        this.directory = methodPlugin.directory(this);
-        this.websocket = methodPlugin.websocket(this, this, '*');
+        methodPlugin.maps(this, this);
     }
     setupSSL(){
         if(this.opt.use !== 'https'){
@@ -126,15 +138,15 @@ module.exports = class{
         }
     }
     create(){
-        let use = '';
+        let use = 'http';
         if(this.opt.use == 'http'){
             use = 'http';
         }else if(this.opt.use == 'https'){
             use = 'https';
-        }else{
-            return false;
         }
 
+        this.opt.use = use;
+
         let options = {};
 
         for(let x in this.opt){
@@ -213,6 +225,7 @@ module.exports = class{
                     if(call && call.url){
                         if(call.next !== false){
                             return this.getCall(call.next)(cc, (data)=>{
+                                cc.nextData = data;
                                 this.getCall(call.callback)(cc, data);
                             });
                         }else{
@@ -236,13 +249,20 @@ module.exports = class{
             }
 
             if(call && call.hasOwnProperty(ws.path)){
-                call = call[ws.path].callback;
-                this.traffic(ws);
-                
-                const run = this.getCall(call);
-
-                ws.update(run);
-                run(ws, 'start');
+                call = call[ws.path];
+
+                if(call.next !== false){
+                    this.getCall(call.next)(ws, (data)=>{
+                        ws.nextData = data;
+                        const run = this.getCall(call.callback);
+                        ws.update(run);
+                        run(ws, 'start');
+                    });
+                }else{
+                    const run = this.getCall(call.callback);
+                    ws.update(run);
+                    run(ws, 'start');
+                }
             }else{
                 ws.error(404);
             }
@@ -267,7 +287,7 @@ module.exports = class{
             this.logServer('server', `The server is collecting logs via (${this.opt.log})`);
             port = port || this.opt.port || process.env.PORT || 3000;
             this.server.listen(port, host, ()=>{
-                this.logServer('server', `Started on server(${this.opt.use}) port(${port})`);
+                this.logServer('server', `Started on server(${this.opt.use}) host(${host || '0.0.0.0'}) port(${port})`);
             });
         }
     }
@@ -307,24 +327,9 @@ module.exports = class{
     }
 
     domain(domain){
-        if(domain == undefined){
-            domain = '*';
-        }
+        let config = {};
 
-        let config = {
-            next:(n)=>{
-                let next = {}; 
-                methodPlugin.basic(this, next, {domain, next:this.setCall(n)});
-                next.routes = methodPlugin.routes(next);
-                next.directory = methodPlugin.directory(next);
-
-                return next;
-            }
-        }
-        methodPlugin.basic(this, config, {domain});
-        config.routes = methodPlugin.routes(config);
-        config.directory = methodPlugin.directory(config);
-        config.websocket = methodPlugin.websocket(this, config, domain);
+        methodPlugin.maps(this, config, domain);
         
         return config;
     }
@@ -342,11 +347,11 @@ module.exports = class{
             return false;
         }
 
-        if(typeof next != 'number'){
+        if(typeof next != 'string'){
             next = false;
         }
 
-        if(typeof callback != 'number'){
+        if(typeof callback != 'string'){
             return false;
         }
 
@@ -377,7 +382,7 @@ module.exports = class{
             this.maps[domain][method].params[mode == 'params' ? 0 : 1].push(route);
         }
     }
-    setUpgrade({domain, url, callback}){
+    setUpgrade({domain, next, url, callback}){
         if(typeof domain != 'string'){
             domain = '*';
         }
@@ -386,21 +391,36 @@ module.exports = class{
             return false;
         }
 
-        if(typeof callback != 'number'){
+        if(typeof callback != 'string'){
             return false;
         }
 
+        if(typeof next != 'string'){
+            next = false;
+        }
+
         if(!this.mapws.hasOwnProperty(domain)){
             this.mapws[domain] = {};
         }
 
         this.mapws[domain][url] = {
-            callback:callback
+            callback,
+            next,
         };
     }
-    setCall(callback){
-        this.calls.push(callback);
-        return this.calls.length - 1;
+    setCall(a){
+        if(typeof a == 'function'){
+            let id = `r938_root_${this.idcalls}`;
+            this.calls[id] = a;
+
+            this.idcalls++;
+            return id;
+        }else if(typeof a == 'object' && typeof a.id == 'string' && typeof a.callback == 'function'){
+            if(!this.calls.hasOwnProperty(a.id)){
+                this.calls[a.id] = a.callback;
+            }
+            return a.id;
+        }
     }
     getCall(id){
         if(this.calls[id]){
@@ -410,3 +430,6 @@ module.exports = class{
     }
 }
 
+module.exports.pack = ()=>{
+    return packPlugin();
+}

package/lib/tools.js

@@ -9,18 +9,18 @@ const tools = {
         let output = {};
         if(typeof byteData == 'string'){
             for(let x of byteData.split('&')){
-                var data = x.search('=');
+                const data = x.search('=');
                 let name = '';
                 let value = '';
                 if(data == -1){
-                    name = decodeURIComponent(x.trim());
+                    name = decodeURIComponent(x);
                     value = '';
                 }else{
                     try{
-                        name = decodeURIComponent(x.substring(0, data).trim());
-                        value = decodeURIComponent(x.substr(data + 1));
+                        name = decodeURIComponent(x.slice(0, data));
+                        value = decodeURIComponent(x.slice(data + 1));
                     }catch(e){
-                        this.server.log('error',`${util.format(e)}`);
+                        return {};
                     }
                 }
                 if(typeof output[name] == 'undefined'){
@@ -67,7 +67,7 @@ const tools = {
                     data = new TextDecoder('utf8').decode(rawData);
                 }
 
-                let name=content.indexOf(' name="') + 7;
+                let name = content.indexOf(' name="') + 7;
                 name = content.slice(name,content.indexOf('"',name)).toString();
                 
                 if(typeof output[name] == 'undefined'){

package/lib/websocket.js

@@ -11,6 +11,7 @@ module.exports = class{
     query = {}
     method = ''
     ip = ''
+    isUID = false
     callback = ()=>{}
     log = ()=>{}
     constructor({req, socket, head}){
@@ -170,6 +171,7 @@ module.exports = class{
         const head = tools.head2line(this.header);
         const statusLine = `HTTP/1.1 ${this.status} ${tools.statusText(this.status)}`;
         const headLine = `${statusLine}\r\n${head}\r\n\r\n`;
+        this.isUID = true;
         this.write(Buffer.from(headLine));
 
         this.log();
@@ -177,7 +179,9 @@ module.exports = class{
         return this;
     }
     write(data, callback){
-        if(this.socket.writable){
+        if(!this.isUID){
+            this.error(400);
+        }else if(this.socket.writable){
             this.socket.write(data, callback);
         }else if(this.req.destroyed){
             this.req.destroy();

package/package.json

@@ -3,6 +3,6 @@
     "description": "BirdPack web framework is a tool for web server via TCP HTTP supporting websocket focusing on speed.",
     "author":"R938",
     "license":"R938",
-    "version":"1.0.10",
+    "version":"1.0.12",
     "main": "index.js"
 }