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
import {
CacheKeys,
AUTH_USER_DOC_BY_ID_PREFIX,
AUTH_USER_DOC_EVICTION_FENCE_TTL_MS,
} from 'librechat-data-provider';
import type { CacheStore } from '~/types';
import {
evictAuthUserDocs,
evictAuthUserDocsForUsers,
isAuthUserDocEvictionFenced,
buildAuthUserDocEvictionFenceKey,
} from './eviction';
const INDEX_KEY = `${AUTH_USER_DOC_BY_ID_PREFIX}:user-1`;
const OTHER_INDEX_KEY = `${AUTH_USER_DOC_BY_ID_PREFIX}:user-2`;
/** A Map-backed store that rejects the operations named for a key, as a throwing Redis store does. */
function makeStore(failures: { get?: string[]; set?: string[]; delete?: string[] } = {}) {
const values = new Map<string, unknown>([
[INDEX_KEY, ['doc-a', 'doc-b']],
['doc-a', { id: 'user-1' }],
['doc-b', { id: 'user-1' }],
['doc-c', { id: 'user-1' }],
[OTHER_INDEX_KEY, ['doc-other']],
['doc-other', { id: 'user-2' }],
]);
return {
values,
get: jest.fn(async (key: string) => {
if (failures.get?.includes(key)) {
throw new Error(`GET ${key} failed`);
}
return values.get(key);
}),
set: jest.fn(async (key: string, value: unknown, _ttl?: number) => {
if (failures.set?.includes(key)) {
throw new Error(`SET ${key} failed`);
}
values.set(key, value);
return true;
}),
delete: jest.fn(async (key: string) => {
if (failures.delete?.includes(key)) {
throw new Error(`DEL ${key} failed`);
}
return values.delete(key);
}),
};
}
function expectOtherUserCached(store: ReturnType<typeof makeStore>) {
expect(store.values.get(OTHER_INDEX_KEY)).toEqual(['doc-other']);
expect(store.values.get('doc-other')).toEqual({ id: 'user-2' });
}
describe('evictAuthUserDocs', () => {
it('lets a retry find a document an earlier failed delete left behind', async () => {
const store = makeStore({ delete: ['doc-a'] });
await expect(evictAuthUserDocs(store, { userId: 'user-1' })).resolves.toBe(false);
store.delete.mockImplementation(async (key: string) => store.values.delete(key));
await expect(evictAuthUserDocs(store, { userId: 'user-1' })).resolves.toBe(true);
expect(store.values.has('doc-a')).toBe(false);
expect(store.values.has(INDEX_KEY)).toBe(false);
});
it('deletes the indexed and explicit documents and the index', async () => {
const store = makeStore();
await expect(evictAuthUserDocs(store, { userId: 'user-1', cacheKey: 'doc-c' })).resolves.toBe(
true,
);
for (const key of [INDEX_KEY, 'doc-a', 'doc-b', 'doc-c']) {
expect(store.values.has(key)).toBe(false);
}
expectOtherUserCached(store);
});
it('reports a failed index read and keeps the index for a retry', async () => {
const store = makeStore({ get: [INDEX_KEY] });
await expect(evictAuthUserDocs(store, { userId: 'user-1', cacheKey: 'doc-c' })).resolves.toBe(
false,
);
expect(store.values.has('doc-c')).toBe(false);
expect(store.values.get(INDEX_KEY)).toEqual(['doc-a', 'doc-b']);
expect(store.values.has('doc-a')).toBe(true);
expectOtherUserCached(store);
});
it.each([
['a string', 'doc-a'],
['a list with a non-string entry', ['doc-a', 42]],
])('treats a reverse index holding %s as unreadable', async (_label, indexed) => {
const store = makeStore();
store.values.set(INDEX_KEY, indexed);
await expect(evictAuthUserDocs(store, { userId: 'user-1' })).resolves.toBe(false);
expect(store.values.get(INDEX_KEY)).toEqual(indexed);
expect(store.values.has('doc-a')).toBe(true);
});
it('reports a failed document delete, deletes the others and keeps the index for a retry', async () => {
const store = makeStore({ delete: ['doc-a'] });
await expect(evictAuthUserDocs(store, { userId: 'user-1' })).resolves.toBe(false);
expect(store.values.has('doc-a')).toBe(true);
expect(store.values.has('doc-b')).toBe(false);
expect(store.values.get(INDEX_KEY)).toEqual(['doc-a', 'doc-b']);
expectOtherUserCached(store);
});
it('counts documents as evicted when only the index delete fails', async () => {
const store = makeStore({ delete: [INDEX_KEY] });
await expect(evictAuthUserDocs(store, { userId: 'user-1' })).resolves.toBe(true);
expect(store.values.has('doc-a')).toBe(false);
expect(store.values.has('doc-b')).toBe(false);
expect(store.values.get(INDEX_KEY)).toEqual(['doc-a', 'doc-b']);
expectOtherUserCached(store);
});
it('fences the user for longer than a document read before the eviction can live', async () => {
const store = makeStore();
await expect(evictAuthUserDocs(store, { userId: 'user-1' })).resolves.toBe(true);
expect(store.set).toHaveBeenCalledWith(
buildAuthUserDocEvictionFenceKey('user-1'),
expect.any(Number),
AUTH_USER_DOC_EVICTION_FENCE_TTL_MS,
);
await expect(isAuthUserDocEvictionFenced(store, 'user-1')).resolves.toBe(true);
await expect(isAuthUserDocEvictionFenced(store, 'user-2')).resolves.toBe(false);
});
it('reports a failed fence write even when every document was deleted', async () => {
const store = makeStore({ set: [buildAuthUserDocEvictionFenceKey('user-1')] });
await expect(evictAuthUserDocs(store, { userId: 'user-1' })).resolves.toBe(false);
expect(store.values.has('doc-a')).toBe(false);
expect(store.values.has('doc-b')).toBe(false);
expect(store.values.get(INDEX_KEY)).toEqual(['doc-a', 'doc-b']);
});
it('does not fence when only a cache key is evicted', async () => {
const store = makeStore();
await expect(evictAuthUserDocs(store, { cacheKey: 'doc-c' })).resolves.toBe(true);
expect(store.set).not.toHaveBeenCalled();
expect(store.values.has('doc-c')).toBe(false);
});
});
describe('isAuthUserDocEvictionFenced', () => {
it('treats an unreadable fence as fenced', async () => {
const store = makeStore({ get: [buildAuthUserDocEvictionFenceKey('user-1')] });
await expect(isAuthUserDocEvictionFenced(store, 'user-1')).resolves.toBe(true);
});
});
describe('evictAuthUserDocsForUsers', () => {
const originalMode = process.env.AUTH_USER_CACHE_MODE;
afterEach(() => {
if (originalMode === undefined) {
delete process.env.AUTH_USER_CACHE_MODE;
} else {
process.env.AUTH_USER_CACHE_MODE = originalMode;
}
});
function cacheFor(store: ReturnType<typeof makeStore>) {
return jest.fn((key: string) =>
key === CacheKeys.AUTH_USER_DOC ? (store as CacheStore) : undefined,
);
}
it('evicts and fences each distinct user once', async () => {
process.env.AUTH_USER_CACHE_MODE = 'on';
const store = makeStore();
await expect(
evictAuthUserDocsForUsers(cacheFor(store), [
'user-1',
{ toString: () => 'user-1' },
'user-2',
]),
).resolves.toBe(true);
for (const key of [INDEX_KEY, OTHER_INDEX_KEY, 'doc-a', 'doc-b', 'doc-other']) {
expect(store.values.has(key)).toBe(false);
}
expect(store.set).toHaveBeenCalledTimes(2);
});
it('reports a user whose documents may still be served', async () => {
process.env.AUTH_USER_CACHE_MODE = 'on';
const store = makeStore({ delete: ['doc-other'] });
await expect(evictAuthUserDocsForUsers(cacheFor(store), ['user-1', 'user-2'])).resolves.toBe(
false,
);
expect(store.values.has('doc-a')).toBe(false);
});
it('leaves the cache alone when the auth user cache is off', async () => {
delete process.env.AUTH_USER_CACHE_MODE;
const store = makeStore();
const getCache = cacheFor(store);
await expect(evictAuthUserDocsForUsers(getCache, ['user-1'])).resolves.toBe(true);
expect(getCache).not.toHaveBeenCalled();
expect(store.values.get(INDEX_KEY)).toEqual(['doc-a', 'doc-b']);
});
});