アトミックロック

node ace add @adonisjs/lock

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

const lockConfig = defineConfig({
  default: env.get('LOCK_STORE'),
  stores: {
    redis: stores.redis({}),

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

    memory: stores.memory()
  },
})

export default lockConfig

declare module '@adonisjs/lock/types' {
  export interface LockStoresList extends InferLockStores<typeof lockConfig> {}
}

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

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

{
  database: stores.database({
    connectionName: 'postgres',
    tableName: 'my_locks',
  }),
}

{
  memory: stores.memory(),
}

import locks from '@adonisjs/lock/services/main'

const lock = locks.use('redis').createLock('order.processing.1')

import locks from '@adonisjs/lock/services/main'

const lock = locks.createLock('order.processing.1')

import locks from '@adonisjs/lock/services/main'

export class OrderController {
  async process({ response, request }: HttpContext) {
    const orderId = request.input('order_id')

    const lock = locks.createLock(`order.processing.${orderId}`)
    await lock.acquire()

    /**
     * オーダーを処理するためにバックグラウンドジョブをディスパッチします。
     * 
     * ジョブがオーダーの処理が完了した後、ロックを解放するためにシリアライズされたロックをジョブに渡します。
     */
    queue.dispatch('app/jobs/process_order', {
      lock: lock.serialize()
    })
  }
}

import locks from '@adonisjs/lock/services/main'

export class ProcessOrder {
  async handle({ lock }) {
    /**
     * シリアライズされたバージョンからロックを復元しています
     */
    const handle = locks.restoreLock(lock)

    /**
     * オーダーを処理します
     */
    await processOrder()

    /**
     * ロックを解放します
     */
    await handle.release()
  }
}

LOCK_STORE=memory

import type { LockStore } from '@adonisjs/lock/types'

class NoopStore implements LockStore {
  /**
   * ロックをストアに保存します。
   * このメソッドは、指定されたキーが既にロックされている場合はfalseを返す必要があります。
   *
   * @param key ロックするキー
   * @param owner オーナー
   * @param ttl ロックの有効期限（ミリ秒）。nullの場合は期限なし
   *
   * @returns ロックが取得された場合はtrue、それ以外の場合はfalse
   */
  async save(key: string, owner: string, ttl: number | null): Promise<boolean> {
    return false
  }

  /**
   * オーナーが指定された場合にのみ、ストアからロックを削除します。
   * それ以外の場合はE_LOCK_NOT_OWNEDエラーをスローする必要があります。
   *
   * @param key 削除するキー
   * @param owner オーナー
   */
  async delete(key: string, owner: string): Promise<void> {
    return false
  }

  /**
   * オーナーを確認せずにストアからロックを強制的に削除します。
   */
  async forceDelete(key: string): Promise<Void> {
    return false
  }

  /**
   * ロックが存在するかどうかをチェックします。存在する場合はtrue、それ以外の場合はfalseを返します。
   */
  async exists(key: string): Promise<boolean> {
    return false
  }

  /**
   * ロックの有効期限を延長します。ロックが指定されたオーナーによって所有されていない場合はエラーをスローします。
   * 期間はミリ秒単位です。
   */
  async extend(key: string, owner: string, duration: number): Promise<void> {
    return false
  }
}

function noopStore(options: MyNoopStoreConfig) {
  return { driver: { factory: () => new NoopStore(options) } }
}

import { defineConfig } from '@adonisjs/lock'

const lockConfig = defineConfig({
  default: 'noop',
  stores: {
    noop: noopStore({}),
  },
})