birdpack 1.1.0 → 1.1.1

package/lib/core.js

@@ -1,6 +1,7 @@
 const tools = require('./tools');
 const powered = require('./powered');
 const fs = require('fs');
+const pathLib = require('path');
 const fileType = require('./fileType');
 
 module.exports = class{
@@ -300,153 +301,106 @@ module.exports = class{
         }
     }
     file(options){
-        if(typeof options != 'object'){
-            options = {file: options};
+        if (typeof options !== 'object') {
+            options = { file: options };
         }
 
-        if(typeof options.error !== 'function'){
-            options.error = (code, text)=>{
-                this.error(code, text);
-            }
+        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;
+        const filePath = options.file;
 
-        if(fileStat !== false && fileStat.isFile()){
-            let fileExt = options.file.split('.').pop().toLowerCase();
+        fs.stat(filePath, (err, stat) => {
+            if (err || !stat.isFile()) {
+                return options.error(404, 'File not found.');
+            }
 
-            if(fileStat.size == 0){
+            if (stat.size === 0) {
                 return options.error(400, 'This file is empty.');
             }
 
-            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];
-            }else{
-                options.type = 'application';
+            const ext = pathLib.extname(filePath).slice(1).toLowerCase();
+
+            if (!options.type) {
+                options.type = fileType?.[ext] || 'application/octet-stream';
             }
 
-            if(options.stream === true){
-                fileRange = 'stream';
+            const isMedia = ['mp4','mp3','ogg','weba','webm','avi','wav'].includes(ext);
+            const forceStream = options.stream === true;
+            const allowStream = isMedia && options.download !== true;
+
+            const rangeHeader = this.get('range');
+
+            this.set('accept-ranges', 'bytes')
+            .type(options.type);
+
+            if (options.download === true) {
+                this.set(
+                    'content-disposition',
+                    `attachment; filename="${options.filename || pathLib.basename(filePath)}"`
+                );
             }
 
-            if(fileRange == 'stream'){
-                const totalSize = fileStat.size;
-                const range = this.get('range') || '';
-                let match = range.slice(6).split('-');
+            if ((forceStream || allowStream) && rangeHeader) {
+                const total = stat.size;
+                const [startStr, endStr] = rangeHeader.replace(/bytes=/, '').split('-');
 
-                const start = parseInt(match[0], 10) || 0;
-                const end = parseInt(match[1], 10) || totalSize - 1;
+                const start = parseInt(startStr, 10) || 0;
+                const end = endStr ? parseInt(endStr, 10) : total - 1;
+
+                if (start >= total || end >= total) {
+                    this.code(416)
+                        .set('content-range', `bytes */${total}`)
+                        .writeHead();
+                    return;
+                }
 
                 const chunkSize = end - start + 1;
-                const fileDescriptor = fs.openSync(options.file, "r");
 
-                const sendChunk = (position) => {
-                    if(position > end){
-                        fs.closeSync(fileDescriptor);
-                        return;
-                    }
+                this.code(206)
+                    .length(chunkSize)
+                    .set('content-range', `bytes ${start}-${end}/${total}`)
+                    .writeHead();
 
-                    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(range == '' ? 200 : 206)
-                .length(chunkSize)
-                .type(options.type)
-                .set('accept-ranges', 'bytes')
-                .set('content-range', `bytes ${start}-${end}/${totalSize}`)
-                .writeHead();
-                sendChunk(start);
-            }else if(fileRange == 'file'){
-                if(options.parameter){
-                    let data = fs.readFileSync(options.file, { encoding: 'utf8', flag: 'r' });
-
-                    data = data.replace(/\{\{[a-zA-Z0-9\_]*\}\}/g, (a)=>{
-                        let key = a.slice(2,-2);
-                        if(key != ''){
-                            if(options.parameter.hasOwnProperty(key)){
-                                return options.parameter[key]
-                            }
-                        }
-                        return '';
-                    });
+                const stream = fs.createReadStream(filePath, { start, end });
 
-                    data = Buffer.from(data, "utf8");
+                stream.pipe(this.res);
+                this.res.on('close', () => stream.destroy());
+                stream.on('error', () => stream.destroy());
+
+                return;
+            }
 
-                    if(options.download === true){
-                        this.set('content-disposition', `attachment; filename="${options.filename}"`);
+            if (options.parameter) {
+                fs.readFile(filePath, 'utf8', (err, data) => {
+                    if (err) {
+                        return options.error(500, 'File read error.');
                     }
 
-                    this.code(200)
-                    .type(options.type);
-                    
-                    this.send(data);
-                }else{
-                    const totalSize = fileStat.size;
+                    data = data.replace(/\{\{(\w+)\}\}/g, (_, key) =>
+                        options.parameter?.[key] ?? ''
+                    );
 
-                    const start = 0;
-                    const end = totalSize - 1;
+                    const buf = Buffer.from(data, 'utf8');
 
-                    const chunkSize = end - start + 1;
-                    const fileDescriptor = fs.openSync(options.file, "r");
+                    this.code(200)
+                        .send(buf);
+                });
 
-                    const sendChunk = (position) => {
-                        if(position > end){
-                            fs.closeSync(fileDescriptor);
-                            return;
-                        }
+                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(stat.size)
+                .writeHead();
 
-                    this.code(200)
-                    .length(chunkSize)
-                    .type(options.type);
+            const stream = fs.createReadStream(filePath);
 
-                    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.');
-        }
+            stream.pipe(this.res);
+
+            this.res.on('close', () => stream.destroy());
+            stream.on('error', () => stream.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.1.0",
+    "version":"1.1.1",
     "main": "index.js"
 }