koa-classic-server 1.0.0

package/Readme.md

@@ -0,0 +1,102 @@
+#  koa-classic-file
+koa-cleassic-server is a mildwere aiming for similar but not identical behavior to apache2 . the contents of a folder on the server will be shown remotely and if you want to access a file, click on it. note: not a highly inexperienced programmer use this code with caution, suggestions are welcome
+
+## Installation
+
+in the future when the module is uploaded to the npm repositories for the moment you have to download it locally
+
+const koaClassicServer = require('koa-classic-server');
+
+## API
+
+## Options
+
+```js
+opts = {
+    method: Array("GET"), // methods enabled, otherwise it will have called the next() function
+    showDirContents: true, //show or not the contents of the current directory
+    index: "", // the index file , if a file with this name is found it will be loaded automatically Es index.html
+    //indexExt: array(),// futures supported extensions for the index file
+    urlPrefix: "",// prefix of the URL that will be skipped
+    urlsReserved: Array(), //paths on disk that will not be accessible remotely e.g. array('/api','/views') warning nested folders are not allowed
+    template: {
+        render: undefined, //function that will take care of the rendering if there is a template engine  ES --> const templateRender = async ( ctx, next, filePath) => {
+        Ext: Array(),// template engine file extension ES :Array("ejs", "EJS"),
+    }, // emd template 
+} // end optio
+```
+
+## Exsample
+
+# exsaple0
+
+```js
+const Koa = require('koa');
+const koaClassicServer = require('koa-classic-server');
+
+const app = new Koa();
+
+app.use(koaClassicServer('./public'));
+
+app.listen(3000);
+```
+
+# exsample1
+
+```js
+const koa = require('koa');
+const app = new koa();
+const port = 3000;
+
+const classicServer = require('koa-classic-server');
+
+const ejs = require('ejs');
+
+app.use( classicServer(
+    __dirname + "/public",    
+    (opt = {
+        showDirContents: true,
+        template:{
+            render: async ( ctx, next, filePath) => {
+                ctx.body = await ejs.renderFile(filePath, { filePath: filePath, href: ctx.href, query: ctx.query});
+            },
+            ext: Array('ejs','EJS')
+        }
+    }))
+    );
+
+app.listen(port, console.log("server started on port:" + port));
+```
+
+# exsample2
+
+```js
+const koa = require('koa');
+const app = new koa();
+const port = 3000;
+
+const classicServer = require('koa-classic-server');
+
+const ejs = require('ejs');
+
+const templateRender = async (ctx, next, filePath) => {
+    ctx.body = await ejs.renderFile(filePath, { filePath: filePath });
+};
+
+app.use( classicServer(
+    __dirname + "/public",    
+    (opt = {
+        showDirContents: true,
+        template:{
+            render: templateRender,
+            ext: Array('ejs','EJS')
+        }
+    }))
+    );
+
+app.listen(port, console.log("server started on port:" + port));
+```
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,272 @@
+const { URL } = require("url");
+const fs = require("fs");
+const mime = require("mime-types");
+const { throws } = require("assert");
+const { error } = require("console");
+
+// è la funzione che avierà il server rootDir = cartella dei file statici, UrlPrefix = prefisso del path dove guardare es localhost:3000\views
+// questa funzione deve restituire un midlware
+module.exports = function koaClassicServer(
+    rootDir,
+    opts = {}
+
+    /*
+    opts SRUCTURE
+     opts = {
+        method: Array("GET"), // metodisupportati altrimenti verràchiamata la funzione next()
+        showDirContents: true, // mostrare o meno il contenuto della cartella
+        index: "", // index file name
+        indexExt: array(),// futures possibili estensioni ammesse
+        //setHeaders: Array(), // Futures Function to set custom headers on response.
+        urlPrefix: "",
+        urlsReserved: Array(), //carelle riservate sulle quali i filenon vengono letti Ps solo cartelle di primo livello gli annidamenti non sono supportati
+        template: {
+            render: undefined, // ES --> const templateRender = async ( ctx, next, filePath) => {
+            ext: Array(),
+        }, // emd template 
+    } // end option */
+){
+    // controllo i valori di default options 
+    const options = opts || {};
+    options.template = opts.template || {template:{}};// necessario per rendere possibili i controlli di typo su options.template.render ecc
+
+    options.method = typeof options.method == 'string' ? options.method : Array('GET');// metod 
+    options.showDirContents = typeof options.showDirContents == 'boolean' ? options.showDirContents : true;// di default le cartelle vengono mostrate
+    options.index = typeof options.index == 'string' ? options.index : "";// index filefile che viene caricato se trovato dentro la cartella
+    options.urlPrefix = typeof options.urlPrefix == 'string' ? options.urlPrefix : "";// urlPrefix 
+    options.urlsReserved = Array.isArray( options.urlsReserved ) ? options.urlsReserved : Array();// array di url riservati e non accessibile
+    options.template.render = (options.template.render == undefined || typeof options.template.render == 'function' ) ? options.template.render : undefined;// metod 
+    options.template.ext = ( Array.isArray(options.template.ext) ) ? options.template.ext : Array();// metod 
+
+
+    return async (ctx, next) => {
+        
+ 
+        // controlla se il metodo richiesto è presente nella lista di quelli ammessi
+        if (!options.method.includes(ctx.method)) {
+            next();
+            return;
+        }  
+
+        const pageHref = new URL(ctx.href);
+        //console.log( "rootDir="+rootDir+" UrlPrefix="+options.urlPrefix+" pageHref.pathname="+pageHref.pathname );
+
+        // adesso controllo se pageHref rientraun urlPrefix
+        const a_pageHref = pageHref.pathname.split("/");
+        const a_urlPrefix = options.urlPrefix.split("/");
+
+        //controllo urlPrefix
+        for (const key in a_urlPrefix) {
+            if (a_urlPrefix[key] != a_pageHref[key]) {
+                next(); // allora non è un sottoinsieme valido e quindi il percorso non riguarda questomidlwzare            }
+                return;
+            }
+        }
+        // superato questotolgo tutti gli urlprefix dai PageHref
+
+        // creao pageHrefOutPrefix che non conterrà ilprefixnelsuoindirizzo
+        let pageHrefOutPrefix = pageHref;
+        if (options.urlPrefix != "") {
+            // se siste un urlPrefix non nullo costruisco un nuovo pageHref
+            let hrefOuyPrefix =
+                pageHref.origin +
+                "/" +
+                a_pageHref
+                    .slice(-(a_pageHref.length - a_urlPrefix.length))
+                    .join("/"); //stringa href senza urlPrefix
+            pageHrefOutPrefix = new URL(hrefOuyPrefix);
+        }
+
+        //DA MIGLIORARE
+        // inizio controllo urlReserved // vale solo per il primo livello di cartelle non quelle annidate
+        if (Array.isArray(options.urlsReserved)) {
+            const a_pathnameOutPrefix = pageHrefOutPrefix.pathname.split("/");
+            for (const value of options.urlsReserved) {
+                if (a_pathnameOutPrefix[1] == value.substring(1)) {
+                    // allora siamo nella cartella riservata //.substring(1) = taglia lo / iniziale
+                    next();
+                    return;
+                }
+            }
+        }
+        //controllo urlReserved
+
+        // questo if impedirà che ilnome della cartella finisca con "/"
+        let toOpen = ""; // sarà il percorso del file o della directori da aprire
+        if (pageHrefOutPrefix.pathname == "/") {
+            toOpen = rootDir;
+        } else {
+            toOpen = rootDir + decodeURIComponent(pageHrefOutPrefix.pathname);
+        }
+
+        if (!fs.existsSync(toOpen)) {
+            // il filein questione non esiste quindi si può tornare niente
+            //notfound The requested URL was not found on this server.
+            ctx.body = requestedUrlNotFound();
+            return;
+        }
+        const stat = fs.statSync(toOpen);
+        let dir = ""; //solo segnaposto da migliorare
+        if (stat.isDirectory()) {
+            // is directory
+            if ( options.showDirContents ) {
+                if (options.index) {
+                    //quindi esiste un nome di file index da cercare
+                    if (fs.existsSync(toOpen + "/" + options.index)) {
+                        loadFile(toOpen + "/" + options.index);
+                        return;
+                    }
+                }
+                ctx.body = show_dir(toOpen);
+            } else {
+                // allora non devo mostrare il contenuto della directory
+                ctx.body = requestedUrlNotFound();
+            }
+            return;
+        } else {
+            //is file
+            loadFile(toOpen);
+            return;
+        }
+
+        // funzioni interne
+
+        function requestedUrlNotFound() {
+            return `
+                <!DOCTYPE html>
+                    <html>
+                    <head>
+                        <meta charset="UTF-8">
+                        <meta http-equiv="X-UA-Compatible">
+                        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                        <title>URL not found</title>
+                    </head>
+                    <body>
+                    <h1>Not Found</h1>
+
+                    <h3>The requested URL was not found on this server.</h3>
+
+                    </body>
+                    </html>
+                `;
+        } // function requestedUrlNotFound(){
+
+        async function loadFile(toOpen) {
+            if (options.template.ext.length > 0) {
+                // esiste il metodo options.template.render quindi controlliamo i templatengine
+                // ricavo l'estenzione del file
+                const a_path = toOpen.split(".");
+                const fileExt = a_path[a_path.length - 1]; // prendol'ultmo elemento che sarà l'estensione
+                if (options.template.ext.includes(fileExt)) {
+                    // se l'estenzione è nell'elenco si esegue altrimenti mostrerà il file normalmente
+                    await options.template.render(ctx, next, toOpen);
+                    return;
+                }
+            }
+            let mimeType = mime.lookup(toOpen);
+            const src = fs.createReadStream(toOpen);
+            ctx.response.set("content-type", mimeType);
+            ctx.response.set(
+                "content-disposition",
+                `inline; filename=${pageHrefOutPrefix.pathname.substring(1)}`
+            ); //pageHref.pathname.substring(1) = taglia l' / iniziale ;//https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition
+            ctx.body = src;
+        }
+
+        //adesso devo andarenel rootDir e caricare i file e mostrarli al server
+        function show_dir(toOpen) {
+            dir = fs.readdirSync(toOpen, { withFileTypes: true }); // possibile error error.code == "ENOENT" ???
+            let s_dir = "<table>";
+
+            // START PARENT directory
+            if (pageHrefOutPrefix.origin + "/" != pageHrefOutPrefix.href) {
+                // allora non sei nella cartella base e bisogn visualizzare il linkalla Parent Directory
+                const a_pD = pageHref.href.split("/"); // array che conterrà il link della parent directori e che poi verrà ricostruito in stringa
+                a_pD.pop(); // rimuovo l'ultimo elemento per trasormarla dell parent directory
+                const parentDirectory = a_pD.join("/");
+                s_dir += `<tr><td><a href="${parentDirectory}"><b>.. Parent Directory</b></a></td><td>DIR</td></tr>`;
+            }
+            // END PARENT directory
+
+            if (dir.length == 0) {
+                // cartella vuolta
+
+                s_dir += `<tr><td>empty folder</td><td></td></tr>`;
+                s_dir += `</table>`;
+            } else {
+                //la cartella non è vuota per questo si mostrerà il contenuto
+
+                let a_sy = Object.getOwnPropertySymbols(dir[0]); // recupero l'array dei symbol
+                const sy_type = a_sy[0]; // recupero il symbol Symbol(type)
+                //let test = sy_type.description; test == 'type
+                for (const item of dir) {
+                    const s_name = item.name.toString();
+                    const type = item[sy_type];
+
+                    // item["Symbol(type)"] == type == ( 1 == file , 2 == cartella )
+                    if (type == 1) {
+                        // 1 == file
+                        s_dir += `<tr><td> FILE `;
+                    } else if (type == 2 || type == 3) {
+                        //2 == cartella , 3 == symbolic link
+                        s_dir += `<tr><td>`;
+                    } else {
+                        // ne file ne cartella , errore ?
+                        throw new Error("unknown file type  type="+type);
+                    }
+
+                    const itemPath = `${toOpen}/${s_name}`;
+                    let itemUri = "";
+                    if (
+                        pageHref.href ==
+                        pageHref.origin + options.urlPrefix + "/"
+                    ) {
+                        // senza questo if else vi rarà sempre un "/" in più o in meno alla fine dell'origin
+                        itemUri = `${
+                            pageHref.origin + options.urlPrefix
+                        }/${encodeURIComponent(s_name)}`;
+                    } else {
+                        itemUri = `${pageHref.href}/${encodeURIComponent(
+                            s_name
+                        )}`;
+                        //in questo caso non mi trovo nella root ed
+                    }
+
+                    // prendo in considerazione il casoin cui sia presente una cartella poireserved options.urlsReserved coniderare inoltre che queste cartelle posso essere presenti solo nella radice ci pageHrefOutPrefix   type == 2 -->  cartella || type == 3 -->  sybolik link
+                    if(pageHrefOutPrefix.pathname == '/' &&  options.urlsReserved.includes( '/' + s_name ) && (type == 2 || type == 3) ){
+                        s_dir += ` ${s_name}</td> <td> DIR BUT RESERVED</td></tr>`;
+                    }else{// mostro le directori ed i file normalmente
+                        s_dir += ` <a href="${itemUri}">${s_name}</a> </td> <td> ${
+                            type == 2 // type == 2 è una cartellla
+                                ? "DIR"
+                                : ( mime.lookup(itemPath) == false ) ? 'unknow' : mime.lookup(itemPath)
+                        } </td></tr>`;
+                    }
+                } // end for
+            } // end if else
+
+            s_dir += "</table>";
+            //ctx.is('text/html');
+            let toReturn = `
+                        <!DOCTYPE html>
+                    <html>
+                    <head>
+                        <meta charset="UTF-8">
+                        <meta http-equiv="X-UA-Compatible">
+                        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                        <title>Document</title>
+                    </head>
+                    <body>`;
+
+            toReturn += s_dir;
+            // for test
+            //toReturn += s_dir + " \n <br>  rootDir="+rootDir+" UrlPrefix="+options.urlPrefix+" pageHref.pathname="+pageHref.pathname ;
+
+            toReturn += `
+                    </body>
+                    </html>
+                `;
+            return toReturn;
+        } // function show_dir( dir ){
+    }; // return (ctx, next) => {
+};

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "koa-classic-server",
+  "version": "1.0.0",
+  "description": "a server in style aphasche2",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js",
+    "test": "nodemon ./test/test.js"
+  },
+  "keywords": [
+    "file",
+    "server"
+  ],
+  "author": "italo Paesano",
+  "license": "MIT",
+  "dependencies": {
+    "koa": "^2.13.4"
+  
+  }
+}