ultimate-express 1.0.0

package/tests/tests/middlewares/cookie-parser.js

@@ -0,0 +1,28 @@
+// must support cookie parser
+
+const express = require("express");
+const cookieParser = require("cookie-parser");
+
+const app = express();
+
+app.use(cookieParser());
+
+app.get('/abc', (req, res) => {
+    console.log(req.cookies);
+    res.send('ok');
+});
+
+app.listen(13333, async () => {
+    console.log('Server is running on port 13333');
+
+    await Promise.all([
+        fetch('http://localhost:13333/abc', {
+            headers: {
+                'Cookie': 'abc=123; def=456'
+            }
+        }).then(res => res.text())
+    ]);
+
+    process.exit(0);
+
+});

package/tests/tests/middlewares/cookie-session.js

@@ -0,0 +1,40 @@
+// must support cookie-session middleware
+
+const express = require("express");
+const cookieSession = require('cookie-session');
+
+const app = express();
+
+app.use(cookieSession({
+    name: 'session',
+    keys: ["test"],
+  
+    // Cookie Options
+    maxAge: 24 * 60 * 60 * 1000 // 24 hours
+}));
+
+app.get('/abc', (req, res) => {
+    req.session.views = (req.session.views || 0) + 1;
+    res.status(202).send(`Viewed ${req.session.views} times.`);
+});
+
+app.listen(13333, async () => {
+    console.log('Server is running on port 13333');
+
+    const response = await fetch('http://localhost:13333/abc');
+    const sessionCookie = response.headers.get('Set-Cookie').match(/session=(.*?);/)[1];
+    const sessionSig = response.headers.get('Set-Cookie').match(/session.sig=(.*?);/)[1];
+    const text = await response.text();
+    console.log(text, sessionCookie, sessionSig, response.status);
+
+    const response2 = await fetch('http://localhost:13333/abc', {
+        headers: {
+            'Cookie': `session=${sessionCookie}; session.sig=${sessionSig}`
+        }
+    });
+    const text2 = await response2.text();
+    console.log(text2);
+
+    process.exit(0);
+
+});

package/tests/tests/middlewares/cors.js

@@ -0,0 +1,29 @@
+// must support cors middleware
+
+const express = require("express");
+const cors = require("cors");
+
+const app = express();
+
+app.get('/abc', cors(), (req, res) => {
+    res.send('1');
+});
+
+app.get('/def', cors({
+    origin: 'http://example.com',
+}), (req, res) => {
+    res.send('2');
+});
+
+app.listen(13333, async () => {
+    console.log('Server is running on port 13333');
+
+    const response = await fetch('http://localhost:13333/abc');
+    console.log(response.headers.get('access-control-allow-origin'));
+
+    const response2 = await fetch('http://localhost:13333/def');
+    console.log(response2.headers.get('access-control-allow-origin'));
+
+    process.exit(0);
+
+});

package/tests/tests/middlewares/errorhandler.js

@@ -0,0 +1,26 @@
+// must support errorhandler middleware
+
+const express = require("express");
+const errorhandler = require('errorhandler')
+
+const app = express();
+
+app.get('/abc', (req, res) => {
+    throw new Error('test');
+    res.send(req.body);
+});
+
+app.use(errorhandler({
+    log: (err) => {
+        console.log(`hi`, err.message);
+    }
+}));
+
+app.listen(13333, async () => {
+    console.log('Server is running on port 13333');
+
+    const response = await fetch('http://localhost:13333/abc');
+
+    process.exit(0);
+
+});

package/tests/tests/middlewares/express-fileupload-temp.js

@@ -0,0 +1,46 @@
+// must support express-fileupload middleware with temp file
+
+const express = require("express");
+const fileUpload = require("express-fileupload");
+const fs = require("fs");
+
+const app = express();
+
+app.post('/file', fileUpload({
+    tempFileDir: './tmp',
+    useTempFiles: true,
+    debug: false
+}), (req, res) => {
+    req.files.file.mv('./tmp/test.txt');
+    res.send(req.files.file.size.toString());
+});
+
+app.listen(13333, async () => {
+    console.log('Server is running on port 13333');
+
+    const formData = new FormData();
+    console.log('creating file');
+    const arr = new Uint8Array(1024 * 256); // 256 KB
+    console.log('filling file');
+    for (let i = 0; i < arr.length; i++) {
+        arr[i] = i % 256;
+    }
+    console.log('appending file');
+    const file = new File(arr, 'test.txt');
+    formData.append('file', file);
+
+    console.log('sending request');
+    const response = await fetch('http://localhost:13333/file', {
+        method: 'POST',
+        body: formData
+    });
+    console.log('response', response.status);
+    const text = await response.text();
+    console.log(text);
+
+    console.log('temp file', fs.statSync('./tmp/test.txt').size);
+    fs.rmSync('./tmp', { recursive: true, force: true });
+
+    process.exit(0);
+
+});

package/tests/tests/middlewares/express-fileupload.js

@@ -0,0 +1,28 @@
+// must support express-fileupload middleware
+
+const express = require("express");
+const fileUpload = require("express-fileupload");
+
+const app = express();
+
+app.post('/file', fileUpload(), (req, res) => {
+    res.send(req.files);
+});
+
+app.listen(13333, async () => {
+    console.log('Server is running on port 13333');
+
+    const formData = new FormData();
+    const file = new File([1, 2, 3], 'test.txt');
+    formData.append('file', file);
+
+    const response = await fetch('http://localhost:13333/file', {
+        method: 'POST',
+        body: formData
+    });
+    const text = await response.text();
+    console.log(text);
+
+    process.exit(0);
+
+});

package/tests/tests/middlewares/express-rate-limit.js

@@ -0,0 +1,33 @@
+// must support express-rate-limit middleware
+
+const express = require("express");
+const { rateLimit } = require('express-rate-limit');
+
+const app = express();
+
+app.use(rateLimit({
+	windowMs: 15 * 60 * 1000, // 15 minutes
+	limit: 1, 
+    legacyHeaders: true,
+    handler: (req, res, next) => {
+        console.log('Too Many Requests called');
+        res.status(429).send('Too Many Requests');
+    }
+}));
+
+app.get('/abc', (req, res) => {
+    res.send('Hello World');
+});
+
+app.listen(13333, async () => {
+    console.log('Server is running on port 13333');
+
+    const response = await fetch('http://localhost:13333/abc');
+    console.log(await response.text());
+
+    const response2 = await fetch('http://localhost:13333/abc');
+    console.log(await response2.text(), response2.headers.get('X-RateLimit-Limit'), response2.headers.get('X-RateLimit-Remaining'));
+
+    process.exit(0);
+
+});

package/tests/tests/middlewares/express-session.js

@@ -0,0 +1,37 @@
+// must support express-session middleware
+
+const express = require("express");
+const session = require('express-session');
+
+const app = express();
+
+app.use(session({
+    secret: 'keyboard cat',
+    resave: false,
+    saveUninitialized: true
+}));
+
+app.get('/abc', (req, res) => {
+    req.session.views = (req.session.views || 0) + 1;
+    res.status(202).send(`Viewed ${req.session.views} times.`);
+});
+
+app.listen(13333, async () => {
+    console.log('Server is running on port 13333');
+
+    const response = await fetch('http://localhost:13333/abc');
+    const cookie = response.headers.get('Set-Cookie').match(/connect.sid=(.*?);/)[1];
+    const text = await response.text();
+    console.log(text, response.status);
+
+    const response2 = await fetch('http://localhost:13333/abc', {
+        headers: {
+            'Cookie': `connect.sid=${cookie}`
+        }
+    });
+    const text2 = await response2.text();
+    console.log(text2);
+
+    process.exit(0);
+
+});

package/tests/tests/middlewares/express-static-options.js

@@ -0,0 +1,72 @@
+// must support express.static() options
+
+const express = require("express");
+
+const app = express();
+
+app.post('/abc', (req, res) => {
+    res.send('ok');
+});
+app.use('/static', express.static('tests/parts'));
+app.use('/static2', express.static('tests/parts', { redirect: false }));
+app.use('/static3', express.static('tests/parts', { index: 'index.pug' }));
+app.use('/static4', express.static('tests/parts', { dotfiles: 'allow' }));
+app.use('/static5', express.static('tests/parts', { dotfiles: 'deny' }));
+app.use('/static6', express.static('tests/parts', { dotfiles: 'ignore' }));
+app.use('/static7', express.static('tests/parts', { fallthrough: false }));
+app.use('/static8', express.static('tests/parts', { etag: false }));
+app.use('/static9', express.static('tests/parts', { extensions: ['jpg'] }));
+app.use('/static10', express.static('tests/parts', { setHeaders: (res, path, stat) => {
+    console.log(path, stat.size);
+    res.set('X-Test', 'test');
+} }));
+
+app.use((err, req, res, next) => {
+
+    res.status(500).send(err);
+});
+
+app.use((req, res, next) => {
+
+    res.status(404).send('404');
+});
+
+app.listen(13333, async () => {
+    console.log('Server is running on port 13333');
+
+    const response = await fetch('http://localhost:13333/static', { redirect: 'manual' });
+    console.log(response.status, response.headers.get('Location'));
+
+    const response2 = await fetch('http://localhost:13333/static2', { redirect: 'manual' });
+    console.log(response2.status, response2.headers.get('Location'));
+
+    const response3 = await fetch('http://localhost:13333/static3');
+    console.log(response3.status);
+
+    const response4 = await fetch('http://localhost:13333/static4/.test/index.html');
+    console.log(response4.status, (await response4.text()).slice(0, 100));
+
+    const response5 = await fetch('http://localhost:13333/static5/.test/index.html');
+    console.log(response5.status, await response5.text());
+
+    const response6 = await fetch('http://localhost:13333/static6/.test/index.html');
+    console.log(response6.status, await response6.text());
+
+    const response7 = await fetch('http://localhost:13333/static7/assgdgeerdf.html');
+    console.log(response7.status, (await response7.text()).includes('ENOENT'));
+
+    const response8 = await fetch('http://localhost:13333/static8/index.html');
+    console.log(response8.headers.get('ETag'));
+
+    const response9 = await fetch('http://localhost:13333/static/index.html');
+    console.log(response9.headers.get('ETag'));
+
+    const response10 = await fetch('http://localhost:13333/static9/big');
+    console.log(response10.status, response10.headers.get('Content-Type'));
+
+    const response11 = await fetch('http://localhost:13333/static10/index.html');
+    console.log(response11.headers.get('X-Test'));
+
+    process.exit(0);
+
+});

package/tests/tests/middlewares/express-static.js

@@ -0,0 +1,40 @@
+// must support express.static()
+
+const express = require("express");
+
+const app = express();
+
+app.post('/abc', (req, res) => {
+    res.send('ok');
+});
+app.use('/static', (req, res, next) => {
+    express.static('src')(req, res, e => {
+        console.log('caught', e);
+        next();
+    });
+});
+
+app.use('/static', express.static('tests/parts'));
+
+app.use((req, res, next) => {
+    res.status(404).send('404');
+});
+
+app.listen(13333, async () => {
+    console.log('Server is running on port 13333');
+
+    const responses = await Promise.all([
+        fetch('http://localhost:13333/abc'),
+        fetch('http://localhost:13333/static/workers'),
+        fetch('http://localhost:13333/static/'),
+        fetch('http://localhost:13333/static/index.js?1'),
+        fetch('http://localhost:13333/static/../package.json'),
+    ]);
+
+    const texts = await Promise.all(responses.map(r => r.text()));
+
+    console.log(texts.map(t => t.slice(0, 30)));
+
+    process.exit(0);
+
+});

package/tests/tests/middlewares/method-override.js

@@ -0,0 +1,33 @@
+// must support method-override middleware
+
+const express = require("express");
+const methodOverride = require("method-override");
+
+const app = express();
+
+app.use(methodOverride('X-HTTP-Method-Override'));
+
+app.post('/abc', (req, res) => {
+    res.send(req.method+'1');
+});
+
+app.use((req, res, next) => {
+    res.send(req.method+'2');
+});
+
+app.listen(13333, async () => {
+    console.log('Server is running on port 13333');
+
+    const response = await fetch('http://localhost:13333/abc', {
+        method: 'GET',
+        headers: {
+            'X-HTTP-Method-Override': 'POST',
+        },
+    });
+
+    const text = await response.text();
+    console.log(text);
+
+    process.exit(0);
+
+});

package/tests/tests/middlewares/multer.js

@@ -0,0 +1,43 @@
+// must support multer middleware
+
+const express = require("express");
+const multer = require("multer");
+
+const app = express();
+const upload = multer();
+
+app.post('/abc', upload.none(), (req, res) => {
+    res.send(req.body);
+});
+
+app.post('/file', upload.single('file'), (req, res) => {
+    res.send(req.file);
+});
+
+app.listen(13333, async () => {
+    console.log('Server is running on port 13333');
+
+    const formData = new FormData();
+    formData.append('abc', '123');
+
+    const response = await fetch('http://localhost:13333/abc', {
+        method: 'POST',
+        body: formData
+    });
+    const text = await response.text();
+    console.log(text);
+
+    const formData2 = new FormData();
+    const file = new File([1, 2, 3], 'test.txt');
+    formData2.append('file', file);
+
+    const response2 = await fetch('http://localhost:13333/file', {
+        method: 'POST',
+        body: formData2
+    });
+    const text2 = await response2.text();
+    console.log(text2);
+
+    process.exit(0);
+
+});

package/tests/tests/middlewares/multiple-middlewares.js

@@ -0,0 +1,37 @@
+// must support multiple middlewares
+
+const express = require("express");
+const bodyParser = require("body-parser");
+const fileUpload = require("express-fileupload");
+
+const app = express();
+
+
+app.post('/abc', bodyParser.raw(), fileUpload(), (req, res) => {
+    console.log(req.body, req.files);
+    res.send('ok');
+});
+
+app.listen(13333, async () => {
+    console.log('Server is running on port 13333');
+
+    const formData = new FormData();
+    console.log('creating file');
+    const arr = [...new Array(1024 * 32)].map((_, i) => i % 256); // 32 KB
+    const file = new File(arr, 'test.txt');
+    console.log('appending file');
+    formData.append('file', file);
+    formData.append('text', 'hello');
+    console.log('sending request');
+
+    const response = await fetch('http://localhost:13333/abc', {
+        method: 'POST',
+        body: formData
+    });
+    console.log('reading response');
+    const text = await response.text();
+    console.log(text);
+
+    process.exit(0);
+
+});

package/tests/tests/middlewares/response-time.js

@@ -0,0 +1,29 @@
+// must support response-time middleware
+
+const express = require("express");
+const responseTime = require("response-time");
+
+const app = express();
+
+app.use(responseTime((req, res, time) => {
+    console.log(typeof time);
+}));
+
+app.post('/abc', (req, res) => {
+    res.send('1');
+});
+
+app.listen(13333, async () => {
+    console.log('Server is running on port 13333');
+
+    const response = await fetch('http://localhost:13333/abc', {
+        method: 'POST',
+        body: 'abc',
+    });
+
+    const text = await response.text();
+    console.log(text);
+
+    process.exit(0);
+
+});

package/tests/tests/middlewares/serve-index.js

@@ -0,0 +1,38 @@
+// must support serve index
+
+const express = require("express");
+const serveStatic = require("serve-static");
+const serveIndex = require("serve-index");
+
+const app = express();
+
+app.use('/static', serveStatic('src'), (req, res, next) => {
+    serveIndex('src')(req, res, next);
+});
+
+app.get('/static/asdf', (req, res, next) => {
+    res.send(req.url);
+});
+
+app.use((req, res, next) => {
+    res.status(404).send('404');
+});
+
+app.listen(13333, async () => {
+    console.log('Server is running on port 13333');
+
+    const responses = await Promise.all([
+        fetch('http://localhost:13333/abc'),
+        fetch('http://localhost:13333/static'),
+        fetch('http://localhost:13333/static/workers'),
+        fetch('http://localhost:13333/static/index.js'),
+        fetch('http://localhost:13333/static/../package.json'),
+    ]);
+
+    const texts = await Promise.all(responses.map(r => r.text()));
+
+    console.log(texts.map(i => i.slice(0, 100)));
+
+    process.exit(0);
+
+});

package/tests/tests/middlewares/serve-static.js

@@ -0,0 +1,38 @@
+// must support serve static
+
+const express = require("express");
+const serveStatic = require("serve-static");
+
+const app = express();
+
+app.post('/abc', (req, res) => {
+    res.send('ok');
+});
+app.use('/static', (req, res, next) => {
+    serveStatic('src')(req, res, () => {
+        console.log('caught');
+        next();
+    });
+});
+
+app.use((req, res, next) => {
+    res.status(404).send('404');
+});
+
+app.listen(13333, async () => {
+    console.log('Server is running on port 13333');
+
+    const responses = await Promise.all([
+        fetch('http://localhost:13333/abc'),
+        fetch('http://localhost:13333/static/workers'),
+        fetch('http://localhost:13333/static/index.js'),
+        fetch('http://localhost:13333/static/../package.json'),
+    ]);
+
+    const texts = await Promise.all(responses.map(r => r.text()));
+
+    console.log(texts);
+
+    process.exit(0);
+
+});

package/tests/tests/middlewares/vhost.js

@@ -0,0 +1,50 @@
+// must support vhost middleware
+
+const net = require("net");
+
+async function sendRequest(method, url, customHost) {
+    // arrayHeaders is an array of [key, value] pairs
+    return new Promise((resolve, reject) => {
+        const client = new net.Socket();
+        const [host, port] = url.split('://')[1].split('/')[0].split(':');
+        const path = '/' + url.split('/').slice(3).join('/');
+
+        client.connect(parseInt(port), host, () => {
+            let request = `${method} ${path} HTTP/1.1\r\n`;
+            request += `Host: ${customHost}\r\n`;
+            
+            request += '\r\n';
+
+            client.on('data', (data) => {
+                resolve(data.toString().split('\r\n\r\n')[1]);
+            });
+            
+            client.write(request);
+
+        });
+    });
+}
+
+const express = require("express");
+const vhost = require("vhost");
+
+const app = express();
+
+app.use(vhost('*.example.com', (req, res) => {
+    res.send('Hello from example.com');
+}));
+
+app.get('/abc', (req, res) => {
+    res.send('hi');
+});
+
+app.listen(13333, async () => {
+    console.log('Server is running on port 13333');
+
+    console.log(await sendRequest('GET', 'http://localhost:13333/abc', 'example.com'));
+    console.log(await sendRequest('GET', 'http://localhost:13333/abc', 'sub.example.com'));
+    console.log(await sendRequest('GET', 'http://localhost:13333/abc', 'localhost.com'));
+
+    process.exit(0);
+
+});