Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

5.9 KB
Raw Blame
import { logger } from '@librechat/data-schemas';
import { isBalanceRefillDue } from 'librechat-data-provider';
import type {
  IBalanceUpdate,
  BalanceConfig,
  AppConfig,
  ObjectId,
  IBalance,
  IUser,
} from '@librechat/data-schemas';
import type { NextFunction, Request as ServerRequest, Response as ServerResponse } from 'express';
import type { BalanceUpdateFields } from '~/types';
import { getBalanceConfig } from '~/app/config';

export interface BalanceMiddlewareOptions {
  getAppConfig: (options?: {
    role?: string;
    userId?: string;
    tenantId?: string;
    refresh?: boolean;
  }) => Promise<AppConfig>;
  findBalanceByUser: (
    userId: string,
    options?: { applyReset?: boolean },
  ) => Promise<IBalance | null>;
  upsertBalanceFields: (
    userId: string,
    fields: IBalanceUpdate,
    insertOnly?: IBalanceUpdate,
  ) => Promise<IBalance | null>;
}

type BalanceLocals = {
  balanceData?: IBalance | null;
  balanceConfigEnabled?: boolean;
};

const balanceUpdateLocks = new Map<string, Promise<void>>();

async function runBalanceUpdate(userId: string, task: () => Promise<void>): Promise<void> {
  const previous = balanceUpdateLocks.get(userId) ?? Promise.resolve();
  const current = previous.catch(() => undefined).then(task);
  const tail = current.then(
    () => undefined,
    () => undefined,
  );

  balanceUpdateLocks.set(userId, tail);

  try {
    await current;
  } finally {
    if (balanceUpdateLocks.get(userId) === tail) {
      balanceUpdateLocks.delete(userId);
    }
  }
}

/**
 * Build an object containing fields that need updating
 * @param config - The balance configuration
 * @param userRecord - The user's current balance record, if any
 * @param userId - The user's ID
 * @returns Fields that need updating
 */
export function buildBalanceUpdateFields(
  config: BalanceConfig,
  userRecord: IBalance | null,
  userId: string,
): BalanceUpdateFields {
  const updateFields: BalanceUpdateFields = {};

  // Ensure user record has the required fields
  if (!userRecord) {
    updateFields.user = userId;
    updateFields.tokenCredits = config.startBalance;
  }

  if (userRecord?.tokenCredits == null && config.startBalance != null) {
    updateFields.tokenCredits = config.startBalance;
  }

  const isAutoRefillConfigValid =
    config.autoRefillEnabled &&
    config.refillIntervalValue != null &&
    config.refillIntervalUnit != null &&
    config.refillAmount != null &&
    (config.refillMode !== 'reset' ||
      (Number.isInteger(config.refillIntervalValue) && config.refillIntervalValue > 0));

  if (!isAutoRefillConfigValid) {
    if (userRecord?.autoRefillEnabled === true) {
      updateFields.autoRefillEnabled = false;
    }
    return updateFields;
  }

  if (userRecord?.autoRefillEnabled !== config.autoRefillEnabled) {
    updateFields.autoRefillEnabled = config.autoRefillEnabled;
  }

  if (userRecord?.refillIntervalValue !== config.refillIntervalValue) {
    updateFields.refillIntervalValue = config.refillIntervalValue;
  }

  if (userRecord?.refillIntervalUnit !== config.refillIntervalUnit) {
    updateFields.refillIntervalUnit = config.refillIntervalUnit;
  }

  const refillMode = config.refillMode ?? 'add';
  if ((userRecord?.refillMode ?? 'add') !== refillMode) {
    updateFields.refillMode = refillMode;
  }

  if (userRecord?.refillAmount !== config.refillAmount) {
    updateFields.refillAmount = config.refillAmount;
  }

  // Initialize lastRefill if it's missing when auto-refill is enabled
  if (config.autoRefillEnabled && !userRecord?.lastRefill) {
    updateFields.lastRefill = new Date();
  }

  return updateFields;
}

/**
 * Factory function to create middleware that synchronizes user balance settings with current balance configuration.
 * @param options - Options containing getBalanceConfig function and Balance model
 * @returns Express middleware function
 */
export function createSetBalanceConfig({
  getAppConfig,
  findBalanceByUser,
  upsertBalanceFields,
}: BalanceMiddlewareOptions): (
  req: ServerRequest,
  res: ServerResponse,
  next: NextFunction,
) => Promise<void> {
  return async (req: ServerRequest, res: ServerResponse, next: NextFunction): Promise<void> => {
    try {
      const balanceLocals = res.locals as BalanceLocals;
      const user = req.user as IUser & { _id: string | ObjectId };
      const appConfig = await getAppConfig({
        role: user?.role,
        userId: user?.id,
        tenantId: user?.tenantId,
      });
      const balanceConfig = getBalanceConfig(appConfig);
      balanceLocals.balanceConfigEnabled = balanceConfig?.enabled === true;
      if (!balanceConfig?.enabled) {
        return next();
      }
      if (balanceConfig.startBalance == null) {
        return next();
      }

      if (!user || !user._id) {
        return next();
      }
      const userId = typeof user._id === 'string' ? user._id : user._id.toString();
      await runBalanceUpdate(userId, async () => {
        const userBalanceRecord = await findBalanceByUser(userId, { applyReset: false });
        const updateFields = buildBalanceUpdateFields(balanceConfig, userBalanceRecord, userId);

        if (Object.keys(updateFields).length === 0) {
          balanceLocals.balanceData =
            balanceConfig.autoRefillEnabled === true &&
            userBalanceRecord?.refillMode === 'reset' &&
            isBalanceRefillDue(userBalanceRecord, new Date())
              ? await findBalanceByUser(userId)
              : userBalanceRecord;
          return;
        }

        if (userBalanceRecord == null) {
          const { tokenCredits, ...syncFields } = updateFields;
          balanceLocals.balanceData = await upsertBalanceFields(userId, syncFields, {
            tokenCredits,
          });
          return;
        }

        balanceLocals.balanceData = await upsertBalanceFields(userId, updateFields);
      });

      next();
    } catch (error) {
      logger.error('Error setting user balance:', error);
      next(error);
    }
  };
}