@universis/janitor 1.9.0 → 1.11.0

package/src/RateLimitService.js

@@ -2,6 +2,7 @@ import { ApplicationService, TraceUtils } from '@themost/common';
 import { rateLimit } from 'express-rate-limit';
 import express from 'express';
 import path from 'path';
+import { BehaviorSubject } from 'rxjs';
 
 export class RateLimitService extends ApplicationService {
     /**
@@ -9,87 +10,71 @@ export class RateLimitService extends ApplicationService {
      */
     constructor(app) {
         super(app);
-        app.serviceRouter.subscribe(serviceRouter => {
-            if (serviceRouter == null) {
+
+        // get proxy address forwarding option
+        const proxyAddressForwarding = app.getConfiguration().getSourceAt('settings/universis/api/proxyAddressForwarding');
+        this.proxyAddressForwarding = typeof proxyAddressForwarding !== 'boolean'? false : proxyAddressForwarding; 
+
+        /**
+         * @type {BehaviorSubject<{ target: RateLimitService }>}
+         */
+        this.loaded = new BehaviorSubject(null);
+
+        const serviceContainer = this.getServiceContainer();
+        if (serviceContainer == null) {
+            TraceUtils.warn(`${this.getServiceName()} is being started but the parent router seems to be unavailable.`);
+            return;
+        }
+        serviceContainer.subscribe((router) => {
+            if (router == null) {
                 return;
             }
             try {
-                const addRouter = express.Router();
-                let serviceConfiguration = app.getConfiguration().getSourceAt('settings/universis/janitor/rateLimit') || {
-                    profiles: [],
-                    paths: []
-                };
-                if (serviceConfiguration.extends) {
-                    // get additional configuration
-                    const configurationPath = app.getConfiguration().getConfigurationPath();
-                    const extendsPath = path.resolve(configurationPath, serviceConfiguration.extends);
-                    TraceUtils.log(`@universis/janitor#RateLimitService will try to extend service configuration from ${extendsPath}`);
-                    serviceConfiguration = require(extendsPath);
-                }
-                const pathsArray = serviceConfiguration.paths || [];
-                const profilesArray = serviceConfiguration.profiles || [];
+                // set router for further processing
+                Object.defineProperty(this, 'router', {
+                    value: express.Router(),
+                    writable: false,
+                    enumerable: false,
+                    configurable: true
+                });
+                const serviceConfiguration = this.getServiceConfiguration();
                 // create maps
-                const paths = new Map(pathsArray);
-                const profiles = new Map(profilesArray);
+                const paths = serviceConfiguration.paths;
                 if (paths.size === 0) {
-                    TraceUtils.warn('@universis/janitor#RateLimitService is being started but the collection of paths is empty.');
-                }
-                // get proxy address forwarding option
-                let proxyAddressForwarding = app.getConfiguration().getSourceAt('settings/universis/api/proxyAddressForwarding');
-                if (typeof proxyAddressForwarding !== 'boolean') {
-                    proxyAddressForwarding = false;
+                    TraceUtils.warn(`${this.getServiceName()} is being started but the collection of paths is empty.`);
                 }
                 paths.forEach((value, path) => {
-                    let profile;
-                    // get profile
-                    if (value.profile) {
-                        profile = profiles.get(value.profile);
-                    } else {
-                        // or options defined inline
-                        profile = value
-                    }
-                    if (profile != null) {
-                        const rateLimitOptions = Object.assign({
-                            windowMs: 5 * 60 * 1000, // 5 minutes
-                            limit: 50, // 50 requests
-                            legacyHeaders: true // send headers
-                        }, profile, {
-                            keyGenerator: (req) => {
-                                let remoteAddress;
-                                if (proxyAddressForwarding) {
-                                    // get proxy headers or remote address
-                                    remoteAddress = req.headers['x-real-ip'] || req.headers['x-forwarded-for'] || (req.connection ? req.connection.remoteAddress : req.socket.remoteAddress);
-                                } else {
-                                    // get remote address
-                                    remoteAddress = (req.connection ? req.connection.remoteAddress : req.socket.remoteAddress);
-                                }
-                                return `${path}:${remoteAddress}`;
-                            }
+                    this.set(path, value);
+                });
+                if (router.stack) {
+                        router.stack.unshift.apply(router.stack, this.router.stack);
+                } else {
+                    // use router
+                    router.use(this.router);
+                    // get router stack (use a workaround for express 4.x)
+                    const stack = router._router && router._router.stack;
+                    if (Array.isArray(stack)) {
+                        // stage #1 find logger middleware (for supporting request logging)
+                        let index = stack.findIndex((item) => {
+                            return item.name === 'logger';
                         });
-                        if (typeof rateLimitOptions.store === 'string') {
-                            // load store
-                            const store = rateLimitOptions.store.split('#');
-                            let StoreClass;
-                            if (store.length === 2) {
-                                const storeModule = require(store[0]);
-                                if (Object.prototype.hasOwnProperty.call(storeModule, store[1])) {
-                                    StoreClass = storeModule[store[1]];
-                                    rateLimitOptions.store = new StoreClass(this, rateLimitOptions);
-                                } else {
-                                    throw new Error(`${store} cannot be found or is inaccessible`);
-                                }
-                            } else {
-                                StoreClass = require(store[0]);
-                                // create store
-                                rateLimitOptions.store = new StoreClass(this, rateLimitOptions);
-                            }
+                        if (index === -1) {
+                            // stage #2 find expressInit middleware
+                            index = stack.findIndex((item) => {
+                                return item.name === 'expressInit';
+                            });
+                        }
+                        // if found, move the last middleware to be after expressInit
+                        if (index > -1) {
+                            // move the last middleware to be after expressInit
+                            stack.splice(index + 1, 0, stack.pop());
                         }
-                        addRouter.use(path, rateLimit(rateLimitOptions));
+                    } else {
+                        TraceUtils.warn(`${this.getServiceName()} is being started but the container stack is not available.`);
                     }
-                });
-                if (addRouter.stack.length) {
-                    serviceRouter.stack.unshift.apply(serviceRouter.stack, addRouter.stack);
                 }
+                // notify that the service is loaded
+                this.loaded.next({ target: this });
             } catch (err) {
                 TraceUtils.error('An error occurred while validating rate limit configuration.');
                 TraceUtils.error(err);
@@ -98,4 +83,150 @@ export class RateLimitService extends ApplicationService {
         });
     }
 
+    /**
+     * Returns the service router that is used to register rate limit middleware.
+     * @returns {import('rxjs').BehaviorSubject<import('express').Router | import('express').Application>} The service router.
+     */
+    getServiceContainer() {
+        return this.getApplication() && this.getApplication().serviceRouter;
+    }
+
+    /**
+     * Returns the service name.
+     * @returns {string} The service name.
+     */
+    getServiceName() {
+        return '@universis/janitor#RateLimitService';
+    }
+    /**
+     * Returns the service configuration.
+     * @returns {{extends?: string, profiles?: Array, paths?: Array}} The service configuration.
+     */
+    getServiceConfiguration() {
+        if (this.serviceConfiguration) {
+            return this.serviceConfiguration;
+        }
+        let serviceConfiguration = {
+            profiles: [],
+            paths: []
+        };
+        // get service configuration
+        const serviceConfigurationSource = this.getApplication().getConfiguration().getSourceAt('settings/universis/janitor/rateLimit');
+        if (serviceConfigurationSource) {
+            if (typeof serviceConfigurationSource.extends === 'string') {
+                // get additional configuration
+                const configurationPath = this.getApplication().getConfiguration().getConfigurationPath();
+                const extendsPath = path.resolve(configurationPath, serviceConfigurationSource.extends);
+                TraceUtils.log(`${this.getServiceName()} will try to extend service configuration using ${extendsPath}`);
+                serviceConfiguration = Object.assign({}, {
+                    profiles: [],
+                    paths: []
+                }, require(extendsPath));
+            } else {
+                TraceUtils.log(`${this.getServiceName()} will use service configuration from settings/universis/janitor/rateLimit`);
+                serviceConfiguration = Object.assign({}, {
+                    profiles: [],
+                    paths: []
+                }, serviceConfigurationSource);
+            }
+        }
+        const pathsArray = serviceConfiguration.paths || [];
+        const profilesArray = serviceConfiguration.profiles || [];
+        // create maps
+        serviceConfiguration.paths = new Map(pathsArray);
+        serviceConfiguration.profiles = new Map(profilesArray);
+        // set service configuration
+        Object.defineProperty(this, 'serviceConfiguration', {
+            value: serviceConfiguration,
+            writable: false,
+            enumerable: false,
+            configurable: true
+        });
+        return this.serviceConfiguration;
+    }
+
+    /**
+     * Sets the rate limit configuration for a specific path.
+     * @param {string} path 
+     * @param {{ profile: string } | import('express-rate-limit').Options} options 
+     * @returns {RateLimitService} The service instance for chaining.
+     */
+    set(path, options) {
+        let opts;
+        // get profile
+        if (options.profile) {
+            opts = this.serviceConfiguration.profiles.get(options.profile);
+        } else {
+            // or options defined inline
+            opts = options
+        }
+        /**
+         * @type { import('express-rate-limit').Options }
+         */
+        const rateLimitOptions = Object.assign({
+            windowMs: 5 * 60 * 1000, // 5 minutes
+            limit: 50, // 50 requests
+            legacyHeaders: true // send headers
+        }, opts, {
+            keyGenerator: (req) => {
+                let remoteAddress;
+                if (this.proxyAddressForwarding) {
+                    // get proxy headers or remote address
+                    remoteAddress = req.headers['x-real-ip'] || req.headers['x-forwarded-for'] || (req.connection ? req.connection.remoteAddress : req.socket.remoteAddress);
+                } else {
+                    // get remote address
+                    remoteAddress = (req.connection ? req.connection.remoteAddress : req.socket.remoteAddress);
+                }
+                return `${path}:${remoteAddress}`;
+            }
+        });
+        if (typeof rateLimitOptions.store === 'undefined') {
+            const StoreClass = this.getStoreType();
+            if (typeof StoreClass === 'function') {
+                rateLimitOptions.store = new StoreClass(this, rateLimitOptions);
+            }
+        }
+        this.router.use(path, rateLimit(rateLimitOptions));
+        return this;
+    }
+
+    /**
+     * @returns {function} The type of store used for rate limiting.
+     */
+    getStoreType() {
+        const serviceConfiguration = this.getServiceConfiguration();
+        if (typeof serviceConfiguration.storeType !== 'string') {
+            return;
+        }
+        let StoreClass;
+        const store = serviceConfiguration.storeType.split('#');
+        if (store.length === 2) {
+            const storeModule = require(store[0]);
+            if (Object.prototype.hasOwnProperty.call(storeModule, store[1])) {
+                StoreClass = storeModule[store[1]];
+                return StoreClass
+            } else {
+                throw new Error(`${store} cannot be found or is inaccessible`);
+            }
+        } else {
+            StoreClass = require(store[0]);
+            return StoreClass;
+        }
+    }
+
+    /**
+     * Unsets the rate limit configuration for a specific path.
+     * @param {string} path 
+     * @returns {RateLimitService} The service instance for chaining.
+     */
+    unset(path) {
+        const index =this.router.stack.findIndex((layer) => {
+            return layer.route && layer.route.path === path;
+        });
+        if (index !== -1) {
+            this.router.stack.splice(index, 1);
+        }
+        return this;
+    }
+
 }

package/src/SpeedLimitService.d.ts

@@ -1,4 +1,22 @@
-import { ApplicationService } from '@themost/common';
-export declare class SpeedLimitService extends ApplicationService {
+import { ApplicationBase, ApplicationService } from '@themost/common';
+import { Application, Router } from 'express';
+import { BehaviorSubject } from 'rxjs';
+import { Options as SpeedLimitProfile, Store } from 'express-slow-down';
+
+export declare type SpeedLimitStoreConstructor = new (...arg: unknown[]) => Store;
 
+export declare interface SpeedLimitServiceConfiguration {
+    extends?: string;
+    storeType?: string;
+    profiles?: Map<string, SpeedLimitProfile>;
+    paths?: Map<string, ({ profile: string } | SpeedLimitProfile)>;
+}
+
+export declare class SpeedLimitService extends ApplicationService {
+    constructor(app: ApplicationBase);
+    getServiceContainer(): BehaviorSubject<Router | Application>;
+    getServiceName(): string;
+    getServiceConfiguration(): SpeedLimitServiceConfiguration;
+    set(path: string, options: { profile?: string } | SpeedLimitProfile): this;
+    unset(path: string): this;
 }

package/src/SpeedLimitService.js

@@ -2,105 +2,72 @@ import { ApplicationService, TraceUtils } from '@themost/common';
 import slowDown from 'express-slow-down';
 import express from 'express';
 import path from 'path';
+import { BehaviorSubject } from 'rxjs';
 
 export class SpeedLimitService extends ApplicationService {
     constructor(app) {
         super(app);
 
-        app.serviceRouter.subscribe(serviceRouter => {
-            if (serviceRouter == null) {
+        // get proxy address forwarding option
+        const proxyAddressForwarding = app.getConfiguration().getSourceAt('settings/universis/api/proxyAddressForwarding');
+        this.proxyAddressForwarding = typeof proxyAddressForwarding !== 'boolean'? false : proxyAddressForwarding; 
+
+        /**
+         * @type {BehaviorSubject<{ target: SpeedLimitService }>}
+         */
+        this.loaded = new BehaviorSubject(null);
+
+        const serviceContainer = this.getServiceContainer();
+        if (serviceContainer == null) {
+            TraceUtils.warn(`${this.getServiceName()} is being started but the parent router seems to be unavailable.`);
+            return;
+        }
+
+        serviceContainer.subscribe(router => {
+            if (router == null) {
                 return;
             }
             try {
-                const addRouter = express.Router();
-                let serviceConfiguration = app.getConfiguration().getSourceAt('settings/universis/janitor/speedLimit') || {
-                    profiles: [],
-                    paths: []
-                };
-                if (serviceConfiguration.extends) {
-                    // get additional configuration
-                    const configurationPath = app.getConfiguration().getConfigurationPath();
-                    const extendsPath = path.resolve(configurationPath, serviceConfiguration.extends);
-                    TraceUtils.log(`@universis/janitor#SpeedLimitService will try to extend service configuration from ${extendsPath}`);
-                    serviceConfiguration = require(extendsPath);
-                }
-                const pathsArray = serviceConfiguration.paths || [];
-                const profilesArray = serviceConfiguration.profiles || [];
+                // set router for further processing
+                Object.defineProperty(this, 'router', {
+                    value: express.Router(),
+                    writable: false,
+                    enumerable: false,
+                    configurable: true
+                });
+                const serviceConfiguration = this.getServiceConfiguration();
                 // create maps
-                const paths = new Map(pathsArray);
-                const profiles = new Map(profilesArray);
+                const paths = serviceConfiguration.paths;
                 if (paths.size === 0) {
-                    TraceUtils.warn('@universis/janitor#SpeedLimitService is being started but the collection of paths is empty.');
-                }
-                // get proxy address forwarding option
-                let proxyAddressForwarding = app.getConfiguration().getSourceAt('settings/universis/api/proxyAddressForwarding');
-                if (typeof proxyAddressForwarding !== 'boolean') {
-                    proxyAddressForwarding = false;
+                    TraceUtils.warn(`${this.getServiceName()} is being started but the collection of paths is empty.`);
                 }
                 paths.forEach((value, path) => {
-                    let profile;
-                    // get profile
-                    if (value.profile) {
-                        profile = profiles.get(value.profile);
-                    } else {
-                        // or options defined inline
-                        profile = value
-                    }
-                    if (profile != null) {
-                        const slowDownOptions = Object.assign({
-                            windowMs: 5 * 60 * 1000, // 5 minutes
-                            delayAfter: 20, // 20 requests
-                            delayMs: 500, // 500 ms
-                            maxDelayMs: 10000 // 10 seconds
-                        }, profile, {
-                            keyGenerator: (req) => {
-                                let remoteAddress;
-                                if (proxyAddressForwarding) {
-                                    // get proxy headers or remote address
-                                    remoteAddress = req.headers['x-real-ip'] || req.headers['x-forwarded-for'] || (req.connection ? req.connection.remoteAddress : req.socket.remoteAddress);
-                                } else {
-                                    // get remote address
-                                    remoteAddress = (req.connection ? req.connection.remoteAddress : req.socket.remoteAddress);
-                                }
-                                return `${path}:${remoteAddress}`;
-                            }
+                    this.set(path, value);
+                });
+                if (router.stack) {
+                        router.stack.unshift.apply(router.stack, this.router.stack);
+                } else {
+                    // use router
+                    router.use(this.router);
+                    // get router stack (use a workaround for express 4.x)
+                    const stack = router._router && router._router.stack;
+                    if (Array.isArray(stack)) {
+                        // stage #1 find logger middleware (for supporting request logging)
+                        let index = stack.findIndex((item) => {
+                            return item.name === 'logger';
                         });
-                        if (Array.isArray(slowDownOptions.randomDelayMs)) {
-                            slowDownOptions.delayMs = () => {
-                                const delayMs = Math.floor(Math.random() * (slowDownOptions.randomDelayMs[1] - slowDownOptions.randomDelayMs[0] + 1) + slowDownOptions.randomDelayMs[0]);
-                                return delayMs;
-                            }
+                        if (index === -1) {
+                            // stage #2 find expressInit middleware
+                            index = stack.findIndex((item) => {
+                                return item.name === 'expressInit';
+                            });
                         }
-                        if (Array.isArray(slowDownOptions.randomMaxDelayMs)) {
-                            slowDownOptions.maxDelayMs = () => {
-                                const maxDelayMs = Math.floor(Math.random() * (slowDownOptions.randomMaxDelayMs[1] - slowDownOptions.randomMaxDelayMs[0] + 1) + slowDownOptions.randomMaxDelayMs[0]);
-                                return maxDelayMs;
-                            }
-                        }
-                        if (typeof slowDownOptions.store === 'string') {
-                            // load store
-                            const store = slowDownOptions.store.split('#');
-                            let StoreClass;
-                            if (store.length === 2) {
-                                const storeModule = require(store[0]);
-                                if (Object.prototype.hasOwnProperty.call(storeModule, store[1])) {
-                                    StoreClass = storeModule[store[1]];
-                                    slowDownOptions.store = new StoreClass(this, slowDownOptions);
-                                } else {
-                                    throw new Error(`${store} cannot be found or is inaccessible`);
-                                }
-                            } else {
-                                StoreClass = require(store[0]);
-                                // create store
-                                slowDownOptions.store = new StoreClass(this, slowDownOptions);
-                            }
-                        }
-                        addRouter.use(path, slowDown(slowDownOptions));
+                    } else {
+                        TraceUtils.warn(`${this.getServiceName()} is being started but the container stack is not available.`);
                     }
-                });
-                if (addRouter.stack.length) {
-                    serviceRouter.stack.unshift.apply(serviceRouter.stack, addRouter.stack);
                 }
+                // notify that the service is loaded
+                this.loaded.next({ target: this });
             } catch (err) {
                 TraceUtils.error('An error occurred while validating speed limit configuration.');
                 TraceUtils.error(err);
@@ -109,4 +76,161 @@ export class SpeedLimitService extends ApplicationService {
         });
     }
 
+    /**
+     * @returns {function} The type of store used for rate limiting.
+     */
+    getStoreType() {
+        const serviceConfiguration = this.getServiceConfiguration();
+        if (typeof serviceConfiguration.storeType !== 'string') {
+            return;
+        }
+        let StoreClass;
+        const store = serviceConfiguration.storeType.split('#');
+        if (store.length === 2) {
+            const storeModule = require(store[0]);
+            if (Object.prototype.hasOwnProperty.call(storeModule, store[1])) {
+                StoreClass = storeModule[store[1]];
+                return StoreClass
+            } else {
+                throw new Error(`${store} cannot be found or is inaccessible`);
+            }
+        } else {
+            StoreClass = require(store[0]);
+            return StoreClass;
+        }
+    }
+
+    /**
+     * Returns the service name.
+     * @returns {string} The service name.
+     */
+    getServiceName() {
+        return '@universis/janitor#SpeedLimitService';
+    }
+
+     /**
+     * Returns the service router that is used to register speed limit middleware.
+     * @returns {import('express').Router | import('express').Application} The service router.
+     */
+    getServiceContainer() {
+        return this.getApplication() && this.getApplication().serviceRouter;
+    }
+
+    /**
+     * Sets the speed limit configuration for a specific path.
+     * @param {string} path 
+     * @param {{ profile: string } | import('express-slow-down').Options} options 
+     * @returns {SpeedLimitService} The service instance for chaining.
+     */
+    set(path, options) {
+        let opts;
+        // get profile
+        if (options.profile) {
+            opts = this.serviceConfiguration.profiles.get(options.profile);
+        } else {
+            // or options defined inline
+            opts = options
+        }
+        const slowDownOptions = Object.assign({
+            windowMs: 5 * 60 * 1000, // 5 minutes
+            delayAfter: 20, // 20 requests
+            delayMs: 500, // 500 ms
+            maxDelayMs: 10000 // 10 seconds
+        }, opts, {
+            keyGenerator: (req) => {
+                let remoteAddress;
+                if (this.proxyAddressForwarding) {
+                    // get proxy headers or remote address
+                    remoteAddress = req.headers['x-real-ip'] || req.headers['x-forwarded-for'] || (req.connection ? req.connection.remoteAddress : req.socket.remoteAddress);
+                } else {
+                    // get remote address
+                    remoteAddress = (req.connection ? req.connection.remoteAddress : req.socket.remoteAddress);
+                }
+                return `${path}:${remoteAddress}`;
+            }
+        });
+        if (Array.isArray(slowDownOptions.randomDelayMs)) {
+            slowDownOptions.delayMs = () => {
+                const delayMs = Math.floor(Math.random() * (slowDownOptions.randomDelayMs[1] - slowDownOptions.randomDelayMs[0] + 1) + slowDownOptions.randomDelayMs[0]);
+                return delayMs;
+            }
+        }
+        if (Array.isArray(slowDownOptions.randomMaxDelayMs)) {
+            slowDownOptions.maxDelayMs = () => {
+                const maxDelayMs = Math.floor(Math.random() * (slowDownOptions.randomMaxDelayMs[1] - slowDownOptions.randomMaxDelayMs[0] + 1) + slowDownOptions.randomMaxDelayMs[0]);
+                return maxDelayMs;
+            }
+        }
+        if (typeof slowDownOptions.store === 'undefined') {
+            const StoreClass = this.getStoreType();
+            if (typeof StoreClass === 'function') {
+                slowDownOptions.store = new StoreClass(this, slowDownOptions);
+            }
+        }
+        this.router.use(path, slowDown(slowDownOptions));
+        return this;
+    }
+        
+
+    /**
+     * Unsets the speed limit configuration for a specific path.
+     * @param {string} path 
+     * @return {SpeedLimitService} The service instance for chaining.
+     */
+    unset(path) {
+        const index =this.router.stack.findIndex((layer) => {
+            return layer.route && layer.route.path === path;
+        });
+        if (index !== -1) {
+            this.router.stack.splice(index, 1);
+        }
+        return this;
+    }
+
+    /**
+     * 
+     * @returns {{extends?: string, profiles?: Array, paths?: Array}} The service configuration.
+     */
+    getServiceConfiguration() {
+        if (this.serviceConfiguration) {
+            return this.serviceConfiguration;
+        }
+        let serviceConfiguration = {
+            profiles: [],
+            paths: []
+        };
+        // get service configuration
+        const serviceConfigurationSource = this.getApplication().getConfiguration().getSourceAt('settings/universis/janitor/speedLimit');
+        if (serviceConfigurationSource) {
+            if (typeof serviceConfigurationSource.extends === 'string') {
+                // get additional configuration
+                const configurationPath = this.getApplication().getConfiguration().getConfigurationPath();
+                const extendsPath = path.resolve(configurationPath, serviceConfigurationSource.extends);
+                TraceUtils.log(`${this.getServiceName()} will try to extend service configuration using ${extendsPath}`);
+                serviceConfiguration = Object.assign({}, {
+                    profiles: [],
+                    paths: []
+                }, require(extendsPath));
+            } else {
+                TraceUtils.log(`${this.getServiceName()} will use service configuration from settings/universis/janitor/speedLimit`);
+                serviceConfiguration = Object.assign({}, {
+                    profiles: [],
+                    paths: []
+                }, serviceConfigurationSource);
+            }
+        }
+        const profilesArray = serviceConfiguration.profiles || [];
+        serviceConfiguration.profiles = new Map(profilesArray);
+        const pathsArray = serviceConfiguration.paths || [];
+        serviceConfiguration.paths = new Map(pathsArray);
+
+        Object.defineProperty(this, 'serviceConfiguration', {
+            value: serviceConfiguration,
+            writable: false,
+            enumerable: false,
+            configurable: true
+        });
+        return this.serviceConfiguration;
+    }
+
 }

package/src/index.d.ts

@@ -5,3 +5,7 @@ export * from './ScopeAccessConfiguration';
 export * from './validateScope';
 export * from './OAuth2ClientService';
 export * from './RemoteAddressValidator';
+export * from './AppRateLimitService';
+export * from './AppSpeedLimitService';
+export * from './HttpBearerStategy';
+export * from './PassportService';

package/src/index.js

@@ -6,3 +6,7 @@ export * from './ScopeAccessConfiguration';
 export * from './validateScope';
 export * from './OAuth2ClientService';
 export * from './RemoteAddressValidator';
+export * from './AppRateLimitService';
+export * from './AppSpeedLimitService';
+export * from './HttpBearerStategy';
+export * from './PassportService';