Method withLock

src/server/cache/distributedLock.ts:229–265

* Execute a function with a distributed lock * @param lockName - Name of the lock * @param fn - Function to execute while holding the lock * @param options - Lock options * @returns Promise - Result of the function execution

(
    lockName: string,
    fn: () => Promise<T>,
    options?: Partial<DistributedLockOptions>
  )

   * @returns Promise<T> - Result of the function execution
   */
  async withLock<T>(
    lockName: string,
    fn: () => Promise<T>,
    options?: Partial<DistributedLockOptions>
  ): Promise<T | null> {
    const lockResult = await this.acquire(lockName, options);

    if (!lockResult.acquired) {
      const skipMessage = options?.skipOnFailure
        ? `[DistributedLock] Skipping execution for: ${lockName} (skipOnFailure=true)`
        : `[DistributedLock] Could not acquire lock for: ${lockName}, skipping execution`;

      logger.debug(skipMessage);
      return null;
    }

    try {
      logger.debug(
        `[DistributedLock] Executing function with lock: ${lockName}`
      );
      const result = await fn();
      logger.debug(
        `[DistributedLock] Function completed successfully with lock: ${lockName}`
      );
      return result;
    } catch (error) {
      logger.error(
        `[DistributedLock] Error executing function with lock ${lockName}:`,
        error
      );
      throw error;
    } finally {
      if (lockResult.release) {
        await lockResult.release();
      }
    }
  }

  /**
   * Check if a lock is currently held