refactor(data-schemas): enhance method organization and add librechat-data-provider dependency

package-lock.json

@@ -45642,6 +45642,7 @@
       },
       "peerDependencies": {
         "keyv": "^5.3.2",
+        "librechat-data-provider": "*",
         "mongoose": "^8.12.1"
       }
     },

packages/data-schemas/package.json

@@ -70,7 +70,8 @@
   },
   "peerDependencies": {
     "keyv": "^5.3.2",
-    "mongoose": "^8.12.1"
+    "mongoose": "^8.12.1",
+    "librechat-data-provider": "*"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",

packages/data-schemas/src/methods/index.ts

@@ -1,8 +1,24 @@
-// User methods
-export * from './user';
+import { createUserMethods, type UserMethods } from './user';
+import { createSessionMethods, type SessionMethods } from './session';
+import { createTokenMethods, type TokenMethods } from './token';
+import { createRoleMethods, type RoleMethods } from './role';
 
-// Session methods
-export * from './session';
+/**
+ * Creates all database methods for all collections
+ */
+export function createAllMethods(mongoose: typeof import('mongoose')) {
+  return {
+    ...createUserMethods(mongoose),
+    ...createSessionMethods(mongoose),
+    ...createTokenMethods(mongoose),
+    ...createRoleMethods(mongoose),
+  };
+}
 
-// Token methods
-export * from './token';
+export type AllMethods = UserMethods & SessionMethods & TokenMethods & RoleMethods;
+
+// Also export individual factory functions for granular usage if needed
+export { createUserMethods, type UserMethods } from './user';
+export { createSessionMethods, type SessionMethods } from './session';
+export { createTokenMethods, type TokenMethods } from './token';
+export { createRoleMethods, type RoleMethods } from './role';

packages/data-schemas/src/methods/session.ts

@@ -1,5 +1,3 @@
-import mongoose from 'mongoose';
-import { Session } from '~/models';
 import {
   ISession,
   CreateSessionOptions,
@@ -16,13 +14,15 @@ import logger from '~/config/winston';
 const { REFRESH_TOKEN_EXPIRY } = process.env ?? {};
 const expires = eval(REFRESH_TOKEN_EXPIRY ?? '0') ?? 1000 * 60 * 60 * 24 * 7; // 7 days default
 
-/**
+// Factory function that takes mongoose instance and returns the methods
+export function createSessionMethods(mongoose: typeof import('mongoose')) {
+  /**
    * Creates a new session for a user
    */
-export async function createSession(
+  async function createSession(
     userId: string,
     options: CreateSessionOptions = {},
-): Promise<SessionResult> {
+  ): Promise<SessionResult> {
     if (!userId) {
       throw new SessionError('User ID is required', 'INVALID_USER_ID');
     }
@@ -40,20 +40,24 @@ export async function createSession(
       logger.error('[createSession] Error creating session:', error);
       throw new SessionError('Failed to create session', 'CREATE_SESSION_FAILED');
     }
-}
+  }
 
-/**
+  /**
    * Finds a session by various parameters
    */
-export async function findSession(
+  async function findSession(
     params: SessionSearchParams,
     options: SessionQueryOptions = { lean: true },
-): Promise<ISession | null> {
+  ): Promise<ISession | null> {
     try {
+      const Session = mongoose.models.Session;
       const query: Record<string, unknown> = {};
 
       if (!params.refreshToken && !params.userId && !params.sessionId) {
-      throw new SessionError('At least one search parameter is required', 'INVALID_SEARCH_PARAMS');
+        throw new SessionError(
+          'At least one search parameter is required',
+          'INVALID_SEARCH_PARAMS',
+        );
       }
 
       if (params.refreshToken) {
@@ -82,7 +86,7 @@ export async function findSession(
       const sessionQuery = Session.findOne(query);
 
       if (options.lean) {
-      return await sessionQuery.lean();
+        return (await sessionQuery.lean()) as ISession | null;
       }
 
       return await sessionQuery.exec();
@@ -90,15 +94,15 @@ export async function findSession(
       logger.error('[findSession] Error finding session:', error);
       throw new SessionError('Failed to find session', 'FIND_SESSION_FAILED');
     }
-}
+  }
 
-/**
+  /**
    * Deletes a session by refresh token or session ID
    */
-export async function deleteSession(
-  params: DeleteSessionParams,
-): Promise<{ deletedCount?: number }> {
+  async function deleteSession(params: DeleteSessionParams): Promise<{ deletedCount?: number }> {
     try {
+      const Session = mongoose.models.Session;
+
       if (!params.refreshToken && !params.sessionId) {
         throw new SessionError(
           'Either refreshToken or sessionId is required',
@@ -127,17 +131,18 @@ export async function deleteSession(
       logger.error('[deleteSession] Error deleting session:', error);
       throw new SessionError('Failed to delete session', 'DELETE_SESSION_FAILED');
     }
-}
+  }
 
-/**
+  /**
    * Generates a refresh token for a session
    */
-export async function generateRefreshToken(session: Partial<ISession>): Promise<string> {
+  async function generateRefreshToken(session: Partial<ISession>): Promise<string> {
     if (!session || !session.user) {
       throw new SessionError('Invalid session object', 'INVALID_SESSION');
     }
 
     try {
+      const Session = mongoose.models.Session;
       const expiresIn = session.expiration ? session.expiration.getTime() : Date.now() + expires;
       if (!session.expiration) {
         session.expiration = new Date(expiresIn);
@@ -159,16 +164,18 @@ export async function generateRefreshToken(session: Partial<ISession>): Promise<
       logger.error('[generateRefreshToken] Error generating refresh token:', error);
       throw new SessionError('Failed to generate refresh token', 'GENERATE_TOKEN_FAILED');
     }
-}
+  }
 
-/**
+  /**
    * Deletes all sessions for a user
    */
-export async function deleteAllUserSessions(
+  async function deleteAllUserSessions(
     userId: string | { userId: string },
     options: DeleteAllSessionsOptions = {},
-): Promise<{ deletedCount?: number }> {
+  ): Promise<{ deletedCount?: number }> {
     try {
+      const Session = mongoose.models.Session;
+
       if (!userId) {
         throw new SessionError('User ID is required', 'INVALID_USER_ID');
       }
@@ -199,4 +206,16 @@ export async function deleteAllUserSessions(
       logger.error('[deleteAllUserSessions] Error deleting user sessions:', error);
       throw new SessionError('Failed to delete user sessions', 'DELETE_ALL_SESSIONS_FAILED');
     }
+  }
+
+  // Return all methods
+  return {
+    createSession,
+    findSession,
+    deleteSession,
+    generateRefreshToken,
+    deleteAllUserSessions,
+  };
 }
+
+export type SessionMethods = ReturnType<typeof createSessionMethods>;

packages/data-schemas/src/methods/token.ts

@@ -1,12 +1,14 @@
-import { Token } from '~/models';
 import { IToken, TokenCreateData, TokenQuery, TokenUpdateData, TokenDeleteResult } from '~/types';
 import logger from '~/config/winston';
 
-/**
+// Factory function that takes mongoose instance and returns the methods
+export function createTokenMethods(mongoose: typeof import('mongoose')) {
+  /**
    * Creates a new Token instance.
    */
-export async function createToken(tokenData: TokenCreateData): Promise<IToken> {
+  async function createToken(tokenData: TokenCreateData): Promise<IToken> {
     try {
+      const Token = mongoose.models.Token;
       const currentTime = new Date();
       const expiresAt = new Date(currentTime.getTime() + tokenData.expiresIn * 1000);
 
@@ -21,28 +23,30 @@ export async function createToken(tokenData: TokenCreateData): Promise<IToken> {
       logger.debug('An error occurred while creating token:', error);
       throw error;
     }
-}
+  }
 
-/**
+  /**
    * Updates a Token document that matches the provided query.
    */
-export async function updateToken(
+  async function updateToken(
     query: TokenQuery,
     updateData: TokenUpdateData,
-): Promise<IToken | null> {
+  ): Promise<IToken | null> {
     try {
+      const Token = mongoose.models.Token;
       return await Token.findOneAndUpdate(query, updateData, { new: true });
     } catch (error) {
       logger.debug('An error occurred while updating token:', error);
       throw error;
     }
-}
+  }
 
-/**
+  /**
    * Deletes all Token documents that match the provided token, user ID, or email.
    */
-export async function deleteTokens(query: TokenQuery): Promise<TokenDeleteResult> {
+  async function deleteTokens(query: TokenQuery): Promise<TokenDeleteResult> {
     try {
+      const Token = mongoose.models.Token;
       const conditions = [];
 
       if (query.userId) {
@@ -69,13 +73,14 @@ export async function deleteTokens(query: TokenQuery): Promise<TokenDeleteResult
       logger.debug('An error occurred while deleting tokens:', error);
       throw error;
     }
-}
+  }
 
-/**
+  /**
    * Finds a Token document that matches the provided query.
    */
-export async function findToken(query: TokenQuery): Promise<IToken | null> {
+  async function findToken(query: TokenQuery): Promise<IToken | null> {
     try {
+      const Token = mongoose.models.Token;
       const conditions = [];
 
       if (query.userId) {
@@ -102,4 +107,15 @@ export async function findToken(query: TokenQuery): Promise<IToken | null> {
       logger.debug('An error occurred while finding token:', error);
       throw error;
     }
+  }
+
+  // Return all methods
+  return {
+    createToken,
+    updateToken,
+    deleteTokens,
+    findToken,
+  };
 }
+
+export type TokenMethods = ReturnType<typeof createTokenMethods>;

packages/data-schemas/src/methods/user.ts

@@ -1,38 +1,44 @@
 import mongoose, { FilterQuery } from 'mongoose';
-import { User, Balance } from '~/models';
 import { IUser, BalanceConfig, UserCreateData, UserUpdateResult } from '~/types';
 import { signPayload } from '~/schema/session';
 
-/**
+/** Factory function that takes mongoose instance and returns the methods */
+export function createUserMethods(mongoose: typeof import('mongoose')) {
+  /**
    * Search for a single user based on partial data and return matching user document as plain object.
    */
-export async function findUser(
+  async function findUser(
     searchCriteria: FilterQuery<IUser>,
     fieldsToSelect?: string | string[] | null,
-): Promise<IUser | null> {
+  ): Promise<IUser | null> {
+    const User = mongoose.models.User;
     const query = User.findOne(searchCriteria);
     if (fieldsToSelect) {
       query.select(fieldsToSelect);
     }
-  return await query.lean();
-}
+    return (await query.lean()) as IUser | null;
+  }
 
-/**
+  /**
    * Count the number of user documents in the collection based on the provided filter.
    */
-export async function countUsers(filter: FilterQuery<IUser> = {}): Promise<number> {
+  async function countUsers(filter: FilterQuery<IUser> = {}): Promise<number> {
+    const User = mongoose.models.User;
     return await User.countDocuments(filter);
-}
+  }
 
-/**
+  /**
    * Creates a new user, optionally with a TTL of 1 week.
    */
-export async function createUser(
+  async function createUser(
     data: UserCreateData,
     balanceConfig?: BalanceConfig,
     disableTTL: boolean = true,
     returnUser: boolean = false,
-): Promise<mongoose.Types.ObjectId | Partial<IUser>> {
+  ): Promise<mongoose.Types.ObjectId | Partial<IUser>> {
+    const User = mongoose.models.User;
+    const Balance = mongoose.models.Balance;
+
     const userData: Partial<IUser> = {
       ...data,
       expiresAt: disableTTL ? undefined : new Date(Date.now() + 604800 * 1000), // 1 week in milliseconds
@@ -72,51 +78,54 @@ export async function createUser(
         };
       }
 
-    await Balance.findOneAndUpdate({ user: user._id }, update, { upsert: true, new: true }).lean();
+      await Balance.findOneAndUpdate({ user: user._id }, update, {
+        upsert: true,
+        new: true,
+      }).lean();
     }
 
     if (returnUser) {
       return user.toObject() as Partial<IUser>;
     }
     return user._id as mongoose.Types.ObjectId;
-}
+  }
 
-/**
+  /**
    * Update a user with new data without overwriting existing properties.
    */
-export async function updateUser(
-  userId: string,
-  updateData: Partial<IUser>,
-): Promise<IUser | null> {
+  async function updateUser(userId: string, updateData: Partial<IUser>): Promise<IUser | null> {
+    const User = mongoose.models.User;
     const updateOperation = {
       $set: updateData,
       $unset: { expiresAt: '' }, // Remove the expiresAt field to prevent TTL
     };
-  return await User.findByIdAndUpdate(userId, updateOperation, {
+    return (await User.findByIdAndUpdate(userId, updateOperation, {
       new: true,
       runValidators: true,
-  }).lean();
-}
+    }).lean()) as IUser | null;
+  }
 
-/**
+  /**
    * Retrieve a user by ID and convert the found user document to a plain object.
    */
-export async function getUserById(
+  async function getUserById(
     userId: string,
     fieldsToSelect?: string | string[] | null,
-): Promise<IUser | null> {
+  ): Promise<IUser | null> {
+    const User = mongoose.models.User;
     const query = User.findById(userId);
     if (fieldsToSelect) {
       query.select(fieldsToSelect);
     }
-  return await query.lean();
-}
+    return (await query.lean()) as IUser | null;
+  }
 
-/**
+  /**
    * Delete a user by their unique ID.
    */
-export async function deleteUserById(userId: string): Promise<UserUpdateResult> {
+  async function deleteUserById(userId: string): Promise<UserUpdateResult> {
     try {
+      const User = mongoose.models.User;
       const result = await User.deleteOne({ _id: userId });
       if (result.deletedCount === 0) {
         return { deletedCount: 0, message: 'No user found with that ID.' };
@@ -126,12 +135,12 @@ export async function deleteUserById(userId: string): Promise<UserUpdateResult>
       const errorMessage = error instanceof Error ? error.message : 'Unknown error';
       throw new Error('Error deleting user: ' + errorMessage);
     }
-}
+  }
 
-/**
+  /**
    * Generates a JWT token for a given user.
    */
-export async function generateToken(user: IUser): Promise<string> {
+  async function generateToken(user: IUser): Promise<string> {
     if (!user) {
       throw new Error('No user provided');
     }
@@ -148,4 +157,18 @@ export async function generateToken(user: IUser): Promise<string> {
       secret: process.env.JWT_SECRET,
       expirationTime: expires / 1000,
     });
+  }
+
+  // Return all methods
+  return {
+    findUser,
+    countUsers,
+    createUser,
+    updateUser,
+    getUserById,
+    deleteUserById,
+    generateToken,
+  };
 }
+
+export type UserMethods = ReturnType<typeof createUserMethods>;