Retries are safe.Charges happen once.

import { Elysia } from 'elysia'
import { idempotency } from 'elysia-idempotency'

let charges = 0

const app = new Elysia()
  .use(idempotency())
  .post('/charges', ({ body }) => ({ charge: ++charges, body }))
  .listen(3000)

import { Elysia } from 'elysia'
import { idempotency } from 'elysia-idempotency'

const orders = new Elysia({ prefix: '/orders' })
  .use(idempotency({ required: true, prefix: 'orders' }))
  .post('/', () => ({ created: true }))
  .patch('/:id', ({ params }) => ({ updated: params.id }))

const app = new Elysia()
  .post('/search', () => ({ results: [] }))
  .use(orders)

import { RedisClient } from 'bun'
import { Elysia } from 'elysia'
import { RedisStore, idempotency } from 'elysia-idempotency'

const redis = new RedisClient(process.env.REDIS_URL ?? 'redis://localhost:6379')
const store = new RedisStore({ client: redis })

const app = new Elysia()
  .use(idempotency({ store }))
  .post('/orders', () => ({ created: true }))
  .onStop(() => redis.close())

import { Elysia } from 'elysia'
import { idempotency } from 'elysia-idempotency'

const sessions = new Map<string, { readonly userId: string }>()

const app = new Elysia()
  .use(
    idempotency({
      identity: ({ elysia, ip }) => {
        const sessionId = elysia.cookie.session?.value
        const session = typeof sessionId === 'string' ? sessions.get(sessionId) : undefined
        if (session !== undefined) return `user:${session.userId}`
        return ip === null ? 'anonymous' : `ip:${ip}`
      },
    }),
  )
  .post('/posts', () => ({ created: true }))

import { Elysia } from 'elysia'
import { idempotency } from 'elysia-idempotency'
import { rateLimit } from 'elysia-rate-limiter'

const app = new Elysia()
  .use(rateLimit({ limit: 20, window: '1m' }))
  .use(idempotency())
  .post('/orders', () => ({ created: true }))

import { IdempotencyEngine } from 'elysia-idempotency'

interface OrderPaid {
  readonly messageId: string
  readonly orderId: string
}

const engine = new IdempotencyEngine({ retention: '7d', lockTimeout: '5m' })

const shipOrder = async (orderId: string): Promise<void> => {
  console.log(`shipping ${orderId}`)
}

export const onOrderPaid = async (message: OrderPaid): Promise<'done' | 'duplicate' | 'busy'> => {
  const fingerprint = Bun.CryptoHasher.hash('sha256', JSON.stringify(message), 'hex')
  const outcome = await engine.begin({ scope: 'order-paid', key: message.messageId, fingerprint })
  if (outcome.kind === 'replay' || outcome.kind === 'mismatch') return 'duplicate'
  if (outcome.kind === 'in-progress') return 'busy'
  try {
    await shipOrder(message.orderId)
    await engine.complete(outcome.lease, { status: 200, headers: [], body: null, bodyOmitted: false })
    return 'done'
  } catch (error) {
    await engine.release(outcome.lease)
    throw error
  }
}