nestjs-shield 1.0.0

package/dist/checks/payload.check.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PayloadCheck = void 0;
+class PayloadCheck {
+    static run(req, config) {
+        if (!config)
+            return { allowed: true };
+        if (config.maxHeaderBytes !== undefined) {
+            const size = PayloadCheck.estimateHeaderBytes(req.headers);
+            if (size > config.maxHeaderBytes) {
+                return {
+                    allowed: false,
+                    layer: 'payload',
+                    status: 431,
+                    reason: `Header size ${size} exceeds limit ${config.maxHeaderBytes}`,
+                };
+            }
+        }
+        if (config.maxBodyBytes !== undefined) {
+            const cl = req.headers['content-length'];
+            if (cl !== undefined) {
+                const declared = Number(Array.isArray(cl) ? cl[0] : cl);
+                if (Number.isFinite(declared) && declared > config.maxBodyBytes) {
+                    return {
+                        allowed: false,
+                        layer: 'payload',
+                        status: 413,
+                        reason: `Payload size ${declared} exceeds limit ${config.maxBodyBytes}`,
+                    };
+                }
+            }
+        }
+        return { allowed: true };
+    }
+    static estimateHeaderBytes(headers) {
+        let total = 0;
+        for (const [k, v] of Object.entries(headers)) {
+            if (v === undefined)
+                continue;
+            const value = Array.isArray(v) ? v.join(',') : String(v);
+            total += k.length + value.length + 4;
+        }
+        return total;
+    }
+}
+exports.PayloadCheck = PayloadCheck;

package/dist/checks/rate-limit.check.d.ts

@@ -0,0 +1,9 @@
+import type { ShieldStorage } from '../storage/shield-storage.interface';
+import type { AnyRequest, CheckOutcome, RateLimitConfig } from '../shield.types';
+export declare class RateLimitCheck {
+    static check(storage: ShieldStorage, req: AnyRequest, ip: string, config: RateLimitConfig): Promise<CheckOutcome & {
+        limit: number;
+        remaining: number;
+        resetMs: number;
+    }>;
+}

package/dist/checks/rate-limit.check.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitCheck = void 0;
+const fixed_window_1 = require("../algorithms/fixed-window");
+const leaky_bucket_1 = require("../algorithms/leaky-bucket");
+const sliding_window_counter_1 = require("../algorithms/sliding-window-counter");
+const sliding_window_log_1 = require("../algorithms/sliding-window-log");
+const token_bucket_1 = require("../algorithms/token-bucket");
+const shield_constants_1 = require("../shield.constants");
+const key_util_1 = require("../utils/key.util");
+class RateLimitCheck {
+    static async check(storage, req, ip, config) {
+        if (config.skip && config.skip(req)) {
+            return {
+                allowed: true,
+                limit: config.limit,
+                remaining: config.limit,
+                resetMs: 0,
+            };
+        }
+        const tracker = key_util_1.KeyUtil.fromRequest(req, ip, config.keyBy);
+        const algo = config.algorithm ?? 'token-bucket';
+        const key = `${shield_constants_1.KEY_RATE_LIMIT}:${algo}:${tracker}`;
+        let result;
+        switch (algo) {
+            case 'token-bucket':
+                result = await token_bucket_1.TokenBucket.check(storage, key, config.limit, config.ttl);
+                break;
+            case 'sliding-window':
+                result = await sliding_window_counter_1.SlidingWindowCounter.check(storage, key, config.limit, config.ttl);
+                break;
+            case 'sliding-window-log':
+                result = await sliding_window_log_1.SlidingWindowLog.check(storage, key, config.limit, config.ttl);
+                break;
+            case 'fixed-window':
+                result = await fixed_window_1.FixedWindow.check(storage, key, config.limit, config.ttl);
+                break;
+            case 'leaky-bucket':
+                result = await leaky_bucket_1.LeakyBucket.check(storage, key, config.limit, config.ttl);
+                break;
+            default:
+                result = await token_bucket_1.TokenBucket.check(storage, key, config.limit, config.ttl);
+        }
+        const remaining = 'remaining' in result && result.remaining !== undefined
+            ? result.remaining
+            : Math.max(0, config.limit - (result.count ?? 0));
+        return {
+            allowed: result.allowed,
+            layer: 'rate-limit',
+            status: result.allowed ? undefined : 429,
+            reason: result.allowed ? undefined : 'Rate limit exceeded',
+            retryAfterMs: result.allowed ? undefined : result.resetMs,
+            limit: config.limit,
+            remaining,
+            resetMs: result.resetMs,
+        };
+    }
+}
+exports.RateLimitCheck = RateLimitCheck;

package/dist/checks/slow-down.check.d.ts

@@ -0,0 +1,5 @@
+import type { ShieldStorage } from '../storage/shield-storage.interface';
+import type { CheckOutcome, SlowDownConfig } from '../shield.types';
+export declare class SlowDownCheck {
+    static check(storage: ShieldStorage, ip: string, ttlMs: number, config?: SlowDownConfig): Promise<CheckOutcome>;
+}

package/dist/checks/slow-down.check.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlowDownCheck = void 0;
+const shield_constants_1 = require("../shield.constants");
+class SlowDownCheck {
+    static async check(storage, ip, ttlMs, config) {
+        if (!config)
+            return { allowed: true };
+        const key = `${shield_constants_1.KEY_SLOW_DOWN}:${ip}`;
+        const { count } = await storage.increment(key, ttlMs);
+        if (count <= config.delayAfter)
+            return { allowed: true };
+        const overflow = count - config.delayAfter;
+        const computed = typeof config.delayMs === 'function' ? config.delayMs(overflow) : config.delayMs * overflow;
+        const delay = config.maxDelayMs ? Math.min(config.maxDelayMs, computed) : computed;
+        return { allowed: true, layer: 'slow-down', delayMs: Math.max(0, delay) };
+    }
+}
+exports.SlowDownCheck = SlowDownCheck;

package/dist/checks/user-agent.check.d.ts

@@ -0,0 +1,4 @@
+import type { CheckOutcome, UserAgentConfig } from '../shield.types';
+export declare class UserAgentCheck {
+    static run(ua: string, config?: UserAgentConfig): CheckOutcome;
+}

package/dist/checks/user-agent.check.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserAgentCheck = void 0;
+const ua_util_1 = require("../utils/ua.util");
+class UserAgentCheck {
+    static run(ua, config) {
+        if (!config)
+            return { allowed: true };
+        if (config.requirePresent && !ua) {
+            return {
+                allowed: false,
+                layer: 'user-agent',
+                status: 403,
+                reason: 'User-Agent header required',
+            };
+        }
+        if (config.allow && config.allow.length > 0 && ua_util_1.UaUtil.match(ua, config.allow)) {
+            return { allowed: true };
+        }
+        if (config.block && config.block.length > 0 && ua_util_1.UaUtil.match(ua, config.block)) {
+            return {
+                allowed: false,
+                layer: 'user-agent',
+                status: 403,
+                reason: 'User-Agent is blocked',
+            };
+        }
+        return { allowed: true };
+    }
+}
+exports.UserAgentCheck = UserAgentCheck;

package/dist/checks/whitelist.check.d.ts

@@ -0,0 +1,4 @@
+import type { IpListConfig, CheckOutcome } from '../shield.types';
+export declare class WhitelistCheck {
+    static run(ip: string, config?: IpListConfig): CheckOutcome;
+}

package/dist/checks/whitelist.check.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhitelistCheck = void 0;
+const ip_util_1 = require("../utils/ip.util");
+class WhitelistCheck {
+    static run(ip, config) {
+        if (!config)
+            return { allowed: false };
+        const hit = ip_util_1.IpUtil.matches(ip, config.ips, config.cidrs);
+        if (hit)
+            return { allowed: true, layer: 'whitelist' };
+        return { allowed: false };
+    }
+}
+exports.WhitelistCheck = WhitelistCheck;

package/dist/decorators/blacklist.decorator.d.ts

@@ -0,0 +1,2 @@
+import type { IpListConfig } from '../shield.types';
+export declare const Blacklist: (config: IpListConfig) => import("@nestjs/common").CustomDecorator<string>;

package/dist/decorators/blacklist.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Blacklist = void 0;
+const common_1 = require("@nestjs/common");
+const shield_constants_1 = require("../shield.constants");
+const Blacklist = (config) => (0, common_1.SetMetadata)(shield_constants_1.META_BLACKLIST, config);
+exports.Blacklist = Blacklist;

package/dist/decorators/burst-limit.decorator.d.ts

@@ -0,0 +1,2 @@
+import type { BurstConfig } from '../shield.types';
+export declare const BurstLimit: (config: BurstConfig) => import("@nestjs/common").CustomDecorator<string>;

package/dist/decorators/burst-limit.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BurstLimit = void 0;
+const common_1 = require("@nestjs/common");
+const shield_constants_1 = require("../shield.constants");
+const BurstLimit = (config) => (0, common_1.SetMetadata)(shield_constants_1.META_BURST, config);
+exports.BurstLimit = BurstLimit;

package/dist/decorators/max-payload.decorator.d.ts

@@ -0,0 +1,2 @@
+import type { PayloadConfig } from '../shield.types';
+export declare const MaxPayload: (config: PayloadConfig) => import("@nestjs/common").CustomDecorator<string>;

package/dist/decorators/max-payload.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaxPayload = void 0;
+const common_1 = require("@nestjs/common");
+const shield_constants_1 = require("../shield.constants");
+const MaxPayload = (config) => (0, common_1.SetMetadata)(shield_constants_1.META_MAX_PAYLOAD, config);
+exports.MaxPayload = MaxPayload;

package/dist/decorators/rate-limit.decorator.d.ts

@@ -0,0 +1,2 @@
+import type { RateLimitConfig } from '../shield.types';
+export declare const RateLimit: (options: RateLimitConfig) => import("@nestjs/common").CustomDecorator<string>;

package/dist/decorators/rate-limit.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimit = void 0;
+const common_1 = require("@nestjs/common");
+const shield_constants_1 = require("../shield.constants");
+const RateLimit = (options) => (0, common_1.SetMetadata)(shield_constants_1.META_RATE_LIMIT, options);
+exports.RateLimit = RateLimit;

package/dist/decorators/skip-shield.decorator.d.ts

@@ -0,0 +1,2 @@
+import type { ShieldLayer } from '../shield.constants';
+export declare const SkipShield: (...layers: ShieldLayer[]) => import("@nestjs/common").CustomDecorator<string>;

package/dist/decorators/skip-shield.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkipShield = void 0;
+const common_1 = require("@nestjs/common");
+const shield_constants_1 = require("../shield.constants");
+const SkipShield = (...layers) => (0, common_1.SetMetadata)(shield_constants_1.META_SKIP, layers.length === 0 ? true : layers);
+exports.SkipShield = SkipShield;

package/dist/decorators/slow-down.decorator.d.ts

@@ -0,0 +1,2 @@
+import type { SlowDownConfig } from '../shield.types';
+export declare const SlowDown: (config: SlowDownConfig) => import("@nestjs/common").CustomDecorator<string>;

package/dist/decorators/slow-down.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlowDown = void 0;
+const common_1 = require("@nestjs/common");
+const shield_constants_1 = require("../shield.constants");
+const SlowDown = (config) => (0, common_1.SetMetadata)(shield_constants_1.META_SLOW_DOWN, config);
+exports.SlowDown = SlowDown;

package/dist/decorators/user-agent-policy.decorator.d.ts

@@ -0,0 +1,2 @@
+import type { UserAgentConfig } from '../shield.types';
+export declare const UserAgentPolicy: (config: UserAgentConfig) => import("@nestjs/common").CustomDecorator<string>;

package/dist/decorators/user-agent-policy.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserAgentPolicy = void 0;
+const common_1 = require("@nestjs/common");
+const shield_constants_1 = require("../shield.constants");
+const UserAgentPolicy = (config) => (0, common_1.SetMetadata)(shield_constants_1.META_UA, config);
+exports.UserAgentPolicy = UserAgentPolicy;

package/dist/decorators/whitelist.decorator.d.ts

@@ -0,0 +1,2 @@
+import type { IpListConfig } from '../shield.types';
+export declare const Whitelist: (config: IpListConfig) => import("@nestjs/common").CustomDecorator<string>;

package/dist/decorators/whitelist.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Whitelist = void 0;
+const common_1 = require("@nestjs/common");
+const shield_constants_1 = require("../shield.constants");
+const Whitelist = (config) => (0, common_1.SetMetadata)(shield_constants_1.META_WHITELIST, config);
+exports.Whitelist = Whitelist;

package/dist/exceptions/shield.exceptions.d.ts

@@ -0,0 +1,23 @@
+import { HttpException } from '@nestjs/common';
+export interface ShieldExceptionPayload {
+    message: string;
+    code: string;
+    layer: string;
+    retryAfter?: number;
+}
+export declare class ShieldRateLimitException extends HttpException {
+    constructor(payload: Omit<ShieldExceptionPayload, 'code'> & {
+        code?: string;
+    });
+}
+export declare class ShieldBlockedException extends HttpException {
+    constructor(payload: Omit<ShieldExceptionPayload, 'code'> & {
+        code?: string;
+        status?: number;
+    });
+}
+export declare class ShieldPayloadException extends HttpException {
+    constructor(payload: Omit<ShieldExceptionPayload, 'code'> & {
+        code?: string;
+    });
+}

package/dist/exceptions/shield.exceptions.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShieldPayloadException = exports.ShieldBlockedException = exports.ShieldRateLimitException = void 0;
+const common_1 = require("@nestjs/common");
+class ShieldRateLimitException extends common_1.HttpException {
+    constructor(payload) {
+        super({
+            statusCode: common_1.HttpStatus.TOO_MANY_REQUESTS,
+            code: payload.code ?? 'SHIELD_RATE_LIMITED',
+            message: payload.message,
+            layer: payload.layer,
+            retryAfter: payload.retryAfter,
+        }, common_1.HttpStatus.TOO_MANY_REQUESTS);
+    }
+}
+exports.ShieldRateLimitException = ShieldRateLimitException;
+class ShieldBlockedException extends common_1.HttpException {
+    constructor(payload) {
+        const status = payload.status ?? common_1.HttpStatus.FORBIDDEN;
+        super({
+            statusCode: status,
+            code: payload.code ?? 'SHIELD_BLOCKED',
+            message: payload.message,
+            layer: payload.layer,
+            retryAfter: payload.retryAfter,
+        }, status);
+    }
+}
+exports.ShieldBlockedException = ShieldBlockedException;
+class ShieldPayloadException extends common_1.HttpException {
+    constructor(payload) {
+        super({
+            statusCode: common_1.HttpStatus.PAYLOAD_TOO_LARGE,
+            code: payload.code ?? 'SHIELD_PAYLOAD_TOO_LARGE',
+            message: payload.message,
+            layer: payload.layer,
+        }, common_1.HttpStatus.PAYLOAD_TOO_LARGE);
+    }
+}
+exports.ShieldPayloadException = ShieldPayloadException;

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+export { ShieldModule } from './shield.module';
+export type { ShieldAsyncOptions } from './shield.module';
+export { ShieldEngine } from './shield.engine';
+export { ShieldGuard } from './shield.guard';
+export { Shield } from './apply-to';
+export type { NestAppLike } from './apply-to';
+export { SHIELD_CONFIG, SHIELD_ENGINE, SHIELD_STORAGE, ALL_LAYERS, } from './shield.constants';
+export type { ShieldLayer } from './shield.constants';
+export type { ShieldConfig, RateLimitConfig, RateLimitAlgorithm, KeyByOption, IpListConfig, BlacklistConfig, AutoBanConfig, SlowDownConfig, UserAgentConfig, BurstConfig, PayloadConfig, ResponseConfig, StorageOption, RejectInfo, DecoratorOverrides, AnyRequest, AnyResponse, CheckOutcome, } from './shield.types';
+export { RateLimit } from './decorators/rate-limit.decorator';
+export { SkipShield } from './decorators/skip-shield.decorator';
+export { Blacklist } from './decorators/blacklist.decorator';
+export { Whitelist } from './decorators/whitelist.decorator';
+export { SlowDown } from './decorators/slow-down.decorator';
+export { MaxPayload } from './decorators/max-payload.decorator';
+export { BurstLimit } from './decorators/burst-limit.decorator';
+export { UserAgentPolicy } from './decorators/user-agent-policy.decorator';
+export { MemoryStorage } from './storage/memory.storage';
+export type { MemoryStorageOptions } from './storage/memory.storage';
+export { RedisStorage } from './storage/redis.storage';
+export type { RedisStorageOptions } from './storage/redis.storage';
+export type { ShieldStorage, CounterResult, TokenBucketResult, WindowResult, } from './storage/shield-storage.interface';
+export { TokenBucket } from './algorithms/token-bucket';
+export { SlidingWindowCounter } from './algorithms/sliding-window-counter';
+export { SlidingWindowLog } from './algorithms/sliding-window-log';
+export { FixedWindow } from './algorithms/fixed-window';
+export { LeakyBucket } from './algorithms/leaky-bucket';
+export { ShieldRateLimitException, ShieldBlockedException, ShieldPayloadException, } from './exceptions/shield.exceptions';
+export { IpUtil } from './utils/ip.util';
+export { HeadersUtil } from './utils/headers.util';
+export { UaUtil } from './utils/ua.util';
+export { KeyUtil } from './utils/key.util';

package/dist/index.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyUtil = exports.UaUtil = exports.HeadersUtil = exports.IpUtil = exports.ShieldPayloadException = exports.ShieldBlockedException = exports.ShieldRateLimitException = exports.LeakyBucket = exports.FixedWindow = exports.SlidingWindowLog = exports.SlidingWindowCounter = exports.TokenBucket = exports.RedisStorage = exports.MemoryStorage = exports.UserAgentPolicy = exports.BurstLimit = exports.MaxPayload = exports.SlowDown = exports.Whitelist = exports.Blacklist = exports.SkipShield = exports.RateLimit = exports.ALL_LAYERS = exports.SHIELD_STORAGE = exports.SHIELD_ENGINE = exports.SHIELD_CONFIG = exports.Shield = exports.ShieldGuard = exports.ShieldEngine = exports.ShieldModule = void 0;
+var shield_module_1 = require("./shield.module");
+Object.defineProperty(exports, "ShieldModule", { enumerable: true, get: function () { return shield_module_1.ShieldModule; } });
+var shield_engine_1 = require("./shield.engine");
+Object.defineProperty(exports, "ShieldEngine", { enumerable: true, get: function () { return shield_engine_1.ShieldEngine; } });
+var shield_guard_1 = require("./shield.guard");
+Object.defineProperty(exports, "ShieldGuard", { enumerable: true, get: function () { return shield_guard_1.ShieldGuard; } });
+var apply_to_1 = require("./apply-to");
+Object.defineProperty(exports, "Shield", { enumerable: true, get: function () { return apply_to_1.Shield; } });
+var shield_constants_1 = require("./shield.constants");
+Object.defineProperty(exports, "SHIELD_CONFIG", { enumerable: true, get: function () { return shield_constants_1.SHIELD_CONFIG; } });
+Object.defineProperty(exports, "SHIELD_ENGINE", { enumerable: true, get: function () { return shield_constants_1.SHIELD_ENGINE; } });
+Object.defineProperty(exports, "SHIELD_STORAGE", { enumerable: true, get: function () { return shield_constants_1.SHIELD_STORAGE; } });
+Object.defineProperty(exports, "ALL_LAYERS", { enumerable: true, get: function () { return shield_constants_1.ALL_LAYERS; } });
+var rate_limit_decorator_1 = require("./decorators/rate-limit.decorator");
+Object.defineProperty(exports, "RateLimit", { enumerable: true, get: function () { return rate_limit_decorator_1.RateLimit; } });
+var skip_shield_decorator_1 = require("./decorators/skip-shield.decorator");
+Object.defineProperty(exports, "SkipShield", { enumerable: true, get: function () { return skip_shield_decorator_1.SkipShield; } });
+var blacklist_decorator_1 = require("./decorators/blacklist.decorator");
+Object.defineProperty(exports, "Blacklist", { enumerable: true, get: function () { return blacklist_decorator_1.Blacklist; } });
+var whitelist_decorator_1 = require("./decorators/whitelist.decorator");
+Object.defineProperty(exports, "Whitelist", { enumerable: true, get: function () { return whitelist_decorator_1.Whitelist; } });
+var slow_down_decorator_1 = require("./decorators/slow-down.decorator");
+Object.defineProperty(exports, "SlowDown", { enumerable: true, get: function () { return slow_down_decorator_1.SlowDown; } });
+var max_payload_decorator_1 = require("./decorators/max-payload.decorator");
+Object.defineProperty(exports, "MaxPayload", { enumerable: true, get: function () { return max_payload_decorator_1.MaxPayload; } });
+var burst_limit_decorator_1 = require("./decorators/burst-limit.decorator");
+Object.defineProperty(exports, "BurstLimit", { enumerable: true, get: function () { return burst_limit_decorator_1.BurstLimit; } });
+var user_agent_policy_decorator_1 = require("./decorators/user-agent-policy.decorator");
+Object.defineProperty(exports, "UserAgentPolicy", { enumerable: true, get: function () { return user_agent_policy_decorator_1.UserAgentPolicy; } });
+var memory_storage_1 = require("./storage/memory.storage");
+Object.defineProperty(exports, "MemoryStorage", { enumerable: true, get: function () { return memory_storage_1.MemoryStorage; } });
+var redis_storage_1 = require("./storage/redis.storage");
+Object.defineProperty(exports, "RedisStorage", { enumerable: true, get: function () { return redis_storage_1.RedisStorage; } });
+var token_bucket_1 = require("./algorithms/token-bucket");
+Object.defineProperty(exports, "TokenBucket", { enumerable: true, get: function () { return token_bucket_1.TokenBucket; } });
+var sliding_window_counter_1 = require("./algorithms/sliding-window-counter");
+Object.defineProperty(exports, "SlidingWindowCounter", { enumerable: true, get: function () { return sliding_window_counter_1.SlidingWindowCounter; } });
+var sliding_window_log_1 = require("./algorithms/sliding-window-log");
+Object.defineProperty(exports, "SlidingWindowLog", { enumerable: true, get: function () { return sliding_window_log_1.SlidingWindowLog; } });
+var fixed_window_1 = require("./algorithms/fixed-window");
+Object.defineProperty(exports, "FixedWindow", { enumerable: true, get: function () { return fixed_window_1.FixedWindow; } });
+var leaky_bucket_1 = require("./algorithms/leaky-bucket");
+Object.defineProperty(exports, "LeakyBucket", { enumerable: true, get: function () { return leaky_bucket_1.LeakyBucket; } });
+var shield_exceptions_1 = require("./exceptions/shield.exceptions");
+Object.defineProperty(exports, "ShieldRateLimitException", { enumerable: true, get: function () { return shield_exceptions_1.ShieldRateLimitException; } });
+Object.defineProperty(exports, "ShieldBlockedException", { enumerable: true, get: function () { return shield_exceptions_1.ShieldBlockedException; } });
+Object.defineProperty(exports, "ShieldPayloadException", { enumerable: true, get: function () { return shield_exceptions_1.ShieldPayloadException; } });
+var ip_util_1 = require("./utils/ip.util");
+Object.defineProperty(exports, "IpUtil", { enumerable: true, get: function () { return ip_util_1.IpUtil; } });
+var headers_util_1 = require("./utils/headers.util");
+Object.defineProperty(exports, "HeadersUtil", { enumerable: true, get: function () { return headers_util_1.HeadersUtil; } });
+var ua_util_1 = require("./utils/ua.util");
+Object.defineProperty(exports, "UaUtil", { enumerable: true, get: function () { return ua_util_1.UaUtil; } });
+var key_util_1 = require("./utils/key.util");
+Object.defineProperty(exports, "KeyUtil", { enumerable: true, get: function () { return key_util_1.KeyUtil; } });

package/dist/shield.constants.d.ts

@@ -0,0 +1,22 @@
+export declare const SHIELD_CONFIG = "SHIELD_CONFIG";
+export declare const SHIELD_STORAGE = "SHIELD_STORAGE";
+export declare const SHIELD_ENGINE = "SHIELD_ENGINE";
+export declare const META_RATE_LIMIT = "shield:rate-limit";
+export declare const META_SKIP = "shield:skip";
+export declare const META_BLACKLIST = "shield:blacklist";
+export declare const META_WHITELIST = "shield:whitelist";
+export declare const META_SLOW_DOWN = "shield:slow-down";
+export declare const META_MAX_PAYLOAD = "shield:max-payload";
+export declare const META_BURST = "shield:burst";
+export declare const META_UA = "shield:user-agent";
+export declare const KEY_PREFIX = "shield";
+export declare const KEY_RATE_LIMIT = "shield:rl";
+export declare const KEY_VIOLATIONS = "shield:violations";
+export declare const KEY_BAN = "shield:ban";
+export declare const KEY_BAN_COUNT = "shield:ban-count";
+export declare const KEY_BURST = "shield:burst";
+export declare const KEY_SLOW_DOWN = "shield:sd";
+export declare const DEFAULT_MEMORY_MAX_KEYS = 100000;
+export declare const DEFAULT_HEADERS_STANDARD: "draft-7";
+export type ShieldLayer = 'whitelist' | 'blacklist' | 'auto-ban' | 'user-agent' | 'payload' | 'burst' | 'rate-limit' | 'slow-down';
+export declare const ALL_LAYERS: ShieldLayer[];

package/dist/shield.constants.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_LAYERS = exports.DEFAULT_HEADERS_STANDARD = exports.DEFAULT_MEMORY_MAX_KEYS = exports.KEY_SLOW_DOWN = exports.KEY_BURST = exports.KEY_BAN_COUNT = exports.KEY_BAN = exports.KEY_VIOLATIONS = exports.KEY_RATE_LIMIT = exports.KEY_PREFIX = exports.META_UA = exports.META_BURST = exports.META_MAX_PAYLOAD = exports.META_SLOW_DOWN = exports.META_WHITELIST = exports.META_BLACKLIST = exports.META_SKIP = exports.META_RATE_LIMIT = exports.SHIELD_ENGINE = exports.SHIELD_STORAGE = exports.SHIELD_CONFIG = void 0;
+exports.SHIELD_CONFIG = 'SHIELD_CONFIG';
+exports.SHIELD_STORAGE = 'SHIELD_STORAGE';
+exports.SHIELD_ENGINE = 'SHIELD_ENGINE';
+exports.META_RATE_LIMIT = 'shield:rate-limit';
+exports.META_SKIP = 'shield:skip';
+exports.META_BLACKLIST = 'shield:blacklist';
+exports.META_WHITELIST = 'shield:whitelist';
+exports.META_SLOW_DOWN = 'shield:slow-down';
+exports.META_MAX_PAYLOAD = 'shield:max-payload';
+exports.META_BURST = 'shield:burst';
+exports.META_UA = 'shield:user-agent';
+exports.KEY_PREFIX = 'shield';
+exports.KEY_RATE_LIMIT = `${exports.KEY_PREFIX}:rl`;
+exports.KEY_VIOLATIONS = `${exports.KEY_PREFIX}:violations`;
+exports.KEY_BAN = `${exports.KEY_PREFIX}:ban`;
+exports.KEY_BAN_COUNT = `${exports.KEY_PREFIX}:ban-count`;
+exports.KEY_BURST = `${exports.KEY_PREFIX}:burst`;
+exports.KEY_SLOW_DOWN = `${exports.KEY_PREFIX}:sd`;
+exports.DEFAULT_MEMORY_MAX_KEYS = 100_000;
+exports.DEFAULT_HEADERS_STANDARD = 'draft-7';
+exports.ALL_LAYERS = [
+    'whitelist',
+    'blacklist',
+    'auto-ban',
+    'user-agent',
+    'payload',
+    'burst',
+    'rate-limit',
+    'slow-down',
+];

package/dist/shield.engine.d.ts

@@ -0,0 +1,21 @@
+import { ShieldBlockedException, ShieldPayloadException, ShieldRateLimitException } from './exceptions/shield.exceptions';
+import type { AnyRequest, AnyResponse, DecoratorOverrides, ShieldConfig } from './shield.types';
+import type { ShieldStorage } from './storage/shield-storage.interface';
+export interface EngineDecision {
+    allowed: boolean;
+    delayMs?: number;
+    release?: () => Promise<void> | void;
+    ip: string;
+    exception?: ShieldRateLimitException | ShieldBlockedException | ShieldPayloadException;
+}
+export declare class ShieldEngine {
+    private readonly config;
+    private readonly storage;
+    constructor(config: ShieldConfig, storage: ShieldStorage);
+    getConfig(): ShieldConfig;
+    getStorage(): ShieldStorage;
+    run(req: AnyRequest, res: AnyResponse, overrides?: DecoratorOverrides): Promise<EngineDecision>;
+    private merge;
+    private mergeRateLimit;
+    private notifyReject;
+}