fix: distinguish local mutex correctly

packages/backend/server/src/base/mutex/mutex.ts

@@ -3,6 +3,7 @@ import { randomUUID } from 'node:crypto';
 import { Inject, Injectable, Logger, Scope } from '@nestjs/common';
 import { ModuleRef, REQUEST } from '@nestjs/core';
 import type { Request } from 'express';
+import { nanoid } from 'nanoid';
 
 import { GraphqlContext } from '../graphql';
 import { retryable } from '../utils/promise';
@@ -14,7 +15,7 @@ export const MUTEX_WAIT = 100;
 @Injectable()
 export class Mutex {
   protected logger = new Logger(Mutex.name);
-  private readonly clusterIdentifier = `cluster:${randomUUID()}`;
+  private readonly clusterIdentifier = `cluster:${nanoid()}`;
 
   constructor(protected readonly locker: Locker) {}
 
@@ -39,7 +40,10 @@ export class Mutex {
    * @param key resource key
    * @returns LockGuard
    */
-  async acquire(key: string, owner: string = this.clusterIdentifier) {
+  async acquire(
+    key: string,
+    owner: string = `${this.clusterIdentifier}:${nanoid()}`
+  ) {
     try {
       return await retryable(
         () => this.locker.lock(owner, key),

packages/backend/server/tests/mutex.spec.ts

@@ -0,0 +1,65 @@
+import { TestingModule } from '@nestjs/testing';
+import ava, { TestFn } from 'ava';
+import Sinon from 'sinon';
+
+import { Locker, Mutex } from '../src/base/mutex';
+import { SessionRedis } from '../src/base/redis';
+import { createTestingModule, sleep } from './utils';
+
+const test = ava as TestFn<{
+  module: TestingModule;
+  mutex: Mutex;
+  locker: Locker;
+  session: SessionRedis;
+}>;
+
+test.beforeEach(async t => {
+  const module = await createTestingModule();
+
+  t.context.module = module;
+  t.context.mutex = module.get(Mutex);
+  t.context.locker = module.get(Locker);
+  t.context.session = module.get(SessionRedis);
+});
+
+test.afterEach(async t => {
+  await t.context.module.close();
+});
+
+test('should be able to acquire lock', async t => {
+  const { mutex } = t.context;
+
+  {
+    t.truthy(await mutex.acquire('test'), 'should be able to acquire lock');
+    t.falsy(
+      await mutex.acquire('test'),
+      'should not be able to acquire lock again'
+    );
+  }
+
+  {
+    const lock1 = await mutex.acquire('test');
+    t.truthy(lock1);
+    await lock1?.release();
+    const lock2 = await mutex.acquire('test');
+    t.truthy(lock2);
+  }
+});
+
+test('should be able to acquire lock parallel', async t => {
+  const { mutex, locker } = t.context;
+  const spyedLocker = Sinon.spy(locker, 'lock');
+  const requestLock = async (key: string) => {
+    const lock = mutex.acquire(key);
+    await using _lock = await lock;
+    await t.throwsAsync(spyedLocker.lastCall.returnValue, {
+      message: `Failed to acquire lock for resource [${key}]`,
+    });
+    await sleep(100);
+  };
+
+  await t.notThrowsAsync(
+    Promise.all(Array.from({ length: 10 }, _ => requestLock('test'))),
+    'should be able to acquire lock parallel'
+  );
+});