yekonga-server/src/core/server.js

Yekonga Server

// @ts-nocheck
/*global Yekonga, serverLibrary */
const os = serverLibrary.os;
const http = serverLibrary.http;
const express = serverLibrary.express;
const ip = serverLibrary.ip;
const path = serverLibrary.path;
const compression = serverLibrary.compression;
const cors = serverLibrary.cors;
const URL = serverLibrary.URL;
const fs = serverLibrary.fs;
const cookieSession = serverLibrary.cookieSession;

const { setupMaster, setupWorker } = serverLibrary.socketSticky;
const { createAdapter, setupPrimary } = serverLibrary.socketClusterAdapter;

const logger = require('./logger');
const Middleware = require('./middleware');
const logPath = path.join(serverLibrary.__dirname, "logs/request.log");
const OtherRouteSetup = require('./routes');

const numCPUs = os.cpus().length;
const nodeVersion = parseInt(process.versions.node.split('.').shift());

Yekonga.route = express();
Yekonga.Route = Yekonga.route;

Yekonga.route.disable('x-powered-by');
// Yekonga.route.set('view engine', 'pug');
// Yekonga.route.set('views', `${serverLibrary.__dirname}`);

Yekonga.route.enable('trust proxy');
Yekonga.route.use(compression({ filter: shouldCompress }))
function shouldCompress (req, res) {
    var encodeKey = 'accept-encoding';

    for (const key in req.headers) {
        if (Object.hasOwnProperty.call(req.headers, key)) {
            if(key.toLowerCase() == encodeKey) {
                const value = req.headers[key];

                if (
                    value && 
                    (
                        value.includes("deflate") || 
                        value.includes("gzip") ||  
                        value.includes("br")
                    )
                ) {
                    // fallback to standard filter function
                    return compression.filter(req, res);
                }
                break;
            }
        }
    }
    
    // don't compress responses with this request header
    return false
}
// parse application/x-www-form-urlencoded
Yekonga.route.use(express.urlencoded({ limit: '250mb', extended: false }));
// parse application/json 
Yekonga.route.use(express.json({ limit: '250mb' }));
// @ts-ignore
Yekonga.route.use(cookieSession({
    name: 'yekonga',
    keys: ['userId', 'profileId', 'accessToken'], 
}));
Yekonga.route.use(cors());

if (logger) {
    // Yekonga.route.use(logger({ path: logPath }));
} else {
    console.debug(`Log not configared`);
}

Yekonga.route.use(Middleware.setYekonga);
Yekonga.route.use(Middleware.customBeforeAllMiddleware);
Yekonga.route.use(Middleware.headers);
Yekonga.route.use(Middleware.init);
Yekonga.route.use(Middleware.applicationKey);
Yekonga.route.use(Middleware.setToken);
Yekonga.route.use(Middleware.customInitMiddleware);
Yekonga.route.use(Middleware.setCurrentProfile);
Yekonga.route.use(Middleware.apiOptions);
Yekonga.route.use(Middleware.authorization);
Yekonga.route.use(Middleware.customMiddleware);
Yekonga.route.use(function(request, response, next) {
    const proto = (request.header('x-forwarded-proto')) ? request.header('x-forwarded-proto') : request.header('proto');

    if (Yekonga.Config.secureOnly && proto === 'http' && !request.secure) {
        const host = (request.header('x-forwarded-host')) ? request.header('x-forwarded-host') : request.header('host');
        const url = `https://${host}${request.url}`;

        return response.redirect(url);
    }

    return next();
});

const setDefaultPage = async function(req, res) {
    if (
        (req.header('accept') && req.header('accept').includes('json')) ||
        (req.header('content-type') && req.header('content-type').includes('json'))
    ) {
        res.status(404).json({ error: "Not found", code: 404 });
        return;
    }

    var extname = path.extname(URL.parse(req.url).pathname);
    if (req.url != '/index.html' && !(extname == null || (extname.trim() == ''))) {
        res.status(404).send('Not found');
        return;
    }

    let systemConfig = await Yekonga.Cloud.systemConfig(req, res);
    let headContent = await Yekonga.Cloud.headContent(req, res);
    let systemScript = await Yekonga.Cloud.systemScript(req, res);
    // console.debug(systemConfig);

    let content = fs.readFileSync(defaultFile, {
        encoding: 'utf8'
    });

    content = Yekonga.Helper.textTemplate(content, {
        route: '',
        version: Yekonga.Helper.getVersion(),
        appName: Yekonga.Config.appName,
        appDescription: Yekonga.Config.description,
        logoUrl: Yekonga.Config.logoUrl,
        faviconUrl: Yekonga.Config.faviconUrl,
        baseHost: Yekonga.Client.origin,
        baseUrl: Yekonga.Helper.getBaseUrl('', {res,req}),
        baseProto: Yekonga.Client.proto,
        baseApi: Yekonga.Helper.getApiRoute(),
        baseAuth: Yekonga.Helper.getApiAuthRoute(),
        headContent: headContent,
        systemScript: systemScript,
        ...systemConfig,
    });

    res.status(200).send(content);
}

var defaultFile = null;
module.exports = async function(createdServer, callback) {
    await Yekonga.Storage.connect();

    const storage = serverLibrary.multer.diskStorage({
        destination: function (req, file, cb) {
            if (Yekonga.Config.public) {
                if (Array.isArray(Yekonga.Config.public)) {
                    for (const publicPath of Yekonga.Config.public) {
                        var _dir = path.join(serverLibrary.__dirname, publicPath, 'uploads');
                        cb(null, _dir); break;
                    }
                } else {
                    var _dir = path.join(serverLibrary.__dirname, Yekonga.Config.public, 'uploads');
                    cb(null, _dir);
                }
            } else {
                var _dir = path.join(serverLibrary.__dirname, 'public', 'uploads');
                cb(null, _dir);
            }
        },
        filename: function (req, file, cb) {
            const uniqueSuffix = Yekonga.Helper.uuid4() + '.' + file.originalname.split('.').pop();
            cb(null, uniqueSuffix);
        }
    })

    const upload = serverLibrary.multer({ storage: storage });
    const cpUpload = upload.fields([
        { name: 'file', maxCount: 1 }, 
        { name: 'files', maxCount: 10 },
    ])
    const cpUploadFunction = async function (req, res, next) {
        var data = {};
        if (req.files.file) data.files = [req.files.file];
        if (req.files.files) data.files = req.files.files;


        data.files = data.files.map((e) => {
            var filename = `${e.filename}`;
            var dist = Yekonga.Helper.getBasePath(`/public/uploads/${e.filename}`);

            return {
                fileSize: e.size,
                fileType: 'url',
                fileName: filename,
                base64: Yekonga.Helper.getBaseUrl(`uploads/${filename}`, { req, res }),
            }
        });

        console.debug(data.files);

        var _data = await Yekonga.Cloud.afterFileUpload({ files: data, req, res });
        if (_data) { data = _data; }

        return res.json(data);
    }

    Yekonga.route.post('/upload', cpUpload, cpUploadFunction);
    Yekonga.route.post('/upload-files', cpUpload, cpUploadFunction);

    if(typeof createdServer == 'function') {
        callback = createdServer;
        createdServer = null;
    }

    if(createdServer) {
        Yekonga.serverSetup = createdServer;
    } else {
        Yekonga.serverSetup = http.createServer();
    }
    
    Yekonga.serverSetup.on("request", Yekonga.route);

    //====================================================

    Yekonga.route.all('/img/mail/:id/logo.png', function(req, res) {
        var id = req.params.id;
        if(!Yekonga.Helper.isEmpty(id)) {
            Yekonga.Model.Notification.update(
                { isSeen: true, status: 'delivered' }, 
                { notificationId: id }, 
                null, true);
        }

        res.setHeader('Cache-Control', `public, max-age=0`);
        return res.sendFile(Yekonga.Helper.getLogoPath());
    })

    Yekonga.route.all('/yekonga/yekonga.js', function(req, res) {
        res.setHeader('Cache-Control', `public, max-age=0`);
        res.setHeader('Content-Type', 'application/javascript; charset=UTF-8');

        let scripts = fs.readFileSync(path.join(__dirname, `/assets/sdk/axios.min.js`), { encoding: 'utf8' });
        scripts += fs.readFileSync(path.join(__dirname, `/assets/sdk/simplepeer.min.js`), { encoding: 'utf8' });
        scripts += require(`./assets/sdk/config.js`)(req, res);
        try {
            scripts += fs.readFileSync(path.join(__dirname, '/assets/sdk/socket.io.min.js'), { encoding: 'utf8' });
        } catch (error) {
            console.error(error.message);
        }
        scripts += fs.readFileSync(path.join(__dirname, '/assets/sdk/webRTC.js'), { encoding: 'utf8' });
        scripts += fs.readFileSync(path.join(__dirname, '/assets/sdk/yekonga.js'), { encoding: 'utf8' });

        return res.send(scripts);
    })


    Yekonga.route.all('/yekonga/socket.io.js', function(req, res) {
        let scripts = "";
        res.setHeader('Cache-Control', `public, max-age=0`);
        res.setHeader('Content-Type', 'application/javascript; charset=UTF-8');

        try {
            scripts += fs.readFileSync(path.join(__dirname, '../..', '/node_modules/socket.io/client-dist/socket.io.min.js'), { encoding: 'utf8' });
        } catch (error) {
            console.error(error.message);
        }

        return res.send(scripts);
    })

    //====================================================

    if(Yekonga.Config.enableDashboard) {
        const AdminRouteSetup = require('../admin');
        Yekonga.route.use(await AdminRouteSetup()); 
    }

    Yekonga.route.all('/', setDefaultPage);
    Yekonga.route.all('/index.html', setDefaultPage);
    Yekonga.route.use(OtherRouteSetup());

    if (!defaultFile) {
        if (Yekonga.Config.indexTemplate) {
            let indexTemplate = Yekonga.Config.indexTemplate;
            defaultFile = path.join(serverLibrary.__dirname, indexTemplate);
        }

        if (!defaultFile || !fs.existsSync(defaultFile)) {
            defaultFile = path.join(__dirname, '../..', '/public/frontend/dashboard.html');
        }

        if (!defaultFile || !fs.existsSync(defaultFile)) {
            defaultFile = path.join(__dirname, '../..', '/public/404.html');
        }
    }

    Yekonga.route.use(setDefaultPage);

    // 3. Add error-handling middleware after routes
    Yekonga.route.use((err, req, res, next) => {
        if (err instanceof SyntaxError && err.status === 400 && 'body' in err) {
        return res.status(400).json({ error: 'Invalid JSON format' });
        }
        next(err); // Pass other errors to subsequent handlers (if any)
    });
    
    // Optional: Catch-all error handler for unhandled errors
    Yekonga.route.use((err, req, res, next) => {
        console.debug(err);
        res.status(500).json({ error: 'Something went wrong' });
    });

    const serverExec = function() {
        const address = Yekonga.serverSetup.address();

        console.info(`Host is running on`, `http://${Yekonga.Config.domain}`);
        console.warn(`Host is running on`, `http://${ip.address()}:${address.port}`);

        if(Array.isArray(Yekonga.CloudService.callbacks)) {
            for (const callback of Yekonga.CloudService.callbacks) {
                try {
                    callback();
                } catch (error) {
                    console.error(error.message)
                }
            }
        }

        Yekonga.cronjobProcess();
        setTimeout(() => {
            Yekonga.Helper.createAdmin();
            Yekonga.Helper.createDefaultLanguage();
            Yekonga.GenerateIndex();

            if(typeof callback == 'function') {
                callback({
                    address: ip.address(),
                    port: address.port,
                });
            }
        }, 6000);
    };

    const POST = process.env.PORT || Yekonga.Config.ports.server || null;
    
    if (typeof Yekonga.setSocket == 'function') {
        await Yekonga.setSocket(Yekonga.serverSetup);
    }

    if(serverLibrary.cluster.isPrimary || serverLibrary.cluster.isMaster) {
        Yekonga.serverSetup.listen(POST, serverExec);
    } else {
        if(Yekonga.Config.localCluster) {
            Yekonga.serverSetup.listen(null, serverExec);
        } else {
            Yekonga.serverSetup.listen(POST, serverExec);
        }
    }
}