@universis/janitor 2.2.0 → 2.4.0

package/src/outputCacheRouter.js

@@ -0,0 +1,145 @@
+import {Router} from 'express';
+import cloneDeep from 'lodash/cloneDeep';
+import MD5 from 'crypto-js/md5';
+import { ValueFormatter } from '@themost/data';
+
+/**
+ *
+ * @param {{profiles:Map<string, import('./outputCacheRouter').OutputCachingProfile>,elements: import('./outputCacheRouter').OutputCachingElement[]}} options
+ * @returns {import('express').Router}
+ */
+function outputCache({profiles, elements}) {
+    const router = new Router();
+    // prepare regular expressions
+    const outputCacheElements = Array.isArray(elements) ? elements : [];
+    outputCacheElements.forEach((element) => {
+        if (!(element.expr instanceof RegExp)) {
+            element.expr = new RegExp('^' + element.resource, 'g');
+        }
+    });
+    router.use((req, res, next) => {
+        // only GET requests are cacheable
+        if (req.method !== 'GET') {
+            return next();
+        }
+        // if cache-control header is set to no-cache then skip caching
+        const cacheControl = req.headers['cache-control'];
+        if (cacheControl && cacheControl.includes('no-cache')) {
+            return next();
+        }
+        for (let element of outputCacheElements) {
+            if (element.expr.test(req.path)) {
+                let profile;
+                if (typeof element.profile === 'string') {
+                    profile = profiles.get(element.profile);
+                } else if (typeof element.profile === 'object') {
+                    profile = element.profile;
+                }
+                if (profile) {
+                    // clone profile to avoid mutation
+                    Object.assign(req, {
+                        outputCaching: cloneDeep(profile)
+                    });
+                }
+                return next();
+            }
+        }
+       return next();
+    });
+    router.use((req, res, next) => {
+        try {
+            const shouldCached = req.outputCaching && (req.outputCaching.location === 'any' || req.outputCaching.location === 'client');
+            if (!shouldCached) {
+                return next();
+            }
+            // determine cache location
+            let cacheLocation = req.outputCaching.location === 'any' ? 'public' : 'private';
+            if (req.headers.authorization && req.headers.authorization.length > 0) {
+                // if authorization header is present, we should not cache the response publicly
+                cacheLocation = 'private';
+            }
+            if (req.outputCaching.duration) {
+                res.setHeader('Cache-Control', `${cacheLocation}, max-age=${req.outputCaching.duration}`);
+            } else {
+                res.setHeader('Cache-Control', cacheLocation);
+            }
+            const {varyByContentEncoding, varyByHeader, varyByParam, location, duration} = req.outputCaching;
+            if (varyByContentEncoding) {
+                res.setHeader('Vary', 'Accept-Encoding');
+            }
+            const varyByReqHeader = varyByHeader || [];
+            if (varyByReqHeader.length) {
+                res.setHeader('Vary', varyByReqHeader.join(', '));
+            }
+            let varyByQueryParam = varyByParam || [];
+            if (varyByQueryParam.length === 1 && varyByQueryParam[0] === '*') {
+                varyByQueryParam = Object.keys(req.query).sort((a, b) => {
+                    if (a < b) {
+                        return -1;
+                    }
+                    if (a > b) {
+                        return 1;
+                    }
+                    return 0;
+                });
+            }
+
+            const headers = varyByReqHeader.reduce((acc, val) => {
+                acc[val] = req.get(val);
+                return acc;
+            }, {});
+
+            const params = varyByQueryParam.reduce((acc, val) => {
+                if (req.query[val]) {
+                    acc[val] = req.query[val];
+                }
+                return acc;
+            }, {});
+
+            // vary by query parameters is not supported by HTTP caching, but we can use it to create a cache key
+            const entry = {
+                path: req.path,
+                location: location,
+                contentEncoding: varyByContentEncoding,
+                headers,
+                params,
+                customParams: null,
+                duration: duration
+            };
+
+            (async () => {
+                const {varyByExpr} = req.outputCaching;
+                if (varyByExpr && typeof  varyByExpr === 'object') {
+                    // noinspection JSCheckFunctionSignatures
+                    const formatter = new ValueFormatter(req.context, null, req);
+                    entry.customParams = await formatter.format(varyByExpr);
+                }
+                return `W/"${MD5(JSON.stringify({
+                    path: entry.path,
+                    location: entry.location,
+                    contentEncoding: entry.contentEncoding,
+                    headers: entry.headers,
+                    params: entry.params,
+                    customParams: entry.customParams,
+                    duration: entry.duration,
+                })).toString()}"`;
+            })().then((entityTag) => {
+                if (req.headers['if-none-match'] === entityTag) {
+                    return res.status(304).end();
+                }
+                res.setHeader('ETag', entityTag);
+                res.setHeader('Date', new Date().toUTCString());
+                return next();
+            }).catch((err) => {
+                return next(err);
+            });
+        } catch (err) {
+            return next(err);
+        }
+    });
+    return router;
+}
+
+export {
+    outputCache
+}

package/src/outputCaching.json

@@ -0,0 +1,96 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "profiles": {
+      "type": "array",
+        "items": {
+            "type": "array",
+            "items": [
+              {
+                  "type": "string"
+              },
+              {
+                  "$ref": "#/definitions/OutputCachingProfile"
+              }
+            ]
+        }
+    },
+    "elements": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/OutputCachingElement"
+      }
+    }
+  },
+  "required": [
+    "profiles",
+    "elements"
+  ],
+  "definitions": {
+    "OutputCachingProfile": {
+      "type": "object",
+      "properties": {
+        "location": {
+          "type": "string",
+          "enum": [
+            "any",
+            "none",
+            "server",
+            "client",
+            "serverAndClient"
+          ]
+        },
+        "duration": {
+          "type": "number"
+        },
+        "varyByContentEncoding": {
+          "type": "string"
+        },
+        "varyByHeader": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "varyByParam": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "varyByExpr": {
+          "type": "object"
+        }
+      },
+      "required": [
+        "location"
+      ]
+    },
+    "OutputCachingElement": {
+      "type": "object",
+      "properties": {
+        "resource": {
+          "type": "string"
+        },
+        "expr": {
+          "type": "object"
+        },
+        "profile": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/OutputCachingProfile"
+            },
+            {
+              "type": "string"
+            }
+          ]
+        }
+      },
+      "required": [
+        "resource",
+        "profile"
+      ]
+    }
+  }
+}

package/src/validateScope.d.ts

@@ -1,2 +1,3 @@
 import { Handler } from 'express';
 export declare function validateScope(): Handler;
+export declare function validateClientScope(): Handler;

package/src/validateScope.js

@@ -1,26 +1,54 @@
 import { ScopeAccessConfiguration } from './ScopeAccessConfiguration';
 import {HttpForbiddenError} from '@themost/common';
+import {VerifyUserClientScope} from './VerifyUserClientScope';
+
+function validateClientScope() {
+    return function (req, res, next) {
+        try {
+            /**
+             * @type {VerifyUserClientScope}
+             */
+            const service = req.context.getApplication().getService(VerifyUserClientScope);
+            if (service == null) {
+                return next();
+            }
+            void service.verify(req).then(() => {
+                return next();
+            }).catch((reason) => {
+                return next(reason);
+            });
+        } catch (err) {
+            return next(err);
+        }
+    }
+}
 
 function validateScope() {
     return (req, res, next) => {
-        /**
-         * @type {ScopeAccessConfiguration}
-         */
-        let scopeAccessConfiguration = req.context.getApplication().getConfiguration().getStrategy(ScopeAccessConfiguration);
-        if (typeof scopeAccessConfiguration === 'undefined') {
-            return next(new Error('Invalid application configuration. Scope access configuration strategy is missing or is in accessible.'));
-        }
-        scopeAccessConfiguration.verify(req).then(value => {
-            if (value) {
-                return next();
+        return validateClientScope(req, res, (err) => {
+            if (err) {
+                return next(err);
+            }
+            /**
+             * @type {ScopeAccessConfiguration}
+             */
+            let scopeAccessConfiguration = req.context.getApplication().getConfiguration().getStrategy(ScopeAccessConfiguration);
+            if (typeof scopeAccessConfiguration === 'undefined') {
+                return next(new Error('Invalid application configuration. Scope access configuration strategy is missing or is in accessible.'));
             }
-            return next(new HttpForbiddenError('Access denied due to authorization scopes.'))
-        }).catch(reason => {
-            return next(reason);
+            scopeAccessConfiguration.verify(req).then(value => {
+                if (value) {
+                    return next();
+                }
+                return next(new HttpForbiddenError('Access denied due to authorization scopes.'))
+            }).catch(reason => {
+                return next(reason);
+            });
         });
     };
 }
 
 export {
-    validateScope
+    validateScope,
+    validateClientScope
 }