@universis/janitor 1.9.0 → 1.10.0

package/README.md

@@ -82,6 +82,57 @@ Rate limit headers will be available only if the request is made from the same o
 }
 ```
 
+## AppRateLimitService
+
+`AppRateLimitService` is a configurable extension of [express-rate-limit](https://www.npmjs.com/package/express-rate-limit) for limiting service requests based on application settings.
+`AppRateLimitService` is an alternative to `RateLimitService` that allows you to configure rate limits based on container paths instead of service paths. This allows you to configure rate limits for all services in a container.
+
+You can register `AppRateLimitService` under application services:
+
+```json
+{
+    "services": [
+        {
+            "serviceType": "@universis/janitor#RateLimitService",
+            "strategyType": "@universis/janitor#AppRateLimitService"
+        }
+    ]
+}
+```
+
+The configuration should use the same structure as `RateLimitService` but under `settings/universis/rateLimit`:
+
+```json
+    {
+        "settings": {
+            "universis": {
+                "appRateLimit": {
+                    "profiles": [
+                        [
+                            "appRateLimitProfile",
+                            {
+                                "windowMs": 300000,
+                                "limit": 50,
+                                "legacyHeaders": true
+                            }
+                        ]
+                    ],
+                    "paths": [
+                            [
+                                "/api/users/me",
+                                {
+                                    "profile": "appRateLimitProfile"
+                                }
+                            ]
+                        ]
+                }
+            }
+        }
+    }
+```
+
+where paths are the container paths instead of service paths. The `AppRateLimitService` will apply the rate limit to all services in the container that match the path.
+
 
 ## SpeedLimitService
 
@@ -230,6 +281,61 @@ Speed limit headers will be available only if the request is made from the same
 }
 ```
 
+## AppSpeedLimitService
+
+`AppSpeedLimitService` is a configurable extension of [express-slow-down](https://www.npmjs.com/package/express-slow-down) for slowing down service responses based on application settings.
+
+`AppSpeedLimitService` is an alternative to `SpeedLimitService` that allows you to configure speed limits based on container paths instead of service paths. This allows you to configure speed limits for all services in a container.
+
+You can register `AppSpeedLimitService` under application services:
+
+```json
+{
+    "services": [
+        {
+            "serviceType": "@universis/janitor#SpeedLimitService",
+            "strategyType": "@universis/janitor#AppSpeedLimitService"
+        }
+    ]
+}
+```
+
+The configuration should use the same structure as `SpeedLimitService` but under `settings/universis/speedLimit`:
+
+```json
+    {
+        "settings": {
+            "universis": {
+                "appSpeedLimit": {
+                    "profiles": [
+                        [
+                            "appSpeedLimitProfile",
+                            {
+                                "windowMs": 300000,
+                                "delayAfter": 5,
+                                "delayMs": 500,
+                                "maxDelayMs": 20000,
+                                "headers": true
+                            }
+                        ]
+                    ],
+                    "paths": [
+                            [
+                                "/api/users/me",
+                                {
+                                    "profile": "appSpeedLimitProfile"
+                                }
+                            ]
+                        ]
+                }
+            }
+        }
+    }
+```
+
+where paths are the container paths instead of service paths. The `AppSpeedLimitService` will apply the speed limit to all services in the container that match the path.
+
+
 ## ScopeAccessConfiguration
 
 `ScopeAccessConfiguration` is a configurable application configuration strategy for limiting access to service endpoints based on user scopes.

package/dist/index.d.ts

@@ -1,14 +1,47 @@
-import { ApplicationService, ConfigurationStrategy, ConfigurationBase, ApplicationBase } from '@themost/common';
+import * as _themost_common from '@themost/common';
+import { ApplicationService, ApplicationBase, ConfigurationStrategy, ConfigurationBase } from '@themost/common';
+import { Router, Application, Handler, Request as Request$1 } from 'express';
+import { Store, Options } from 'express-rate-limit';
+import { BehaviorSubject } from 'rxjs';
+import { Store as Store$1, Options as Options$1 } from 'express-slow-down';
 import RedisStore from 'rate-limit-redis';
-import { Handler, Request as Request$1 } from 'express';
 import { DataContext } from '@themost/data';
 
+declare type RateLimitStoreConstructor = new (...arg: unknown[]) => Store;
+
+declare interface RateLimitServiceConfiguration {
+    extends?: string;
+    storeType?: string;
+    profiles?: [string, Options][];
+    paths?: [string, ({ profile: string } | Options)][];
+}
+
 declare class RateLimitService extends ApplicationService {
+    constructor(app: _themost_common.ApplicationBase);
+    readonly loaded: BehaviorSubject<Router>;
+    getServiceContainer(): BehaviorSubject<Router | Application>;
+    getServiceName(): string;
+    getServiceConfiguration(): RateLimitServiceConfiguration;
+    set(path: string, options: { profile?: string } | Options): this;
+    unset(path: string): this;
+}
+
+declare type SpeedLimitStoreConstructor = new (...arg: unknown[]) => Store$1;
 
+declare interface SpeedLimitServiceConfiguration {
+    extends?: string;
+    storeType?: string;
+    profiles?: Map<string, Options$1>;
+    paths?: Map<string, ({ profile: string } | Options$1)>;
 }
 
 declare class SpeedLimitService extends ApplicationService {
-
+    constructor(app: ApplicationBase);
+    getServiceContainer(): BehaviorSubject<Router | Application>;
+    getServiceName(): string;
+    getServiceConfiguration(): SpeedLimitServiceConfiguration;
+    set(path: string, options: { profile?: string } | Options$1): this;
+    unset(path: string): this;
 }
 
 declare class RedisClientStore extends RedisStore {
@@ -209,5 +242,13 @@ declare class RemoteAddressValidator extends ApplicationService {
 
 }
 
-export { DefaultScopeAccessConfiguration, EnableScopeAccessConfiguration, ExtendScopeAccessConfiguration, OAuth2ClientService, RateLimitService, RedisClientStore, RemoteAddressValidator, ScopeAccessConfiguration, ScopeString, SpeedLimitService, validateScope };
-export type { GenericUser, OAuth2AuthorizeUser, OAuth2MethodOptions, OAuth2ServiceSettings, OAuth2User, OAuth2UserProfile, ScopeAccessConfigurationElement, ScopeAccessConfigurationSection, UniversisConfigurationSection };
+declare class AppRateLimitService extends RateLimitService {
+    constructor(app: _themost_common.ApplicationBase);
+}
+
+declare class AppSpeedLimitService extends SpeedLimitService {
+    constructor(app: _themost_common.ApplicationBase);
+}
+
+export { AppRateLimitService, AppSpeedLimitService, DefaultScopeAccessConfiguration, EnableScopeAccessConfiguration, ExtendScopeAccessConfiguration, OAuth2ClientService, RateLimitService, RedisClientStore, RemoteAddressValidator, ScopeAccessConfiguration, ScopeString, SpeedLimitService, validateScope };
+export type { GenericUser, OAuth2AuthorizeUser, OAuth2MethodOptions, OAuth2ServiceSettings, OAuth2User, OAuth2UserProfile, RateLimitServiceConfiguration, RateLimitStoreConstructor, ScopeAccessConfigurationElement, ScopeAccessConfigurationSection, SpeedLimitServiceConfiguration, SpeedLimitStoreConstructor, UniversisConfigurationSection };