レート制限

node ace add @adonisjs/limiter

import env from '#start/env'
import { defineConfig, stores } from '@adonisjs/limiter'

const limiterConfig = defineConfig({
  default: env.get('LIMITER_STORE'),

  stores: {
    redis: stores.redis({}),

    database: stores.database({
      tableName: 'rate_limits'
    }),

    memory: stores.memory({}),
  },
})

export default limiterConfig

declare module '@adonisjs/limiter/types' {
  export interface LimitersList extends InferLimiters<typeof limiterConfig> {}
}

{
  LIMITER_STORE: Env.schema.enum(['redis', 'database', 'memory'] as const),
}

{
  redis: stores.redis({
    connectionName: 'main',
    rejectIfRedisNotReady: false,
  }),
}

{
  database: stores.database({
    connectionName: 'mysql',
    dbName: 'my_app',
    tableName: 'rate_limits',
    schemaName: 'public',
    clearExpiredByTimeout: false,
  }),
}

import limiter from '@adonisjs/limiter/services/main'

export const throttle = limiter.define('global', () => {
  return limiter.allowRequests(10).every('1 minute')
})

import router from '@adonisjs/core/services/router'
import { throttle } from '#start/limiter'

router
  .get('/', () => {})
  .use(throttle)

export const apiThrottle = limiter.define('api', (ctx) => {
  /**
   * ログイン済みのユーザーは、ユーザーIDごとに100リクエストを許可します。
   */
  if (ctx.auth.user) {
    return limiter
      .allowRequests(100)
      .every('1 minute')
      .usingKey(`user_${ctx.auth.user.id}`)
  }

  /**
   * ゲストユーザーは、IPアドレスごとに10リクエストを許可します。
   */
  return limiter
    .allowRequests(10)
    .every('1 minute')
    .usingKey(`ip_${ctx.request.ip()}`)
})

import { apiThrottle } from '#start/limiter'

router
  .get('/api/repos/:id/stats', [RepoStatusController])
  .use(apiThrottle)

limiter
  .allowRequests(10)
  .every('1 minute')
  .store('redis')

limiter
  .allowRequests(10)
  .every('1 minute')
  .usingKey(`user_${ctx.auth.user.id}`)

limiter
  .allowRequests(10)
  .every('1 minute')
  /**
   * 1分間に10リクエストを超える場合、30分間ブロックされます。
   */
  .blockFor('30 mins')

import { errors } from '@adonisjs/limiter'
import { HttpContext, ExceptionHandler } from '@adonisjs/core/http'

export default class HttpExceptionHandler extends ExceptionHandler {
  protected debug = !app.inProduction
  protected renderStatusPages = app.inProduction

  async handle(error: unknown, ctx: HttpContext) {
    if (error instanceof errors.E_TOO_MANY_REQUESTS) {
      const message = error.getResponseMessage(ctx)
      const headers = error.getDefaultHeaders()

      Object.keys(headers).forEach((header) => {
        ctx.response.header(header, headers[header])
      })

      return ctx.response.status(error.status).send(message)
    }

    return super.handle(error, ctx)
  }
}

import limiter from '@adonisjs/limiter/services/main'

export const throttle = limiter.define('global', () => {
  return limiter
    .allowRequests(10)
    .every('1 minute')
    .limitExceeded((error) => {
      error
        .setStatus(400)
        .setMessage('リクエストを処理できません。後でもう一度お試しください')
    })
})

{
  "E_TOO_MANY_REQUESTS": "リクエストが多すぎます"
}

limitExceeded((error) => {
  error.t('errors.rate_limited', {
    limit: error.response.limit,
    remaining: error.response.remaining,
  })
})

import limiter from '@adonisjs/limiter/services/main'

const reportsLimiter = limiter.use('redis', {
  requests: 1,
  duration: '1 hour'
})

const reportsLimiter = limiter.use({
  requests: 1,
  duration: '1 hour'
})

const key = 'user_1_reports'

/**
 * 指定されたキーでアクションを実行しようとします。
 * 結果はコールバック関数の戻り値または、コールバックが実行されなかった場合はundefinedになります。
 */ 
const executed = reportsLimiter.attempt(key, async () => {
  await generateReport()
  return true
})

/**
 * 制限を超えたことをユーザーに通知します。
 */
if (!executed) {
  const availableIn = await reportsLimiter.availableIn(key)
  return `${availableIn}秒後に再試行してください`
}

return 'レポートが生成されました'

import User from '#models/user'
import { HttpContext } from '@adonisjs/core/http'
import limiter from '@adonisjs/limiter/services/main'

export default class SessionController {
  async store({ request, response, session }: HttpContext) {
    const { email, password } = request.only(['email', 'passwords'])

    /**
     * リミッターを作成する
     */
    const loginLimiter = limiter.use({
      requests: 5,
      duration: '1 min',
      blockDuration: '20 mins'
    })

    /**
     * IPアドレス+メールの組み合わせを使用します。これにより、
     * 攻撃者がメールを悪用している場合、実際のユーザーが
     * ログインできなくなることなく、攻撃者のIPアドレスのみをペナルティとします。
     */
    const key = `login_${request.ip()}_${email}`

    /**
     * User.verifyCredentialsを"penalize"メソッドでラップして、
     * 無効な資格情報のエラーごとに1つのリクエストを消費します。
     */
    const [error, user] = await loginLimiter.penalize(key, () => {
      return User.verifyCredentials(email, password)
    })

    /**
     * ThrottleExceptionの場合、カスタムエラーメッセージを含む
     * ユーザーを元のページにリダイレクトします。
     */
    if (error) {
      session.flashAll()
      session.flashErrors({
        E_TOO_MANY_REQUESTS: `${error.response.availableIn}秒後に再試行してください`
      })
      return response.redirect().back()
    }

    /**
     * それ以外の場合は、ユーザーをログインします。
     */
  }
}

import limiter from '@adonisjs/limiter/services/main'

const requestsLimiter = limiter.use({
  requests: 10,
  duration: '1 minute'
})

if (await requestsLimiter.remaining('unique_key') > 0) {
  await requestsLimiter.increment('unique_key')
  await performAction()
} else {
  return 'リクエストが多すぎます'
}

import { errors } from '@adonisjs/limiter'

try {
  await requestsLimiter.consume('unique_key')
  await performAction()
} catch (error) {
  if (error instanceof errors.E_TOO_MANY_REQUESTS) {
    return 'リクエストが多すぎます'
  }
}

import limiter from '@adonisjs/limiter/services/main'

const requestsLimiter = limiter.use({
  requests: 10,
  duration: '1 minute',
  blockDuration: '30 mins'
})

/**
 * ユーザーは1分間に10リクエストを行うことができます。ただし、
 * 11番目のリクエストを送信すると、キーを30分間ブロックします。
 */ 
await requestLimiter.consume('a_unique_key')

/**
 * consumeと同じ動作
 */
await requestLimiter.attempt('a_unique_key', () => {
})

/**
 * 10回の失敗を許可し、その後30分間キーをブロックします。
 */
await requestLimiter.penalize('a_unique_key', () => {
})

const requestsLimiter = limiter.use({
  requests: 10,
  duration: '1 minute',
})

await requestsLimiter.block('a_unique_key', '30 mins')

import limiter from '@adonisjs/limiter/services/main'

const jobsLimiter = limiter.use({
  requests: 2,
  duration: '5 mins',
})

await jobsLimiter.attempt('unique_key', async () => {
  await processJob()

  /**
   * ジョブの処理が完了した後に消費されたリクエストを減らします。
   * これにより、他のワーカーがスロットを使用できるようになります。
   */
  await jobsLimiter.decrement('unique_key')
})

import limiter from '@adonisjs/limiter/services/main'

const requestsLimiter = limiter.use({
  requests: 2,
  duration: '5 mins',
})

await requestsLimiter.delete('unique_key')

LIMITER_STORE=memory

import limiter from '@adonisjs/limiter/services/main'

test.group('Reports', (group) => {
  group.each.setup(() => {
    return () => limiter.clear(['redis', 'memory'])
  })
})

test.group('Reports', (group) => {
  group.each.setup(() => {
    return () => limiter.clear()
  })
})

import string from '@adonisjs/core/helpers/string'
import { LimiterResponse } from '@adonisjs/limiter'
import {
  LimiterStoreContract,
  LimiterConsumptionOptions
} from '@adonisjs/limiter/types'

/**
 * 受け入れるカスタムオプションのセット
 */
export type MongoDbLimiterConfig = {
  client: MongoDBConnection
}

export class MongoDbLimiterStore implements LimiterStoreContract {
  readonly name = 'mongodb'
  declare readonly requests: number
  declare readonly duration: number
  declare readonly blockDuration: number

  constructor(public config: MongoDbLimiterConfig & LimiterConsumptionOptions) {
    this.requests = this.config.requests
    this.duration = string.seconds.parse(this.config.duration)
    this.blockDuration = string.seconds.parse(this.config.blockDuration)
  }

  /**
   * 指定されたキーのリクエストを1つ消費します。すべてのリクエストが既に消費されている場合は、エラーをスローする必要があります。
   */
  async consume(key: string | number): Promise<LimiterResponse> {
  }

  /**
   * 指定されたキーのリクエストを1つ消費しますが、すべてのリクエストが消費されている場合はエラーをスローしません。
   */
  async increment(key: string | number): Promise<LimiterResponse> {}

  /**
   * 指定されたキーのリクエストを1つ減らします。可能な場合は、リクエスト数を負の値に設定しないようにします。
   */
  async decrement(key: string | number): Promise<LimiterResponse> {}

  /**
   * 指定された期間キーをブロックします。
   */ 
  async block(
    key: string | number,
    duration: string | number
  ): Promise<LimiterResponse> {}
  
  /**
   * 指定されたキーの消費されたリクエスト数を設定します。明示的な期間が指定されていない場合は、設定ファイルから期間を推測する必要があります。
   */ 
  async set(
    key: string | number,
    requests: number,
    duration?: string | number
  ): Promise<LimiterResponse> {}

  /**
   * キーをストレージから削除します。
   */
  async delete(key: string | number): Promise<boolean> {}

  /**
   * データベースからすべてのキーをフラッシュします。
   */
  async clear(): Promise<void> {}

  /**
   * 指定されたキーに対するレートリミットのレスポンスを取得します。キーが存在しない場合は`null`を返します。
   */
  async get(key: string | number): Promise<LimiterResponse | null> {}
}

import { LimiterManagerStoreFactory } from '@adonisjs/limiter/types'

/**
 * 設定ファイル内でmongoDbストアを使用するための設定ヘルパー
 */
export function mongoDbStore(config: MongoDbLimiterConfig) {
  const storeFactory: LimiterManagerStoreFactory = (runtimeOptions) => {
    return new MongoDbLimiterStore({
      ...config,
      ...runtimeOptions
    })
  }
}

import env from '#start/env'
import { mongoDbStore } from 'my-custom-package'
import { defineConfig } from '@adonisjs/limiter'

const limiterConfig = defineConfig({
  default: env.get('LIMITER_STORE'),

  stores: {
    mongodb: mongoDbStore({
      client: mongoDb // create mongoDb client
    })
  },
})

import { RateLimiterBridge } from '@adonisjs/limiter'
import { RateLimiterMongo } from 'rate-limiter-flexible'

export class MongoDbLimiterStore extends RateLimiterBridge {
  readonly name = 'mongodb'

  constructor(public config: MongoDbLimiterConfig & LimiterConsumptionOptions) {
    super(
      new RateLimiterMongo({
        storeClient: config.client,
        points: config.requests,
        duration: string.seconds.parse(config.duration),
        blockDuration: string.seconds.parse(this.config.blockDuration)
        // ... 他のオプションも提供します
      })
    )
  }

  /**
   * clearメソッドを自己実装します。理想的には、
   * config.clientを使用して削除クエリを発行します
   */
  async clear() {}
}