• Index
• Search by APIs
• Search by Words
• Project Search

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• ts-di-starter-master
  • .eslintignore
  • src
    • configLoader.ts
    • config.ts
    • server.ts
    • lib
      • services
        • limiters
          • error.ts
          • general.ts
          • limiterGroup.ts
        • events.ts
        • users.ts
        • records.ts
      • express
        • responseBuilder.ts
        • middleware
          • user.ts
          • index.ts
          • exceptionHandler.ts
          • logger.ts
          • limiter.ts
        • controllers
          • user.ts
          • index.ts
          • records.ts
          • health.ts
        • utils.ts
        • .eslintrc.js
      • models
        • record.ts
        • user.ts
        • event.ts
        • limiter.ts
      • socket
        • socket.ts
        • middleware
          • user.ts
          • index.ts
        • controllers
          • index.ts
          • userData.ts
          • .eslintrc.js
      • requests
        • createRecord.ts
    • logger.ts
    • app
      • index.ts
      • api
        • v1
          • health
            • index.ts
          • user
            • index.ts
          • index.ts
          • records
            • index.ts
        • index.ts
      • socketMiddleware.ts
      • expressMiddleware.ts
      • serviceManager.ts
    • start.ts
  • .circleci
    • config.yml
  • example.env
  • images
  • LICENSE
  • commitlint.config.js
  • webpack.config.js
  • example.env.local
  • README.md
  • package.json
  • tests
    • mockRedis.ts
    • lib
      • services
        • events.it.ts
        • users.unit.ts
        • events.unit.ts
    • getAppForTest.ts
    • firestore.ts
    • app
      • health
        • health.unit.ts
      • fixture.ts
      • user
        • user.unit.ts
      • records
        • records.unit.ts
    • .eslintrc.js
  • .eslintrc.js
  • tsconfig.json
  • .gitignore
  • .nycrc.json
  • .prettierrc.js
  • .dockerignore
  • docker-compose.yml

import { Redis } from '@ehacke/redis';
import { RateLimiterMemory, RateLimiterRedis } from 'rate-limiter-flexible';

export interface LimitResultInterface {
  name: string;
  limit: number;
  remaining: number;
  resetMs: number;
  blockReason: string | null;
}

export interface CreateLimiterInterface {
  redis: Redis;

  points: number;
  durationSec: number;
  blockDurationSec: number;

  name: string;
  reason: string;

  getKey(body, ipAddress: string): string;
  shouldConsume(body, ipAddress: string): Promise<boolean>;
  shouldReset(body, ipAddress: string): Promise<boolean>;

  execEvenly?: boolean;
  execEvenlyMinDelayMs?: number;
}

interface LimiterInterface {
  limiter: RateLimiterRedis;
  name: string;
  max: number;
  reason: string;
  blockDurationSec: number;
  getKey(body, ipAddress): string;
  shouldConsume(body, ipAddress: string): Promise<boolean>;
  shouldReset(body, ipAddress: string): Promise<boolean>;
}

const CONSTANTS = {
  WORKER_COUNT: 1,
};

/**
 * @class
 */
export class Limiter implements LimiterInterface {
  /**
   * @param {LimiterInterface} params
   */
  constructor(params: LimiterInterface) {
    this.limiter = params.limiter;

    this.name = params.name;
    this.reason = params.reason;
    this.max = params.max;
    this.getKey = params.getKey;
    this.shouldConsume = params.shouldConsume;
    this.shouldReset = params.shouldReset;
    this.blockDurationSec = params.blockDurationSec;
  }

  readonly name: string;

  readonly reason: string;

  readonly max: number;

  readonly blockDurationSec: number;

  // eslint-disable-next-line no-unused-vars,class-methods-use-this,@typescript-eslint/no-unused-vars,require-jsdoc
  getKey(body: any, ipAddress: string): string {
    throw new Error('Method not implemented.');
  }

  // eslint-disable-next-line no-unused-vars,class-methods-use-this,@typescript-eslint/no-unused-vars,require-jsdoc
  shouldConsume(body: any, ipAddress: string): Promise<boolean> {
    throw new Error('Method not implemented.');
  }

  // eslint-disable-next-line no-unused-vars,class-methods-use-this,@typescript-eslint/no-unused-vars,require-jsdoc
  shouldReset(body: any, ipAddress: string): Promise<boolean> {
    throw new Error('Method not implemented.');
  }

  readonly limiter: RateLimiterRedis;

  /**
   * Create instance
   *
   * @param {CreateLimiterInterface} params
   * @returns {Limiter}
   */
  static create(params: CreateLimiterInterface): Limiter {
    const rateLimiterMemory = new RateLimiterMemory({
      keyPrefix: params.name,
      points: Math.round(params.points / CONSTANTS.WORKER_COUNT),
      duration: params.durationSec,
      blockDuration: params.blockDurationSec,
      execEvenly: params.execEvenly,
      execEvenlyMinDelayMs: params.execEvenlyMinDelayMs,
    });

    return new Limiter({
      name: params.name,
      reason: params.reason,
      getKey: params.getKey,
      shouldConsume: params.shouldConsume,
      shouldReset: params.shouldReset,
      max: params.points,
      blockDurationSec: params.blockDurationSec,
      limiter: new RateLimiterRedis({
        storeClient: params.redis,
        keyPrefix: params.name,
        points: params.points,
        duration: params.durationSec,
        blockDuration: params.blockDurationSec,
        execEvenly: params.execEvenly,
        execEvenlyMinDelayMs: params.execEvenlyMinDelayMs,
        insuranceLimiter: rateLimiterMemory,
      }),
    });
  }
}