ultimate-express 1.0.0

package/src/utils.js

@@ -0,0 +1,285 @@
+const mime = require("mime-types");
+const path = require("path");
+const proxyaddr = require("proxy-addr");
+const qs = require("qs");
+const etag = require("etag");
+const { Stats } = require("fs");
+
+function removeDuplicateSlashes(path) {
+    return path.replace(/\/{2,}/g, '/');
+}
+
+function patternToRegex(pattern, isPrefix = false) {
+    if(pattern instanceof RegExp) {
+        return pattern;
+    }
+    if(isPrefix && pattern === '/') {
+        return new RegExp(``);
+    }
+
+    let regexPattern = pattern
+        .replace(/\./g, '\\.')
+        .replace(/\-/g, '\\-')
+        .replace(/\*/g, '.*') // Convert * to .*
+        .replace(/:(\w+)(\(.+?\))?/g, (match, param, regex) => {
+            return `(?<${param}>${regex ? regex + '($|\\/)' : '[^/]+'})`;
+        }); // Convert :param to capture group
+
+    return new RegExp(`^${regexPattern}${isPrefix ? '(?=$|\/)' : '$'}`);
+}
+
+function needsConversionToRegex(pattern) {
+    if(pattern instanceof RegExp) {
+        return false;
+    }
+    if(pattern === '/*') {
+        return false;
+    }
+
+    return pattern.includes('*') ||
+        pattern.includes('?') ||
+        pattern.includes('+') ||
+        pattern.includes('(') ||
+        pattern.includes(')') ||
+        pattern.includes(':') ||
+        pattern.includes('{') ||
+        pattern.includes('}') ||
+        pattern.includes('[') ||
+        pattern.includes(']');
+}
+
+function acceptParams(str) {
+    const parts = str.split(/ *; */);
+    const ret = { value: parts[0], quality: 1, params: {} }
+  
+    for (let i = 1; i < parts.length; ++i) {
+      const pms = parts[i].split(/ *= */);
+      if ('q' === pms[0]) {
+        ret.quality = parseFloat(pms[1]);
+      } else {
+        ret.params[pms[0]] = pms[1];
+      }
+    }
+  
+    return ret;
+}
+
+function normalizeType(type) {
+    return ~type.indexOf('/') ?
+        acceptParams(type) :
+        { value: (mime.lookup(type) || 'application/octet-stream'), params: {} };
+}
+
+function stringify(value, replacer, spaces, escape) {
+    let json = replacer || spaces
+        ? JSON.stringify(value, replacer, spaces)
+        : JSON.stringify(value);
+  
+    if (escape && typeof json === 'string') {
+        json = json.replace(/[<>&]/g, function (c) {
+            switch (c.charCodeAt(0)) {
+                case 0x3c:
+                    return '\\u003c'
+                case 0x3e:
+                    return '\\u003e'
+                case 0x26:
+                    return '\\u0026'
+                default:
+                    return c
+            }
+        });
+    }
+  
+    return json;
+}
+
+const defaultSettings = {
+    'jsonp callback name': 'callback',
+    'env': () => process.env.NODE_ENV ?? 'development',
+    'etag': 'weak',
+    'etag fn': () => createETagGenerator({ weak: true }),
+    'query parser': 'extended',
+    'query parser fn': () => qs.parse,
+    'subdomain offset': 2,
+    'trust proxy': false,
+    'views': () => path.join(process.cwd(), 'views'),
+    'view cache': () => process.env.NODE_ENV === 'production',
+    'x-powered-by': true,
+    'case sensitive routing': true
+};
+
+function compileTrust(val) {
+    if (typeof val === 'function') return val;
+  
+    if (val === true) {
+        // Support plain true/false
+        return function(){ return true };
+    }
+  
+    if (typeof val === 'number') {
+        // Support trusting hop count
+        return function(a, i){ return i < val };
+    }
+  
+    if (typeof val === 'string') {
+        // Support comma-separated values
+        val = val.split(',')
+            .map(function (v) { return v.trim() })
+    }
+  
+    return proxyaddr.compile(val || []);
+}
+
+const shownWarnings = new Set();
+function deprecated(oldMethod, newMethod, full = false) {
+    const err = new Error();
+    const pos = full ? err.stack.split('\n').slice(1).join('\n') : err.stack.split('\n')[3].trim().split('(').slice(1).join('(').split(')').slice(0, -1).join(')');
+    if(shownWarnings.has(pos)) return;
+    shownWarnings.add(pos);
+    console.warn(`${new Date().toLocaleString('en-UK', {
+        weekday: 'short',
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+        hour: 'numeric',
+        minute: 'numeric',
+        second: 'numeric',
+        timeZone: 'GMT',
+        timeZoneName: 'short'
+    })} u-express deprecated ${oldMethod}: Use ${newMethod} instead at ${pos}`);
+}
+
+function findIndexStartingFrom(arr, fn, index = 0) {
+    for(let i = index; i < arr.length; i++) {
+        if(fn(arr[i], i, arr)) {
+            return i;
+        }
+    }
+    return -1;
+};
+
+function decode (path) {
+    try {
+        return decodeURIComponent(path)
+    } catch (err) {
+        return -1
+    }
+}
+
+const UP_PATH_REGEXP = /(?:^|[\\/])\.\.(?:[\\/]|$)/;
+
+function containsDotFile(parts) {
+    for(let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if(part.length > 1 && part[0] === '.') {
+            return true;
+        }
+    }
+  
+    return false;
+}
+
+function parseTokenList(str) {
+    let end = 0;
+    const list = [];
+    let start = 0;
+  
+    // gather tokens
+    for (let i = 0, len = str.length; i < len; i++) {
+        switch(str.charCodeAt(i)) {
+            case 0x20: /*   */
+                if (start === end) {
+                    start = end = i + 1;
+                }
+                break;
+            case 0x2c: /* , */
+                if (start !== end) {
+                    list.push(str.substring(start, end));
+                }
+                start = end = i + 1;
+                break;
+            default:
+                end = i + 1;
+                break;
+        }
+    }
+  
+    // final token
+    if (start !== end) {
+        list.push(str.substring(start, end));
+    }
+  
+    return list;
+}
+
+
+function parseHttpDate(date) {
+    const timestamp = date && Date.parse(date);
+    return typeof timestamp === 'number' ? timestamp : NaN;
+}
+
+function isPreconditionFailure(req, res) {
+    const match = req.headers['if-match'];
+
+    // if-match
+    if(match) {
+        const etag = res.get('etag');
+        return !etag || (match !== '*' && parseTokenList(match).every(match => {
+            return match !== etag && match !== 'W/' + etag && 'W/' + match !== etag;
+        }));
+    }
+
+    // if-unmodified-since
+    const unmodifiedSince = parseHttpDate(req.headers['if-unmodified-since']);
+    if(!isNaN(unmodifiedSince)) {
+        const lastModified = parseHttpDate(res.get('Last-Modified'));
+        return isNaN(lastModified) || lastModified > unmodifiedSince;
+    }
+
+    return false;
+}
+
+function createETagGenerator(options) {
+    return function generateETag (body, encoding) {
+        const buf = !(body instanceof Stats) && !Buffer.isBuffer(body) ? Buffer.from(body, encoding) : body;
+        return etag(buf, options);
+    }
+}
+
+function isRangeFresh(req, res) {
+    const ifRange = req.headers['if-range'];
+    if(!ifRange) {
+        return true;
+    }
+
+    // if-range as etag
+    if(ifRange.indexOf('"') !== -1) {
+        const etag = res.get('etag');
+        return Boolean(etag && ifRange.indexOf(etag) !== -1);
+    }
+
+    // if-range as modified date
+    const lastModified = res.get('Last-Modified');
+    return parseHttpDate(lastModified) <= parseHttpDate(ifRange);
+}
+
+module.exports = {
+    removeDuplicateSlashes,
+    patternToRegex,
+    needsConversionToRegex,
+    acceptParams,
+    normalizeType,
+    stringify,
+    defaultSettings,
+    compileTrust,
+    deprecated,
+    UP_PATH_REGEXP,
+    decode,
+    containsDotFile,
+    parseTokenList,
+    parseHttpDate,
+    isPreconditionFailure,
+    createETagGenerator,
+    isRangeFresh,
+    findIndexStartingFrom
+};

package/src/view.js

@@ -0,0 +1,103 @@
+const path = require("path");
+const fs = require("fs");
+
+module.exports = class View {
+    constructor(name, options) {
+        this.name = name;
+        this.options = options ? Object.assign({}, options) : {};
+        this.defaultEngine = options.defaultEngine;
+        this.ext = path.extname(name);
+        this.root = options.root;
+
+        if (!this.ext && !this.defaultEngine) {
+            throw new Error('No default engine was specified and no extension was provided.');
+        }
+
+        let fileName = name;
+        if(!this.ext) {
+            this.ext = this.defaultEngine[0] !== '.'
+                ? '.' + this.defaultEngine
+                : this.defaultEngine;
+        
+            fileName += this.ext;
+        }
+
+        if (!this.options.engines[this.ext]) {
+            const mod = this.ext.slice(1);
+
+            // default engine export
+            const fn = require(mod).__express;
+        
+            if (typeof fn !== 'function') {
+              throw new Error('Module "' + mod + '" does not provide a view engine.')
+            }
+        
+            this.options.engines[this.ext] = fn;
+        }
+
+        this.engine = this.options.engines[this.ext];
+        this.path = path.join(this.root, fileName);
+    }
+
+    lookup(name) {
+        let path;
+        let roots = [].concat(this.root);
+        for (let i = 0; i < roots.length && !path; i++) {
+            const root = roots[i];
+        
+            // resolve the path
+            const loc = path.resolve(root, name);
+            const dir = path.dirname(loc);
+            const file = path.basename(loc);
+        
+            // resolve the file
+            path = this.resolve(dir, file);
+        }
+        
+        return path;
+    }
+
+    // ill be real idk what exactly this does but express implements it this way
+    render(options, callback) {
+        let sync = true;
+        this.engine(this.path, options, function onRender() {
+            if(!sync) {
+                return callback.apply(this, arguments);
+            }
+
+            return process.nextTick(() => {
+                return callback.apply(this, arguments);
+            });
+        });
+
+        sync = false;
+    }
+
+    resolve(dir, file) {
+        const ext = this.ext;
+
+        // <path>.<ext>
+        let path = path.join(dir, file);
+        let stat = tryStat(path);
+
+        if(stat && stat.isFile()) {
+            return path;
+        }
+
+        // <path>/index.<ext>
+        path = path.join(dir, path.basename(file, ext) + ext);
+        stat = tryStat(path);
+
+        if(stat && stat.isFile()) {
+            return path;
+        }
+    }
+}
+
+function tryStat(path) {  
+    try {
+        return fs.statSync(path);
+    } catch (e) {
+        return undefined;
+    }
+}

package/src/workers/fs.js

@@ -0,0 +1,14 @@
+const fs = require("fs");
+const { parentPort } = require("worker_threads");
+
+parentPort.on('message', (message) => {
+    if(message.type === 'readFile') {
+        try {
+            const data = fs.readFileSync(message.path);
+            const ab = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+            parentPort.postMessage({ key: message.key, data: ab }, [ab]);
+        } catch(err) {
+            parentPort.postMessage({ key: message.key, err: String(err) });
+        }
+    }
+});

package/tests/index.js

@@ -0,0 +1,64 @@
+// npm run test - runs all tests
+// npm run test routing - runs all tests in the routing category
+// npm run test tests/tests/routing - runs all tests in the routing category
+// npm run test tests/tests/listen/listen-random.js - runs the test at tests/tests/listen/listen-random.js
+
+const fs = require("fs");
+const path = require("path");
+const test = require("node:test");
+const childProcess = require("node:child_process");
+const assert = require("node:assert");
+
+const testPath = path.join(__dirname, 'tests');
+
+let testCategories = fs.readdirSync(testPath).sort((a, b) => parseInt(a) - parseInt(b));
+const filterPath = process.argv[2];
+
+if(filterPath) {
+    if(!filterPath.endsWith('.js')) {
+        testCategories = testCategories.filter(category => category.startsWith(path.basename(filterPath)));
+    } else {
+        testCategories = [path.dirname(filterPath).split(path.sep).pop()];
+    }
+}
+
+for (const testCategory of testCategories) {
+    test(testCategory, async () => {
+        let tests = fs.readdirSync(path.join(__dirname, 'tests', testCategory)).sort((a, b) => parseInt(a) - parseInt(b));
+        for (const testName of tests) {
+            if(filterPath && filterPath.endsWith('.js')) {
+                if(path.basename(testName) !== path.basename(filterPath)) {
+                    continue;
+                }
+            }
+            let testPath = path.join(__dirname, 'tests', testCategory, testName);
+            let testCode = fs.readFileSync(testPath, 'utf8').replace(`const express = require("../../../src/index.js");`, 'const express = require("express");');
+            fs.writeFileSync(testPath, testCode);
+            let testDescription = testCode.split('\n')[0].slice(2).trim();
+            if(testDescription.endsWith('OFF')) {
+                return true;
+            }
+
+            await new Promise(resolve => {
+                test(testDescription, () => {
+                    process.stdout.write(testDescription + '...');
+                    try {
+                        let expressOutput = childProcess.execSync(`node ${testPath}`).toString();
+
+                        fs.writeFileSync(testPath, testCode.replace(`const express = require("express");`, `const express = require("../../../src/index.js");`));
+                        let uExpressOutput = childProcess.execSync(`node ${testPath}`).toString();
+
+                        assert.strictEqual(uExpressOutput, expressOutput);
+                        console.log('\x1b[32mOK\x1b[0m');
+                    } catch (error) {
+                        console.log('\x1b[31mFAIL\x1b[0m');
+                        throw error;
+                    } finally {
+                        fs.writeFileSync(testPath, testCode);
+                        resolve();
+                    }
+                });
+            });
+        }
+    });
+}

package/tests/parts/.test/index.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Document</title>
+</head>
+<body>
+    test
+</body>
+</html>

package/tests/parts/index.art

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>{{ title }}</title>
+</head>
+<body>
+  <h1>{{ message }}</h1>
+  <span>{{ asdf }}</span>
+</body>
+</html>

package/tests/parts/index.dot

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>[[= title ]]</title>
+</head>
+<body>
+  <h1>[[= message ]]</h1>
+  <span>[[= asdf ]]</span>
+</body>
+</html>

package/tests/parts/index.ejs

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title><%= title %></title>
+</head>
+<body>
+  <h1><%= message %></h1>
+  <span><%= asdf %></span>
+</body>
+</html>

package/tests/parts/index.handlebars

@@ -0,0 +1,2 @@
+<h1>{{{ message }}}</h1>
+<span>{{{ asdf }}}</span>

package/tests/parts/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>test</title>
+</head>
+<body>
+  <h1>test</h1>
+  <span>index test</span>
+</body>
+</html>

package/tests/parts/index.mustache

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>{{ title }}</title>
+</head>
+<body>
+  <h1>{{ message }}</h1>
+  <span>{{ asdf }}</span>
+</body>
+</html>

package/tests/parts/index.pug

@@ -0,0 +1,6 @@
+html
+  head
+    title= title
+  body
+    h1= message
+    span= asdf

package/tests/parts/index.swig

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>{{ title }}</title>
+</head>
+<body>
+  <h1>{{ message }}</h1>
+  <span>{{ asdf }}</span>
+</body>
+</html>

package/tests/parts/layouts/main.handlebars

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>Example App</title>
+</head>
+<body>
+
+    {{{body}}}
+
+</body>
+</html>

package/tests/preload.cjs

@@ -0,0 +1,5 @@
+let _processExit = process.exit;
+process.exit = (...args) => {
+    console.log('process.exit', ...args);
+    // _processExit(...args);
+};

package/tests/singular.js

@@ -0,0 +1,41 @@
+const childProcess = require("child_process");
+const fs = require("fs");
+const exitHook = require("exit-hook");
+const { exit } = require("process");
+
+let args = process.argv.slice(2);
+
+let u = args.some(arg => arg === '-u');
+args = args.filter(arg => arg !== '-u');
+
+let path = args[0];
+
+if (!path) {
+    console.error('Usage: node singular.js [-u] <path>');
+    process.exit(1);
+}
+
+if (u) {
+    console.log('Running as µExpress');
+    let code = fs.readFileSync(path, 'utf8');
+    fs.writeFileSync(path, code.replace('const express = require("express");', 'const express = require("../../../src/index.js");'));
+} else {
+    let code = fs.readFileSync(path, 'utf8');
+    fs.writeFileSync(path, code.replace(`const express = require("../../../src/index.js");`, `const express = require("express");`));
+    console.log('Running as normal Express');
+}
+
+let node = childProcess.spawn('node', ['-r', './tests/preload.cjs', path]);
+
+node.stdout.on('data', data => {
+    console.log(data.toString());
+});
+
+node.stderr.on('data', data => {
+    console.error(data.toString());
+});
+
+exitHook(() => {
+    let code = fs.readFileSync(path, 'utf8');
+    fs.writeFileSync(path, code.replaceAll(`const express = require("../../../src/index.js");`, `const express = require("express");`));
+});

package/tests/tests/app/app-engine.js

@@ -0,0 +1,8 @@
+// must support app.engine()
+
+const express = require("express");
+
+const app = express();
+app.engine('asdf', function test() {});
+
+console.log(app.engines);

package/tests/tests/app/app-on-mount.js

@@ -0,0 +1,24 @@
+// must emit 'mount' when using subapp
+
+const express = require("express");
+
+const app = express();
+const student = express();
+const teacher = express();
+
+teacher.on('mount', (parent) => {
+	console.log('aaaaaaaaaaaaaaaaaaaaaaaaaa');
+});
+
+student.on('mount', (parent) => {
+	console.log('dewd');
+});
+
+app.use('/student', student);
+app.use('/teacher', teacher);
+
+app.listen(13333, (err) => {
+    console.log("Server is running on port 13333");
+    
+    process.exit(0);
+});