@universis/janitor 2.1.1 → 2.4.0

package/dist/index.d.ts

@@ -1,13 +1,12 @@
 import * as _themost_common from '@themost/common';
-import { ApplicationService, ApplicationBase, ConfigurationStrategy, ConfigurationBase, HttpForbiddenError, HttpError } from '@themost/common';
+import { ApplicationService, ApplicationBase, ConfigurationStrategy, ConfigurationBase, HttpForbiddenError } from '@themost/common';
 import { Router, Application, Handler, Request as Request$1 } from 'express';
-import { Store, Options } from 'express-rate-limit';
+import { Options, Store } from 'express-rate-limit';
 import { BehaviorSubject } from 'rxjs';
-import { Store as Store$1, Options as Options$1 } from 'express-slow-down';
+import { Options as Options$1, Store as Store$1 } from 'express-slow-down';
 import RedisStore from 'rate-limit-redis';
-import { DataContext } from '@themost/data';
-import BearerStrategy from 'passport-http-bearer';
-import { Authenticator } from 'passport';
+import { DataContext, UserService } from '@themost/data';
+import { Strategy, Authenticator } from 'passport';
 
 declare type RateLimitStoreConstructor = new (...arg: unknown[]) => Store;
 
@@ -139,6 +138,7 @@ declare class ExtendScopeAccessConfiguration extends ApplicationService {
 }
 
 declare function validateScope(): Handler;
+declare function validateClientScope(): Handler;
 
 declare interface OAuth2MethodOptions {
     access_token: string;
@@ -237,13 +237,17 @@ declare class OAuth2ClientService extends ApplicationService {
 }
 
 declare class RemoteAddressValidator extends ApplicationService {
-    
+
     constructor(app: ApplicationService);
     validateRemoteAddress(request: Request$1): Promise<boolean>;
     getRemoteAddress(request: Request$1): string;
 
 }
 
+declare class HttpRemoteAddrForbiddenError extends HttpForbiddenError {
+    constructor();
+}
+
 declare class AppRateLimitService extends RateLimitService {
     constructor(app: _themost_common.ApplicationBase);
 }
@@ -252,133 +256,106 @@ declare class AppSpeedLimitService extends SpeedLimitService {
     constructor(app: _themost_common.ApplicationBase);
 }
 
-declare class HttpBearerTokenRequired extends HttpError {
-    constructor() {
-        super(499, 'A token is required to fulfill the request.');
-        this.code = 'E_TOKEN_REQUIRED';
-        this.title = 'Token Required';
-    }
+declare class HttpBearerStrategy extends Strategy {
+    constructor();
 }
 
-declare class HttpBearerTokenNotFound extends HttpError {
-    constructor() {
-        super(498, 'Token was not found.');
-        this.code = 'E_TOKEN_NOT_FOUND';
-        this.title = 'Invalid token';
-    }
+declare class PassportService extends ApplicationService {
+    getInstance(): Authenticator
 }
 
-declare class HttpBearerTokenExpired extends HttpError {
-    constructor() {
-        super(498, 'Token was expired or is in invalid state.');
-        this.code = 'E_TOKEN_EXPIRED';
-        this.title = 'Invalid token';
-    }
+declare interface OutputCachingProfile {
+    /**
+     * Defines the location where the output cache will be stored. Possible values are: client, server, clientServer, none. The default value is client.
+     */
+    location: 'any' | 'none' | 'server' | 'client' | 'serverAndClient';
+    /**
+     * Defines the duration in seconds for which the output cache will be stored. The default value is 60 seconds.
+     */
+    duration?: number;
+    /**
+     * Defines the content encoding that will be used to vary the output cache. The default value is null, which means that the output cache will not be varied by content encoding.
+     */
+    varyByContentEncoding?: string;
+    /**
+     * Defines the headers that will be used to vary the output cache. The default value is an empty array.
+     */
+    varyByHeader?: string[];
+    /**
+     * Defines the query string parameters that will be used to vary the output cache. The default value is a "*" character, which means that the output cache will be varied by all query string parameters.
+     */
+    varyByParam?: string[];
+    /**
+     * Defines the custom expression that will be used to vary the output cache. The default value is null.
+     * An example of a custom expression is: { "$md5": { "$user": 1 } } where the output cache will be varied by the MD5 hash of the user ID.
+     */
+    varyByExpr?: any;
 }
 
-declare class HttpAccountDisabled extends HttpForbiddenError {
-    constructor() {
-        super('Access is denied. User account is disabled.');
-        this.code = 'E_ACCOUNT_DISABLED';
-        this.statusCode = 403.2;
-        this.title = 'Disabled account';
+declare module 'express' {
+    interface Request {
+        outputCaching?: OutputCachingProfile
     }
 }
 
-declare class HttpBearerStrategy extends BearerStrategy {
-    constructor() {
-        super({
-        passReqToCallback: true
-        },
-        /**
-         * @param {Request} req
-         * @param {string} token
-         * @param {Function} done
-         */
-        function(req, token, done) {
-            /**
-             * Gets OAuth2 client services
-             * @type {import('./OAuth2ClientService').OAuth2ClientService}
-             */
-            let client = req.context.getApplication().getStrategy(function OAuth2ClientService() {});
-            // if client cannot be found
-            if (client == null) {
-                // throw configuration error
-                return done(new Error('Invalid application configuration. OAuth2 client service cannot be found.'))
-            }
-            if (token == null) {
-                // throw 499 Token Required error
-                return done(new HttpBearerTokenRequired());
-            }
-            // get token info
-            client.getTokenInfo(req.context, token).then(info => {
-                if (info == null) {
-                    // the specified token cannot be found - 498 invalid token with specific code
-                    return done(new HttpBearerTokenNotFound());
-                }
-                // if the given token is not active throw token expired - 498 invalid token with specific code
-                if (!info.active) {
-                    return done(new HttpBearerTokenExpired());
-                }
-                // find user from token info
-                return (function () {
-                    /**
-                     * @type {import('./services/user-provisioning-mapper-service').UserProvisioningMapperService}
-                     */
-                    const mapper = req.context.getApplication().getService(function UserProvisioningMapperService() {});
-                    if (mapper == null) {
-                        return req.context.model('User').where('name').equal(info.username).silent().getItem();
-                    }
-                    return mapper.getUser(req.context, info);
-                })().then((user) => {
-                   // check if userProvisioning service is installed and try to find related user only if user not found
-                    if (user == null) {
-                        /**
-                         * @type {import('./services/user-provisioning-service').UserProvisioningService}
-                         */
-                        const service = req.context.getApplication().getService(function UserProvisioningService() {});
-                        if (service == null) {
-                            return user;
-                        }
-                        return service.validateUser(req.context, info);
-                    }
-                    return user;
-                }).then( user => {
-                    // user cannot be found and of course cannot be authenticated (throw forbidden error)
-                    if (user == null) {
-                        // write access log for forbidden
-                        return done(new HttpForbiddenError());
-                    }
-                    // check if user has enabled attribute
-                    if (Object.prototype.hasOwnProperty.call(user, 'enabled') && !user.enabled) {
-                        //if user.enabled is off throw forbidden error
-                        return done(new HttpAccountDisabled('Access is denied. User account is disabled.'));
-                    }
-                    // otherwise return user data
-                    return done(null, {
-                        'name': user.name,
-                        'authenticationProviderKey': user.id,
-                        'authenticationType':'Bearer',
-                        'authenticationToken': token,
-                        'authenticationScope': info.scope
-                    });
-                });
-            }).catch(err => {
-                // end log token info request with error
-                if (err && err.statusCode === 404) {
-                    // revert 404 not found returned by auth server to 498 invalid token
-                    return done(new HttpBearerTokenNotFound());
-                }
-                // otherwise continue with error
-                return done(err);
-            });
-        });
-    }
+declare interface OutputCachingElement {
+    /**
+     * Defines the URL pattern for which the output caching profile will be applied. The URL pattern can include wildcards, such as /api/*, which means that the output caching profile will be applied to all URLs that start with /api/.
+     */
+    resource: string;
+    /**
+     * Defines the regular expression that will be used to match the URL pattern. The regular expression should be defined as a string and will be converted to a RegExp object internally. If the regular expression is not defined, the URL pattern will be used as a simple string match.
+     */
+    expr?: RegExp;
+    /**
+     * Defines the output caching profile that will be applied to the URL pattern. The output caching profile can be defined as an object of type OutputCachingProfile or as a string that references a predefined output caching profile.
+     */
+    profile: (OutputCachingProfile | string);
 }
 
-declare class PassportService extends ApplicationService {
-    getInstance(): Authenticator
+declare function outputCache(options: {
+    profiles: Map<string, OutputCachingProfile>,
+    elements: OutputCachingElement[]
+}): Router;
+
+declare class OutputCachingService extends ApplicationService{
+    profiles: Map<string, OutputCachingProfile>;
+    elements: OutputCachingElement[];
+}
+
+declare class InvalidClientScopeError extends HttpForbiddenError {
+    constructor();
+}
+
+declare class VerifyUserClientScope extends ApplicationService {
+    constructor(app: ApplicationBase);
+    options: { whitelist: string[] };
+    verify(context: DataContext): Promise<boolean>;
+}
+
+declare class DisableUserClientScopeVerification extends VerifyUserClientScope {
+}
+
+declare class UserWithNetworkAddress extends UserService {
+    constructor(app: ApplicationBase);
+
+    protected queryUser(context: DataContext, username: string): Promise<any>;
+    protected queryGroup(context: DataContext, username: string): Promise<any>;
 }
 
-export { AppRateLimitService, AppSpeedLimitService, DefaultScopeAccessConfiguration, EnableScopeAccessConfiguration, ExtendScopeAccessConfiguration, HttpAccountDisabled, HttpBearerStrategy, HttpBearerTokenExpired, HttpBearerTokenNotFound, HttpBearerTokenRequired, OAuth2ClientService, PassportService, RateLimitService, RedisClientStore, RemoteAddressValidator, ScopeAccessConfiguration, ScopeString, SpeedLimitService, validateScope };
-export type { GenericUser, OAuth2AuthorizeUser, OAuth2MethodOptions, OAuth2ServiceSettings, OAuth2User, OAuth2UserProfile, RateLimitServiceConfiguration, RateLimitStoreConstructor, ScopeAccessConfigurationElement, ScopeAccessConfigurationSection, SpeedLimitServiceConfiguration, SpeedLimitStoreConstructor, UniversisConfigurationSection };
+declare class NetworkRestrictAccess extends ApplicationService {
+    constructor(app: ApplicationBase);
+}
+
+declare class EnableNetworkRestrictAccess extends NetworkRestrictAccess {
+    constructor(app: ApplicationBase);
+}
+
+declare class DisableNetworkRestrictAccess extends NetworkRestrictAccess {
+    constructor(app: ApplicationBase);
+}
+
+declare function validateNetworkAccess(): Handler;
+
+export { AppRateLimitService, AppSpeedLimitService, DefaultScopeAccessConfiguration, DisableNetworkRestrictAccess, DisableUserClientScopeVerification, EnableNetworkRestrictAccess, EnableScopeAccessConfiguration, ExtendScopeAccessConfiguration, HttpBearerStrategy, HttpRemoteAddrForbiddenError, InvalidClientScopeError, NetworkRestrictAccess, OAuth2ClientService, OutputCachingService, PassportService, RateLimitService, RedisClientStore, RemoteAddressValidator, ScopeAccessConfiguration, ScopeString, SpeedLimitService, UserWithNetworkAddress, VerifyUserClientScope, outputCache, validateClientScope, validateNetworkAccess, validateScope };
+export type { GenericUser, OAuth2AuthorizeUser, OAuth2MethodOptions, OAuth2ServiceSettings, OAuth2User, OAuth2UserProfile, OutputCachingElement, OutputCachingProfile, RateLimitServiceConfiguration, RateLimitStoreConstructor, ScopeAccessConfigurationElement, ScopeAccessConfigurationSection, SpeedLimitServiceConfiguration, SpeedLimitStoreConstructor, UniversisConfigurationSection };