🏘️ fix: Resolve Tenant Profiles in Their Own Partition and Keep Role Operations in the Caller's (#17417)
Some checks failed
Backend Unit Tests / Build packages (push) Waiting to run
Backend Unit Tests / Codegraph select (push) Waiting to run
Backend Unit Tests / TypeScript type checks (push) Blocked by required conditions
Backend Unit Tests / Circular dependency checks (push) Waiting to run
Backend Unit Tests / Tests: api (shard 1/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 2/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 3/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: data-provider (push) Blocked by required conditions
Backend Unit Tests / Tests: data-schemas (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 1/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 2/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 3/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 4/4) (push) Blocked by required conditions
Codegraph E2E Vote Gate / Gate (push) Waiting to run
Codegraph E2E Votes / vote (shard 1/10) (push) Waiting to run
Codegraph E2E Votes / vote (shard 10/10) (push) Waiting to run
Codegraph E2E Votes / vote (shard 2/10) (push) Waiting to run
Codegraph E2E Votes / vote (shard 3/10) (push) Waiting to run
Codegraph E2E Votes / vote (shard 4/10) (push) Waiting to run
Codegraph E2E Votes / vote (shard 5/10) (push) Waiting to run
Codegraph E2E Votes / vote (shard 6/10) (push) Waiting to run
Codegraph E2E Votes / vote (shard 7/10) (push) Waiting to run
Codegraph E2E Votes / vote (shard 8/10) (push) Waiting to run
Codegraph E2E Votes / vote (shard 9/10) (push) Waiting to run
Docker Dev Branch Images Build / publish (push) Waiting to run
Frontend Unit Tests / Client build recovery regression (push) Waiting to run
Frontend Unit Tests / Codegraph select (push) Waiting to run
Frontend Unit Tests / Build packages (push) Waiting to run
Frontend Unit Tests / TypeScript type checks (client) (push) Blocked by required conditions
Frontend Unit Tests / Tests: @librechat/chat (push) Blocked by required conditions
Frontend Unit Tests / Tests: @librechat/client (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 1/2) (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 2/2) (push) Blocked by required conditions
Frontend Unit Tests / Vite build verification (push) Blocked by required conditions
Sync Locize Translations & Create Translation PR / Sync Translation Keys with Locize (push) Has been cancelled
Sync Locize Translations & Create Translation PR / Create Translation PR on Version Published (push) Has been cancelled

- GET /resolved resolves a group or user profile in the partition its document belongs to, as
  writes judge it: for an admin without a tenant reading a tenant's profile, that tenant's
  librechat.yaml and __base__. GET /catalog resolves such a scope there too, instead of
  answering 404, and GET /effective finds a user by id the way profiles are addressed and
  resolves them in their own tenant: their role, groups and documents there.
- findPartitionUser becomes findPrincipalUser, which also returns the user's tenant.
- Admin role operations address the role of the caller's tenant partition: the role lookup
  (getPartitionRole), listing, creation's name check, the members a rename migrates or a deletion
  reassigns, the members listed and counted, and the ACL entries (deletePrincipalAclEntries) and
  grants a deletion removes. A member added or removed by id must be a user of that partition.
- getRoleByName, which every request's permission checks read, reads the role of the caller's
  partition too: outside a tenant and under the system context the platform-level one, never an
  older tenant role of the same name. updateRoleByName without an id and updateAccessPermissions
  for a role read without its _id write that role, so the legacy permission route changes the
  platform role. The grants route checks a role exists with getPartitionRole.
- runInPartition moves a read into another partition only from outside a tenant, and rejects
  leaving an active one.
- deleteGrantsForPrincipal and findGrantsForPrincipal without a tenantId reach only
  platform-level grants, as moveGrantsToPrincipal does.
- updateRoleByName takes { id } to change one role document; renames, their rollback,
  description updates and updateAccessPermissions write the document they read.
- The exported keyed rename helpers (applyConfigChange rename, renameConfigEntryTombstones)
  refuse a new name no keyed path can address, as the admin routes do.
This commit is contained in:
Danny Avila 2026-10-24 18:33:12 +02:00 • committed by GitHub
parent a378657583
commit 080e5f500c
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
29 changed files with 1310 additions and 197 deletions

View file

@ -65,7 +65,7 @@ function createApp(user) {
hasCapabilityForPrincipals: db.hasCapabilityForPrincipals,
getHeldCapabilities: db.getHeldCapabilities,
getCachedPrincipals,
checkRoleExists: async (name) => (await db.getRoleByName(name)) != null,
checkRoleExists: async (name) => (await db.getPartitionRole(name)) != null,
});
const app = express();
@ -168,6 +168,29 @@ describe('Admin Grants Routes — Integration', () => {
expect(res.body.error).toBe('Role not found');
});
it('POST / returns 400 for a role only a tenant holds, as the roles API addresses it', async () => {
const { tenantStorage } = require('@librechat/data-schemas');
await tenantStorage.run({ tenantId: 'tenant-a' }, () =>
db.createRoleByName({ name: 'tenant-only-role' }),
);
const app = createApp(adminUser);
const res = await request(app)
.post('/api/admin/grants')
.send({
principalType: PrincipalType.ROLE,
principalId: 'tenant-only-role',
capability: 'read:users',
})
.expect(400);
expect(res.body.error).toBe('Role not found');
expect(
await mongoose.models.SystemGrant.countDocuments({ principalId: 'tenant-only-role' }),
).toBe(0);
await mongoose.models.Role.deleteMany({ name: 'tenant-only-role' });
});
it('POST / returns 401 without authenticated user', async () => {
const app = createApp(undefined);

View file

@ -64,7 +64,7 @@ const readHandlers = createAdminConfigReadHandlers({
hasCapability,
resolveConfigLayers,
principalExists: db.principalExists,
findPartitionUser: db.findPartitionUser,
findPrincipalUser: db.findPrincipalUser,
getUserPrincipals: db.getUserPrincipals,
getApplicableConfigs: db.getApplicableConfigs,
});
@ -81,6 +81,7 @@ const catalogHandlers = createAdminConfigCatalogHandlers({
toolManifest: availableTools,
toolkits,
principalExists: db.principalExists,
findConfigByPrincipal: db.findConfigByPrincipal,
listAllConfigs: db.listAllConfigs,
overrideEnvAllowlist: process.env.CONFIG_OVERRIDE_ENV_ALLOWLIST,
});

View file

@ -35,7 +35,7 @@ const mockDb = {
toggleConfigActiveTracked: jest.fn(),
recordAuditEntry: jest.fn(),
principalExists: jest.fn(async () => true),
findPartitionUser: jest.fn(async () => null),
findPrincipalUser: jest.fn(async () => null),
getUserPrincipals: jest.fn(async () => []),
getApplicableConfigs: jest.fn(async () => []),
};

View file

@ -25,7 +25,7 @@ const handlers = createAdminGrantsHandlers({
hasCapabilityForPrincipals: db.hasCapabilityForPrincipals,
getHeldCapabilities: db.getHeldCapabilities,
getCachedPrincipals,
checkRoleExists: async (name) => (await db.getRoleByName(name)) != null,
checkRoleExists: async (name) => (await db.getPartitionRole(name)) != null,
recordAuditEntry: db.recordAuditEntry,
auditFailClosed: isAuditFailClosed(),
lease: {

View file

@ -15,7 +15,7 @@ const requireManageRoles = requireCapability(SystemCapabilities.MANAGE_ROLES);
const handlers = createAdminRolesHandlers({
listRoles: db.listRoles,
countRoles: db.countRoles,
getRoleByName: db.getRoleByName,
getRoleByName: db.getPartitionRole,
createRoleByName: db.createRoleByName,
updateRoleByName: db.updateRoleByName,
updateAccessPermissions: db.updateAccessPermissions,
@ -28,7 +28,7 @@ const handlers = createAdminRolesHandlers({
listUsersByRole: db.listUsersByRole,
countUsersByRole: db.countUsersByRole,
deleteConfig: db.deleteConfig,
deleteAclEntries: db.deleteAclEntries,
deleteAclEntries: db.deletePrincipalAclEntries,
deleteGrantsForPrincipal: db.deleteGrantsForPrincipal,
restoreConfig: db.restoreConfig,
findConfigByPrincipal: db.findConfigByPrincipal,

View file

@ -164,7 +164,7 @@ function roleHandlers(overrides: Partial<AdminRolesDeps>) {
return createAdminRolesHandlers({
listRoles: methods.listRoles,
countRoles: methods.countRoles,
getRoleByName: methods.getRoleByName,
getRoleByName: methods.getPartitionRole,
createRoleByName: methods.createRoleByName,
updateRoleByName: methods.updateRoleByName,
updateAccessPermissions: methods.updateAccessPermissions,
@ -177,9 +177,7 @@ function roleHandlers(overrides: Partial<AdminRolesDeps>) {
listUsersByRole: methods.listUsersByRole,
countUsersByRole: methods.countUsersByRole,
deleteConfig: methods.deleteConfig,
deleteAclEntries: async (filter) => {
await methods.deleteAclEntries(filter);
},
deleteAclEntries: methods.deletePrincipalAclEntries,
deleteGrantsForPrincipal: methods.deleteGrantsForPrincipal,
restoreConfig: methods.restoreConfig,
findConfigByPrincipal: methods.findConfigByPrincipal,

View file

@ -50,6 +50,7 @@ import {
collectDefaultEnvReferenceSections,
} from '~/app/allowlist';
import { resolveServedCustomEndpoints } from '~/endpoints/custom/config';
import { getConfigPartition, getActivePartition } from './partition';
import { listAvailableTools } from '~/tools/available';
import { getSafeErrorMetadata } from '~/utils/errors';
import { resolveConfigSecret } from './secrets';
@ -98,6 +99,16 @@ export interface AdminConfigCatalogDeps {
toolkits?: TPlugin[];
/** Whether the principal exists in the caller's tenant partition (`principalExists`). */
principalExists?: (principalType: PrincipalType, principalId: string) => Promise<boolean>;
/**
* A principal's config document, active or not. A group or user scope resolves in the tenant
* partition that stores its profile, as `GET /resolved` resolves it; without this lookup every
* scope resolves in the caller's.
*/
findConfigByPrincipal?: (
principalType: PrincipalType,
principalId: string,
options?: { includeInactive?: boolean },
) => Promise<ConfigRecord | null>;
/** Every config document of the caller's partition, for the env names profiles reference. */
listAllConfigs?: () => Promise<ConfigRecord[]>;
/** `CONFIG_OVERRIDE_ENV_ALLOWLIST`, as the app config service is given it. */
@ -348,6 +359,7 @@ export function createAdminConfigCatalogHandlers(deps: AdminConfigCatalogDeps):
toolManifest = [],
toolkits = [],
principalExists,
findConfigByPrincipal,
listAllConfigs,
overrideEnvAllowlist,
} = deps;
@ -473,11 +485,38 @@ export function createAdminConfigCatalogHandlers(deps: AdminConfigCatalogDeps):
}).map(toCatalogTool);
}
/**
* Whether a scope can be resolved, and the tenant partition it resolves in: the caller's, or for
* a group or user profile a caller without a tenant reads from a tenant, the tenant that stores
* it. A scope without a profile must exist in the caller's partition.
*/
async function locateScope(
principalType: PrincipalType,
principalId: string,
isBase: boolean,
): Promise<{ exists: boolean; tenantId: string | undefined }> {
const activePartition = getActivePartition();
if (isBase) {
return { exists: true, tenantId: activePartition };
}
const [stored, exists] = await Promise.all([
principalType !== PrincipalType.ROLE && findConfigByPrincipal
? findConfigByPrincipal(principalType, principalId, { includeInactive: true })
: null,
principalExists ? principalExists(principalType, principalId) : true,
]);
if (stored) {
return { exists: true, tenantId: getConfigPartition(stored) };
}
return { exists, tenantId: activePartition };
}
/**
* GET /catalog?principalType=&principalId= — the endpoints, models, MCP servers and tools a
* scope serves (Base when no principal is named), resolved as `getAppConfig` resolves it for
* that scope from the stored documents, never the override cache. Model lists are never loaded
* with a user's stored key. A part is left out unless the caller can read its section.
* that scope from the stored documents, never the override cache, in the partition the scope's
* profile merges in (`locateScope`). Model lists are never loaded with a user's stored key. A
* part is left out unless the caller can read its section.
*/
async function getConfigCatalog(req: ServerRequest, res: Response): Promise<Response> {
try {
@ -501,24 +540,24 @@ export function createAdminConfigCatalogHandlers(deps: AdminConfigCatalogDeps):
return forbiddenResponse(res);
}
const isBase = isBaseConfigPrincipal({ principalType, principalId });
const [readable, exists] = await Promise.all([
const [readable, scope] = await Promise.all([
getReadableConfigSections(user, [
'endpoints',
'mcpServers',
'filteredTools',
'includedTools',
]),
isBase || !principalExists ? true : principalExists(principalType, principalId),
locateScope(principalType, principalId, isBase),
]);
if (!exists) {
if (!scope.exists) {
return principalNotFoundResponse(res);
}
const config = await getAppConfig(toScopeOptions(principalType, principalId, user.tenantId));
const config = await getAppConfig(toScopeOptions(principalType, principalId, scope.tenantId));
const request: CatalogScopeRequest = {
config,
user: {
tenantId: user.tenantId,
tenantId: scope.tenantId,
...(principalType === PrincipalType.ROLE && !isBase && { role: principalId }),
},
};

View file

@ -16,9 +16,7 @@ import {
import {
logger,
getAtPath,
getTenantId,
unsetAtPath,
tenantStorage,
isPlainRecord,
isDotFreePath,
isSegmentPrefix,
@ -64,7 +62,6 @@ import {
MAX_CONFIG_PATH_DEPTH,
getDefaultConfigPriority,
BASE_CONFIG_PRINCIPAL_ID,
SYSTEM_TENANT_ID,
isConfigRevisionConflict,
ConfigRevisionConflictError,
isConfigOverrideStateEmpty,
@ -177,6 +174,7 @@ import {
isWebSearchBindingPath,
getWebSearchReentryIssues,
} from './binding';
import { getConfigPartition, getActivePartition, runInPartition } from './partition';
import { buildAdminConfigMeta, getCatalogModelsTtlMs } from './meta';
import { createAdminAuditEmitter, configTarget } from './audit';
import { DEFAULT_OVERRIDE_CACHE_TTL } from '~/app/service';
@ -1452,21 +1450,6 @@ interface WriteScope {
activeTenantId: string | undefined;
}
/** The tenant partition a stored document belongs to; `null` and `''` are tenantless. */
function getConfigPartition(record: Pick<ConfigRecord, 'tenantId'>): string | undefined {
return record.tenantId || undefined;
}
/**
* The partition the config store reads and writes role documents in for this request
* (`tenantPartition`): the active tenant's, or the deployment's own outside a tenant and under
* the system context.
*/
function getActivePartition(): string | undefined {
const tenantId = getTenantId();
return tenantId && tenantId !== SYSTEM_TENANT_ID ? tenantId : undefined;
}
/**
* Why a planned unset or tombstone wrote nothing: no document to unset, no principal to create
* one for, or a stored credential it would send elsewhere without entering it again.
@ -3061,11 +3044,9 @@ export function createAdminConfigHandlers(deps: AdminConfigDeps): {
* Base is read in that tenant's context; the partition rules themselves stay the store's.
*/
function readActiveBase(tenantId: string | undefined): Promise<ConfigRecord | null> {
const read = () => findConfigByPrincipal(PrincipalType.ROLE, BASE_CONFIG_PRINCIPAL_ID);
if (tenantId === getActivePartition()) {
return read();
}
return tenantStorage.run({ ...tenantStorage.getStore(), tenantId }, read);
return runInPartition(tenantId, () =>
findConfigByPrincipal(PrincipalType.ROLE, BASE_CONFIG_PRINCIPAL_ID),
);
}
/**

View file

@ -1972,7 +1972,7 @@ const FEATURE_PROBES: Record<AdminConfigFeatureFlag, () => Promise<boolean>> = {
}),
hasCapability: async () => true,
resolveConfigLayers: service.resolveConfigLayers,
findPartitionUser: async (id) => (id === 'member' ? { id, role: 'r1' } : null),
findPrincipalUser: async (id) => (id === 'member' ? { id, role: 'r1' } : null),
getUserPrincipals: async () => [{ principalType: PrincipalType.ROLE, principalId: 'r1' }],
getApplicableConfigs: async () => [role],
});

View file

@ -0,0 +1,41 @@
import { getTenantId, tenantStorage, SYSTEM_TENANT_ID } from '@librechat/data-schemas';
import { runInPartition } from './partition';
/** The tenant context a read runs in. */
const readContext = jest.fn(async () => getTenantId());
const inContext = <T>(tenantId: string, run: () => Promise<T>): Promise<T> =>
tenantStorage.run({ tenantId }, run);
beforeEach(() => {
readContext.mockClear();
});
describe('runInPartition', () => {
it("runs in the request's own context when that is the partition", async () => {
expect(await runInPartition(undefined, readContext)).toBeUndefined();
expect(await inContext('tenant-a', () => runInPartition('tenant-a', readContext))).toBe(
'tenant-a',
);
expect(await inContext(SYSTEM_TENANT_ID, () => runInPartition(undefined, readContext))).toBe(
SYSTEM_TENANT_ID,
);
});
it('moves a read from outside a tenant into the tenant partition it names', async () => {
expect(await runInPartition('tenant-a', readContext)).toBe('tenant-a');
expect(await inContext(SYSTEM_TENANT_ID, () => runInPartition('tenant-a', readContext))).toBe(
'tenant-a',
);
});
it('refuses to leave an active tenant, for the platform or another tenant, without reading', async () => {
await expect(
inContext('tenant-a', () => runInPartition(undefined, readContext)),
).rejects.toThrow('cannot leave the active tenant partition');
await expect(
inContext('tenant-a', () => runInPartition('tenant-b', readContext)),
).rejects.toThrow('cannot leave the active tenant partition');
expect(readContext).not.toHaveBeenCalled();
});
});

View file

@ -0,0 +1,50 @@
import { getTenantId, tenantStorage, SYSTEM_TENANT_ID } from '@librechat/data-schemas';
import type { ConfigRecord } from '@librechat/data-schemas';
/**
* The tenant partitions the admin config API reads and judges in. The config store addresses
* role documents (whose ids are names every tenant reuses) in the active partition, and group
* and user documents by id, so an admin without a tenant reaches a tenant's group or user
* profile. Such a profile merges in its own tenant: librechat.yaml as that tenant resolves it,
* that tenant's `__base__`, and, for a user, that tenant's roles and groups. Reads and writes
* of it run there (`runInPartition`); the partition rules themselves stay the store's.
*/
/** The tenant partition a stored document belongs to; `null` and `''` are tenantless. */
export function getConfigPartition(record: Pick<ConfigRecord, 'tenantId'>): string | undefined {
return record.tenantId || undefined;
}
/**
* The partition the config store reads and writes role documents in for this request
* (`tenantPartition`): the active tenant's, or the deployment's own outside a tenant and under
* the system context.
*/
export function getActivePartition(): string | undefined {
const tenantId = getTenantId();
return tenantId && tenantId !== SYSTEM_TENANT_ID ? tenantId : undefined;
}
/**
* Runs `read` in tenant partition `tenantId` (`undefined`: the deployment's own): in the
* request's own context when that is the partition, otherwise in that tenant's context, so every
* store read it makes lands there. Only a request outside a tenant moves: inside one, leaving it
* would read another tenant, or with `undefined` no tenant context at all, which the tenant plugin
* scopes to nothing outside strict mode, so that rejects. Capability checks never run inside it:
* they judge the caller, in the caller's own tenant.
*/
export function runInPartition<T>(
tenantId: string | undefined,
read: () => Promise<T>,
): Promise<T> {
const active = getActivePartition();
if (tenantId === active) {
return read();
}
if (active !== undefined) {
return Promise.reject(
new Error('[runInPartition] A read cannot leave the active tenant partition'),
);
}
return tenantStorage.run({ ...tenantStorage.getStore(), tenantId }, read);
}

View file

@ -92,7 +92,7 @@ function readHandlers(extra: Partial<ReadDeps> = {}) {
hasCapability: async () => true,
resolveConfigLayers: service.resolveConfigLayers,
principalExists: methods.principalExists,
findPartitionUser: methods.findPartitionUser,
findPrincipalUser: methods.findPrincipalUser,
getUserPrincipals: methods.getUserPrincipals,
getApplicableConfigs: methods.getApplicableConfigs,
...extra,
@ -460,3 +460,194 @@ describe('GET /effective?userId=', () => {
expect((await getEffective(new mongoose.Types.ObjectId().toString())).statusCode).toBe(404);
});
});
describe("a tenant's profile read by an admin without a tenant", () => {
const TENANT = 'tenant-a';
const inTenant = <T>(run: () => Promise<T>): Promise<T> =>
dataSchemas.tenantStorage.run({ tenantId: TENANT }, run);
/** librechat.yaml with a custom endpoint only tenant-a resolves. */
const TENANT_YAML: DeepPartial<TCustomConfig> = {
...YAML,
endpoints: {
custom: [
...(YAML.endpoints?.custom ?? []),
{
name: 'Regional',
tenantId: TENANT,
apiKey: 'regional-literal-key',
baseURL: 'https://regional.example.com/v1',
models: { default: ['regional-1'] },
} as NonNullable<NonNullable<TCustomConfig['endpoints']>['custom']>[number],
],
},
};
let tenantService: AppConfigService;
beforeAll(async () => {
const { createAppConfigService } = await import('~/app/service');
const appConfig: AppConfig = await dataSchemas.AppService({
config: structuredClone(TENANT_YAML),
});
const store = new Map<string, unknown>();
tenantService = createAppConfigService({
loadBaseConfig: async () => structuredClone(appConfig),
setCachedTools: async () => undefined,
getCache: () => ({
get: async (key: string) => store.get(key),
set: async (key: string, value: unknown) => {
store.set(key, value);
},
delete: async (key: string) => store.delete(key),
opts: { store: { keys: () => store.keys() } },
}),
cacheKeys: { APP_CONFIG: 'app_config' },
getApplicableConfigs: methods.getApplicableConfigs,
getUserPrincipals: methods.getUserPrincipals,
});
});
const customNames = (tree: Partial<TCustomConfig>) =>
(tree.endpoints?.custom ?? []).map(({ name }) => name);
/** Base documents that tell the partitions apart, and a tenant-a user in a tenant-a group. */
async function seedPartitions(): Promise<{ groupId: string; userId: string }> {
await patch(ROLE, dataSchemas.BASE_CONFIG_PRINCIPAL_ID, [
{ fieldPath: 'interface.customWelcome', value: 'Platform Base' },
{ fieldPath: 'registration.socialLogins', value: ['platform'] },
]);
await new mongoose.models.Role({ name: 'EDITOR' }).save();
await patch(ROLE, 'EDITOR', [{ fieldPath: 'interface.modelSelect', value: true }]);
return inTenant(async () => {
await patch(ROLE, dataSchemas.BASE_CONFIG_PRINCIPAL_ID, [
{ fieldPath: 'interface.customWelcome', value: 'Tenant Base' },
]);
await new mongoose.models.Role({ name: 'EDITOR' }).save();
await patch(ROLE, 'EDITOR', [{ fieldPath: 'interface.modelSelect', value: false }]);
const userId = await createUser('tenant-member@example.com', 'EDITOR');
const groupId = await createGroup('Tenant Engineering', [userId]);
await patch(PrincipalType.GROUP, groupId, [
{ fieldPath: 'registration.socialLogins', value: ['tenant-group'] },
]);
return { groupId, userId };
});
}
it("resolves a group profile on that tenant's librechat.yaml and Base, as its members get it", async () => {
const { groupId } = await seedPartitions();
const tenantBase = await inTenant(() =>
methods.findConfigByPrincipal(ROLE, dataSchemas.BASE_CONFIG_PRINCIPAL_ID),
);
const res = await getResolved(PrincipalType.GROUP, groupId, {
resolveConfigLayers: tenantService.resolveConfigLayers,
});
const body = res.body as AdminResolvedConfigResponse;
expect(res.statusCode).toBe(200);
expect(body.layers.map(({ principalType, revision }) => [principalType, revision])).toEqual([
[ROLE, tenantBase && dataSchemas.getConfigRevision(tenantBase)],
[PrincipalType.GROUP, expect.any(String)],
]);
expect(body.resolved.interface?.customWelcome).toBe('Tenant Base');
expect(body.resolved.registration?.socialLogins).toEqual(['tenant-group']);
expect(customNames(body.yaml)).toEqual(['Gateway', 'Regional']);
expect(customNames(body.resolved)).toEqual(['Gateway', 'Regional']);
const served = await inTenant(() =>
tenantService.getAppConfig({
resolvedPrincipals: [{ principalType: PrincipalType.GROUP, principalId: groupId }],
bypassOverrideCache: true,
}),
);
expect(served.interfaceConfig?.customWelcome).toBe(body.resolved.interface?.customWelcome);
expect(served.registration?.socialLogins).toEqual(body.resolved.registration?.socialLogins);
/** Another tenant's admin still cannot read it. */
const other = await dataSchemas.tenantStorage.run({ tenantId: 'tenant-b' }, () =>
getResolved(
PrincipalType.GROUP,
groupId,
{ resolveConfigLayers: tenantService.resolveConfigLayers },
{ id: 'admin-b', role: 'ADMIN', tenantId: 'tenant-b' },
),
);
expect(other.statusCode).toBe(404);
});
it("resolves a tenant's user over that tenant's role, groups and Base, as their requests do", async () => {
const { groupId, userId } = await seedPartitions();
const res = await getEffective(userId, {
resolveConfigLayers: tenantService.resolveConfigLayers,
});
const body = res.body as AdminEffectiveConfigResponse;
expect(res.statusCode).toBe(200);
expect(body.principals).toEqual(
expect.arrayContaining([
{ principalType: ROLE, principalId: 'EDITOR' },
{ principalType: PrincipalType.GROUP, principalId: groupId },
]),
);
const tenantDocuments = await inTenant(() =>
methods.getApplicableConfigs([
{ principalType: ROLE, principalId: 'EDITOR' },
{ principalType: PrincipalType.GROUP, principalId: groupId },
]),
);
expect(body.layers.map(({ revision }) => revision)).toEqual(
tenantDocuments.map(dataSchemas.getConfigRevision),
);
expect(body.resolved.interface?.customWelcome).toBe('Tenant Base');
expect(body.resolved.interface?.modelSelect).toBe(false);
expect(body.resolved.registration?.socialLogins).toEqual(['tenant-group']);
expect(customNames(body.yaml)).toEqual(['Gateway', 'Regional']);
const served = await inTenant(() =>
tenantService.getAppConfig({ role: 'EDITOR', userId, bypassOverrideCache: true }),
);
expect(served.interfaceConfig?.customWelcome).toBe(body.resolved.interface?.customWelcome);
expect(served.interfaceConfig?.modelSelect).toBe(body.resolved.interface?.modelSelect);
expect(served.registration?.socialLogins).toEqual(body.resolved.registration?.socialLogins);
});
it("lists the catalog of a group profile from that tenant's librechat.yaml and Base", async () => {
const { groupId } = await seedPartitions();
await patch(ROLE, dataSchemas.BASE_CONFIG_PRINCIPAL_ID, [
{ fieldPath: 'mcpServers.platform-tools.url', value: 'https://platform.example.com/mcp' },
]);
await inTenant(() =>
patch(ROLE, dataSchemas.BASE_CONFIG_PRINCIPAL_ID, [
{ fieldPath: 'mcpServers.tenant-tools.url', value: 'https://tenant.example.com/mcp' },
]),
);
const { createAdminConfigCatalogHandlers } = await import('./catalog');
const getAppConfig = jest.fn(tenantService.getAppConfig);
const handlers = createAdminConfigCatalogHandlers({
hasAnyConfigReadAccess: async () => true,
getReadableConfigSections: async () => ({
broad: false,
sections: new Set(['endpoints', 'mcpServers']),
}),
hasConfigCapability: async () => true,
getAppConfig,
getEndpointsConfig: async () => ({}),
loadDefaultModels: async () => ({}),
loadConfigModels: async () => ({}),
principalExists: methods.principalExists,
findConfigByPrincipal: methods.findConfigByPrincipal,
});
const res = mockRes();
await handlers.getConfigCatalog(
mockReq({ query: { principalType: PrincipalType.GROUP, principalId: groupId } }),
res,
);
const body = res.body as { endpoints?: Record<string, unknown>; mcpServers?: unknown[] };
expect(res.statusCode).toBe(200);
expect(getAppConfig).toHaveBeenCalledWith(expect.objectContaining({ tenantId: TENANT }));
expect(Object.keys(body.endpoints ?? {})).toEqual(expect.arrayContaining(['Regional']));
expect(body.mcpServers).toEqual([expect.objectContaining({ name: 'tenant-tools' })]);
});
});

View file

@ -34,6 +34,7 @@ import {
filterSectionsByReadAccess,
filterConfigDocForReadAccess,
} from './config';
import { getConfigPartition, getActivePartition, runInPartition } from './partition';
import { redactConfigSecrets, redactResolvedConfigSecrets } from './secrets';
import { getSafeErrorMetadata } from '~/utils/errors';
@ -62,17 +63,24 @@ export interface AdminConfigReadDeps {
resolveConfigLayers?: (options: ResolveConfigLayersOptions) => Promise<ResolvedConfigLayers>;
/** Whether the principal exists in the caller's tenant partition (`principalExists`). */
principalExists?: (principalType: PrincipalType, principalId: string) => Promise<boolean>;
/** A user of the caller's tenant partition, with what principal resolution reads of them. */
findPartitionUser?: (
userId: string,
) => Promise<{ id: string; role?: string; idOnTheSource?: string | null } | null>;
/** The principals a user resolves to: the user, their role and their groups. */
/**
* A user the caller addresses by id (`findPrincipalUser`), with what principal resolution reads
* of them and the tenant that holds them: inside a tenant only that tenant's users, outside one
* any tenant's, as group and user profiles are addressed.
*/
findPrincipalUser?: (userId: string) => Promise<{
id: string;
role?: string;
idOnTheSource?: string | null;
tenantId?: string;
} | null>;
/** The principals a user resolves to in the active tenant: the user, their role and groups. */
getUserPrincipals?: (params: {
userId: string;
role?: string | null;
idOnTheSource?: string | null;
}) => Promise<ResolvedPrincipal[]>;
/** Base and the principals' active documents, from the caller's tenant partition. */
/** Base and the principals' active documents, from the active tenant partition. */
getApplicableConfigs?: (
principals: Array<{ principalType: string; principalId?: string }>,
) => Promise<ConfigRecord[]>;
@ -167,17 +175,33 @@ export function createAdminConfigReadHandlers(deps: AdminConfigReadDeps): {
hasCapability,
resolveConfigLayers,
principalExists,
findPartitionUser,
findPrincipalUser,
getUserPrincipals,
getApplicableConfigs,
} = deps;
/** The Base document of one tenant partition, active or not; none for Base itself. */
function readBase(isBase: boolean, tenantId: string | undefined): Promise<ConfigRecord | null> {
if (isBase) {
return Promise.resolve(null);
}
return runInPartition(tenantId, () =>
findConfigByPrincipal(PrincipalType.ROLE, BASE_CONFIG_PRINCIPAL_ID, {
includeInactive: true,
}),
);
}
/**
* GET /resolved/:principalType/:principalId — what a profile resolves to over librechat.yaml
* and the Base document (Base alone for Base), in librechat.yaml shape, with each document and
* what the merge does not apply of it. The profile's other principals vary per user and are
* left out; `GET /effective` resolves a user. A principal with no document resolves to Base,
* unless it does not exist in the caller's tenant (404 `PRINCIPAL_NOT_FOUND`).
*
* It resolves in the partition the profile merges in, as writes judge it (`resolveWriteScope`):
* the caller's, or for a group or user profile a caller without a tenant reads from a tenant,
* that tenant's librechat.yaml and Base, read once the document names it.
*/
async function getResolvedConfig(req: ServerRequest, res: Response): Promise<Response> {
try {
@ -200,12 +224,9 @@ export function createAdminConfigReadHandlers(deps: AdminConfigReadDeps): {
}
const isBase = isBaseConfigPrincipal({ principalType, principalId });
const [base, target] = await Promise.all([
isBase
? null
: findConfigByPrincipal(PrincipalType.ROLE, BASE_CONFIG_PRINCIPAL_ID, {
includeInactive: true,
}),
const activePartition = getActivePartition();
const [activeBase, target] = await Promise.all([
readBase(isBase, activePartition),
findConfigByPrincipal(principalType, principalId, { includeInactive: true }),
]);
if (
@ -216,9 +237,11 @@ export function createAdminConfigReadHandlers(deps: AdminConfigReadDeps): {
) {
return principalNotFoundResponse(res);
}
const partition = target ? getConfigPartition(target) : activePartition;
const base = partition === activePartition ? activeBase : await readBase(isBase, partition);
const records = [base, target].filter((record): record is ConfigRecord => record != null);
const resolution = await resolveConfigLayers({
tenantId: user.tenantId,
tenantId: partition,
configs: records.filter((record) => record.isActive),
});
const body: AdminResolvedConfigResponse = {
@ -236,8 +259,12 @@ export function createAdminConfigReadHandlers(deps: AdminConfigReadDeps): {
/**
* GET /effective?userId= — what one user's requests resolve to: Base, then the active profiles
* of their role, groups and their own, in merge order. Needs `read:users` and `read:groups`
* besides config read access, since it shows the user's role and group memberships. A user who
* is not in the caller's tenant answers 404 `USER_NOT_FOUND`.
* besides config read access, since it shows the user's role and group memberships. A user the
* caller cannot address answers 404 `USER_NOT_FOUND`: inside a tenant, one of another tenant.
*
* It resolves in the user's own tenant, as their requests do: their role and groups, that
* tenant's documents, librechat.yaml as it resolves it. Inside a tenant that is the caller's;
* a caller without a tenant reads a tenant's user there.
*/
async function getEffectiveConfig(req: ServerRequest, res: Response): Promise<Response> {
try {
@ -259,30 +286,33 @@ export function createAdminConfigReadHandlers(deps: AdminConfigReadDeps): {
}
if (
!resolveConfigLayers ||
!findPartitionUser ||
!findPrincipalUser ||
!getUserPrincipals ||
!getApplicableConfigs
) {
return res.status(501).json({ error: 'Effective config is not available' });
}
const target = await findPartitionUser(userId);
const target = await findPrincipalUser(userId);
if (!target) {
return res.status(404).json({ error: 'User not found', code: 'USER_NOT_FOUND' });
}
const principals = await getUserPrincipals({
userId: target.id,
role: target.role ?? null,
idOnTheSource: target.idOnTheSource ?? null,
const partition = getConfigPartition(target);
const { named, records } = await runInPartition(partition, async () => {
const principals = await getUserPrincipals({
userId: target.id,
role: target.role ?? null,
idOnTheSource: target.idOnTheSource ?? null,
});
const resolvedNamed = principals.flatMap((principal) => {
const id = toPrincipalId(principal);
return id == null
? []
: [{ principalType: principal.principalType as PrincipalType, principalId: id }];
});
return { named: resolvedNamed, records: await getApplicableConfigs(resolvedNamed) };
});
const named = principals.flatMap((principal) => {
const id = toPrincipalId(principal);
return id == null
? []
: [{ principalType: principal.principalType as PrincipalType, principalId: id }];
});
const records = await getApplicableConfigs(named);
const resolution = await resolveConfigLayers({ tenantId: user.tenantId, configs: records });
const resolution = await resolveConfigLayers({ tenantId: partition, configs: records });
const body: AdminEffectiveConfigResponse = {
userId: target.id,
principals: named,

View file

@ -86,7 +86,7 @@ function createHandlers(overrides: Partial<AdminRolesDeps> = {}) {
return createAdminRolesHandlers({
listRoles: methods.listRoles,
countRoles: methods.countRoles,
getRoleByName: methods.getRoleByName,
getRoleByName: methods.getPartitionRole,
createRoleByName: methods.createRoleByName,
updateRoleByName: methods.updateRoleByName,
updateAccessPermissions: methods.updateAccessPermissions,
@ -99,9 +99,7 @@ function createHandlers(overrides: Partial<AdminRolesDeps> = {}) {
listUsersByRole: methods.listUsersByRole,
countUsersByRole: methods.countUsersByRole,
deleteConfig: methods.deleteConfig,
deleteAclEntries: async (filter) => {
await methods.deleteAclEntries(filter);
},
deleteAclEntries: methods.deletePrincipalAclEntries,
deleteGrantsForPrincipal: methods.deleteGrantsForPrincipal,
restoreConfig: methods.restoreConfig,
findConfigByPrincipal: methods.findConfigByPrincipal,
@ -195,14 +193,22 @@ async function seedRole(name: string, description = 'Writes things') {
return { userId: userId.toString(), resourceId };
}
/** Everything keyed by `name`: its role document, members, profile, grants and ACL entries. */
/**
* Everything keyed by `name` in the active tenant partition (platform-level outside a tenant):
* its role document, members, profile, grants and ACL entries.
*/
async function keyedBy(name: string) {
const tenantId = dataSchemas.getTenantId();
const [role, members, profile, grants, aclEntries] = await Promise.all([
methods.getRoleByName(name),
methods.getPartitionRole(name),
methods.findUserIdsByRole(name),
methods.findConfigByPrincipal(PrincipalType.ROLE, name, { includeInactive: true }),
methods.findGrantsForPrincipal(PrincipalType.ROLE, name),
mongoose.models.AclEntry.find({ principalType: PrincipalType.ROLE, principalId: name })
methods.findGrantsForPrincipal(PrincipalType.ROLE, name, { tenantId }),
mongoose.models.AclEntry.find({
principalType: PrincipalType.ROLE,
principalId: name,
tenantId: tenantId ?? { $in: [null, ''] },
})
.select('resourceId')
.lean<Array<{ resourceId: Types.ObjectId }>>(),
]);
@ -694,6 +700,189 @@ describe('role rename without a tenant', () => {
});
});
describe('role operations without a tenant keep to the platform role', () => {
/** A tenant-a role of `name` with one member, created in that tenant. */
async function seedTenantRole(name: string, description: string): Promise<string> {
return inTenant('tenant-a', async () => {
await methods.createRoleByName({ name, description, permissions: {} });
const userId = await methods.createUser(
{ email: `tenant-${name}@example.com`, name, provider: 'local', role: name },
undefined,
true,
);
await setWelcome(name, `tenant ${name}`);
await methods.grantCapability({
principalType: PrincipalType.ROLE,
principalId: name,
capability: dataSchemas.SystemCapabilities.READ_CONFIGS,
tenantId: 'tenant-a',
});
await methods.grantPermission(
PrincipalType.ROLE,
name,
ResourceType.AGENT,
new Types.ObjectId(),
PermissionBits.VIEW,
);
return userId.toString();
});
}
/** What tenant-a holds for `name`, read in that tenant. */
const tenantKeyedBy = (name: string) => inTenant('tenant-a', () => keyedBy(name));
async function remove(name: string, tenantId?: string): Promise<MockRes> {
const res = mockRes();
const req = {
params: { name },
body: {},
query: {},
user: { _id: new Types.ObjectId(), id: 'admin', role: 'ADMIN', tenantId },
} as Partial<ServerRequest> as ServerRequest;
const run = () => createHandlers().deleteRole(req, res);
await (tenantId ? inTenant(tenantId, run) : run());
return res;
}
it("migrates and renames only the platform role and its members, never a tenant's role", async () => {
const { userId } = await seedRole('editor');
const tenantUserId = await seedTenantRole('editor', 'Tenant editors');
const tenantBefore = await tenantKeyedBy('editor');
const res = await rename(createHandlers(), 'editor', { name: 'writer', description: 'New' });
expect(res.statusCode).toBe(200);
expect(await keyedBy('writer')).toMatchObject({
role: { name: 'writer', description: 'New' },
members: [userId],
});
expect(tenantBefore.members).toEqual([tenantUserId]);
expect(await tenantKeyedBy('editor')).toEqual(tenantBefore);
expect(await inTenant('tenant-a', () => keyedBy('writer'))).toEqual(nothing);
});
it("serves a platform role created or renamed after a tenant's role of its name to the platform's permission checks", async () => {
await seedTenantRole('editor', 'Tenant editors');
await seedTenantRole('tenant-only', 'Tenant only');
await seedRole('writer');
const params: Record<string, string> = {};
const body: Record<string, unknown> = { name: 'editor', description: 'Platform editors' };
const created = mockRes();
await createHandlers().createRole(
{
params,
body,
query: {},
user: { _id: new Types.ObjectId(), id: 'admin', role: 'ADMIN' },
} as Partial<ServerRequest> as ServerRequest,
created,
);
const renamed = await rename(createHandlers(), 'writer', { name: 'tenant-only' });
/** `getRoleByName` as every request's permission checks read it, with no cached role. */
const served = async (name: string) => (await methods.getRoleByName(name))?.description;
expect(created.statusCode).toBe(201);
expect(renamed.statusCode).toBe(200);
expect(await served('editor')).toBe('Platform editors');
expect(await served('tenant-only')).toBe('Writes things');
expect(await inTenant('tenant-a', () => served('editor'))).toBe('Tenant editors');
expect(await inTenant('tenant-a', () => served('tenant-only'))).toBe('Tenant only');
});
it('answers 404 for a role only a tenant holds, renaming nothing in that tenant', async () => {
await seedTenantRole('tenant-editor', 'Tenant only');
const before = await tenantKeyedBy('tenant-editor');
const res = await rename(createHandlers(), 'tenant-editor', { name: 'renamed' });
expect(res.statusCode).toBe(404);
expect(await tenantKeyedBy('tenant-editor')).toEqual(before);
expect(await inTenant('tenant-a', () => keyedBy('renamed'))).toEqual(nothing);
});
it("deletes only the platform role and what it holds, never a tenant role's members, grants or ACL entries", async () => {
await seedRole('editor');
await seedTenantRole('editor', 'Tenant editors');
const tenantBefore = await tenantKeyedBy('editor');
const res = await remove('editor');
expect(res.statusCode).toBe(200);
expect(await keyedBy('editor')).toEqual(nothing);
expect(await tenantKeyedBy('editor')).toEqual(tenantBefore);
expect(tenantBefore).toMatchObject({
role: { name: 'editor', description: 'Tenant editors' },
grants: [dataSchemas.SystemCapabilities.READ_CONFIGS],
aclEntries: [expect.any(String)],
});
});
it('answers 404 for a deletion of a role only a tenant holds, removing nothing there', async () => {
await seedTenantRole('tenant-editor', 'Tenant only');
const before = await tenantKeyedBy('tenant-editor');
const res = await remove('tenant-editor');
expect(res.statusCode).toBe(404);
expect(await tenantKeyedBy('tenant-editor')).toEqual(before);
});
it("lists, adds and removes only the platform's users as the platform role's members", async () => {
const { userId } = await seedRole('editor');
const tenantMember = await seedTenantRole('editor', 'Tenant editors');
const tenantUser = await inTenant('tenant-a', async () =>
(
await methods.createUser(
{ email: 'tenant-user@example.com', name: 'tu', provider: 'local', role: 'USER' },
undefined,
true,
)
).toString(),
);
const handlers = createHandlers();
const call = async (
handler: 'getRoleMembers' | 'addRoleMember' | 'removeRoleMember',
params: Record<string, string>,
body: Record<string, unknown> = {},
): Promise<MockRes> => {
const res = mockRes();
const req = {
params,
body,
query: {},
user: { _id: new Types.ObjectId(), id: 'admin', role: 'ADMIN' },
} as Partial<ServerRequest> as ServerRequest;
await handlers[handler](req, res);
return res;
};
const roleOf = async (id: string) =>
(await mongoose.models.User.collection.findOne({ _id: new Types.ObjectId(id) }))?.role;
const members = await call('getRoleMembers', { name: 'editor' });
const added = await call('addRoleMember', { name: 'editor' }, { userId: tenantUser });
const removed = await call('removeRoleMember', { name: 'editor', userId: tenantMember });
expect(members.statusCode).toBe(200);
expect(members.body).toMatchObject({ members: [{ userId }], total: 1 });
expect(added.statusCode).toBe(404);
expect(removed.statusCode).toBe(404);
expect(await roleOf(tenantUser)).toBe('USER');
expect(await roleOf(tenantMember)).toBe('editor');
});
it("deletes only the active tenant's role inside it, leaving the platform role", async () => {
await seedRole('editor');
await seedTenantRole('editor', 'Tenant editors');
const platformBefore = await keyedBy('editor');
const res = await remove('editor', 'tenant-a');
expect(res.statusCode).toBe(200);
expect(await tenantKeyedBy('editor')).toEqual(nothing);
expect(await keyedBy('editor')).toEqual(platformBefore);
});
});
describe('role rename inside a tenant', () => {
it("moves only that tenant's profile, never the platform role's of the same name", async () => {
await seedRole('editor');

View file

@ -442,8 +442,9 @@ describe('createAdminRolesHandlers', () => {
describe('updateRole', () => {
it('updates role and returns 200', async () => {
const role = mockRole({ name: 'senior-editor' });
const existing = mockRole({ _id: new Types.ObjectId() } as Partial<IRole>);
const deps = createDeps({
getRoleByName: jest.fn().mockResolvedValueOnce(mockRole()).mockResolvedValueOnce(null),
getRoleByName: jest.fn().mockResolvedValueOnce(existing).mockResolvedValueOnce(null),
updateRoleByName: jest.fn().mockResolvedValue(role),
});
const handlers = createAdminRolesHandlers(deps);
@ -456,7 +457,12 @@ describe('createAdminRolesHandlers', () => {
expect(status).toHaveBeenCalledWith(200);
expect(json).toHaveBeenCalledWith({ role });
expect(deps.updateRoleByName).toHaveBeenCalledWith('editor', { name: 'senior-editor' });
/** The rename writes the role document it read, not another tenant's of that name. */
expect(deps.updateRoleByName).toHaveBeenCalledWith(
'editor',
{ name: 'senior-editor' },
{ id: String(existing._id) },
);
});
it('writes and audits nothing when the description already matches', async () => {
@ -493,7 +499,7 @@ describe('createAdminRolesHandlers', () => {
await handlers.updateRole(req, res);
expect(deps.updateRoleByName).toHaveBeenCalledWith('editor', { name: 'trimmed' });
expect(deps.updateRoleByName).toHaveBeenCalledWith('editor', { name: 'trimmed' }, undefined);
});
it('migrates users before renaming role', async () => {
@ -579,10 +585,11 @@ describe('createAdminRolesHandlers', () => {
expect(status).toHaveBeenCalledWith(200);
expect(json).toHaveBeenCalledWith({ role });
expect(deps.updateUsersByRole).toHaveBeenCalledWith('editor', 'senior-editor');
expect(deps.updateRoleByName).toHaveBeenCalledWith('editor', {
name: 'senior-editor',
description: 'Updated desc',
});
expect(deps.updateRoleByName).toHaveBeenCalledWith(
'editor',
{ name: 'senior-editor', description: 'Updated desc' },
undefined,
);
});
it('returns 403 when renaming a system role', async () => {
@ -1400,8 +1407,7 @@ describe('createAdminRolesHandlers', () => {
it('scopes each cascade audit entry to the removed grant’s own tenant', async () => {
const recordAuditEntry = jest.fn().mockResolvedValue(undefined);
const deps = deleteDeps({
// a platform admin (no tenantId) deletes a role holding both a
// platform-level grant and a tenant-scoped one
// each removed grant names its own scope, whatever the caller's
deleteGrantsForPrincipal: jest
.fn()
.mockResolvedValue([

View file

@ -24,6 +24,7 @@ import type { CascadeStep } from './cascade';
import { createAdminAuditEmitter, diffRolePermissions, configTarget } from './audit';
import { cascadeStep, runCascade, invalidatingConfigStore } from './cascade';
import { getSafeErrorMetadata } from '~/utils/errors';
import { getActivePartition } from './partition';
import { parsePagination } from './pagination';
const systemRoleValues = new Set<string>(Object.values(SystemRoles));
@ -119,19 +120,37 @@ interface RoleMemberParams extends RoleNameParams {
export type RoleListItem = { _id: Types.ObjectId | string; name: string; description?: string };
/**
* Role ids are names every tenant reuses, so every role operation here addresses the role of the
* caller's tenant partition and what it holds there (members, profile, grants and ACL entries):
* the active tenant's, or for an admin without a tenant only the platform-level ones, never each
* tenant's own role of the same name. The routes wire the data-schemas methods that keep to that
* partition, and a member added or removed by id must be a user of it too.
*/
export interface AdminRolesDeps {
/** The roles of the caller's tenant partition (`listRoles`). */
listRoles: (options?: { limit?: number; offset?: number }) => Promise<RoleListItem[]>;
countRoles: () => Promise<number>;
/**
* The role of exactly this name in the caller's tenant partition, read as stored
* (`getPartitionRole`); a missing system role is created there.
*/
getRoleByName: (name: string, fields?: string | string[] | null) => Promise<IRole | null>;
createRoleByName: (roleData: Partial<IRole>) => Promise<IRole>;
updateRoleByName: (name: string, updates: Partial<IRole>) => Promise<IRole | null>;
/** With `options.id`, updates only the role document with that `_id`. */
updateRoleByName: (
name: string,
updates: Partial<IRole>,
options?: { id?: string },
) => Promise<IRole | null>;
updateAccessPermissions: (
name: string,
perms: Record<string, Record<string, boolean>>,
roleData?: IRole,
) => Promise<void>;
/** With `options.id`, deletes only the role that still has that `_id`, so a role recreated
* under the same name is never removed by a request that targeted the original. */
* under the same name is never removed by a request that targeted the original. Reassigns the
* role's members in the caller's partition to USER. */
deleteRoleByName: (name: string, options?: { id?: string }) => Promise<IRole | null>;
findUser: (
criteria: FilterQuery<IUser>,
@ -143,7 +162,9 @@ export interface AdminRolesDeps {
data: Partial<IUser>,
expectedState?: Record<string, unknown>,
) => Promise<IUser | null>;
/** Moves the role's members in the caller's partition to `newRole` (a rename's migration). */
updateUsersByRole: (oldRole: string, newRole: string) => Promise<void>;
/** The ids of the role's members in the caller's partition. */
findUserIdsByRole: (roleName: string) => Promise<string[]>;
/** With `fromRole`, only users whose role is still that one change. */
updateUsersRoleByIds: (
@ -161,15 +182,16 @@ export interface AdminRolesDeps {
principalType: PrincipalType,
principalId: string | Types.ObjectId,
) => Promise<ConfigRecord | null>;
/** Removes all ACL entries scoped to this principal. */
/** Removes the role's ACL entries in the caller's partition (`deletePrincipalAclEntries`). */
deleteAclEntries: (filter: {
principalType: PrincipalType;
principalId: string | Types.ObjectId;
}) => Promise<void>;
/** Drops cached prompt group access IDs; role deletion can remove PROMPTGROUP grants. */
invalidatePromptGroupAccessContext?: () => Promise<void>;
/** Removes all system capability grants held by this principal and returns
* the removed grants so each can be audited. */
/** Removes the system capability grants this principal holds in one scope (exactly
* `tenantId`, or platform-level ones without it) and returns the removed grants so each can be
* audited. */
deleteGrantsForPrincipal: (
principalType: PrincipalType,
principalId: string | Types.ObjectId,
@ -258,6 +280,20 @@ function roleTarget(name: string) {
return { type: 'role', id: name, name };
}
/**
* Whether a user belongs to the caller's tenant partition, the one a role name addresses. Outside
* a tenant a user is found by id in any tenant, but a tenant user's `role` names that tenant's own
* role, so the platform role's member routes never change it.
*/
function isPartitionUser(user: Pick<IUser, 'tenantId'>): boolean {
return (user.tenantId || undefined) === getActivePartition();
}
/** The document a role was read as, so a write changes that role and no other of its name. */
function roleIdentity(role: Pick<IRole, '_id'>): { id: string } | undefined {
return role._id != null ? { id: String(role._id) } : undefined;
}
/** What a role rename moved to the new name along with the role. */
interface RoleDependentsMoved {
/** The profile as the new name now holds it; `null` when the role had none. */
@ -358,9 +394,8 @@ export function createAdminRolesHandlers(deps: AdminRolesDeps): {
severity: 'warning',
target: { type: PrincipalType.ROLE, id: roleName, name: roleName },
metadata: { capability: grant.capability },
/** Scope each entry to the removed grant's own tenant: a platform
* admin's role deletion can remove tenant-scoped grants, and those
* removals must land in the affected tenant's chain, not the caller's. */
/** Scope each entry to the removed grant's own tenant, so a removal
* always lands in the chain of the tenant whose grant it was. */
tenantId: grant.tenantId,
});
}
@ -479,7 +514,7 @@ export function createAdminRolesHandlers(deps: AdminRolesDeps): {
}
}
try {
await updateRoleByName(newName, revert);
await updateRoleByName(newName, revert, roleIdentity(existing));
} catch (revertError) {
logger.error(
`[adminRoles] CRITICAL: rename rollback failed — role "${currentName}" is still named "${newName}"`,
@ -649,7 +684,7 @@ export function createAdminRolesHandlers(deps: AdminRolesDeps): {
let role: IRole | null;
try {
const updates: Partial<IRole> = { name: newName, ...extraUpdates };
role = await updateRoleByName(currentName, updates);
role = await updateRoleByName(currentName, updates, roleIdentity(existing));
} catch (error) {
await rollbackMigratedUsers(migratedIds, currentName, newName);
throw error;
@ -760,7 +795,7 @@ export function createAdminRolesHandlers(deps: AdminRolesDeps): {
return res.status(200).json({ role });
}
const role = await updateRoleByName(name, updates);
const role = await updateRoleByName(name, updates, roleIdentity(existing));
if (!role) {
return res.status(404).json({ error: 'Role not found' });
}
@ -780,10 +815,8 @@ export function createAdminRolesHandlers(deps: AdminRolesDeps): {
}
/**
* The re-fetch via `getRoleByName` after `updateAccessPermissions` depends on the
* callee having written the updated document to the role cache. If the cache layer
* is refactored to stop writing from within `updateAccessPermissions`, this handler
* must be updated to perform an explicit uncached DB read.
* The re-fetch via `getRoleByName` after `updateAccessPermissions` reads the role as
* stored (`getPartitionRole` reads no cache), so it returns what the update wrote.
*/
async function updateRolePermissionsHandler(req: ServerRequest, res: Response) {
try {
@ -1113,7 +1146,7 @@ export function createAdminRolesHandlers(deps: AdminRolesDeps): {
}
const user = await findUser({ _id: userId });
if (!user) {
if (!user || !isPartitionUser(user)) {
return res.status(404).json({ error: 'User not found' });
}
@ -1200,7 +1233,7 @@ export function createAdminRolesHandlers(deps: AdminRolesDeps): {
}
const user = await findUser({ _id: userId });
if (!user) {
if (!user || !isPartitionUser(user)) {
return res.status(404).json({ error: 'User not found' });
}

View file

@ -414,6 +414,25 @@ describe('applyConfigChange: rename', () => {
);
});
it.each([
['an unsafe name', '$where'],
['a reserved name', '__proto__'],
['a name past the length limit', 'k'.repeat(257)],
])(
'refuses %s for an entry of a collection merged by key, as the admin route does',
(_label, to) => {
const stored = deepFreeze(
state({ endpoints: { custom: [endpoint('a')] } }, ['endpoints.custom["a"].headers.X']),
);
const refused = errorOf(() =>
applyConfigChange(stored, { op: 'rename', segments: CUSTOM, from: 'a', to }),
);
expect(isConfigEntryError(refused) && refused.reason).toBe('invalid_entry');
},
);
it('lets a renamed entry be edited by its new name later in the same batch', () => {
const { state: next, changed } = applyConfigChanges(
state({ endpoints: { custom: [endpoint('old', { apiKey: 'v3:cipher' })] } }),

View file

@ -9,12 +9,6 @@ import {
getWriteClearedTombstones,
renameConfigEntryTombstones,
} from './mutations';
import {
getConfigEntryIdentity,
getConfigArrayMergeKey,
isConfigEntryTombstone,
getConfigTombstoneSegments,
} from './collections';
import {
getAtPath,
setAtPath,
@ -22,8 +16,15 @@ import {
isPlainRecord,
ConfigPathError,
isSegmentPrefix,
isConfigEntryKey,
pruneEmptyAncestors,
} from './paths';
import {
getConfigEntryIdentity,
getConfigArrayMergeKey,
isConfigEntryTombstone,
getConfigTombstoneSegments,
} from './collections';
import { combineFoldedConfigEntries } from './resolution';
/**
@ -366,9 +367,13 @@ function applyRename(
throw new ConfigEntryError([...segments], 'invalid_entry');
}
const keyField = getConfigArrayMergeKey(segments);
return keyField
? renameKeyedEntry(state, segments, keyField, from, to)
: renameRecordKey(state, segments, from, to);
if (!keyField) {
return renameRecordKey(state, segments, from, to);
}
if (!isConfigEntryKey(to)) {
throw new ConfigEntryError([...segments], 'invalid_entry');
}
return renameKeyedEntry(state, segments, keyField, from, to);
}
/**

View file

@ -391,4 +391,28 @@ describe('keyed locations: entries of an array merged by key', () => {
renameConfigEntriesTombstones(input, [{ segments: CUSTOM, from: 'ollama', to: 'new' }]),
).toEqual(moved);
});
it.each([
['an unsafe new name', CUSTOM, '$where'],
['a reserved new name', CUSTOM, 'constructor'],
['a new name past the length limit', CUSTOM, 'k'.repeat(257)],
['a record rather than an array merged by key', ['mcpServers'], 'new'],
])('refuses %s instead of moving tombstones no path can address', (_label, segments, to) => {
const input = state({}, ['endpoints.custom["old"].headers.A']);
const refused = (run: () => unknown) => {
try {
run();
} catch (caught) {
return isConfigPathError(caught) && caught.reason;
}
return 'applied';
};
expect(refused(() => renameConfigEntryTombstones(input, segments, 'old', to))).toBe(
'keyed_path',
);
expect(
refused(() => renameConfigEntriesTombstones(input, [{ segments, from: 'old', to }])),
).toBe('keyed_path');
});
});

View file

@ -314,7 +314,10 @@ export function renameConfigEntriesTombstones(
* Moves the keyed tombstones of entry `from` of the merged-by-key array at `segments` to entry
* `to`, as a rename of the principal's own entry carries what it hides: each keeps its path
* inside the entry. The tombstone that hides `to` whole goes, since the principal's own entry
* now has that key, and a moved tombstone that `to` already has is kept once.
* now has that key, and a moved tombstone that `to` already has is kept once. A `to` no keyed
* path can address (`isConfigEntryKey`), or `segments` that are not an array merged by key,
* throw a `ConfigPathError` (`requireEntryLocation`), as the admin routes refuse such a rename:
* a moved tombstone would name a path no read or removal can address.
*/
export function renameConfigEntryTombstones(
state: ConfigOverrideState,
@ -322,6 +325,7 @@ export function renameConfigEntryTombstones(
from: string,
to: string,
): ConfigOverrideState {
requireEntryLocation({ segments, entry: { key: to, rest: [] } });
const fromIdentity = getConfigEntryIdentity(segments, from);
const tombstones: string[] = [];
let changed = false;

View file

@ -964,6 +964,65 @@ describe('AclEntry Model Tests', () => {
});
});
describe('deletePrincipalAclEntries', () => {
const grantTo = (principalType: PrincipalType, principalId: string | mongoose.Types.ObjectId) =>
methods.grantPermission(
principalType,
principalId,
ResourceType.AGENT,
new mongoose.Types.ObjectId(),
PermissionBits.VIEW,
grantedById,
);
const remainingIds = async () =>
(await AclEntry.find({}).select('_id').lean()).map(({ _id }) => _id.toString()).sort();
it("removes a role's platform-level entries outside a tenant, never a tenant role's of that name", async () => {
await grantTo(PrincipalType.ROLE, 'editor');
const unclaimed = await grantTo(PrincipalType.ROLE, 'editor');
const tenant = await grantTo(PrincipalType.ROLE, 'editor');
const other = await grantTo(PrincipalType.ROLE, 'other');
await AclEntry.collection.updateOne({ _id: unclaimed?._id }, { $set: { tenantId: '' } });
await AclEntry.collection.updateOne({ _id: tenant?._id }, { $set: { tenantId: 'tenant-a' } });
await methods.deletePrincipalAclEntries({
principalType: PrincipalType.ROLE,
principalId: 'editor',
});
expect(await remainingIds()).toEqual([tenant?._id.toString(), other?._id.toString()].sort());
});
it("removes only the active tenant's role entries inside it", async () => {
const platform = await grantTo(PrincipalType.ROLE, 'editor');
const tenant = await grantTo(PrincipalType.ROLE, 'editor');
await AclEntry.collection.updateOne({ _id: tenant?._id }, { $set: { tenantId: 'tenant-a' } });
await tenantStorage.run({ tenantId: 'tenant-a' }, () =>
methods.deletePrincipalAclEntries({
principalType: PrincipalType.ROLE,
principalId: 'editor',
}),
);
expect(await remainingIds()).toEqual([platform?._id.toString()]);
});
it('removes a group principal entries by id, whichever tenant holds them', async () => {
const groupId = new mongoose.Types.ObjectId();
const tenant = await grantTo(PrincipalType.GROUP, groupId);
const other = await grantTo(PrincipalType.GROUP, new mongoose.Types.ObjectId());
await AclEntry.collection.updateOne({ _id: tenant?._id }, { $set: { tenantId: 'tenant-a' } });
await methods.deletePrincipalAclEntries({
principalType: PrincipalType.GROUP,
principalId: groupId,
});
expect(await remainingIds()).toEqual([other?._id.toString()]);
});
});
describe('moveAclEntriesToPrincipal', () => {
const grantToRole = (roleName: string, bits: number) =>
methods.grantPermission(

View file

@ -191,6 +191,10 @@ export function createAclEntryMethods(mongoose: typeof import('mongoose')): {
filter: Record<string, unknown>,
options?: { session?: ClientSession },
) => Promise<DeleteResult>;
deletePrincipalAclEntries: (principal: {
principalType: PrincipalType;
principalId: string | Types.ObjectId;
}) => Promise<void>;
moveAclEntriesToPrincipal: (
principalType: PrincipalType,
fromPrincipalId: string,
@ -552,6 +556,27 @@ export function createAclEntryMethods(mongoose: typeof import('mongoose')): {
return AclEntry.deleteMany(filter, options || {});
}
/**
* Removes every ACL entry a principal holds, as the principal's deletion does. A role is keyed
* by a name every tenant reuses, so only its entries in the caller's tenant partition
* (`tenantPartitionFilter`) go: that tenant's, or without a tenant only platform-level ones,
* never those of each tenant's own role that shares the name (as `moveAclEntriesToPrincipal`
* moves them on a rename). A group or user is addressed by id, passed as stored (an ObjectId).
*/
async function deletePrincipalAclEntries(principal: {
principalType: PrincipalType;
principalId: string | Types.ObjectId;
}): Promise<void> {
const AclEntry = mongoose.models.AclEntry as Model<IAclEntry>;
const { principalType, principalId } = principal;
await AclEntry.deleteMany({
principalType,
principalId,
...(principalType === PrincipalType.ROLE &&
tenantPartitionFilter('deletePrincipalAclEntries')),
});
}
/**
* Re-keys a role principal's entries to another name (a role rename) and returns the ids it
* moved; with `ids`, moves only those (how a caller undoes a move). Entries keep their
@ -892,6 +917,7 @@ export function createAclEntryMethods(mongoose: typeof import('mongoose')): {
modifyPermissionBits,
findAccessibleResources,
deleteAclEntries,
deletePrincipalAclEntries,
replaceRoleBits,
bulkWriteAclEntries,
findPublicResourceIds,

View file

@ -140,8 +140,8 @@ describe('principalExists', () => {
});
});
describe('findPartitionUser', () => {
it('returns what principal resolution reads, only for a user of the caller partition', async () => {
describe('findPrincipalUser', () => {
it('returns what principal resolution reads and the tenant that holds the user', async () => {
const platform = await seedPrincipals('platform');
const tenant = await inTenant('tenant-a', async () => {
const user = await new mongoose.models.User({
@ -152,26 +152,51 @@ describe('findPartitionUser', () => {
}).save();
return user._id.toString();
});
const tenantUser = {
id: tenant,
role: 'EDITOR',
idOnTheSource: 'entra-oid',
tenantId: 'tenant-a',
};
expect(await methods.findPartitionUser(platform.userId)).toEqual({
expect(await methods.findPrincipalUser(platform.userId)).toEqual({
id: platform.userId,
role: SystemRoles.USER,
idOnTheSource: null,
});
expect(await methods.findPartitionUser(tenant)).toBeNull();
expect(await inTenant('tenant-a', () => methods.findPartitionUser(tenant))).toEqual({
id: tenant,
role: 'EDITOR',
idOnTheSource: 'entra-oid',
});
expect(await inTenant('tenant-b', () => methods.findPartitionUser(tenant))).toBeNull();
expect(await inTenant('tenant-a', () => methods.findPartitionUser(platform.userId))).toBeNull();
/** Outside a tenant a user is addressed by id, as group and user profiles are. */
expect(await methods.findPrincipalUser(tenant)).toEqual(tenantUser);
expect(await inTenant('tenant-a', () => methods.findPrincipalUser(tenant))).toEqual(tenantUser);
expect(await inTenant('tenant-b', () => methods.findPrincipalUser(tenant))).toBeNull();
expect(await inTenant('tenant-a', () => methods.findPrincipalUser(platform.userId))).toBeNull();
});
it('treats an unclaimed user (null or empty tenant) as platform-level', async () => {
const [unset, empty] = await Promise.all(
[null, ''].map(async (tenantId, index) => {
const { insertedId } = await mongoose.models.User.collection.insertOne({
email: `unclaimed-${index}@example.com`,
provider: 'local',
role: 'USER',
tenantId,
});
return insertedId.toString();
}),
);
for (const userId of [unset, empty]) {
expect(await methods.findPrincipalUser(userId)).toEqual({
id: userId,
role: 'USER',
idOnTheSource: null,
});
}
});
it('answers null without a query for an id that cannot name a user', async () => {
const findOne = jest.spyOn(mongoose.models.User, 'findOne');
expect(await methods.findPartitionUser('not-an-id')).toBeNull();
expect(await methods.findPartitionUser('F6E5D4C3B2A1F6E5D4C3B2A1')).toBeNull();
expect(await methods.findPrincipalUser('not-an-id')).toBeNull();
expect(await methods.findPrincipalUser('F6E5D4C3B2A1F6E5D4C3B2A1')).toBeNull();
expect(findOne).not.toHaveBeenCalled();
findOne.mockRestore();
});

View file

@ -5,19 +5,23 @@ import { isCanonicalObjectIdString } from '~/utils/objectId';
const systemRoleNames: ReadonlySet<string> = new Set(Object.values(SystemRoles));
/** What principal resolution reads of a user: their role and external identity. */
export interface PartitionUser {
/**
* What principal resolution reads of a user (their role and external identity), and the tenant
* that holds them (absent for a platform-level user).
*/
export interface PrincipalUser {
id: string;
role?: string;
idOnTheSource?: string | null;
tenantId?: string;
}
export interface PrincipalMethods {
principalExists: (principalType: PrincipalType, principalId: string) => Promise<boolean>;
findPartitionUser: (userId: string) => Promise<PartitionUser | null>;
findPrincipalUser: (userId: string) => Promise<PrincipalUser | null>;
}
/** Principal lookups that stay in the caller's tenant partition. */
/** Principal lookups for the admin API, in the caller's tenant partition or by id. */
export function createPrincipalMethods(mongoose: typeof import('mongoose')): PrincipalMethods {
async function existsInPartition(
modelName: 'Role' | 'Group' | 'User',
@ -62,24 +66,33 @@ export function createPrincipalMethods(mongoose: typeof import('mongoose')): Pri
}
/**
* A user of the caller's tenant partition (`tenantPartitionFilter`), by canonical ObjectId, with
* the fields principal resolution reads (`getUserPrincipals`); `null` when the partition holds
* no such user, as for a user of another tenant.
* A user the caller addresses by canonical ObjectId, with the fields principal resolution reads
* (`getUserPrincipals`) and the tenant that holds them. Users are addressed by id the way their
* config documents are: inside a tenant only that tenant's (the tenant plugin scopes the read),
* and outside one any tenant's, so their profile resolves in their own tenant. Strict mode
* refuses the read without a tenant context, as every query does. `null` when the caller sees
* no such user, as for a user of another tenant inside a tenant.
*/
async function findPartitionUser(userId: string): Promise<PartitionUser | null> {
async function findPrincipalUser(userId: string): Promise<PrincipalUser | null> {
if (!isCanonicalObjectIdString(userId)) {
return null;
}
const model = mongoose.models.User as Model<{ role?: string; idOnTheSource?: string | null }>;
const user = await model
.findOne({ _id: userId, ...tenantPartitionFilter('findPartitionUser') })
.select('role idOnTheSource')
.lean();
const model = mongoose.models.User as Model<{
role?: string;
idOnTheSource?: string | null;
tenantId?: string | null;
}>;
const user = await model.findOne({ _id: userId }).select('role idOnTheSource tenantId').lean();
if (user == null) {
return null;
}
return { id: userId, role: user.role, idOnTheSource: user.idOnTheSource ?? null };
return {
id: userId,
role: user.role,
idOnTheSource: user.idOnTheSource ?? null,
...(user.tenantId ? { tenantId: user.tenantId } : {}),
};
}
return { principalExists, findPartitionUser };
return { principalExists, findPrincipalUser };
}

View file

@ -1,10 +1,10 @@
import mongoose from 'mongoose';
import { MongoMemoryServer } from 'mongodb-memory-server';
import { PermissionTypes, Permissions } from 'librechat-data-provider';
import { PermissionTypes, Permissions, SystemRoles } from 'librechat-data-provider';
import type { IRole } from '..';
import { runAsSystem, tenantStorage } from '../config/tenantContext';
import { createRoleMethods } from './role';
import { createModels } from '../models';
import { tenantStorage } from '../config/tenantContext';
jest.mock('~/config/winston', () => ({
error: jest.fn(),
@ -120,11 +120,44 @@ describe('getRoleByName cache is scoped to the active tenant', () => {
findOneSpy.mockRestore();
});
it('serves the platform role outside a tenant when an older tenant role has its name', async () => {
await seedRole(TENANT_A, false);
await new Role({
name: ROLE_NAME,
permissions: { [PermissionTypes.PROMPTS]: { [Permissions.USE]: true } },
}).save();
const platform = await getRoleByName(ROLE_NAME);
const system = await runAsSystem(() => getRoleByName(ROLE_NAME));
const tenant = await runAs(TENANT_A, () => getRoleByName(ROLE_NAME));
expect(platform?.tenantId).toBeUndefined();
expect(usePromptsPermission(platform)).toBe(true);
expect(usePromptsPermission(system)).toBe(true);
expect(usePromptsPermission(cache.store.get(ROLE_NAME) as IRole)).toBe(true);
expect(usePromptsPermission(tenant)).toBe(false);
});
it('finds no role outside a tenant that only a tenant holds, and creates a missing system role at platform level', async () => {
await seedRole(TENANT_A, true);
await runAs(TENANT_A, () => new Role({ name: SystemRoles.USER }).save());
const tenantOnly = await getRoleByName(ROLE_NAME);
const user = await getRoleByName(SystemRoles.USER);
expect(tenantOnly).toBeNull();
expect(user?.tenantId).toBeUndefined();
expect(await Role.collection.countDocuments({ name: SystemRoles.USER })).toBe(2);
});
it('uses the unscoped key when no tenant context is active (single-tenant)', async () => {
const previousDefault = process.env.DEFAULT_TENANT_ID;
delete process.env.DEFAULT_TENANT_ID;
try {
await seedRole(TENANT_A, true);
await new Role({
name: ROLE_NAME,
permissions: { [PermissionTypes.PROMPTS]: { [Permissions.USE]: true } },
}).save();
const role = await getRoleByName(ROLE_NAME);
expect(usePromptsPermission(role)).toBe(true);

View file

@ -44,6 +44,8 @@ let countUsersByRole: ReturnType<typeof createRoleMethods>['countUsersByRole'];
let updateRoleByName: ReturnType<typeof createRoleMethods>['updateRoleByName'];
let listRoles: ReturnType<typeof createRoleMethods>['listRoles'];
let countRoles: ReturnType<typeof createRoleMethods>['countRoles'];
let getPartitionRole: ReturnType<typeof createRoleMethods>['getPartitionRole'];
let findUserIdsByRole: ReturnType<typeof createRoleMethods>['findUserIdsByRole'];
let mongoServer: MongoMemoryServer;
beforeAll(async () => {
@ -67,6 +69,8 @@ beforeAll(async () => {
countUsersByRole = methods.countUsersByRole;
listRoles = methods.listRoles;
countRoles = methods.countRoles;
getPartitionRole = methods.getPartitionRole;
findUserIdsByRole = methods.findUserIdsByRole;
});
afterAll(async () => {
@ -1303,3 +1307,222 @@ describe('createRoleByName - duplicate key race', () => {
insertSpy.mockRestore();
});
});
describe('role-name-keyed operations stay in the caller tenant partition', () => {
const inTenant = <T>(tenantId: string, run: () => Promise<T>): Promise<T> =>
tenantStorage.run({ tenantId }, run);
/** An `editor` role and member at platform level and in tenant-a, and a tenant-only role. */
async function seed() {
const platformRole = await Role.create({ name: 'editor', description: 'platform' });
const platformUser = await User.create({ email: 'p@example.com', role: 'editor' });
const tenant = await inTenant('tenant-a', async () => ({
role: await Role.create({ name: 'editor', description: 'tenant' }),
user: await User.create({ email: 't@example.com', role: 'editor' }),
only: await Role.create({ name: 'tenant-only' }),
}));
return {
platformRoleId: platformRole._id.toString(),
platformUserId: platformUser._id.toString(),
tenantRoleId: tenant.role._id.toString(),
tenantUserId: tenant.user._id.toString(),
};
}
const userRole = async (id: string) =>
(await User.collection.findOne({ _id: new mongoose.Types.ObjectId(id) }))?.role;
const roleDescription = async (id: string) =>
(await Role.collection.findOne({ _id: new mongoose.Types.ObjectId(id) }))?.description;
it('reads and lists only the platform roles and members outside a tenant', async () => {
const ids = await seed();
expect(String((await getPartitionRole('editor'))?._id)).toBe(ids.platformRoleId);
expect(await getPartitionRole('tenant-only')).toBeNull();
expect((await listRoles()).map(({ name }) => name)).toEqual(['editor']);
expect(await countRoles()).toBe(1);
expect(await findUserIdsByRole('editor')).toEqual([ids.platformUserId]);
expect((await listUsersByRole('editor')).map(({ _id }) => String(_id))).toEqual([
ids.platformUserId,
]);
expect(await countUsersByRole('editor')).toBe(1);
});
it("reads and lists only the active tenant's roles and members inside it", async () => {
const ids = await seed();
const found = await inTenant('tenant-a', async () => ({
role: await getPartitionRole('editor'),
roles: (await listRoles()).map(({ name }) => name).sort(),
members: await findUserIdsByRole('editor'),
count: await countUsersByRole('editor'),
}));
expect(String(found.role?._id)).toBe(ids.tenantRoleId);
expect(found.roles).toEqual(['editor', 'tenant-only']);
expect(found.members).toEqual([ids.tenantUserId]);
expect(found.count).toBe(1);
});
it('creates a missing system role in the partition that reads it, never reading the role cache', async () => {
await inTenant('tenant-a', () => Role.create({ name: SystemRoles.USER }));
const platform = await getPartitionRole(SystemRoles.USER);
expect(platform?.name).toBe(SystemRoles.USER);
expect(platform?.tenantId).toBeUndefined();
expect(await Role.collection.countDocuments({ name: SystemRoles.USER })).toBe(2);
expect(mockCache.get).not.toHaveBeenCalled();
});
it("renames and migrates only the platform role and its members, leaving the tenant's", async () => {
const ids = await seed();
const platform = await getPartitionRole('editor');
await updateUsersByRole('editor', 'writer');
const renamed = await updateRoleByName(
'editor',
{ name: 'writer', description: 'moved' },
{ id: String(platform?._id) },
);
expect(String(renamed._id)).toBe(ids.platformRoleId);
expect(await userRole(ids.platformUserId)).toBe('writer');
expect(await userRole(ids.tenantUserId)).toBe('editor');
expect(await roleDescription(ids.tenantRoleId)).toBe('tenant');
expect(
(await Role.collection.findOne({ _id: new mongoose.Types.ObjectId(ids.tenantRoleId) }))?.name,
).toBe('editor');
});
it("creates a platform role whose name a tenant's role holds, and refuses one the partition holds", async () => {
await seed();
const created = await createRoleByName({ name: 'tenant-only' });
expect(created.tenantId).toBeUndefined();
await expect(createRoleByName({ name: 'editor' })).rejects.toThrow(/already exists/);
await expect(
inTenant('tenant-a', () => createRoleByName({ name: 'tenant-only' })),
).rejects.toThrow(/already exists/);
});
it('updates only the role document an id names, and nothing once it no longer has the name', async () => {
const tenantRole = await inTenant('tenant-a', () =>
Role.create({ name: 'editor', description: 'tenant' }),
);
const platformRole = await Role.create({ name: 'editor', description: 'platform' });
const updated = await updateRoleByName(
'editor',
{ description: 'changed' },
{ id: String(platformRole._id) },
);
const missed = await updateRoleByName(
'writer',
{ description: 'never' },
{ id: String(platformRole._id) },
);
expect(String(updated._id)).toBe(String(platformRole._id));
expect(missed).toBeNull();
expect(await roleDescription(String(platformRole._id))).toBe('changed');
expect(await roleDescription(String(tenantRole._id))).toBe('tenant');
});
it('writes access permissions to the role document it was given, never another of its name', async () => {
const tenantRole = await inTenant('tenant-a', () =>
Role.create({ name: 'editor', permissions: {} }),
);
await Role.create({ name: 'editor', permissions: {} });
const platform = await getPartitionRole('editor');
await updateAccessPermissions(
'editor',
{ [PermissionTypes.BOOKMARKS]: { [Permissions.USE]: true } },
platform as IRole,
);
const stored = await Role.collection
.find({ name: 'editor' })
.project({ tenantId: 1, permissions: 1 })
.toArray();
const byTenant = new Map(stored.map((role) => [role.tenantId ?? '-', role.permissions]));
expect(byTenant.get('-')?.[PermissionTypes.BOOKMARKS]).toEqual({ [Permissions.USE]: true });
expect(byTenant.get('tenant-a')?.[PermissionTypes.BOOKMARKS]).toBeUndefined();
expect(String(tenantRole._id)).not.toBe(String(platform?._id));
});
it('reads and writes by name alone the platform role outside a tenant, though an older tenant role has its name', async () => {
const tenantRole = await inTenant('tenant-a', () =>
Role.create({ name: 'editor', description: 'tenant', permissions: {} }),
);
const platformRole = await Role.create({
name: 'editor',
description: 'platform',
permissions: {},
});
const read = await getRoleByName('editor');
const updated = await updateRoleByName('editor', { description: 'changed' });
await updateAccessPermissions('editor', {
[PermissionTypes.BOOKMARKS]: { [Permissions.USE]: true },
});
/** A role read without its `_id`, as `GET /api/roles/:roleName` reads (and caches) it. */
const withoutId = await getRoleByName('editor', '-_id -__v');
await updateAccessPermissions(
'editor',
{ [PermissionTypes.PROMPTS]: { [Permissions.USE]: false } },
withoutId,
);
expect(String(read._id)).toBe(String(platformRole._id));
expect(String(updated._id)).toBe(String(platformRole._id));
expect(withoutId._id).toBeUndefined();
const stored = async (id: unknown) =>
Role.collection.findOne({ _id: new mongoose.Types.ObjectId(String(id)) });
expect(await stored(platformRole._id)).toMatchObject({
description: 'changed',
permissions: {
[PermissionTypes.BOOKMARKS]: { [Permissions.USE]: true },
[PermissionTypes.PROMPTS]: { [Permissions.USE]: false },
},
});
const tenantStored = await stored(tenantRole._id);
expect(tenantStored?.description).toBe('tenant');
expect(tenantStored?.permissions?.[PermissionTypes.BOOKMARKS]).toBeUndefined();
expect(tenantStored?.permissions?.[PermissionTypes.PROMPTS]).toBeUndefined();
});
it("deletes only the platform role and reassigns only its members, leaving the tenant's", async () => {
const ids = await seed();
const deleted = await deleteRoleByName('editor');
const refused = await deleteRoleByName('editor', { id: ids.tenantRoleId });
expect(String(deleted?._id)).toBe(ids.platformRoleId);
expect(refused).toBeNull();
expect(await userRole(ids.platformUserId)).toBe(SystemRoles.USER);
expect(await userRole(ids.tenantUserId)).toBe('editor');
expect(await roleDescription(ids.tenantRoleId)).toBe('tenant');
});
it("deletes and renames only the active tenant's role and members inside it", async () => {
const ids = await seed();
await inTenant('tenant-a', async () => {
await updateUsersByRole('editor', 'writer');
await updateRoleByName('editor', { name: 'writer' });
await deleteRoleByName('tenant-only');
});
expect(await userRole(ids.tenantUserId)).toBe('writer');
expect(await userRole(ids.platformUserId)).toBe('editor');
expect(await roleDescription(ids.platformRoleId)).toBe('platform');
expect(
(await Role.collection.findOne({ _id: new mongoose.Types.ObjectId(ids.platformRoleId) }))
?.name,
).toBe('editor');
expect(await Role.collection.countDocuments({ name: 'tenant-only' })).toBe(0);
});
});

View file

@ -6,9 +6,10 @@ import {
permissionsSchema,
removeNullishValues,
} from 'librechat-data-provider';
import type { Model } from 'mongoose';
import type { FilterQuery, Model } from 'mongoose';
import type { CacheStore, IRole, IUser } from '~/types';
import { scopedCacheKey, getTenantId, runAsSystem, SYSTEM_TENANT_ID } from '~/config/tenantContext';
import { tenantPartitionFilter } from '~/models/plugins/tenantIsolation';
import { escapeRegExp } from '~/utils/string';
import logger from '~/config/winston';
@ -46,11 +47,16 @@ export function createRoleMethods(
countRoles: () => Promise<number>;
initializeRoles: () => Promise<void>;
getRoleByName: (roleName: string, fieldsToSelect?: string | string[] | null) => Promise<IRole>;
getPartitionRole: (roleName: string) => Promise<IRole | null>;
findRolesByNames: (
roleNames: string[],
fieldsToSelect?: string | string[] | null,
) => Promise<IRole[]>;
updateRoleByName: (roleName: string, updates: Partial<IRole>) => Promise<IRole>;
updateRoleByName: (
roleName: string,
updates: Partial<IRole>,
options?: { id?: string },
) => Promise<IRole>;
updateAccessPermissions: (
roleName: string,
permissionsUpdate: Record<string, Record<string, boolean>>,
@ -71,6 +77,32 @@ export function createRoleMethods(
) => Promise<IUser[]>;
countUsersByRole: (roleName: string) => Promise<number>;
} {
/**
* The users holding `roleName` in the caller's tenant partition (`tenantPartitionFilter`): the
* active tenant's, or outside a tenant only platform-level ones. Role names are reused across
* tenants (the role index is unique on name plus `tenantId`), and outside a tenant the tenant
* plugin scopes nothing, so a filter on the name alone would reach the members of each
* tenant's own role of that name; the role reads and writes by name below keep to the same
* partition for the same reason.
*/
function roleMembersFilter(roleName: string, operation: string): FilterQuery<IUser> {
return { role: roleName, ...tenantPartitionFilter(operation) };
}
/**
* The role named `roleName` in the caller's tenant partition, or with `id` exactly that role
* document (which a caller read in its own partition) as long as it still has the name.
*/
function roleDocumentFilter(
roleName: string,
operation: string,
id?: string,
): FilterQuery<IRole> {
return id
? { name: roleName, _id: id }
: { name: roleName, ...tenantPartitionFilter(operation) };
}
/**
* Initialize default roles in the system.
* Creates the default roles (ADMIN, USER) if they don't exist in the database.
@ -139,7 +171,8 @@ export function createRoleMethods(
}
/**
* List all roles in the system. Returns only name and description (projected).
* List the roles of the caller's tenant partition (`tenantPartitionFilter`), the ones a role
* name addresses. Returns only name and description (projected).
*/
async function listRoles(options?: {
limit?: number;
@ -148,7 +181,7 @@ export function createRoleMethods(
const Role = mongoose.models.Role as Model<IRole>;
const limit = options?.limit ?? 50;
const offset = options?.offset ?? 0;
return await Role.find({})
return await Role.find(tenantPartitionFilter('listRoles'))
.select('name description')
.sort({ name: 1 })
.skip(offset)
@ -156,15 +189,18 @@ export function createRoleMethods(
.lean();
}
/** Counts the roles {@link listRoles} lists. */
async function countRoles(): Promise<number> {
const Role = mongoose.models.Role;
return await Role.countDocuments({});
return await Role.countDocuments(tenantPartitionFilter('countRoles'));
}
/**
* Retrieve a role by name and convert the found role document to a plain object.
* If the role with the given name doesn't exist and the name is a system defined role,
* create it and return the lean version.
* Retrieve the role named `roleName` in the caller's tenant partition (`tenantPartitionFilter`)
* as a plain object: the active tenant's, or outside a tenant (and under the system context)
* the platform-level one, never a tenant's role of the same name, which the tenant plugin
* would not filter out there. The cache key carries the same partition (`scopedCacheKey`).
* If the role doesn't exist there and the name is a system defined role, it is created there.
*/
async function getRoleByName(
roleName: string,
@ -179,7 +215,7 @@ export function createRoleMethods(
}
}
const Role = mongoose.models.Role;
let query = Role.findOne({ name: roleName });
let query = Role.findOne(roleDocumentFilter(roleName, 'getRoleByName'));
if (fieldsToSelect) {
query = query.select(fieldsToSelect);
}
@ -201,6 +237,34 @@ export function createRoleMethods(
}
}
/**
* The role named exactly `roleName` in the caller's tenant partition (`tenantPartitionFilter`),
* as the admin roles API addresses it: never a tenant's role of the same name outside that
* tenant. A system role with no document there is created there, as {@link getRoleByName}
* creates it. Reads no cache, so an admin read never returns another partition's cached role.
*/
async function getPartitionRole(roleName: string): Promise<IRole | null> {
const Role = mongoose.models.Role as Model<IRole>;
const read = () =>
Role.findOne(roleDocumentFilter(roleName, 'getPartitionRole'))
.select('-__v')
.lean<IRole>()
.exec();
const role = await read();
if (role || !systemRoleValues.has(roleName)) {
return role;
}
try {
const created = await new Role(roleDefaults[roleName as keyof typeof roleDefaults]).save();
return created.toObject() as IRole;
} catch (error) {
if (error && typeof error === 'object' && 'code' in error && error.code === 11000) {
return read();
}
throw error;
}
}
/**
* Find roles by name without using or populating the shared role-name cache.
* Use this for tenant-scoped authorization lookups where the active ALS tenant context must control the query.
@ -252,13 +316,24 @@ export function createRoleMethods(
}
/**
* Update role values by name.
* Update the values of the role named `roleName` in the caller's tenant partition, as
* {@link getRoleByName} reads it. With `options.id`, only the role document with that `_id`
* changes (`null` when it no longer has the name), so a caller that read one role writes that
* role and never another tenant's role of the same name.
*/
async function updateRoleByName(roleName: string, updates: Partial<IRole>): Promise<IRole> {
async function updateRoleByName(
roleName: string,
updates: Partial<IRole>,
options?: { id?: string },
): Promise<IRole> {
const cache = deps.getCache?.(CacheKeys.ROLES);
try {
const Role = mongoose.models.Role;
const role = await Role.findOneAndUpdate({ name: roleName }, { $set: updates }, { new: true })
const role = await Role.findOneAndUpdate(
roleDocumentFilter(roleName, 'updateRoleByName', options?.id),
{ $set: updates },
{ new: true },
)
.select('-__v')
.lean()
.exec();
@ -314,6 +389,9 @@ export function createRoleMethods(
if (!role) {
return;
}
/** The role read is the one written, whichever tenant partition it was read in. */
const id = role._id != null ? String(role._id) : undefined;
const target = roleDocumentFilter(roleName, 'updateAccessPermissions', id);
const currentPermissions =
((role as unknown as Record<string, unknown>).permissions as Record<
@ -417,16 +495,13 @@ export function createRoleMethods(
);
try {
await Role.updateOne(
{ name: roleName },
{
$set: updateObj,
$unset: unsetFields,
},
);
await Role.updateOne(target, {
$set: updateObj,
$unset: unsetFields,
});
const cache = deps.getCache?.(CacheKeys.ROLES);
const updatedRole = await Role.findOne({ name: roleName }).select('-__v').lean().exec();
const updatedRole = await Role.findOne(target).select('-__v').lean().exec();
if (cache) {
await cache.set(scopedCacheKey(roleName), updatedRole);
}
@ -437,7 +512,7 @@ export function createRoleMethods(
throw updateError;
}
} else {
await updateRoleByName(roleName, updateObj as unknown as Partial<IRole>);
await updateRoleByName(roleName, updateObj as unknown as Partial<IRole>, { id });
}
logger.info(`Updated '${roleName}' role permissions`);
@ -449,7 +524,10 @@ export function createRoleMethods(
}
}
/** Rejects names that match system roles. */
/**
* Rejects names that match system roles, and a name the caller's tenant partition already holds
* (`tenantPartitionFilter`); another tenant's role of that name is a different role.
*/
async function createRoleByName(roleData: Partial<IRole>): Promise<IRole> {
const { name } = roleData;
if (!name || typeof name !== 'string' || !name.trim()) {
@ -460,7 +538,7 @@ export function createRoleMethods(
throw new RoleConflictError(`Cannot create role with reserved system name: ${name}`);
}
const Role = mongoose.models.Role;
const existing = await Role.findOne({ name: trimmed }).lean();
const existing = await Role.findOne(roleDocumentFilter(trimmed, 'createRoleByName')).lean();
if (existing) {
throw new RoleConflictError(`Role "${trimmed}" already exists`);
}
@ -491,7 +569,9 @@ export function createRoleMethods(
}
/**
* Guards against deleting system roles. Reassigns affected users back to USER.
* Guards against deleting system roles. Reassigns affected users back to USER. Only the role
* of the caller's tenant partition and its members there are touched
* (`tenantPartitionFilter`).
*
* No existence pre-check is performed: for a nonexistent role the `updateMany`
* is a harmless no-op and `findOneAndDelete` returns null. This makes the
@ -512,16 +592,19 @@ export function createRoleMethods(
throw new Error(`Cannot delete system role: ${roleName}`);
}
const Role = mongoose.models.Role;
const role = { name: roleName, ...tenantPartitionFilter('deleteRoleByName') };
/** A role recreated under this name has another `_id`: leave it and its members alone. */
if (options?.id && !(await Role.exists({ _id: options.id, name: roleName }))) {
if (options?.id && !(await Role.exists({ ...role, _id: options.id }))) {
return null;
}
const User = mongoose.models.User as Model<IUser>;
const affectedUserIds = await findUserIdsByRole(roleName);
await User.updateMany({ role: roleName }, { $set: { role: SystemRoles.USER } });
await User.updateMany(roleMembersFilter(roleName, 'deleteRoleByName'), {
$set: { role: SystemRoles.USER },
});
await invalidateAuthUserDocCache(affectedUserIds);
const deleted = await Role.findOneAndDelete({
name: roleName,
...role,
...(options?.id ? { _id: options.id } : {}),
}).lean();
try {
@ -538,16 +621,22 @@ export function createRoleMethods(
return deleted as IRole | null;
}
/** Moves the members of `oldRole` in the caller's tenant partition to `newRole` (a rename). */
async function updateUsersByRole(oldRole: string, newRole: string): Promise<void> {
const User = mongoose.models.User as Model<IUser>;
const affectedUserIds = await findUserIdsByRole(oldRole);
await User.updateMany({ role: oldRole }, { $set: { role: newRole } });
await User.updateMany(roleMembersFilter(oldRole, 'updateUsersByRole'), {
$set: { role: newRole },
});
await invalidateAuthUserDocCache(affectedUserIds);
}
/** The ids of the users holding `roleName` in the caller's tenant partition. */
async function findUserIdsByRole(roleName: string): Promise<string[]> {
const User = mongoose.models.User as Model<IUser>;
const users = await User.find({ role: roleName }).select('_id').lean();
const users = await User.find(roleMembersFilter(roleName, 'findUserIdsByRole'))
.select('_id')
.lean();
return users.map((u) => u._id.toString());
}
@ -601,6 +690,7 @@ export function createRoleMethods(
}
}
/** The users holding `roleName` in the caller's tenant partition, a page at a time. */
async function listUsersByRole(
roleName: string,
options?: { limit?: number; offset?: number },
@ -608,7 +698,7 @@ export function createRoleMethods(
const User = mongoose.models.User as Model<IUser>;
const limit = options?.limit ?? 50;
const offset = options?.offset ?? 0;
return await User.find({ role: roleName })
return await User.find(roleMembersFilter(roleName, 'listUsersByRole'))
.select('_id name email avatar')
.sort({ _id: 1 })
.skip(offset)
@ -616,9 +706,10 @@ export function createRoleMethods(
.lean<IUser[]>();
}
/** Counts the users {@link listUsersByRole} lists. */
async function countUsersByRole(roleName: string): Promise<number> {
const User = mongoose.models.User as Model<IUser>;
return await User.countDocuments({ role: roleName });
return await User.countDocuments(roleMembersFilter(roleName, 'countUsersByRole'));
}
return {
@ -626,6 +717,7 @@ export function createRoleMethods(
countRoles,
initializeRoles,
getRoleByName,
getPartitionRole,
findRolesByNames,
updateRoleByName,
updateAccessPermissions,

View file

@ -843,7 +843,7 @@ describe('systemGrant methods', () => {
);
});
it('moves only platform-level grants when no tenant is given, unlike the delete cascade', async () => {
it('moves only platform-level grants when no tenant is given, as the delete cascade removes them', async () => {
await grant('editor', SystemCapabilities.READ_USERS, 'tenant-a');
await grant('editor', SystemCapabilities.READ_CONFIGS);
await grant('writer', SystemCapabilities.READ_USERS, 'tenant-a');
@ -1113,7 +1113,7 @@ describe('systemGrant methods', () => {
expect(caps).toEqual([SystemCapabilities.READ_GROUPS, SystemCapabilities.READ_USERS]);
});
it('without tenantId deletes all grants across all tenants', async () => {
it("without tenantId deletes only platform-level grants, never a tenant's own role's", async () => {
await methods.grantCapability({
principalType: PrincipalType.ROLE,
principalId: 'temp-role',
@ -1126,13 +1126,18 @@ describe('systemGrant methods', () => {
tenantId: 'tenant-a',
});
await methods.deleteGrantsForPrincipal(PrincipalType.ROLE, 'temp-role');
const found = await methods.findGrantsForPrincipal(PrincipalType.ROLE, 'temp-role');
const removed = await methods.deleteGrantsForPrincipal(PrincipalType.ROLE, 'temp-role');
const remaining = await SystemGrant.countDocuments({
expect(found.map((g) => g.capability)).toEqual([SystemCapabilities.READ_USERS]);
expect(removed.map((g) => g.capability)).toEqual([SystemCapabilities.READ_USERS]);
const remaining = await SystemGrant.find({
principalType: PrincipalType.ROLE,
principalId: 'temp-role',
});
expect(remaining).toBe(0);
}).lean();
expect(remaining.map((g) => [g.capability, g.tenantId])).toEqual([
[SystemCapabilities.READ_CONFIGS, 'tenant-a'],
]);
});
});

View file

@ -158,6 +158,11 @@ export function createSystemGrantMethods(mongoose: typeof import('mongoose')): {
move: SystemGrantMove,
) => Promise<void>;
} {
/** The grants of exactly one scope: `tenantId`'s, or the platform-level ones without it. */
function grantScope(tenantId?: string): FilterQuery<ISystemGrant> {
return tenantId != null ? { tenantId } : { tenantId: { $exists: false } };
}
function tenantCondition(tenantId?: string): FilterQuery<ISystemGrant> {
return tenantId != null
? { $and: [{ $or: [{ tenantId }, { tenantId: { $exists: false } }] }] }
@ -581,11 +586,11 @@ export function createSystemGrantMethods(mongoose: typeof import('mongoose')): {
* Delete system grants for a principal.
* Used for cascade cleanup when a principal (group, role) is deleted.
*
* When `tenantId` is provided, only grants scoped to **exactly** that
* tenant are removed — platform-level grants (no tenantId) are left
* intact so they continue to serve other tenants.
* When `tenantId` is omitted, ALL grants for the principal are removed
* regardless of tenant scope.
* Only the grants of one scope go, as `moveGrantsToPrincipal` moves them on a rename: with
* `tenantId`, those scoped to **exactly** that tenant (platform-level grants, with no
* tenantId, are left intact so they continue to serve other tenants); without it, only the
* platform-level ones. A role is keyed by a name every tenant reuses, so deleting the
* platform's role never removes the grants a tenant's own role of that name holds.
*/
async function deleteGrantsForPrincipal(
principalType: PrincipalType,
@ -598,7 +603,7 @@ export function createSystemGrantMethods(mongoose: typeof import('mongoose')): {
const filter: FilterQuery<ISystemGrant> = {
principalType,
principalId: normalizedPrincipalId,
...(options?.tenantId != null && { tenantId: options.tenantId }),
...grantScope(options?.tenantId),
};
const queryOptions = options?.session ? { session: options.session } : {};
/** Read the matching grants before deleting so cascade callers (e.g. role
@ -618,7 +623,7 @@ export function createSystemGrantMethods(mongoose: typeof import('mongoose')): {
return SystemGrant.find({
principalType,
principalId: normalizePrincipalId(principalId, principalType),
...(options?.tenantId != null && { tenantId: options.tenantId }),
...grantScope(options?.tenantId),
}).lean<ISystemGrant[]>();
}
@ -646,9 +651,9 @@ export function createSystemGrantMethods(mongoose: typeof import('mongoose')): {
/**
* Re-keys a principal's grants to another id of the same type (a role rename), in one tenant
* scope: exactly `tenantId` when given, platform-level grants (no `tenantId`) otherwise. A
* rename re-keys one role, so unlike {@link deleteGrantsForPrincipal} a caller without a
* tenant never re-keys the grants of each tenant's own role that shares the name. Each grant
* scope: exactly `tenantId` when given, platform-level grants (no `tenantId`) otherwise, as
* {@link deleteGrantsForPrincipal} removes them. A rename re-keys one role, so a caller without
* a tenant never re-keys the grants of each tenant's own role that shares the name. Each grant
* keeps its identity and history. One the target already holds in the same scope is removed
* from the source instead, since the unique index allows one.
*
@ -665,13 +670,11 @@ export function createSystemGrantMethods(mongoose: typeof import('mongoose')): {
options?: { tenantId?: string },
): Promise<SystemGrantMove> {
const SystemGrant = mongoose.models.SystemGrant as Model<ISystemGrant>;
const scope: FilterQuery<ISystemGrant> =
options?.tenantId != null ? { tenantId: options.tenantId } : { tenantId: { $exists: false } };
const source = normalizePrincipalId(fromPrincipalId, principalType);
const grants = await SystemGrant.find({
principalType,
principalId: source,
...scope,
...grantScope(options?.tenantId),
}).lean<ISystemGrant[]>();
if (grants.length === 0) {
return { moved: [], superseded: [] };