birdpack 1.0.0

package/lib/core.js

@@ -0,0 +1,411 @@
+const tools = require('./tools');
+const fs = require('fs');
+const fileType = require('./fileType');
+
+module.exports = class{
+    status = 0
+    header = {}
+    cookie = {}
+    buffers = []
+    body = {}
+    host = ''
+    url = ''
+    query = {}
+    method = ''
+    callrouter = ()=>{}
+    params = {}
+    constructor({req, res}){
+        this.req = req;
+        this.res = res;
+
+        this.req.on('data', chunk => {
+            this.buffers.push(chunk);
+        })
+        .on('end', () => {
+            if(this.buffers.length !== 0){
+                this.buffers = Buffer.concat(this.buffers);
+            }else{
+                this.buffers = Buffer.alloc(0);
+            }
+
+            if(this.process() !== false){
+                let type = this.get('content-type');
+                if(type !== false){
+                    type = type.split('; ');
+
+                    if(type[0] == 'application/x-www-form-urlencoded'){
+                        this.body = tools.wwwform(this.buffers);
+                    }else if(type[0] == 'application/json'){
+                        try{
+                            this.body = JSON.parse(this.buffers);
+                        }catch(e){
+                            this.error(500, 'Invalid JSON.');
+                            return false;
+                        }
+                    }else if(type[0] == 'multipart/form-data' && type[1]){
+                        let key = type[1].slice(9);
+                        this.body = tools.formdata(this.buffers, key);
+                    }
+                }
+                this.callrouter();
+            }
+        })
+        .on('error', (e) => {
+            console.log(e);
+        })
+    }
+    process(){
+        if(!this.req.headers.host){
+            this.error(400, 'Invalid Host.');
+            return false;
+        }
+
+        const findHost = this.req.headers.host.indexOf(':');
+        this.host = findHost === -1 ? this.req.headers.host : this.req.headers.host.slice(0, findHost);
+
+        this.method = this.req.method.toLowerCase();
+
+        const url = this.req.url.split('?');
+        this.path = url[0];
+        if(url[1]){
+            this.query = tools.wwwform(url[1]);
+        }
+
+        if(this.req.headers.hasOwnProperty('cookie')){
+            let cookie = [];
+            if(Array.isArray(this.req.headers.cookie)){
+                cookie = this.req.headers.cookie;
+            }else{
+                cookie.push(this.req.headers.cookie);
+            }
+
+            for(let x of cookie){
+                for(let i of x.split('; ')){
+                    let index = i.indexOf('=');
+                    let key = i.slice(0, index);
+                    let value = i.slice(index + 1);
+
+                    try{
+                        key = decodeURIComponent(key);
+                        value = decodeURIComponent(value);
+                    }catch(e){}
+
+                    this.cookie[key] = value;
+                }
+            }
+        }
+        return true;
+    }
+    router(call){
+        this.callrouter = call;
+    }
+
+    code(status){
+        this.status = status;
+        return this;
+    }
+    set(key, value){
+        if(this.header.hasOwnProperty(key)){
+            this.header[key].push(value);
+        }else{
+            this.header[key] = [value];
+        }
+        return this;
+    }
+    get(key){
+        if(this.req.headers.hasOwnProperty(key)){
+            let header = this.req.headers[key];
+            if(typeof header == 'string'){
+                return header;
+            }else if(Array.isArray(header)){
+                return header[header.length - 1];
+            }
+        }
+        return false;
+    }
+    param(key, value){
+        this.params[key] =value ;
+        return this;
+    }
+    look(keys){
+        for(let x of keys.split(/[\s]*,[\s]*/)){
+            if(!this.query.hasOwnProperty(x)){
+                return false;
+            }
+        }
+        return true;
+    }
+    u(key){
+        if(this.query.hasOwnProperty(key)){
+            if(Array.isArray(this.query[key])){
+                return this.query[key][this.query[key].length - 1];
+            }else{
+                return this.query[key];
+            }
+        }
+        return false;
+    }
+    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}`);
+                }
+            }
+        }
+        this.set('set-cookie', text.join('; '));
+        return this;
+    }
+    rcookie(name, option){
+        if(typeof option != 'object'){
+            option = {};
+        }
+        option['max-age'] = '-1';
+        this.scookie(name, '', option);
+        return this;
+    }
+
+    writeHead(){
+        this.header['x-powered-by'] = `R938`;
+        if(this.res.writable){
+            this.res.writeHead(this.status ? this.status : 200, this.header);
+        }else if(this.req.destroyed){
+            this.req.destroy();
+        }
+        return this;
+    }
+    write(data, callback){
+        if(this.res.writable){
+            this.res.write(data, callback);
+        }else if(this.req.destroyed){
+            this.req.destroy();
+        }
+    }
+    end(data, callback){
+        if(this.res.writable){
+            this.res.end(data, callback);
+        }else if(this.req.destroyed){
+            this.req.destroy();
+        }
+    }
+    error(status, text){
+        this.code(status).send(text || '');
+    }
+
+
+    length(length){
+       this.set('content-length', length);
+       return this;
+    }
+    type(type){
+        this.set('content-type', type);
+        return this;
+    }
+
+    check(keys){
+        for(let x of keys.split(/[\s]*,[\s]*/)){
+            if(!this.body.hasOwnProperty(x)){
+                return false;
+            }
+        }
+        return true;
+    }
+    q(key){
+        if(this.body.hasOwnProperty(key)){
+            if(Array.isArray(this.body[key])){
+                return this.body[key][this.body[key].length - 1];
+            }else{
+                return this.body[key];
+            }
+        }
+
+        return false;
+    }
+
+    send(data){
+        if(typeof data === 'string' || typeof data === 'number'){
+            data = Buffer.from(data.toString(), 'utf8');
+        }else if(!Buffer.isBuffer(data)){
+            data = Buffer.alloc(0);
+        }
+
+        if(!this.header.hasOwnProperty('content-type')){
+            this.type('text/plain; charset=UTF-8')
+        }
+        this.length(data.length);
+
+        this.writeHead();
+        this.end(data);
+    }
+    json(data){
+        try{
+            data = JSON.stringify(data);
+            this.type('application/json; charset=utf-8')
+            .send(data);
+        }catch(e){
+            this.error(500);
+        }
+    }
+    html(data){
+        this.type('text/html; charset=utf-8')
+        .send(data);
+    }
+
+    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){
+            this.code(status)
+            .set('location', location)
+            .writeHead();
+            this.end();
+        }else{
+            this.error(status);
+        }
+    }
+    file(options){
+        if(typeof options != 'object'){
+            options = {file: options};
+        }
+
+        if(typeof options.error !== 'function'){
+            options.error = (code, text)=>{
+                this.error(code, text);
+            }
+        }
+
+        const bufferSize = 64 * 1024;
+        const buffer = Buffer.alloc(bufferSize);
+        let fileStat = fs.existsSync(options.file) ? fs.statSync(options.file) : false;
+
+        if(fileStat !== false && fileStat.isFile()){
+            let fileExt = options.file.split('.').pop().toLowerCase();
+
+            let fileRange = 'file';
+            if(options.hasOwnProperty('type')){
+            }else if(fileType.hasOwnProperty(fileExt)){
+                if(options.download !== true && ['mp4','mp3','ogg','weba','webm','mp4','avi','wav'].includes(fileExt)){
+                    fileRange = 'stream';
+                }
+                options.type = fileType[fileExt];
+            }
+
+            if(options.stream === true){
+                fileRange = 'stream';
+            }
+
+            if(fileRange == 'stream'){
+                const totalSize = fileStat.size;
+                let match = (this.get('range') || '').slice(6).split('-');
+
+                this.set('accept-ranges', 'bytes')
+                .type(options.type);
+
+                if(match.length == 2){
+                    const start = parseInt(match[0], 10) || 0;
+                    const end = parseInt(match[1], 10) || totalSize - 1;
+
+                    const chunkSize = end - start + 1;
+                    const fileDescriptor = fs.openSync(options.file, "r");
+
+                    const sendChunk = (position) => {
+                        if(position > end){
+                            fs.closeSync(fileDescriptor);
+                            return;
+                        }
+
+                        const bytesToRead = Math.min(bufferSize, end - position + 1);
+                        const bytesRead = fs.readSync(fileDescriptor, buffer, 0, bytesToRead, position);
+
+                        if(bytesRead > 0 && this.res.writable){
+                            this[position + bytesRead > end ? 'end' : 'write'](buffer.slice(0, bytesRead), (err) => {
+                                if(err){
+                                    fs.closeSync(fileDescriptor);
+                                }else{
+                                    sendChunk(position + bytesRead);
+                                }
+                            });
+                        }else{
+                            fs.closeSync(fileDescriptor);
+                        }
+                    };
+                    
+                    this.code(206)
+                    .length(chunkSize)
+                    .set('content-range', `bytes ${start}-${end}/${totalSize}`)
+                    .writeHead();
+                    sendChunk(start);
+                }else{
+                    const start = 0;
+                    const end = totalSize - 1;
+                    const chunkSize = end - start + 1;
+
+                    this.code(200)
+                    .length(chunkSize)
+                    .set('content-range', `bytes ${start}-${end}/${totalSize}`)
+                    .writeHead();
+                    this.end();
+                }
+            }else if(fileRange == 'file'){
+                const totalSize = fileStat.size;
+
+                const start = 0;
+                const end = totalSize - 1;
+
+                const chunkSize = end - start + 1;
+                const fileDescriptor = fs.openSync(options.file, "r");
+
+                const sendChunk = (position) => {
+                    if(position > end){
+                        fs.closeSync(fileDescriptor);
+                        return;
+                    }
+
+                    const bytesToRead = Math.min(bufferSize, end - position + 1);
+                    const bytesRead = fs.readSync(fileDescriptor, buffer, 0, bytesToRead, position);
+
+                    if(bytesRead > 0 && this.res.writable){
+                        this[position + bytesRead > end ? 'end' : 'write'](buffer.slice(0, bytesRead), (err) => {
+                            if (err) {
+                                fs.closeSync(fileDescriptor);
+                            } else {
+                                sendChunk(position + bytesRead);
+                            }
+                        });
+                    }else{
+                        fs.closeSync(fileDescriptor);
+                    }
+                };
+
+                this.code(200)
+                .length(chunkSize)
+                .type(options.type);
+
+                if(options.download === true){
+                    this.set('content-disposition', `attachment; filename="${options.filename}"`);
+                }
+                
+                this.writeHead();
+                sendChunk(start);
+            }else{
+                options.error(400, 'This file not supported.');
+            }
+        }else{
+            options.error(404, 'File not found.');
+        }
+    }
+}

package/lib/fileType.json

@@ -0,0 +1,35 @@
+{
+    "html": "text/html; charset=UTF-8",
+    "txt": "text/plain; charset=UTF-8",
+    "json": "application/json; charset=UTF-8",
+    "gif": "image/gif",
+    "jpeg": "image/jpeg",
+    "jpg": "image/jpg",
+    "webp": "image/webp",
+    "png": "image/png",
+    "svg": "image/svg+xml",
+    "ico": "image/x-icon",
+    "css": "text/css; charset=UTF-8",
+    "js": "application/javascript; charset=UTF-8",
+    "xml": "application/xml; charset=UTF-8",
+    "ttf": "font/ttf",
+    "eot": "font/eot",
+    "otf": "font/otf",
+    "woff": "font/woff",
+    "woff2": "font/woff2",
+    "mp3": "audio/mpeg",
+    "ogg": "audio/ogg",
+    "wav": "audio/wav",
+    "weba": "audio/weba",
+    "webm": "video/webm",
+    "mp4": "video/mp4",
+    "ts": "video/MP2T",
+    "m3u8": "application/x-mpegURL",
+    "avi": "video/x-msvideo",
+    "pdf": "application/pdf",
+    "rar": "application/rar",
+    "zip": "application/zip",
+    "tar": "application/tar",
+    "docx": "application/docx",
+    "xlsx": "application/xlsx"
+}