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 { SystemRoles } from 'librechat-data-provider';
import {
getOpenIdRoleSyncOptions,
getOpenIdRolesForOpenIdSync,
getLibreChatRolesForOpenIdSync,
selectOpenIdRole,
recordIdpRoleChange,
} from './openidRoleSync';
describe('getOpenIdRoleSyncOptions', () => {
it('defaults role sync and API role sync to disabled', () => {
expect(getOpenIdRoleSyncOptions({})).toEqual({
enabled: false,
apiEnabled: false,
claimSource: 'id',
claim: undefined,
rolePriority: [],
fallbackRole: undefined,
});
});
it('parses enabled config and comma-separated priority roles', () => {
expect(
getOpenIdRoleSyncOptions({
OPENID_ROLE_SYNC_ENABLED: 'true',
OPENID_ROLE_SYNC_API_ENABLED: 'true',
OPENID_ROLE_SYNC_SOURCE: 'access',
OPENID_ROLE_SYNC_CLAIM: 'roles',
OPENID_ROLE_SYNC_ROLE_PRIORITY: 'STANDARD-USER, BASIC-USER',
OPENID_ROLE_SYNC_FALLBACK_ROLE: SystemRoles.USER,
}),
).toEqual({
enabled: true,
apiEnabled: true,
claimSource: 'access',
claim: 'roles',
rolePriority: ['STANDARD-USER', 'BASIC-USER'],
fallbackRole: SystemRoles.USER,
});
});
it('requires claim when role sync is enabled', () => {
expect(() => getOpenIdRoleSyncOptions({ OPENID_ROLE_SYNC_ENABLED: 'true' })).toThrow(
'OPENID_ROLE_SYNC_CLAIM is required',
);
});
it('rejects invalid claim sources when enabled', () => {
expect(() =>
getOpenIdRoleSyncOptions({
OPENID_ROLE_SYNC_ENABLED: 'true',
OPENID_ROLE_SYNC_CLAIM: 'roles',
OPENID_ROLE_SYNC_SOURCE: 'profile',
}),
).toThrow('OPENID_ROLE_SYNC_SOURCE must be one of');
});
it('ignores role-sync-specific settings when the feature is disabled', () => {
expect(
getOpenIdRoleSyncOptions({
OPENID_ROLE_SYNC_SOURCE: 'profile',
OPENID_ROLE_SYNC_ROLE_PRIORITY: SystemRoles.ADMIN,
OPENID_ROLE_SYNC_FALLBACK_ROLE: SystemRoles.ADMIN,
}),
).toMatchObject({ enabled: false, apiEnabled: false });
});
it('rejects API role sync when global role sync is disabled', () => {
expect(() =>
getOpenIdRoleSyncOptions({
OPENID_ROLE_SYNC_API_ENABLED: 'true',
}),
).toThrow('OPENID_ROLE_SYNC_API_ENABLED requires OPENID_ROLE_SYNC_ENABLED=true');
});
it('rejects ADMIN in role priority and fallback role when enabled', () => {
expect(() =>
getOpenIdRoleSyncOptions({
OPENID_ROLE_SYNC_ENABLED: 'true',
OPENID_ROLE_SYNC_CLAIM: 'roles',
OPENID_ROLE_SYNC_ROLE_PRIORITY: `STANDARD-USER,${SystemRoles.ADMIN}`,
}),
).toThrow('OPENID_ROLE_SYNC_ROLE_PRIORITY cannot include ADMIN');
expect(() =>
getOpenIdRoleSyncOptions({
OPENID_ROLE_SYNC_ENABLED: 'true',
OPENID_ROLE_SYNC_CLAIM: 'roles',
OPENID_ROLE_SYNC_FALLBACK_ROLE: SystemRoles.ADMIN,
}),
).toThrow('OPENID_ROLE_SYNC_FALLBACK_ROLE cannot be ADMIN');
});
});
describe('getOpenIdRolesForOpenIdSync', () => {
const options = {
enabled: true,
apiEnabled: false,
claimSource: 'id' as const,
claim: 'roles',
rolePriority: ['STANDARD-USER'],
};
it('extracts a configured claim from the selected source', async () => {
await expect(
getOpenIdRolesForOpenIdSync({
options,
idToken: 'id-token',
decodeToken: () => ({ roles: ['STANDARD-USER'] }),
}),
).resolves.toEqual(['STANDARD-USER']);
});
it('returns an empty list when the source lacks a usable claim value (applies fallback)', async () => {
await expect(
getOpenIdRolesForOpenIdSync({
options,
idToken: 'id-token',
decodeToken: () => ({ roles: { STANDARD_USER: true } }),
}),
).resolves.toEqual([]);
});
it('returns undefined when no token source is available (skips sync)', async () => {
await expect(
getOpenIdRolesForOpenIdSync({
options,
decodeToken: () => ({ roles: ['STANDARD-USER'] }),
}),
).resolves.toBeUndefined();
});
it('uses overage resolution for id token groups', async () => {
await expect(
getOpenIdRolesForOpenIdSync({
options: { ...options, claim: 'groups' },
idToken: 'id-token',
decodeToken: () => ({ hasgroups: true }),
resolveGroupOverage: async () => ['group-a'],
}),
).resolves.toEqual(['group-a']);
});
it('decodes only the configured access token source', async () => {
const decodeToken = jest.fn((token: string) => ({ token }));
await expect(
getOpenIdRolesForOpenIdSync({
options: { ...options, claimSource: 'access' },
accessToken: 'access-token',
idToken: 'id-token',
decodeToken,
}),
).resolves.toEqual([]);
expect(decodeToken).toHaveBeenCalledTimes(1);
});
it('resolves group overage from an access token source (not just id)', async () => {
await expect(
getOpenIdRolesForOpenIdSync({
options: { ...options, claimSource: 'access', claim: 'groups' },
accessClaims: {
_claim_names: { groups: 'src1' },
_claim_sources: { src1: { endpoint: 'https://graph' } },
},
decodeToken: () => ({}),
resolveGroupOverage: async () => ['group-a'],
}),
).resolves.toEqual(['group-a']);
});
it('uses claims for the id source when no id token is available', async () => {
const decodeToken = jest.fn();
const claims = { roles: ['STANDARD-USER'] };
await expect(
getOpenIdRolesForOpenIdSync({
options,
claims,
decodeToken,
}),
).resolves.toEqual(['STANDARD-USER']);
expect(decodeToken).not.toHaveBeenCalled();
});
it('uses userinfo directly for the userinfo source', async () => {
const userinfo = { roles: ['STANDARD-USER'] };
await expect(
getOpenIdRolesForOpenIdSync({
options: { ...options, claimSource: 'userinfo' },
userinfo,
decodeToken: jest.fn(),
}),
).resolves.toEqual(['STANDARD-USER']);
});
});
describe('getLibreChatRolesForOpenIdSync', () => {
it('deduplicates configured roles and returns canonical role names', async () => {
const getRolesByNames = jest.fn(async (roleNames: string[]) =>
roleNames.map((roleName) => ({
name: roleName.toLowerCase() === 'standard-user' ? 'STANDARD-USER' : roleName,
})),
);
await expect(
getLibreChatRolesForOpenIdSync({
getRolesByNames,
rolePriority: [' standard-user ', 'STANDARD-USER'],
fallbackRole: SystemRoles.USER,
}),
).resolves.toEqual({
rolePriority: ['STANDARD-USER', 'STANDARD-USER'],
fallbackRole: SystemRoles.USER,
});
expect(getRolesByNames).toHaveBeenCalledTimes(1);
expect(getRolesByNames).toHaveBeenCalledWith(['standard-user', SystemRoles.USER], 'name');
});
it('rejects configured roles that do not exist', async () => {
const getRolesByNames = jest.fn(async (roleNames: string[]) =>
roleNames
.filter((roleName) => roleName !== 'MISSING')
.map((roleName) => ({ name: roleName })),
);
await expect(
getLibreChatRolesForOpenIdSync({
getRolesByNames,
rolePriority: ['STANDARD-USER', 'MISSING'],
logPrefix: '[openidStrategy]',
}),
).rejects.toThrow('[openidStrategy] OpenID role sync configured roles do not exist: MISSING');
});
it('accepts a system fallback role even when a tenant-scoped lookup omits it', async () => {
// Tenant-scoped getRolesByNames returns only the tenant's own roles, not the
// globally-provisioned system USER role.
const getRolesByNames = jest.fn(async (roleNames: string[]) =>
roleNames
.filter((roleName) => roleName === 'STANDARD-USER')
.map((roleName) => ({ name: roleName })),
);
await expect(
getLibreChatRolesForOpenIdSync({
getRolesByNames,
rolePriority: ['STANDARD-USER'],
fallbackRole: SystemRoles.USER,
}),
).resolves.toEqual({
rolePriority: ['STANDARD-USER'],
fallbackRole: SystemRoles.USER,
});
});
});
describe('selectOpenIdRole', () => {
it('selects the highest-priority configured role from matching OpenID values', () => {
expect(
selectOpenIdRole({
currentRole: SystemRoles.USER,
openIdRoleValues: 'BASIC-USER STANDARD-USER',
rolePriority: ['STANDARD-USER', 'BASIC-USER'],
}),
).toEqual({
selectedRole: 'STANDARD-USER',
reason: 'matched_priority',
});
});
it('matches roles case-insensitively and returns the configured canonical role name', () => {
expect(
selectOpenIdRole({
openIdRoleValues: ['standard-user'],
rolePriority: ['STANDARD-USER'],
}).selectedRole,
).toBe('STANDARD-USER');
});
it('uses rolePriority as the ordered assignable role list', () => {
expect(
selectOpenIdRole({
currentRole: 'BASIC-USER',
openIdRoleValues: ['BASIC-USER', 'STANDARD-USER'],
rolePriority: ['BASIC-USER', 'STANDARD-USER'],
}),
).toEqual({
selectedRole: 'BASIC-USER',
reason: 'matched_priority',
});
});
it('ignores token values that are not in rolePriority or fallbackRole', () => {
expect(
selectOpenIdRole({
currentRole: SystemRoles.USER,
openIdRoleValues: ['BASIC-USER', 'STANDARD-USER'],
rolePriority: [],
}),
).toEqual({
reason: 'no_matching_role',
});
});
it('applies fallback only when no configured role matches', () => {
expect(
selectOpenIdRole({
currentRole: 'BASIC-USER',
openIdRoleValues: ['UNKNOWN'],
rolePriority: ['BASIC-USER'],
fallbackRole: SystemRoles.USER,
}),
).toEqual({
selectedRole: SystemRoles.USER,
reason: 'fallback',
});
});
it('does not apply fallback when a priority role already matches', () => {
expect(
selectOpenIdRole({
openIdRoleValues: ['BASIC-USER'],
rolePriority: ['BASIC-USER'],
fallbackRole: SystemRoles.USER,
}),
).toEqual({
selectedRole: 'BASIC-USER',
reason: 'matched_priority',
});
});
it('keeps the current fallback role when it is present in the OpenID values', () => {
expect(
selectOpenIdRole({
currentRole: SystemRoles.USER,
openIdRoleValues: [SystemRoles.USER],
rolePriority: ['BASIC-USER'],
fallbackRole: SystemRoles.USER,
}),
).toEqual({
selectedRole: SystemRoles.USER,
reason: 'kept_current',
});
});
it('does not keep a current role that is outside rolePriority and fallbackRole', () => {
expect(
selectOpenIdRole({
currentRole: 'LOCAL-ROLE',
openIdRoleValues: ['LOCAL-ROLE'],
rolePriority: ['STANDARD-USER'],
fallbackRole: SystemRoles.USER,
}),
).toEqual({
selectedRole: SystemRoles.USER,
reason: 'fallback',
});
});
it('selects fallback when the fallback role is present and no priority role matches', () => {
expect(
selectOpenIdRole({
currentRole: 'BASIC-USER',
openIdRoleValues: [SystemRoles.USER],
rolePriority: ['STANDARD-USER'],
fallbackRole: SystemRoles.USER,
}),
).toEqual({
selectedRole: SystemRoles.USER,
reason: 'fallback',
});
});
it('excludes ADMIN from generic matching and fallback assignment', () => {
expect(
selectOpenIdRole({
openIdRoleValues: [SystemRoles.ADMIN],
rolePriority: [SystemRoles.ADMIN],
fallbackRole: SystemRoles.ADMIN,
}),
).toEqual({
reason: 'no_matching_role',
});
});
it('ignores unknown normalized values without affecting priority selection', () => {
expect(
selectOpenIdRole({
openIdRoleValues: ['UNKNOWN', 'unknown', 'BASIC-USER', 'ignored'],
rolePriority: ['BASIC-USER'],
}),
).toEqual({
selectedRole: 'BASIC-USER',
reason: 'matched_priority',
});
});
});
describe('recordIdpRoleChange', () => {
it('records an IdP admin grant as a critical user.role_changed entry', async () => {
const recordAuditEntry = jest.fn().mockResolvedValue(undefined);
await recordIdpRoleChange({
recordAuditEntry,
userId: 'u1',
previousRole: SystemRoles.USER,
role: SystemRoles.ADMIN,
source: 'openid_login',
tenantId: 't1',
});
expect(recordAuditEntry).toHaveBeenCalledWith({
action: 'user.role_changed',
severity: 'critical',
actor: { type: 'system', name: 'OpenID role sync' },
target: { type: 'user', id: 'u1' },
metadata: { previousRole: SystemRoles.USER, role: SystemRoles.ADMIN, source: 'openid_login' },
tenantId: 't1',
});
});
it('records a non-admin change at warning severity', async () => {
const recordAuditEntry = jest.fn().mockResolvedValue(undefined);
await recordIdpRoleChange({
recordAuditEntry,
userId: 'u1',
previousRole: SystemRoles.USER,
role: 'STAFF',
source: 'openid_login',
});
expect(recordAuditEntry).toHaveBeenCalledWith(
expect.objectContaining({
severity: 'warning',
metadata: expect.objectContaining({ role: 'STAFF' }),
}),
);
});
it('records nothing when the role did not change', async () => {
const recordAuditEntry = jest.fn().mockResolvedValue(undefined);
await recordIdpRoleChange({
recordAuditEntry,
userId: 'u1',
previousRole: SystemRoles.ADMIN,
role: SystemRoles.ADMIN,
source: 'openid_login',
});
expect(recordAuditEntry).not.toHaveBeenCalled();
});
it('does not throw when the audit write fails', async () => {
const recordAuditEntry = jest.fn().mockRejectedValue(new Error('audit down'));
await expect(
recordIdpRoleChange({
recordAuditEntry,
userId: 'u1',
previousRole: SystemRoles.ADMIN,
role: SystemRoles.USER,
source: 'openid_login',
}),
).resolves.toBeUndefined();
});
});