📦 refactor: Consolidate DB models, encapsulating Mongoose usage in data-schemas (#11830)

* chore: move database model methods to /packages/data-schemas

* chore: add TypeScript ESLint rule to warn on unused variables

* refactor: model imports to streamline access

- Consolidated model imports across various files to improve code organization and reduce redundancy.
- Updated imports for models such as Assistant, Message, Conversation, and others to a unified import path.
- Adjusted middleware and service files to reflect the new import structure, ensuring functionality remains intact.
- Enhanced test files to align with the new import paths, maintaining test coverage and integrity.

* chore: migrate database models to packages/data-schemas and refactor all direct Mongoose Model usage outside of data-schemas

* test: update agent model mocks in unit tests

- Added `getAgent` mock to `client.test.js` to enhance test coverage for agent-related functionality.
- Removed redundant `getAgent` and `getAgents` mocks from `openai.spec.js` and `responses.unit.spec.js` to streamline test setup and reduce duplication.
- Ensured consistency in agent mock implementations across test files.

* fix: update types in data-schemas

* refactor: enhance type definitions in transaction and spending methods

- Updated type definitions in `checkBalance.ts` to use specific request and response types.
- Refined `spendTokens.ts` to utilize a new `SpendTxData` interface for better clarity and type safety.
- Improved transaction handling in `transaction.ts` by introducing `TransactionResult` and `TxData` interfaces, ensuring consistent data structures across methods.
- Adjusted unit tests in `transaction.spec.ts` to accommodate new type definitions and enhance robustness.

* refactor: streamline model imports and enhance code organization

- Consolidated model imports across various controllers and services to a unified import path, improving code clarity and reducing redundancy.
- Updated multiple files to reflect the new import structure, ensuring all functionalities remain intact.
- Enhanced overall code organization by removing duplicate import statements and optimizing the usage of model methods.

* feat: implement loadAddedAgent and refactor agent loading logic

- Introduced `loadAddedAgent` function to handle loading agents from added conversations, supporting multi-convo parallel execution.
- Created a new `load.ts` file to encapsulate agent loading functionalities, including `loadEphemeralAgent` and `loadAgent`.
- Updated the `index.ts` file to export the new `load` module instead of the deprecated `loadAgent`.
- Enhanced type definitions and improved error handling in the agent loading process.
- Adjusted unit tests to reflect changes in the agent loading structure and ensure comprehensive coverage.

* refactor: enhance balance handling with new update interface

- Introduced `IBalanceUpdate` interface to streamline balance update operations across the codebase.
- Updated `upsertBalanceFields` method signatures in `balance.ts`, `transaction.ts`, and related tests to utilize the new interface for improved type safety.
- Adjusted type imports in `balance.spec.ts` to include `IBalanceUpdate`, ensuring consistency in balance management functionalities.
- Enhanced overall code clarity and maintainability by refining type definitions related to balance operations.

* feat: add unit tests for loadAgent functionality and enhance agent loading logic

- Introduced comprehensive unit tests for the `loadAgent` function, covering various scenarios including null and empty agent IDs, loading of ephemeral agents, and permission checks.
- Enhanced the `initializeClient` function by moving `getConvoFiles` to the correct position in the database method exports, ensuring proper functionality.
- Improved test coverage for agent loading, including handling of non-existent agents and user permissions.

* chore: reorder memory method exports for consistency

- Moved `deleteAllUserMemories` to the correct position in the exported memory methods, ensuring a consistent and logical order of method exports in `memory.ts`.

packages/api/src/apiKeys/permissions.ts

@@ -1,10 +1,11 @@
+import { Types } from 'mongoose';
 import {
   ResourceType,
   PrincipalType,
   PermissionBits,
   AccessRoleIds,
 } from 'librechat-data-provider';
-import type { Types, Model } from 'mongoose';
+import type { PipelineStage, AnyBulkWriteOperation } from 'mongoose';
 
 export interface Principal {
   type: string;
@@ -19,20 +20,14 @@ export interface Principal {
 }
 
 export interface EnricherDependencies {
-  AclEntry: Model<{
-    principalType: string;
-    principalId: Types.ObjectId;
-    resourceType: string;
-    resourceId: Types.ObjectId;
-    permBits: number;
-    roleId: Types.ObjectId;
-    grantedBy: Types.ObjectId;
-    grantedAt: Date;
-  }>;
-  AccessRole: Model<{
-    accessRoleId: string;
-    permBits: number;
-  }>;
+  aggregateAclEntries: (pipeline: PipelineStage[]) => Promise<Record<string, unknown>[]>;
+  bulkWriteAclEntries: (
+    ops: AnyBulkWriteOperation<unknown>[],
+    options?: Record<string, unknown>,
+  ) => Promise<unknown>;
+  findRoleByIdentifier: (
+    accessRoleId: string,
+  ) => Promise<{ _id: Types.ObjectId; permBits: number } | null>;
   logger: { error: (msg: string, ...args: unknown[]) => void };
 }
 
@@ -47,14 +42,12 @@ export async function enrichRemoteAgentPrincipals(
   resourceId: string | Types.ObjectId,
   principals: Principal[],
 ): Promise<EnrichResult> {
-  const { AclEntry } = deps;
-
   const resourceObjectId =
     typeof resourceId === 'string' && /^[a-f\d]{24}$/i.test(resourceId)
-      ? deps.AclEntry.base.Types.ObjectId.createFromHexString(resourceId)
+      ? Types.ObjectId.createFromHexString(resourceId)
       : resourceId;
 
-  const agentOwnerEntries = await AclEntry.aggregate([
+  const agentOwnerEntries = await deps.aggregateAclEntries([
     {
       $match: {
         resourceType: ResourceType.AGENT,
@@ -87,24 +80,28 @@ export async function enrichRemoteAgentPrincipals(
       continue;
     }
 
+    const userInfo = entry.userInfo as Record<string, unknown>;
+    const principalId = entry.principalId as Types.ObjectId;
+
     const alreadyIncluded = enrichedPrincipals.some(
-      (p) => p.type === PrincipalType.USER && p.id === entry.principalId.toString(),
+      (p) => p.type === PrincipalType.USER && p.id === principalId.toString(),
     );
 
     if (!alreadyIncluded) {
       enrichedPrincipals.unshift({
         type: PrincipalType.USER,
-        id: entry.userInfo._id.toString(),
-        name: entry.userInfo.name || entry.userInfo.username,
-        email: entry.userInfo.email,
-        avatar: entry.userInfo.avatar,
+        id: (userInfo._id as Types.ObjectId).toString(),
+        name: (userInfo.name || userInfo.username) as string,
+        email: userInfo.email as string,
+        avatar: userInfo.avatar as string,
         source: 'local',
-        idOnTheSource: entry.userInfo.idOnTheSource || entry.userInfo._id.toString(),
+        idOnTheSource:
+          (userInfo.idOnTheSource as string) || (userInfo._id as Types.ObjectId).toString(),
         accessRoleId: AccessRoleIds.REMOTE_AGENT_OWNER,
         isImplicit: true,
       });
 
-      entriesToBackfill.push(entry.principalId);
+      entriesToBackfill.push(principalId);
     }
   }
 
@@ -121,15 +118,15 @@ export function backfillRemoteAgentPermissions(
     return;
   }
 
-  const { AclEntry, AccessRole, logger } = deps;
+  const { logger } = deps;
 
   const resourceObjectId =
     typeof resourceId === 'string' && /^[a-f\d]{24}$/i.test(resourceId)
-      ? AclEntry.base.Types.ObjectId.createFromHexString(resourceId)
+      ? Types.ObjectId.createFromHexString(resourceId)
       : resourceId;
 
-  AccessRole.findOne({ accessRoleId: AccessRoleIds.REMOTE_AGENT_OWNER })
-    .lean()
+  deps
+    .findRoleByIdentifier(AccessRoleIds.REMOTE_AGENT_OWNER)
     .then((role) => {
       if (!role) {
         logger.error('[backfillRemoteAgentPermissions] REMOTE_AGENT_OWNER role not found');
@@ -161,9 +158,9 @@ export function backfillRemoteAgentPermissions(
         },
       }));
 
-      return AclEntry.bulkWrite(bulkOps, { ordered: false });
+      return deps.bulkWriteAclEntries(bulkOps, { ordered: false });
     })
-    .catch((err) => {
+    .catch((err: unknown) => {
       logger.error('[backfillRemoteAgentPermissions] Failed to backfill:', err);
     });
 }