npm - slower - Versions diffs - 2.1.8 → 2.2.0 - Mend

slower 2.1.8 → 2.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/README.md +386 -0
package/examples/router.js +45 -0
package/examples/subrouter.js +29 -0
package/examples/third-party-middlewares.js +88 -0
package/package.json +11 -15
package/src/decorators.js +3 -7
package/src/slower.js +167 -134
package/src/utils.js +52 -32
package/readme.md.old +0 -180

package/src/utils.js CHANGED Viewed

@@ -1,65 +1,85 @@
-const { statSync, readdirSync } = require('node:fs')
+const { statSync, readdirSync } = require('node:fs');
 const { join } = require('node:path');
 const { parse } = require('node:querystring');
+const { URLPattern } = require('node:url');
 function* getFiles(folder) {
     const files = readdirSync(folder);
     for (const file of files) {
-        const absolutePath = join(folder, file)
+        const absolutePath = join(folder, file);
         if (statSync(absolutePath).isDirectory()) {
-            yield* getFiles(absolutePath)
-        }
-        else {
-            yield absolutePath.replaceAll('..\\','')
+            yield* getFiles(absolutePath);
+        } else {
+            yield absolutePath.replaceAll('..\\', '');
         }
     }
 }
+// This is added to all URLPattern objects, to avoid having it complaining about the
+// absolute URL. As this IP is invalid, it is virtually impossible to receive a request with
+// that origin URL.
+const URL_PATTERN_PREFIX = 'https://0';
+// Wrap the native URLPattern function and add the custom local prefix
+const buildURLPatternFunction = template_url => {
+    const matcher = new URLPattern(template_url, URL_PATTERN_PREFIX);
+    return function (url) {
+        return matcher.test(URL_PATTERN_PREFIX + url) ?
+                matcher.exec(URL_PATTERN_PREFIX + url)
+            :   null;
+    };
+};
 const getMatchingRoute = (url, method, layers) => {
     method = method.toLowerCase();
     let list = [];
     // Get only the layers from the proper HTTP verb
     let routes = layers.get(method) || new Map();
     // Iterate through all routes, and get the one that match
-    for (let [ pathFn, callback ] of routes) {
-        let params = pathFn(getURLPathBody(url));
+    for (let [pathFn, callback] of routes) {
+        let parsed = pathFn(getURLPathBody(url));
         // Return the matching route
-        if (!!params) {
+        if (parsed) {
             // add to list
-            let built = ({ callback });
-            if (params.params && params.params['0'] === undefined)
-                built['params'] = params.params;
+            let built = { callback, params: {} };
+            // Only if the first key in the group is not undefined and not '0'
+            if (parsed?.pathname?.groups && !parsed?.pathname?.groups?.['0'])
+                built['params'] = parsed.pathname.groups;
             list.push(built);
         }
     }
     return list;
-}
+};
-const normalizeAddress = addr => addr.startsWith('::') ? addr : addr.substring(addr.indexOf(':',2)+1);
+const normalizeAddress = addr =>
+    addr.startsWith('::') ? addr : addr.substring(addr.indexOf(':', 2) + 1);
-const getFileExtension = (fname) => fname.split('.').filter(Boolean).slice(-1)[0];
+const getFileExtension = fname => fname.split('.').filter(Boolean).slice(-1)[0];
 // /page?foo=bar&abc=123    ->  /page
 const getURLPathBody = (urlPath = '') => urlPath.split('?')[0] || '';
 // /page?foo=bar&abc=123    ->  { foo: 'bar', abc: '123' }
-const getURLQueryString = (urlPath = '') => parse((urlPath.split('?')[1] || '').split('#')[0]);
+const getURLQueryString = (urlPath = '') =>
+    parse((urlPath.split('?')[1] || '').split('#')[0]);
-const noLayersFoundFallback = (req, res) =>
-    res.status(404).send(
-        `<!DOCTYPE html><html lang="en"><head><meta charset="utf-8">` +
-        `<title>Error</title></head><body>` +
-        `<pre>Cannot ${req.method.toUpperCase()} ${req.url}</pre></body></html>`
-    )
-;
+const noLayersFoundFallback = (req, res) =>
+    res
+        .status(404)
+        .send(
+            `<!DOCTYPE html><html lang="en"><head><meta charset="utf-8">` +
+                `<title>Error</title></head><body>` +
+                `<pre>Cannot ${req.method.toUpperCase()} ${
+                    req.url
+                }</pre></body></html>`
+        );
-module.exports = {
-    getMatchingRoute,
-    getFiles,
-    normalizeAddress,
-    getFileExtension,
-    getURLPathBody,
+module.exports = {
+    buildURLPatternFunction,
+    getMatchingRoute,
+    getFiles,
+    normalizeAddress,
+    getFileExtension,
+    getURLPathBody,
     getURLQueryString,
-    noLayersFoundFallback
-};
+    noLayersFoundFallback,
+};

package/readme.md.old DELETED Viewed

@@ -1,180 +0,0 @@
-# Slower
-Slower is a small web framework, express-like, but simpler and limited.
-It allows for generic route-declaration, fallback pages, and multiple middleware functions.
-### API Methods:
-```
-app.enableStrictHeaders(): this
-> Enables the use of the set of 'Strict Headers'.
-> These headers increase security levels, and are a good practice to apply.
-> However, using these headers in testing scenarios are not a need,
-  and may have buggy or negative effects. So, apply those to simulate scenarios only.
-> Headers configured:
-    > Content-Security-Policy
-    > Cross-Origin-Opener-Policy
-    > Cross-Origin-Resource-Policy
-    > Origin-Agent-Cluster
-    > Referrer-Policy
-    > X-DNS-Prefetch-Control (disabled)
-    > X-Download-Options
-    > X-Frame-Options
-    > X-XSS-Protection (disabled)
-    > X-Powered-By (removed)
-> Returns the own object instance, so that methods can be chained.
-```
-```
-app.disableStrictHeaders(): this
-> Disables the use of the set of 'Strict Headers'.
-> See 'enableStrictHeaders()' for more information.
-> Returns the own object instance, so that methods can be chained.
-```
-```
-app.setRoute(string: path = '/', string: type = 'GET', function: callback): this
-> Creates a new route for path defined in 'path', responding to the HTTP verb defined in 'type' argument.
-> The callback is executed when the route is accessed.
-> Returns the own object instance, so that methods can be chained.
-```
-```
-app.setMiddleware(function: callback): this
-> Sets a new middleware function: callback function will be accessed for every server access.
-> Many middlewares can be defined, and will be applied in the order they are defined.
-> Returns the own object instance, so that methods can be chained.
-```
-```
-app.setDynamic(string: path, string: file = '', string: mime = '', object: replacementData = null): this
-> Creates a new GET route for path defined in 'path'.
-> This is a custom file-response route, configured for template rendering just before response.
-> Providing an object as 'replacementData' in this format { valueToBeReplaced: valueToReplace },
-  allows for template rendering. The value to replace in the file, uses this notation: '<{content}>'.
-> URL reference in filename:
-    > For direct references, it is possible to use the token '{%}' to replace the filename for the URL.
-    > Ex:
-        app.setStatic('/login', './templates/{%}.html', 'text/html');
-        This will access the 'login.html' file when the route '/login' is accessed.
-> Example:
-  Responding a route for '/custom' with file 'custom.html':
-    app.setDynamic('/custom', './templates/custom.html', 'text/html', { smile: ':)' })
-  In file './templates/custom.html':
-    "<h2> This is a custom thing:        <{smile}>      </h2>"
-  Rendered in browser:
-    <h2> This is a custom thing:        :)      </h2>
-> Returns the own object instance, so that methods can be chained.
-```
-```
-app.setStatic(string: path, string: file = '', string: mime = ''): this
-> Creates a new GET route for path defined in 'path', responding with the specified file and MIME type.
-> URL reference in filename:
-    > For direct references, it is possible to use the token '{%}' to replace the filename for the URL.
-    > Ex:
-        app.setStatic('/login', './templates/{%}.html', 'text/html');
-        This will access the 'login.html' file when the route '/login' is accessed.
-> Example: A route for '/login' page, responding with 'login.html' file
-    setStatic('/login', __dirname+'/public/static/views/login.html', 'text/html');
-> Returns the own object instance, so that methods can be chained.
-```
-```
-app.setFallback(function: callback): this
-> Creates a function for fallback state. When no other routes intercept the route, this will be used.
-> Special use for 'page not found' fallback pages or highly customized routes and situations.
-> Returns the own object instance, so that methods can be chained.
-```
-```
-app.setFallbackFile (string: file = '', string: mime = '', object: replacementData = null): this
-> Creates a function for fallback state. When no other routes intercept the route, this will be used.
-> Equivalent to setFallback, but responds with a file. Allows for template rendering.
-> See 'setDynamic' for more information about template rendering.
-> Special use for 'page not found' fallback pages, ex: './e404.html'.
-> Returns the own object instance, so that methods can be chained.
-```
-```
-app.setAllowedMethods(array: methods = []): this
-> Sets a list of methods to respond to.
-> By using this, it is possible to restrict the application to avoid
-  responding to dangerous HTTP verbs, such as 'DELETE'.
-> By default, all methods are allowed (see Slower.constructor.http_methods)
-> Calling this function without parameters is an easy way to block responses to all requests (lock server).
-> Returns the own object instance, so that methods can be chained.
-```
-```
-app.start(number|string: port = 8080, string: host = undefined, function: callback = ()=>{}): this
-> Starts the server, at a specific host and port, then calling the callback function.
-> Not defining a specific port or host will start the server at '0.0.0.0:8080'.
-> Returns the own object instance, so that methods can be chained.
-```
-Example usage:
-```
-const Slower = require('slower');
-const port = 8080;
-let app = Slower();
-app.setMiddleware((req, res) => {
-    req.time = Date.now();
-    console.log(`${req.time} - ${req.method} : ${req.url}`);
-});
-app.setStatic('/favicon.ico', __dirname+'/public/{%}');
-app.setRoute('/', 'GET', (req, res) => {
-    res.writeHead(200, { 'Content-Type': 'text/html' });
-    res.write('<html><body><p>This is the / page.</p></body></html>');
-    res.end();
-});
-app.setRoute('/{*}.css', 'GET', (req, res) => {
-    let data = fs.readFileSync(...some.css.file...)
-    res.writeHead(200, { 'Content-Type': 'text/css' });
-    res.write(data);
-    res.end();
-});
-const generateDownloadNumber = () => { Math.round(Math.random() * 10) }
-app.setDynamic('/download/{?}/', './main-download.txt', { DowloadName: generateDownloadNumber });
-// Responds to download routes such as '/download/2/'
-app.setFallback((req, res) => {
-    res.writeHead(200, { 'Content-Type': 'text/html' });
-    res.write('<html><body><p>This is the fallback page.</p></body></html>');
-    res.end();
-});
-// Start app listening on all interfaces (0.0.0.0)
-app.start(port, null, () => {
-    console.log(`Running on localhost:${port}`);
-    console.log(app);
-});
-```
-### API modifications on 'net.Socket' instances:
- - The API modifies every ```net.Socket``` instance BEFORE it is passed
-to ```app.connectionListener```. This means that all events receiving
-a socket will receive the modified socket instead.
- - The modifications adds the following properties to the socket instance:
-```
- <socket>.session: Object           => A container for persistent data appended to sockets
- <socket>.session.port: Number      => The local port number
- <socket>.session.rport: Number     => The remote port number
- <socket>.session.host: String      => The local host interface address
- <socket>.session.rhost: String     => The remote host interface address
-```
-- It is possible to use the ```socket.session``` object to append data that will persist
-during the lifetime of a single connection. Useful for keeping short-life local variables.
-- In HTTP ```http.IncomingMessage``` instances, the 'socket' instance is found over 'request'.
-So, considering the common callback of ```(req, res)```, the session container will be ```req.session```
-### API security headers implementation:
- - It is possible to enforce a higher set of security headers on responses
-   without having to set them manually. The API 'enableStrictHeaders' and 'disableStrictHeaders'
-   methods do exacly that. The strict headers are disabled by default, as some resources are too strict,
-   but it is also possible to enable them all, and then set a middleware to override any header.
- - Headers set by 'enableStrictHeaders':
-```
-    Content-Security-Policy: default-src=none; script-src=self; connect-src=self; img-src=self;
-        style-src=self; frame-ancestors=none; form-action=self;
-    Cross-Origin-Opener-Policy:  same-origin
-    Cross-Origin-Resource-Policy: same-site
-    Origin-Agent-Cluster: ?1
-    Referrer-Policy: no-referrer
-    Strict-Transport-Security: max-age=31536000; includeSubDomains // temporarily disabled for maintenance
-    X-Content-Type-Options: nosniff // temporarily disabled for maintenance
-    X-DNS-Prefetch-Control: off
-    X-Download-Options: noopen
-    X-Frame-Options: DENY
-    X-Powered-By: (This header is removed if a response includes it)
-    X-XSS-Protection: 0
-```