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
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🧮 refactor: Replace Eval with Safe Math Expression Parser (#11098)
Danny Avila6ffb176056f9
diff --git a/api/package.json b/api/package.jsonindex 6bf1482cb8..771b2e102b 100644--- a/api/package.json+++ b/api/package.json@@ -79,6 +79,7 @@"klona": "^2.0.6","librechat-data-provider": "*","lodash": "^4.17.21",+ "mathjs": "^15.1.0","meilisearch": "^0.38.0","memorystore": "^1.6.7","mime": "^3.0.0",diff --git a/api/server/services/AuthService.js b/api/server/services/AuthService.jsindex 72bda67322..0cb418e076 100644--- a/api/server/services/AuthService.js+++ b/api/server/services/AuthService.js@@ -1,9 +1,13 @@const bcrypt = require('bcryptjs');const jwt = require('jsonwebtoken');const { webcrypto } = require('node:crypto');-const { logger } = require('@librechat/data-schemas');-const { isEnabled, checkEmailConfig, isEmailDomainAllowed } = require('@librechat/api');+const {+ logger,+ DEFAULT_SESSION_EXPIRY,+ DEFAULT_REFRESH_TOKEN_EXPIRY,+} = require('@librechat/data-schemas');const { ErrorTypes, SystemRoles, errorsToString } = require('librechat-data-provider');+const { isEnabled, checkEmailConfig, isEmailDomainAllowed, math } = require('@librechat/api');const {findUser,findToken,@@ -369,19 +373,21 @@ const setAuthTokens = async (userId, res, _session = null) => {let session = _session;let refreshToken;let refreshTokenExpires;+ const expiresIn = math(process.env.REFRESH_TOKEN_EXPIRY, DEFAULT_REFRESH_TOKEN_EXPIRY);if (session && session._id && session.expiration != null) {refreshTokenExpires = session.expiration.getTime();refreshToken = await generateRefreshToken(session);} else {- const result = await createSession(userId);+ const result = await createSession(userId, { expiresIn });session = result.session;refreshToken = result.refreshToken;refreshTokenExpires = session.expiration.getTime();}const user = await getUserById(userId);- const token = await generateToken(user);+ const sessionExpiry = math(process.env.SESSION_EXPIRY, DEFAULT_SESSION_EXPIRY);+ const token = await generateToken(user, sessionExpiry);res.cookie('refreshToken', refreshToken, {expires: new Date(refreshTokenExpires),@@ -418,10 +424,10 @@ const setOpenIDAuthTokens = (tokenset, res, userId, existingRefreshToken) => {logger.error('[setOpenIDAuthTokens] No tokenset found in request');return;}- const { REFRESH_TOKEN_EXPIRY } = process.env ?? {};- const expiryInMilliseconds = REFRESH_TOKEN_EXPIRY- ? eval(REFRESH_TOKEN_EXPIRY)- : 1000 * 60 * 60 * 24 * 7; // 7 days default+ const expiryInMilliseconds = math(+ process.env.REFRESH_TOKEN_EXPIRY,+ DEFAULT_REFRESH_TOKEN_EXPIRY,+ );const expirationDate = new Date(Date.now() + expiryInMilliseconds);if (tokenset == null) {logger.error('[setOpenIDAuthTokens] No tokenset found in request');diff --git a/api/strategies/openIdJwtStrategy.js b/api/strategies/openIdJwtStrategy.jsindex 998a918c30..5d9eb14085 100644--- a/api/strategies/openIdJwtStrategy.js+++ b/api/strategies/openIdJwtStrategy.js@@ -3,8 +3,8 @@ const jwksRsa = require('jwks-rsa');const { logger } = require('@librechat/data-schemas');const { HttpsProxyAgent } = require('https-proxy-agent');const { SystemRoles } = require('librechat-data-provider');+const { isEnabled, findOpenIDUser, math } = require('@librechat/api');const { Strategy: JwtStrategy, ExtractJwt } = require('passport-jwt');-const { isEnabled, findOpenIDUser } = require('@librechat/api');const { updateUser, findUser } = require('~/models');/**@@ -27,9 +27,7 @@ const { updateUser, findUser } = require('~/models');const openIdJwtLogin = (openIdConfig) => {let jwksRsaOptions = {cache: isEnabled(process.env.OPENID_JWKS_URL_CACHE_ENABLED) || true,- cacheMaxAge: process.env.OPENID_JWKS_URL_CACHE_TIME- ? eval(process.env.OPENID_JWKS_URL_CACHE_TIME)- : 60000,+ cacheMaxAge: math(process.env.OPENID_JWKS_URL_CACHE_TIME, 60000),jwksUri: openIdConfig.serverMetadata().jwks_uri,};diff --git a/package-lock.json b/package-lock.jsonindex 47d75fc44c..55584a7cdb 100644--- a/package-lock.json+++ b/package-lock.json@@ -93,6 +93,7 @@"klona": "^2.0.6","librechat-data-provider": "*","lodash": "^4.17.21",+ "mathjs": "^15.1.0","meilisearch": "^0.38.0","memorystore": "^1.6.7","mime": "^3.0.0",@@ -48979,6 +48980,7 @@"keyv": "^5.3.2","keyv-file": "^5.1.2","librechat-data-provider": "*",+ "mathjs": "^15.1.0","memorystore": "^1.6.7","mongoose": "^8.12.1","node-fetch": "2.7.0",diff --git a/packages/api/package.json b/packages/api/package.jsonindex 75f18da0e3..d99f2e1ebf 100644--- a/packages/api/package.json+++ b/packages/api/package.json@@ -102,6 +102,7 @@"keyv": "^5.3.2","keyv-file": "^5.1.2","librechat-data-provider": "*",+ "mathjs": "^15.1.0","memorystore": "^1.6.7","mongoose": "^8.12.1","node-fetch": "2.7.0",diff --git a/packages/api/src/utils/math.integration.spec.ts b/packages/api/src/utils/math.integration.spec.tsnew file mode 100644index 0000000000..ec7822a164--- /dev/null+++ b/packages/api/src/utils/math.integration.spec.ts@@ -0,0 +1,196 @@+/**+ * Integration tests for math function with actual config patterns.+ * These tests verify that real environment variable expressions from .env.example+ * are correctly evaluated by the math function.+ */+import { math } from './math';++describe('math - integration with real config patterns', () => {+ describe('SESSION_EXPIRY patterns', () => {+ test('should evaluate default SESSION_EXPIRY (15 minutes)', () => {+ const result = math('1000 * 60 * 15');+ expect(result).toBe(900000); // 15 minutes in ms+ });++ test('should evaluate 30 minute session', () => {+ const result = math('1000 * 60 * 30');+ expect(result).toBe(1800000); // 30 minutes in ms+ });++ test('should evaluate 1 hour session', () => {+ const result = math('1000 * 60 * 60');+ expect(result).toBe(3600000); // 1 hour in ms+ });+ });++ describe('REFRESH_TOKEN_EXPIRY patterns', () => {+ test('should evaluate default REFRESH_TOKEN_EXPIRY (7 days)', () => {+ const result = math('(1000 * 60 * 60 * 24) * 7');+ expect(result).toBe(604800000); // 7 days in ms+ });++ test('should evaluate 1 day refresh token', () => {+ const result = math('1000 * 60 * 60 * 24');+ expect(result).toBe(86400000); // 1 day in ms+ });++ test('should evaluate 30 day refresh token', () => {+ const result = math('(1000 * 60 * 60 * 24) * 30');+ expect(result).toBe(2592000000); // 30 days in ms+ });+ });++ describe('BAN_DURATION patterns', () => {+ test('should evaluate default BAN_DURATION (2 hours)', () => {+ const result = math('1000 * 60 * 60 * 2');+ expect(result).toBe(7200000); // 2 hours in ms+ });++ test('should evaluate 24 hour ban', () => {+ const result = math('1000 * 60 * 60 * 24');+ expect(result).toBe(86400000); // 24 hours in ms+ });+ });++ describe('Redis config patterns', () => {+ test('should evaluate REDIS_RETRY_MAX_DELAY', () => {+ expect(math('3000')).toBe(3000);+ });++ test('should evaluate REDIS_RETRY_MAX_ATTEMPTS', () => {+ expect(math('10')).toBe(10);+ });++ test('should evaluate REDIS_CONNECT_TIMEOUT', () => {+ expect(math('10000')).toBe(10000);+ });++ test('should evaluate REDIS_MAX_LISTENERS', () => {+ expect(math('40')).toBe(40);+ });++ test('should evaluate REDIS_DELETE_CHUNK_SIZE', () => {+ expect(math('1000')).toBe(1000);+ });+ });++ describe('MCP config patterns', () => {+ test('should evaluate MCP_OAUTH_DETECTION_TIMEOUT', () => {+ expect(math('5000')).toBe(5000);+ });++ test('should evaluate MCP_CONNECTION_CHECK_TTL', () => {+ expect(math('60000')).toBe(60000); // 1 minute+ });++ test('should evaluate MCP_USER_CONNECTION_IDLE_TIMEOUT (15 minutes)', () => {+ const result = math('15 * 60 * 1000');+ expect(result).toBe(900000); // 15 minutes in ms+ });++ test('should evaluate MCP_REGISTRY_CACHE_TTL', () => {+ expect(math('5000')).toBe(5000); // 5 seconds+ });+ });++ describe('Leader election config patterns', () => {+ test('should evaluate LEADER_LEASE_DURATION (25 seconds)', () => {+ expect(math('25')).toBe(25);+ });++ test('should evaluate LEADER_RENEW_INTERVAL (10 seconds)', () => {+ expect(math('10')).toBe(10);+ });++ test('should evaluate LEADER_RENEW_ATTEMPTS', () => {+ expect(math('3')).toBe(3);+ });++ test('should evaluate LEADER_RENEW_RETRY_DELAY (0.5 seconds)', () => {+ expect(math('0.5')).toBe(0.5);+ });+ });++ describe('OpenID config patterns', () => {+ test('should evaluate OPENID_JWKS_URL_CACHE_TIME (10 minutes)', () => {+ const result = math('600000');+ expect(result).toBe(600000); // 10 minutes in ms+ });++ test('should evaluate custom cache time expression', () => {+ const result = math('1000 * 60 * 10');+ expect(result).toBe(600000); // 10 minutes in ms+ });+ });++ describe('simulated process.env usage', () => {+ const originalEnv = process.env;++ beforeEach(() => {+ process.env = { ...originalEnv };+ });++ afterEach(() => {+ process.env = originalEnv;+ });++ test('should work with SESSION_EXPIRY from env', () => {+ process.env.SESSION_EXPIRY = '1000 * 60 * 15';+ const result = math(process.env.SESSION_EXPIRY, 900000);+ expect(result).toBe(900000);+ });++ test('should work with REFRESH_TOKEN_EXPIRY from env', () => {+ process.env.REFRESH_TOKEN_EXPIRY = '(1000 * 60 * 60 * 24) * 7';+ const result = math(process.env.REFRESH_TOKEN_EXPIRY, 604800000);+ expect(result).toBe(604800000);+ });++ test('should work with BAN_DURATION from env', () => {+ process.env.BAN_DURATION = '1000 * 60 * 60 * 2';+ const result = math(process.env.BAN_DURATION, 7200000);+ expect(result).toBe(7200000);+ });++ test('should use fallback when env var is undefined', () => {+ delete process.env.SESSION_EXPIRY;+ const result = math(process.env.SESSION_EXPIRY, 900000);+ expect(result).toBe(900000);+ });++ test('should use fallback when env var is empty string', () => {+ process.env.SESSION_EXPIRY = '';+ const result = math(process.env.SESSION_EXPIRY, 900000);+ expect(result).toBe(900000);+ });++ test('should use fallback when env var has invalid expression', () => {+ process.env.SESSION_EXPIRY = 'invalid';+ const result = math(process.env.SESSION_EXPIRY, 900000);+ expect(result).toBe(900000);+ });+ });++ describe('time calculation helpers', () => {+ // Helper functions to make time calculations more readable+ const seconds = (n: number) => n * 1000;+ const minutes = (n: number) => seconds(n * 60);+ const hours = (n: number) => minutes(n * 60);+ const days = (n: number) => hours(n * 24);++ test('should match helper calculations', () => {+ // Verify our math function produces same results as programmatic calculations+ expect(math('1000 * 60 * 15')).toBe(minutes(15));+ expect(math('1000 * 60 * 60 * 2')).toBe(hours(2));+ expect(math('(1000 * 60 * 60 * 24) * 7')).toBe(days(7));+ });++ test('should handle complex expressions', () => {+ // 2 hours + 30 minutes+ expect(math('(1000 * 60 * 60 * 2) + (1000 * 60 * 30)')).toBe(hours(2) + minutes(30));++ // Half a day+ expect(math('(1000 * 60 * 60 * 24) / 2')).toBe(days(1) / 2);+ });+ });+});diff --git a/packages/api/src/utils/math.spec.ts b/packages/api/src/utils/math.spec.tsnew file mode 100644index 0000000000..7593098946--- /dev/null+++ b/packages/api/src/utils/math.spec.ts@@ -0,0 +1,326 @@+import { math } from './math';++describe('math', () => {+ describe('number input passthrough', () => {+ test('should return number as-is when input is a number', () => {+ expect(math(42)).toBe(42);+ });++ test('should return zero when input is 0', () => {+ expect(math(0)).toBe(0);+ });++ test('should return negative numbers as-is', () => {+ expect(math(-10)).toBe(-10);+ });++ test('should return decimal numbers as-is', () => {+ expect(math(0.5)).toBe(0.5);+ });++ test('should return very large numbers as-is', () => {+ expect(math(Number.MAX_SAFE_INTEGER)).toBe(Number.MAX_SAFE_INTEGER);+ });+ });++ describe('simple string number parsing', () => {+ test('should parse simple integer string', () => {+ expect(math('42')).toBe(42);+ });++ test('should parse zero string', () => {+ expect(math('0')).toBe(0);+ });++ test('should parse negative number string', () => {+ expect(math('-10')).toBe(-10);+ });++ test('should parse decimal string', () => {+ expect(math('0.5')).toBe(0.5);+ });++ test('should parse string with leading/trailing spaces', () => {+ expect(math(' 42 ')).toBe(42);+ });++ test('should parse large number string', () => {+ expect(math('9007199254740991')).toBe(Number.MAX_SAFE_INTEGER);+ });+ });++ describe('mathematical expressions - multiplication', () => {+ test('should evaluate simple multiplication', () => {+ expect(math('2 * 3')).toBe(6);+ });++ test('should evaluate chained multiplication (BAN_DURATION pattern: 1000 * 60 * 60 * 2)', () => {+ // 2 hours in milliseconds+ expect(math('1000 * 60 * 60 * 2')).toBe(7200000);+ });++ test('should evaluate SESSION_EXPIRY pattern (1000 * 60 * 15)', () => {+ // 15 minutes in milliseconds+ expect(math('1000 * 60 * 15')).toBe(900000);+ });++ test('should evaluate multiplication without spaces', () => {+ expect(math('2*3')).toBe(6);+ });+ });++ describe('mathematical expressions - addition and subtraction', () => {+ test('should evaluate simple addition', () => {+ expect(math('2 + 3')).toBe(5);+ });++ test('should evaluate simple subtraction', () => {+ expect(math('10 - 3')).toBe(7);+ });++ test('should evaluate mixed addition and subtraction', () => {+ expect(math('10 + 5 - 3')).toBe(12);+ });++ test('should handle negative results', () => {+ expect(math('3 - 10')).toBe(-7);+ });+ });++ describe('mathematical expressions - division', () => {+ test('should evaluate simple division', () => {+ expect(math('10 / 2')).toBe(5);+ });++ test('should evaluate division resulting in decimal', () => {+ expect(math('7 / 2')).toBe(3.5);+ });+ });++ describe('mathematical expressions - parentheses', () => {+ test('should evaluate expression with parentheses (REFRESH_TOKEN_EXPIRY pattern)', () => {+ // 7 days in milliseconds: (1000 * 60 * 60 * 24) * 7+ expect(math('(1000 * 60 * 60 * 24) * 7')).toBe(604800000);+ });++ test('should evaluate nested parentheses', () => {+ expect(math('((2 + 3) * 4)')).toBe(20);+ });++ test('should respect operator precedence with parentheses', () => {+ expect(math('2 * (3 + 4)')).toBe(14);+ });+ });++ describe('mathematical expressions - modulo', () => {+ test('should evaluate modulo operation', () => {+ expect(math('10 % 3')).toBe(1);+ });++ test('should evaluate modulo with larger numbers', () => {+ expect(math('100 % 7')).toBe(2);+ });+ });++ describe('complex real-world expressions', () => {+ test('should evaluate MCP_USER_CONNECTION_IDLE_TIMEOUT pattern (15 * 60 * 1000)', () => {+ // 15 minutes in milliseconds+ expect(math('15 * 60 * 1000')).toBe(900000);+ });++ test('should evaluate Redis default TTL (5000)', () => {+ expect(math('5000')).toBe(5000);+ });++ test('should evaluate LEADER_RENEW_RETRY_DELAY decimal (0.5)', () => {+ expect(math('0.5')).toBe(0.5);+ });++ test('should evaluate BAN_DURATION default (7200000)', () => {+ // 2 hours in milliseconds+ expect(math('7200000')).toBe(7200000);+ });++ test('should evaluate expression with mixed operators and parentheses', () => {+ // (1 hour + 30 min) in ms+ expect(math('(1000 * 60 * 60) + (1000 * 60 * 30)')).toBe(5400000);+ });+ });++ describe('fallback value behavior', () => {+ test('should return fallback when input is undefined', () => {+ expect(math(undefined, 100)).toBe(100);+ });++ test('should return fallback when input is null', () => {+ // @ts-expect-error - testing runtime behavior with invalid input+ expect(math(null, 100)).toBe(100);+ });++ test('should return fallback when input contains invalid characters', () => {+ expect(math('abc', 100)).toBe(100);+ });++ test('should return fallback when input has SQL injection attempt', () => {+ expect(math('1; DROP TABLE users;', 100)).toBe(100);+ });++ test('should return fallback when input has function call attempt', () => {+ expect(math('console.log("hacked")', 100)).toBe(100);+ });++ test('should return fallback when input is empty string', () => {+ expect(math('', 100)).toBe(100);+ });++ test('should return zero fallback when specified', () => {+ expect(math(undefined, 0)).toBe(0);+ });++ test('should use number input even when fallback is provided', () => {+ expect(math(42, 100)).toBe(42);+ });++ test('should use valid string even when fallback is provided', () => {+ expect(math('42', 100)).toBe(42);+ });+ });++ describe('error cases without fallback', () => {+ test('should throw error when input is undefined without fallback', () => {+ expect(() => math(undefined)).toThrow('str is undefined, but should be a string');+ });++ test('should throw error when input is null without fallback', () => {+ // @ts-expect-error - testing runtime behavior with invalid input+ expect(() => math(null)).toThrow('str is object, but should be a string');+ });++ test('should throw error when input contains invalid characters without fallback', () => {+ expect(() => math('abc')).toThrow('Invalid characters in string');+ });++ test('should throw error when input has letter characters', () => {+ expect(() => math('10x')).toThrow('Invalid characters in string');+ });++ test('should throw error when input has special characters', () => {+ expect(() => math('10!')).toThrow('Invalid characters in string');+ });++ test('should throw error for malicious code injection', () => {+ expect(() => math('process.exit(1)')).toThrow('Invalid characters in string');+ });++ test('should throw error for require injection', () => {+ expect(() => math('require("fs")')).toThrow('Invalid characters in string');+ });+ });++ describe('security - input validation', () => {+ test('should reject strings with alphabetic characters', () => {+ expect(() => math('Math.PI')).toThrow('Invalid characters in string');+ });++ test('should reject strings with brackets', () => {+ expect(() => math('[1,2,3]')).toThrow('Invalid characters in string');+ });++ test('should reject strings with curly braces', () => {+ expect(() => math('{}')).toThrow('Invalid characters in string');+ });++ test('should reject strings with semicolons', () => {+ expect(() => math('1;2')).toThrow('Invalid characters in string');+ });++ test('should reject strings with quotes', () => {+ expect(() => math('"test"')).toThrow('Invalid characters in string');+ });++ test('should reject strings with backticks', () => {+ expect(() => math('`test`')).toThrow('Invalid characters in string');+ });++ test('should reject strings with equals sign', () => {+ expect(() => math('x=1')).toThrow('Invalid characters in string');+ });++ test('should reject strings with ampersand', () => {+ expect(() => math('1 && 2')).toThrow('Invalid characters in string');+ });++ test('should reject strings with pipe', () => {+ expect(() => math('1 || 2')).toThrow('Invalid characters in string');+ });+ });++ describe('edge cases', () => {+ test('should handle expression resulting in Infinity with fallback', () => {+ // Division by zero returns Infinity, which is technically a number+ expect(math('1 / 0')).toBe(Infinity);+ });++ test('should handle very small decimals', () => {+ expect(math('0.001')).toBe(0.001);+ });++ test('should handle scientific notation format', () => {+ // Note: 'e' is not in the allowed character set, so this should fail+ expect(() => math('1e3')).toThrow('Invalid characters in string');+ });++ test('should handle expression with only whitespace with fallback', () => {+ expect(math(' ', 100)).toBe(100);+ });++ test('should handle +number syntax', () => {+ expect(math('+42')).toBe(42);+ });++ test('should handle expression starting with negative', () => {+ expect(math('-5 + 10')).toBe(5);+ });++ test('should handle multiple decimal points with fallback', () => {+ // Invalid syntax should return fallback value+ expect(math('1.2.3', 100)).toBe(100);+ });++ test('should throw for multiple decimal points without fallback', () => {+ expect(() => math('1.2.3')).toThrow();+ });+ });++ describe('type coercion edge cases', () => {+ test('should handle object input with fallback', () => {+ // @ts-expect-error - testing runtime behavior with invalid input+ expect(math({}, 100)).toBe(100);+ });++ test('should handle array input with fallback', () => {+ // @ts-expect-error - testing runtime behavior with invalid input+ expect(math([], 100)).toBe(100);+ });++ test('should handle boolean true with fallback', () => {+ // @ts-expect-error - testing runtime behavior with invalid input+ expect(math(true, 100)).toBe(100);+ });++ test('should handle boolean false with fallback', () => {+ // @ts-expect-error - testing runtime behavior with invalid input+ expect(math(false, 100)).toBe(100);+ });++ test('should throw for object input without fallback', () => {+ // @ts-expect-error - testing runtime behavior with invalid input+ expect(() => math({})).toThrow('str is object, but should be a string');+ });++ test('should throw for array input without fallback', () => {+ // @ts-expect-error - testing runtime behavior with invalid input+ expect(() => math([])).toThrow('str is object, but should be a string');+ });+ });+});diff --git a/packages/api/src/utils/math.ts b/packages/api/src/utils/math.tsindex 7201880ce3..b8a896f49e 100644--- a/packages/api/src/utils/math.ts+++ b/packages/api/src/utils/math.ts@@ -1,3 +1,5 @@+import { evaluate } from 'mathjs';+/*** Evaluates a mathematical expression provided as a string and returns the result.*@@ -5,6 +7,8 @@* If the input is not a string or contains invalid characters, an error is thrown.* If the evaluated result is not a number, an error is thrown.*+ * Uses mathjs for safe expression evaluation instead of eval().+ ** @param str - The mathematical expression to evaluate, or a number.* @param fallbackValue - The default value to return if the input is not a string or number, or if the evaluated result is not a number.*@@ -32,14 +36,22 @@ export function math(str: string | number | undefined, fallbackValue?: number):throw new Error('Invalid characters in string');}- const value = eval(str);+ try {+ const value = evaluate(str);- if (typeof value !== 'number') {+ if (typeof value !== 'number') {+ if (fallback) {+ return fallbackValue;+ }+ throw new Error(`[math] str did not evaluate to a number but to a ${typeof value}`);+ }++ return value;+ } catch (error) {if (fallback) {return fallbackValue;}- throw new Error(`[math] str did not evaluate to a number but to a ${typeof value}`);+ const originalMessage = error instanceof Error ? error.message : String(error);+ throw new Error(`[math] Error while evaluating mathematical expression: ${originalMessage}`);}-- return value;}diff --git a/packages/data-schemas/src/index.ts b/packages/data-schemas/src/index.tsindex 0754dfe258..a9c9a56078 100644--- a/packages/data-schemas/src/index.ts+++ b/packages/data-schemas/src/index.ts@@ -4,7 +4,7 @@ export * from './crypto';export * from './schema';export * from './utils';export { createModels } from './models';-export { createMethods } from './methods';+export { createMethods, DEFAULT_REFRESH_TOKEN_EXPIRY, DEFAULT_SESSION_EXPIRY } from './methods';export type * from './types';export type * from './methods';export { default as logger } from './config/winston';diff --git a/packages/data-schemas/src/methods/index.ts b/packages/data-schemas/src/methods/index.tsindex 122e48419c..b6f1be64e9 100644--- a/packages/data-schemas/src/methods/index.ts+++ b/packages/data-schemas/src/methods/index.ts@@ -1,7 +1,9 @@-import { createSessionMethods, type SessionMethods } from './session';+import { createSessionMethods, DEFAULT_REFRESH_TOKEN_EXPIRY, type SessionMethods } from './session';import { createTokenMethods, type TokenMethods } from './token';import { createRoleMethods, type RoleMethods } from './role';-import { createUserMethods, type UserMethods } from './user';+import { createUserMethods, DEFAULT_SESSION_EXPIRY, type UserMethods } from './user';++export { DEFAULT_REFRESH_TOKEN_EXPIRY, DEFAULT_SESSION_EXPIRY };import { createKeyMethods, type KeyMethods } from './key';import { createFileMethods, type FileMethods } from './file';/* Memories */diff --git a/packages/data-schemas/src/methods/session.ts b/packages/data-schemas/src/methods/session.tsindex 30700bc267..68c851414a 100644--- a/packages/data-schemas/src/methods/session.ts+++ b/packages/data-schemas/src/methods/session.ts@@ -12,8 +12,8 @@ export class SessionError extends Error {}}-const { REFRESH_TOKEN_EXPIRY } = process.env ?? {};-const expires = REFRESH_TOKEN_EXPIRY ? eval(REFRESH_TOKEN_EXPIRY) : 1000 * 60 * 60 * 24 * 7; // 7 days default+/** Default refresh token expiry: 7 days in milliseconds */+export const DEFAULT_REFRESH_TOKEN_EXPIRY = 1000 * 60 * 60 * 24 * 7;// Factory function that takes mongoose instance and returns the methodsexport function createSessionMethods(mongoose: typeof import('mongoose')) {@@ -28,11 +28,13 @@ export function createSessionMethods(mongoose: typeof import('mongoose')) {throw new SessionError('User ID is required', 'INVALID_USER_ID');}+ const expiresIn = options.expiresIn ?? DEFAULT_REFRESH_TOKEN_EXPIRY;+try {const Session = mongoose.models.Session;const currentSession = new Session({user: userId,- expiration: options.expiration || new Date(Date.now() + expires),+ expiration: options.expiration || new Date(Date.now() + expiresIn),});const refreshToken = await generateRefreshToken(currentSession);@@ -105,7 +107,10 @@ export function createSessionMethods(mongoose: typeof import('mongoose')) {async function updateExpiration(session: t.ISession | string,newExpiration?: Date,+ options: t.UpdateExpirationOptions = {},): Promise<t.ISession> {+ const expiresIn = options.expiresIn ?? DEFAULT_REFRESH_TOKEN_EXPIRY;+try {const Session = mongoose.models.Session;const sessionDoc = typeof session === 'string' ? await Session.findById(session) : session;@@ -114,7 +119,7 @@ export function createSessionMethods(mongoose: typeof import('mongoose')) {throw new SessionError('Session not found', 'SESSION_NOT_FOUND');}- sessionDoc.expiration = newExpiration || new Date(Date.now() + expires);+ sessionDoc.expiration = newExpiration || new Date(Date.now() + expiresIn);return await sessionDoc.save();} catch (error) {logger.error('[updateExpiration] Error updating session:', error);@@ -208,7 +213,9 @@ export function createSessionMethods(mongoose: typeof import('mongoose')) {}try {- const expiresIn = session.expiration ? session.expiration.getTime() : Date.now() + expires;+ const expiresIn = session.expiration+ ? session.expiration.getTime()+ : Date.now() + DEFAULT_REFRESH_TOKEN_EXPIRY;if (!session.expiration) {session.expiration = new Date(expiresIn);diff --git a/packages/data-schemas/src/methods/user.test.ts b/packages/data-schemas/src/methods/user.test.tsindex 6dafd4e8fa..522e4fe158 100644--- a/packages/data-schemas/src/methods/user.test.ts+++ b/packages/data-schemas/src/methods/user.test.ts@@ -31,11 +31,10 @@ describe('User Methods', () => {} as IUser;afterEach(() => {- delete process.env.SESSION_EXPIRY;delete process.env.JWT_SECRET;});- it('should default to 15 minutes when SESSION_EXPIRY is not set', async () => {+ it('should default to 15 minutes when expiresIn is not provided', async () => {process.env.JWT_SECRET = 'test-secret';mockSignPayload.mockResolvedValue('mocked-token');@@ -49,16 +48,15 @@ describe('User Methods', () => {email: mockUser.email,},secret: 'test-secret',- expirationTime: 900, // 15 minutes in seconds+ expirationTime: 900, // 15 minutes in seconds (DEFAULT_SESSION_EXPIRY / 1000)});});- it('should default to 15 minutes when SESSION_EXPIRY is empty string', async () => {- process.env.SESSION_EXPIRY = '';+ it('should default to 15 minutes when expiresIn is undefined', async () => {process.env.JWT_SECRET = 'test-secret';mockSignPayload.mockResolvedValue('mocked-token');- await userMethods.generateToken(mockUser);+ await userMethods.generateToken(mockUser, undefined);expect(mockSignPayload).toHaveBeenCalledWith({payload: {@@ -68,16 +66,15 @@ describe('User Methods', () => {email: mockUser.email,},secret: 'test-secret',- expirationTime: 900, // 15 minutes in seconds+ expirationTime: 900, // 15 minutes in seconds (DEFAULT_SESSION_EXPIRY / 1000)});});- it('should use custom expiry when SESSION_EXPIRY is set to a valid expression', async () => {- process.env.SESSION_EXPIRY = '1000 * 60 * 30'; // 30 minutes+ it('should use custom expiry when expiresIn is provided', async () => {process.env.JWT_SECRET = 'test-secret';mockSignPayload.mockResolvedValue('mocked-token');- await userMethods.generateToken(mockUser);+ await userMethods.generateToken(mockUser, 1000 * 60 * 30); // 30 minutesexpect(mockSignPayload).toHaveBeenCalledWith({payload: {@@ -91,12 +88,12 @@ describe('User Methods', () => {});});- it('should default to 15 minutes when SESSION_EXPIRY evaluates to falsy value', async () => {- process.env.SESSION_EXPIRY = '0'; // This will evaluate to 0, which is falsy+ it('should use 0 when expiresIn is 0', async () => {process.env.JWT_SECRET = 'test-secret';mockSignPayload.mockResolvedValue('mocked-token');- await userMethods.generateToken(mockUser);+ // When 0 is passed, it should use 0 (caller's responsibility to pass valid value)+ await userMethods.generateToken(mockUser, 0);expect(mockSignPayload).toHaveBeenCalledWith({payload: {@@ -106,7 +103,7 @@ describe('User Methods', () => {email: mockUser.email,},secret: 'test-secret',- expirationTime: 900, // 15 minutes in seconds+ expirationTime: 0, // 0 seconds});});@@ -119,45 +116,13 @@ describe('User Methods', () => {});it('should return the token from signPayload', async () => {- process.env.SESSION_EXPIRY = '1000 * 60 * 60'; // 1 hourprocess.env.JWT_SECRET = 'test-secret';const expectedToken = 'generated-jwt-token';mockSignPayload.mockResolvedValue(expectedToken);- const token = await userMethods.generateToken(mockUser);+ const token = await userMethods.generateToken(mockUser, 1000 * 60 * 60); // 1 hourexpect(token).toBe(expectedToken);});-- it('should handle invalid SESSION_EXPIRY expressions gracefully', async () => {- process.env.SESSION_EXPIRY = 'invalid expression';- process.env.JWT_SECRET = 'test-secret';- mockSignPayload.mockResolvedValue('mocked-token');-- // Mock console.warn to verify it's called- const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();-- await userMethods.generateToken(mockUser);-- // Should use default value when eval fails- expect(mockSignPayload).toHaveBeenCalledWith({- payload: {- id: mockUser._id,- username: mockUser.username,- provider: mockUser.provider,- email: mockUser.email,- },- secret: 'test-secret',- expirationTime: 900, // 15 minutes in seconds (default)- });-- // Verify warning was logged- expect(consoleWarnSpy).toHaveBeenCalledWith(- 'Invalid SESSION_EXPIRY expression, using default:',- expect.any(SyntaxError),- );-- consoleWarnSpy.mockRestore();- });});});diff --git a/packages/data-schemas/src/methods/user.ts b/packages/data-schemas/src/methods/user.tsindex 07b671eb67..74cb4a1e1c 100644--- a/packages/data-schemas/src/methods/user.ts+++ b/packages/data-schemas/src/methods/user.ts@@ -2,6 +2,9 @@ import mongoose, { FilterQuery } from 'mongoose';import type { IUser, BalanceConfig, CreateUserRequest, UserDeleteResult } from '~/types';import { signPayload } from '~/crypto';+/** Default JWT session expiry: 15 minutes in milliseconds */+export const DEFAULT_SESSION_EXPIRY = 1000 * 60 * 15;+/** Factory function that takes mongoose instance and returns the methods */export function createUserMethods(mongoose: typeof import('mongoose')) {/**@@ -161,24 +164,15 @@ export function createUserMethods(mongoose: typeof import('mongoose')) {/*** Generates a JWT token for a given user.+ * @param user - The user object+ * @param expiresIn - Optional expiry time in milliseconds. Default: 15 minutes*/- async function generateToken(user: IUser): Promise<string> {+ async function generateToken(user: IUser, expiresIn?: number): Promise<string> {if (!user) {throw new Error('No user provided');}- let expires = 1000 * 60 * 15;-- if (process.env.SESSION_EXPIRY !== undefined && process.env.SESSION_EXPIRY !== '') {- try {- const evaluated = eval(process.env.SESSION_EXPIRY);- if (evaluated) {- expires = evaluated;- }- } catch (error) {- console.warn('Invalid SESSION_EXPIRY expression, using default:', error);- }- }+ const expires = expiresIn ?? DEFAULT_SESSION_EXPIRY;return await signPayload({payload: {diff --git a/packages/data-schemas/src/types/session.ts b/packages/data-schemas/src/types/session.tsindex 7df456ac4f..a7e9591e12 100644--- a/packages/data-schemas/src/types/session.ts+++ b/packages/data-schemas/src/types/session.ts@@ -8,6 +8,13 @@ export interface ISession extends Document {export interface CreateSessionOptions {expiration?: Date;+ /** Duration in milliseconds for session expiry. Default: 7 days */+ expiresIn?: number;+}++export interface UpdateExpirationOptions {+ /** Duration in milliseconds for session expiry. Default: 7 days */+ expiresIn?: number;}export interface SessionSearchParams {