@reldens/server-utils 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Damian A. Pastorini
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# Reldens - Server Utils
+
+A set of helpers for Node.js to create a server and handle files.
+
+
+[![Reldens - GitHub - Release](https://www.dwdeveloper.com/media/reldens/reldens-mmorpg-platform.png)](https://github.com/damian-pastorini/reldens)
+
+# Reldens - Server Utils
+
+### Features
+
+- File handler.
+- Express server factory.
+- Multer uploader factory.
+
+Need something specific?
+
+[Request a feature here: https://www.reldens.com/features-request](https://www.reldens.com/features-request)
+
+---
+
+## Documentation
+
+[https://www.reldens.com/documentation/utils/](https://www.reldens.com/documentation/utils/)
+
+
+---
+
+### [Reldens](https://github.com/damian-pastorini/reldens/ "Reldens")
+
+##### [By DwDeveloper](https://www.dwdeveloper.com/ "DwDeveloper")

package/index.js

@@ -0,0 +1,15 @@
+/**
+ *
+ * Reldens - Server Utils
+ *
+ */
+
+const { FileHandler } = require('./lib/file-handler');
+const { AppServerFactory } = require('./lib/app-server-factory');
+const { UploaderFactory } = require('./lib/uploader-factory');
+
+module.exports = {
+    FileHandler,
+    AppServerFactory,
+    UploaderFactory
+};

package/lib/app-server-factory.js

@@ -0,0 +1,132 @@
+/**
+ *
+ * Reldens - AppServerFactory
+ *
+ */
+
+const { FileHandler } = require('./file-handler');
+const http = require('http');
+const https = require('https');
+const express = require('express');
+const bodyParser = require('body-parser');
+const session = require('express-session');
+const rateLimit = require('express-rate-limit');
+const cors = require('cors');
+
+class AppServerFactory
+{
+
+    constructor()
+    {
+        this.applicationFramework = express;
+        this.bodyParser = bodyParser;
+        this.session = session;
+        this.appServer = false;
+        this.app = express();
+        this.useCors = 1 === Number(process.env.RELDENS_USE_CORS || 1);
+        this.useExpressJson = 1 === Number(process.env.RELDENS_USE_EXPRESS_JSON || 1);
+        this.useUrlencoded = 1 === Number(process.env.RELDENS_USE_URLENCODED || 1);
+        this.encoding = String(process.env.RELDENS_DEFAULT_ENCODING || 'utf-8');
+        this.useHttps = 1 === Number(process.env.RELDENS_EXPRESS_USE_HTTPS || 0);
+        this.passphrase = String(process.env.RELDENS_EXPRESS_HTTPS_PASSPHRASE || '');
+        this.httpsChain = String(process.env.RELDENS_EXPRESS_HTTPS_CHAIN || '');
+        this.keyPath = String(process.env.RELDENS_EXPRESS_HTTPS_PRIVATE_KEY || '');
+        this.certPath = String(process.env.RELDENS_EXPRESS_HTTPS_CERT || '');
+        this.trustedProxy = String(process.env.RELDENS_EXPRESS_TRUSTED_PROXY || '');
+        this.windowMs = Number(process.env.RELDENS_EXPRESS_RATE_LIMIT_MS || 60000);
+        this.maxRequests = Number(process.env.RELDENS_EXPRESS_RATE_LIMIT_MAX_REQUESTS || 30);
+        this.applyKeyGenerator = 1 === Number(process.env.RELDENS_EXPRESS_RATE_LIMIT_APPLY_KEY_GENERATOR || 0);
+        this.errorMessage = '';
+    }
+
+    createAppServer(appServerConfig)
+    {
+        if(appServerConfig){
+            Object.assign(this, appServerConfig);
+        }
+        if(this.useCors){
+            this.app.use(cors());
+        }
+        if(this.useExpressJson){
+            this.app.use(express.json());
+        }
+        if(this.useUrlencoded){
+            this.app.use(bodyParser.urlencoded({extended: true}));
+        }
+        if('' !== this.trustedProxy){
+            this.app.enable('trust proxy', this.trustedProxy);
+        }
+        this.appServer = this.createServer();
+        return {app: this.app, appServer: this.appServer};
+    }
+
+    createServer()
+    {
+        if(!this.useHttps){
+            return http.createServer(this.app);
+        }
+        let key = FileHandler.readFile(this.keyPath);
+        if(!key){
+            this.errorMessage = 'Key file not found: ' + this.keyPath;
+            return false;
+        }
+        let cert = FileHandler.readFile(this.certPath);
+        if(!cert){
+            this.errorMessage = 'Cert file not found: ' + this.certPath;
+            return false;
+        }
+        let credentials = {
+            key: key.toString(),
+            cert: cert.toString(),
+            passphrase: this.passphrase
+        };
+        if('' !== this.httpsChain){
+            let ca = FileHandler.readFile(this.httpsChain);
+            if(ca){
+                credentials.ca = ca;
+            }
+        }
+        return https.createServer(credentials, this.app);
+    }
+
+    async enableServeHome(app, homePageLoadCallback)
+    {
+        let limiterParams = {
+            // default 60000 = 1 minute:
+            windowMs: this.windowMs,
+            // limit each IP to 30 requests per windowMs:
+            max: this.maxRequests,
+        };
+        if(this.applyKeyGenerator){
+            limiterParams.keyGenerator = function (req) {
+                return req.ip;
+            };
+        }
+        let limiter = rateLimit(limiterParams);
+        app.post('/', limiter);
+        app.post('/', async (req, res, next) => {
+            if('/' === req._parsedUrl.pathname){
+                return res.redirect('/');
+            }
+            next();
+        });
+        app.get('/', limiter);
+        app.get('/', async (req, res, next) => {
+            if('/' === req._parsedUrl.pathname){
+                if('function' !== typeof homePageLoadCallback){
+                    return res.send('Homepage contents could not be loaded.');
+                }
+                return res.send(await homePageLoadCallback(req));
+            }
+            next();
+        });
+    }
+
+    async enableServeStatics(app, staticsPath)
+    {
+        app.use(express.static(staticsPath));
+    }
+
+}
+
+module.exports.AppServerFactory = AppServerFactory;

package/lib/file-handler.js

@@ -0,0 +1,206 @@
+/**
+ *
+ * Reldens - FileHandler
+ *
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+class FileHandler
+{
+
+    constructor()
+    {
+        this.encoding = (process.env.RELDENS_DEFAULT_ENCODING || 'utf8');
+        this.sep = path.sep;
+        this.error = {message: ''};
+    }
+
+    joinPaths(...args)
+    {
+        return path.join(...args);
+    }
+
+    exists(fullPath)
+    {
+        return fs.existsSync(fullPath);
+    }
+
+    remove(fullPath)
+    {
+        try {
+            let deletePath = Array.isArray(fullPath) ? this.joinPaths(...fullPath) : fullPath
+            if(fs.existsSync(deletePath)){
+                fs.rmSync(deletePath, {recursive: true, force: true});
+                return true;
+            }
+        } catch (error) {
+            this.error = {message: 'Failed to remove folder.', error, fullPath};
+        }
+        return false;
+    }
+
+    createFolder(folderPath)
+    {
+        try {
+            if(fs.existsSync(folderPath)){
+                return true;
+            }
+            fs.mkdirSync(folderPath, {recursive: true});
+            return true;
+        } catch (error) {
+            this.error = {message: 'Failed to create folder.', error, folderPath};
+        }
+        return false;
+    }
+
+    copyFolderSync(from, to)
+    {
+        try {
+            fs.mkdirSync(to, {recursive: true});
+            let folders = fs.readdirSync(from);
+            for(let element of folders){
+                let elementPath = path.join(from, element);
+                if(!fs.existsSync(elementPath)){
+                    continue;
+                }
+                if(fs.lstatSync(elementPath).isFile()){
+                    fs.copyFileSync(elementPath, path.join(to, element));
+                    continue;
+                }
+                this.copyFolderSync(elementPath, path.join(to, element));
+            }
+            return true;
+        } catch (error) {
+            this.error = {message: 'Failed to copy folder.', error, from, to};
+        }
+        return false;
+    }
+
+    copyFileSyncIfDoesNotExist(from, to)
+    {
+        if(!fs.existsSync(to)){
+            return fs.copyFileSync(from, to);
+        }
+    }
+
+    copyFile(from, to)
+    {
+        let origin = Array.isArray(from) ? this.joinPaths(...from) : from;
+        let dest = Array.isArray(to) ? this.joinPaths(...to) : to;
+        if(!this.exists(origin)){
+            return false;
+        }
+        if(!this.exists(dest)){
+            return false;
+        }
+        try {
+            fs.copyFileSync(origin, dest);
+            return true;
+        } catch (error) {
+            this.error = {message: 'Failed to copy file.', error, from, to, origin, dest};
+        }
+        return false;
+    }
+
+    extension(filePath)
+    {
+        return path.extname(filePath);
+    }
+
+    readFolder(folder, options)
+    {
+        return fs.readdirSync(folder, options);
+    }
+
+    fetchSubFoldersList(folder, options)
+    {
+        let files = fs.readdirSync(folder, options);
+        let subFolders = [];
+        for(let file of files){
+            let filePath = path.join(folder, file);
+            if(fs.lstatSync(filePath).isDirectory()){
+                subFolders.push(file);
+            }
+        }
+        return subFolders;
+    }
+
+    isFile(filePath)
+    {
+        try {
+            return fs.lstatSync(filePath).isFile();
+        } catch (error) {
+            this.error = {message: 'Can not check file.', error, filePath};
+        }
+        return false;
+    }
+
+    permissionsCheck(systemPath)
+    {
+        try {
+            let crudTestPath = path.join(systemPath, 'crud-test');
+            fs.mkdirSync(crudTestPath, {recursive: true});
+            fs.rmSync(crudTestPath);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    fetchFileJson(filePath)
+    {
+        let fileContents = this.fetchFileContents(filePath);
+        if(!fileContents){
+            return false;
+        }
+        let importedJson = JSON.parse(fileContents);
+        if(!importedJson){
+            this.error = {message: 'Can not parse data file.', filePath};
+            return false;
+        }
+        return importedJson;
+    }
+
+    fetchFileContents(filePath)
+    {
+        if(!this.isFile(filePath)){
+            return false;
+        }
+        let fileContent = this.readFile(filePath);
+        if(!fileContent){
+            this.error = {message: 'Can not read data or empty file.', filePath};
+            return false;
+        }
+        return fileContent;
+    }
+
+    readFile(filePath)
+    {
+        if(!filePath){
+            this.error = {message: 'Missing data file.', filePath};
+            return false;
+        }
+        return fs.readFileSync(filePath, {encoding: this.encoding, flag: 'r'});
+    }
+
+    async updateFileContents(filePath, contents)
+    {
+        return fs.writeFileSync(fs.openSync(filePath, 'w+'), contents);
+    }
+
+    writeFile(fileName, content)
+    {
+        try {
+            fs.writeFileSync(fileName, content, this.encoding);
+            return true;
+        } catch (error) {
+            this.error = {message: 'Error saving the file.', fileName, error};
+        }
+        return false;
+    }
+
+}
+
+module.exports.FileHandler = new FileHandler();

package/lib/uploader-factory.js

@@ -0,0 +1,67 @@
+/**
+ *
+ * Reldens - UploaderFactory
+ *
+ */
+
+const multer = require('multer');
+const { FileHandler } = require('./file-handler');
+
+class UploaderFactory
+{
+
+    constructor(props)
+    {
+        this.mimeTypes = props.mimeTypes;
+        this.error = {message: ''};
+    }
+
+    createUploader(fields, buckets, allowedFileTypes)
+    {
+        let storage = multer.diskStorage({
+            destination: (req, file, cb) => {
+                cb(null, buckets[file.fieldname]);
+            },
+            filename: (req,file,cb) => {
+                cb(null, file.originalname);
+            }
+        })
+        return multer({
+            storage,
+            fileFilter: (req, file, cb) => {
+                return this.checkFileType(file, allowedFileTypes[file.fieldname], cb);
+            }
+        }).fields(fields);
+    }
+
+    checkFileType(file, allowedFileTypes, cb)
+    {
+        if(!allowedFileTypes){
+            return cb(null, true);
+        }
+        let allowedFileTypeCheck = this.convertToRegex(allowedFileTypes);
+        if(!allowedFileTypeCheck){
+            this.error = {message: 'File type could not be converted to regex.', allowedFileTypes};
+            return cb(null, false);
+        }
+        let extension = allowedFileTypeCheck.test(FileHandler.extension(file.originalname).toLowerCase());
+        let mimeType = allowedFileTypeCheck.test(file.mimetype);
+        if(mimeType && extension){
+            return cb(null, true);
+        }
+        this.error = {message: 'File type not supported.', extension, mimeType, allowedFileTypes};
+        return cb(null, false);
+    }
+
+    convertToRegex(key)
+    {
+        if(!this.mimeTypes[key]){
+            return false;
+        }
+        let types = this.mimeTypes[key].map(type => type.split('/').pop().replace('+', '\\+'));
+        return new RegExp(types.join('|'));
+    }
+
+}
+
+module.exports.UploaderFactory = UploaderFactory;

package/package.json

@@ -0,0 +1,37 @@
+{
+    "name": "@reldens/server-utils",
+    "scope": "@reldens",
+    "version": "0.1.0",
+    "description": "Reldens - Server Utils",
+    "author": "Damian A. Pastorini",
+    "license": "MIT",
+    "homepage": "https://github.com/damian-pastorini/reldens-server-utils",
+    "source": true,
+    "main": "index.js",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/damian-pastorini/reldens-server-utils.git"
+    },
+    "keywords": [
+        "reldens",
+        "utils",
+        "shortcuts",
+        "system",
+        "game",
+        "mmorpg",
+        "rpg",
+        "dwd",
+        "colyseus",
+        "phaser",
+        "parcel",
+        "nodejs",
+        "mmo",
+        "multiplayer",
+        "rol",
+        "platform",
+        "framework"
+    ],
+    "bugs": {
+        "url": "https://github.com/damian-pastorini/reldens-server-utils/issues"
+    }
+}