Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

🏨 fix: Restore Strict Tenant Startup and Sign-In (#17441)

lia-by-librechat[bot]e594cff87465
diff --git a/api/db/indexSync.js b/api/db/indexSync.js
index ad187de111..878e7f4026 100644
--- a/api/db/indexSync.js
+++ b/api/db/indexSync.js
@@ -1,6 +1,6 @@
const mongoose = require('mongoose');
const { MeiliSearch } = require('meilisearch');
-const { logger } = require('@librechat/data-schemas');
+const { logger, runAsSystem } = require('@librechat/data-schemas');
const { CacheKeys } = require('librechat-data-provider');
const { isEnabled, FlowStateManager, evalKeyvRedisScript } = require('@librechat/api');
const { getLogStores } = require('~/cache');
@@ -428,4 +428,4 @@ process.on('exit', () => {
clearTimeout(currentTimeout);
});
-module.exports = indexSync;
+module.exports = () => runAsSystem(indexSync);
diff --git a/api/db/indexSync.spec.js b/api/db/indexSync.spec.js
index c76091d52d..596aec8814 100644
--- a/api/db/indexSync.spec.js
+++ b/api/db/indexSync.spec.js
@@ -35,6 +35,7 @@ const originalConversationModel = mongoose.models.Conversation;
// Mock external modules
jest.mock('@librechat/data-schemas', () => ({
logger: mockLogger,
+ runAsSystem: (fn) => fn(),
}));
jest.mock('meilisearch', () => ({
diff --git a/api/db/indexSync.tenant.spec.js b/api/db/indexSync.tenant.spec.js
new file mode 100644
index 0000000000..1f40fb81eb
--- /dev/null
+++ b/api/db/indexSync.tenant.spec.js
@@ -0,0 +1,92 @@
+const mockIndex = {
+ uid: 'test',
+ getSettings: jest.fn().mockResolvedValue({ filterableAttributes: ['user'] }),
+ search: jest.fn().mockResolvedValue({ hits: [] }),
+ getDocuments: jest.fn().mockResolvedValue({ results: [] }),
+ addDocumentsInBatches: jest.fn().mockResolvedValue([{ taskUid: 1 }]),
+ deleteDocuments: jest.fn().mockResolvedValue({ taskUid: 1 }),
+};
+
+jest.mock('meilisearch', () => ({
+ MeiliSearch: jest.fn(() => ({
+ health: jest.fn().mockResolvedValue({ status: 'available' }),
+ index: jest.fn(() => mockIndex),
+ waitForTask: jest.fn().mockResolvedValue({ status: 'succeeded' }),
+ })),
+}));
+jest.mock('~/cache', () => ({ getLogStores: () => undefined }));
+
+// Both plugins and indexSync read their configuration at module load.
+process.env.SEARCH = 'true';
+process.env.MEILI_HOST = 'http://localhost:7700';
+process.env.MEILI_MASTER_KEY = 'test-only';
+process.env.TENANT_ISOLATION_STRICT = 'true';
+
+const mongoose = require('mongoose');
+const { MongoMemoryServer } = require('mongodb-memory-server');
+const {
+ createModels,
+ runAsSystem,
+ tenantStorage,
+ getTenantId,
+} = require('@librechat/data-schemas');
+const indexSync = require('./indexSync');
+
+let mongo;
+
+beforeAll(async () => {
+ mongo = await MongoMemoryServer.create({ instance: { args: ['--nounixsocket'] } });
+ await mongoose.connect(mongo.getUri());
+ createModels(mongoose);
+});
+
+beforeEach(async () => {
+ await runAsSystem(async () => {
+ await mongoose.models.Message.deleteMany({});
+ await mongoose.models.Conversation.deleteMany({});
+ });
+ // Raw inserts model documents left unindexed by an older deployment.
+ for (const tenantId of ['tenant-a', 'tenant-b']) {
+ await mongoose.models.Message.collection.insertOne({
+ messageId: `message-${tenantId}`,
+ conversationId: `conversation-${tenantId}`,
+ user: `user-${tenantId}`,
+ text: 'Legacy message',
+ tenantId,
+ });
+ await mongoose.models.Conversation.collection.insertOne({
+ conversationId: `conversation-${tenantId}`,
+ user: `user-${tenantId}`,
+ title: 'Legacy conversation',
+ tenantId,
+ });
+ }
+ mockIndex.addDocumentsInBatches.mockClear();
+});
+
+afterAll(async () => {
+ await mongoose.disconnect();
+ await mongo?.stop();
+});
+
+it.each([undefined, 'tenant-a'])(
+ 'reconciles every tenant with no caller-owned system context (caller: %s)',
+ async (tenantId) => {
+ const result = await tenantStorage.run({ tenantId }, async () => {
+ const synced = await indexSync();
+ expect(getTenantId()).toBe(tenantId);
+ return synced;
+ });
+ expect(result).toEqual({ messagesSync: true, convosSync: true });
+ const indexed = await runAsSystem(async () =>
+ Promise.all([
+ mongoose.models.Message.find({ _meiliIndex: true }).lean(),
+ mongoose.models.Conversation.find({ _meiliIndex: true }).lean(),
+ ]),
+ );
+ for (const documents of indexed) {
+ expect(documents.map((doc) => doc.tenantId).sort()).toEqual(['tenant-a', 'tenant-b']);
+ }
+ expect(mockIndex.addDocumentsInBatches).toHaveBeenCalledTimes(2);
+ },
+);
diff --git a/api/server/routes/__tests__/auth.tenant.spec.js b/api/server/routes/__tests__/auth.tenant.spec.js
new file mode 100644
index 0000000000..31b8ba02fd
--- /dev/null
+++ b/api/server/routes/__tests__/auth.tenant.spec.js
@@ -0,0 +1,244 @@
+const { MongoMemoryServer } = require('mongodb-memory-server');
+
+let express;
+let request;
+let passport;
+let mongoose;
+let bcrypt;
+let schemas;
+let api;
+const REFUSAL = {
+ message: 'Tenant context required in strict isolation mode',
+ code: 'TENANT_CONTEXT_REQUIRED',
+};
+const password = 'Tenant-test-password-123!';
+let mongo;
+let app;
+let models;
+let findUser;
+let originalFindUser;
+let userA;
+let userB;
+let platformUser;
+let oauthAttempts;
+const savedEnv = { ...process.env };
+
+describe.each([false, true])('pre-auth tenant routes (strict=%s)', (strictMode) => {
+ beforeAll(async () => {
+ process.env.TRUST_TENANT_HEADER = 'true';
+ process.env.BAN_VIOLATIONS = 'false';
+ process.env.LOGIN_MAX = '1000';
+ process.env.DOMAIN_CLIENT = 'http://localhost:3080';
+ process.env.DOMAIN_SERVER = 'http://localhost:3080';
+ process.env.TENANT_ISOLATION_STRICT = String(strictMode);
+ jest.resetModules();
+ express = require('express');
+ request = require('supertest');
+ passport = require('passport');
+ mongoose = require('mongoose');
+ bcrypt = require('bcryptjs');
+ schemas = require('@librechat/data-schemas');
+ api = require('@librechat/api');
+ mongo = await MongoMemoryServer.create({ instance: { args: ['--nounixsocket'] } });
+ await mongoose.connect(mongo.getUri());
+ schemas.createModels(mongoose);
+ models = require('~/models');
+ originalFindUser = models.findUser;
+ findUser = jest.spyOn(models, 'findUser');
+ passport.use('local', require('~/strategies/localStrategy')());
+ oauthAttempts = jest.fn();
+ for (const name of ['google', 'googleAdmin']) {
+ passport.use(name, {
+ name,
+ authenticate() {
+ oauthAttempts();
+ this.fail({ message: 'Identity provider refused' });
+ },
+ });
+ }
+ await schemas.runAsSystem(async () => {
+ await models.initializeRoles();
+ await models.seedSystemGrants();
+ const hash = await bcrypt.hash(password, 4);
+ [userA, userB, platformUser] = await Promise.all(
+ ['tenant-a', 'tenant-b', undefined].map((tenantId) =>
+ mongoose.models.User.create({
+ email: tenantId ? '[email protected]' : '[email protected]',
+ name: tenantId || 'Platform',
+ username: tenantId || 'platform',
+ password: hash,
+ emailVerified: true,
+ provider: 'local',
+ role: 'ADMIN',
+ tenantId,
+ }),
+ ),
+ );
+ });
+ app = express();
+ app.use(express.json());
+ app.use(passport.initialize());
+ app.use('/api/auth', api.preAuthTenantMiddleware, require('../auth'));
+ app.use('/api/admin', require('../admin/auth'));
+ app.use('/api/user', require('../user'));
+ app.use('/oauth', api.preAuthTenantMiddleware, require('../oauth'));
+ app.use(api.ErrorController);
+ }, 180000);
+
+ afterAll(async () => {
+ jest.restoreAllMocks();
+ await mongoose.disconnect();
+ await mongo?.stop();
+ process.env = savedEnv;
+ }, 180000);
+
+ beforeEach(() => {
+ findUser.mockClear().mockImplementation(originalFindUser);
+ oauthAttempts.mockClear();
+ });
+
+ if (strictMode) {
+ 'refuses strict login for %s before looking up any account',
+ async (email) => {
+ const response = await request(app).post('/api/auth/login').send({ email, password });
+ expect(response.status).toBe(403);
+ expect(response.body).toEqual(REFUSAL);
+ expect(findUser).not.toHaveBeenCalled();
+ },
+ );
+
+ it.each([
+ '/api/auth/register',
+ '/api/auth/requestPasswordReset',
+ '/api/auth/resetPassword',
+ '/api/auth/passkey/login/options',
+ '/api/auth/passkey/login/verify',
+ '/api/auth/2fa/verify-temp',
+ '/api/auth/2fa/setup',
+ '/api/auth/2fa/setup/confirm',
+ '/api/auth/2fa/setup/acknowledge',
+ '/api/auth/2fa/setup/finalize',
+ '/api/user/verify',
+ '/api/user/verify/resend',
+ '/api/admin/login/local',
+ ])('refuses %s without a pre-auth tenant in strict mode', async (path) => {
+ const response = await request(app).post(path).send({});
+ expect(response.status).toBe(403);
+ expect(response.body).toEqual(REFUSAL);
+ expect(findUser).not.toHaveBeenCalled();
+ });
+ }
+
+ it('admin login honors the trusted tenant header', async () => {
+ const observed = [];
+ findUser.mockImplementation((...args) => {
+ observed.push(schemas.getTenantId());
+ return originalFindUser(...args);
+ });
+ const response = await request(app)
+ .post('/api/admin/login/local')
+ .set('X-Tenant-Id', 'tenant-b')
+ .send({ email: '[email protected]', password });
+ expect(observed).toEqual(['tenant-b']);
+ expect(response.status).toBe(200);
+ expect(response.body.user.id).toBe(userB._id.toString());
+ expect(response.body.user.id).not.toBe(userA._id.toString());
+ });
+
+ it('keeps tenant login working and does not find a platform user in that tenant', async () => {
+ const response = await request(app)
+ .post('/api/auth/login')
+ .set('X-Tenant-Id', 'tenant-a')
+ .send({ email: '[email protected]', password });
+ expect(response.status).toBe(200);
+ expect(response.body.user.id).toBe(userA._id.toString());
+ const missing = await request(app)
+ .post('/api/auth/login')
+ .set('X-Tenant-Id', 'tenant-a')
+ .send({ email: platformUser.email, password });
+ expect(missing.status).toBe(404);
+ });
+
+ if (!strictMode) {
+ it('does not require a tenant for platform login outside strict mode', async () => {
+ const response = await request(app)
+ .post('/api/auth/login')
+ .send({ email: platformUser.email, password });
+ expect(response.status).toBe(200);
+ expect(response.body.user.id).toBe(platformUser._id.toString());
+ });
+ }
+
+ if (strictMode) {
+ it.each(
+ ['google', 'facebook', 'openid', 'github', 'discord', 'apple', 'saml'].flatMap((provider) => [
+ `/oauth/${provider}`,
+ `/api/admin/oauth/${provider}`,
+ ]),
+ )('refuses %s before contacting an identity provider without a tenant', async (path) => {
+ const response = await request(app).get(path);
+ expect(response.status).toBe(403);
+ expect(response.body).toEqual(REFUSAL);
+ expect(oauthAttempts).not.toHaveBeenCalled();
+ });
+
+ it.each(
+ ['google', 'facebook', 'openid', 'github', 'discord', 'apple', 'saml'].flatMap((provider) => [
+ `/oauth/${provider}/callback`,
+ `/api/admin/oauth/${provider}/callback`,
+ ]),
+ )('redirects %s to an authentication error without invoking the strategy', async (path) => {
+ const method = /\/(apple|saml)\/callback$/.test(path) ? 'post' : 'get';
+ const response = await request(app)[method](path).send({});
+ expect(response.status).toBe(302);
+ expect(response.headers.location).toContain('TENANT_CONTEXT_REQUIRED');
+ expect(oauthAttempts).not.toHaveBeenCalled();
+ });
+ }
+
+ it('carries the trusted tenant into email verification', async () => {
+ const tenants = [];
+ findUser.mockImplementation((...args) => {
+ tenants.push(schemas.getTenantId());
+ return originalFindUser(...args);
+ });
+ const response = await request(app)
+ .post('/api/user/verify')
+ .set('X-Tenant-Id', 'tenant-b')
+ .send({ email: '[email protected]', token: 'invalid' });
+ expect(response.status).toBe(400);
+ expect(tenants).toEqual(['tenant-b']);
+ });
+
+ it('verifies only the account in the resolved tenant with a real token', async () => {
+ const token = 'tenant-email-verification-token';
+ const hash = await bcrypt.hash(token, 4);
+ await schemas.runAsSystem(async () => {
+ await mongoose.models.User.updateMany(
+ { _id: { $in: [userA._id, userB._id] } },
+ { $set: { emailVerified: false } },
+ );
+ });
+ await schemas.tenantStorage.run({ tenantId: 'tenant-b' }, async () => {
+ await models.createToken({
+ userId: userB._id,
+ email: userB.email,
+ type: 'email_verification',
+ token: hash,
+ createdAt: Date.now(),
+ expiresIn: 900,
+ });
+ });
+ const response = await request(app)
+ .post('/api/user/verify')
+ .set('X-Tenant-Id', 'tenant-b')
+ .send({ email: userB.email, token });
+ expect(response.status).toBe(200);
+ expect(response.body.status).toBe('success');
+ await schemas.runAsSystem(async () => {
+ expect((await models.getUserById(userA._id)).emailVerified).toBe(false);
+ expect((await models.getUserById(userB._id)).emailVerified).toBe(true);
+ });
+ });
+});
diff --git a/api/server/routes/admin/auth.js b/api/server/routes/admin/auth.js
index 2af6f90367..33ae544c4b 100644
--- a/api/server/routes/admin/auth.js
+++ b/api/server/routes/admin/auth.js
@@ -12,6 +12,9 @@ const {
} = require('@librechat/data-schemas');
const {
isEnabled,
+ TENANT_CONTEXT_REQUIRED,
+ createPreAuthTenantGuard,
+ requirePreAuthTenantContext,
getAdminPanelUrl,
exchangeAdminCode,
createSetBalanceConfig,
@@ -155,6 +158,8 @@ function buildGoogleAdminRefreshDeps(sessionExpiry) {
router.post(
'/login/local',
+ preAuthTenantMiddleware,
+ requirePreAuthTenantContext,
middleware.logHeaders,
middleware.requireSameOrigin,
middleware.loginLimiter,
@@ -231,24 +236,34 @@ function retrievePkceChallenge(provider) {
* OpenID Admin Routes
* ────────────────────────────────────────────── */
-router.get('/oauth/openid', requireOpenIdConfig, async (req, res, next) => {
- const state = generateState();
- const cache = getLogStores(CacheKeys.ADMIN_OAUTH_EXCHANGE);
- const stored = await storeAndStripChallenge(cache, req, state, 'openid');
- if (!stored) {
- return res.redirect(
- `${getAdminPanelUrl()}/auth/openid/callback?error=pkce_store_failed&error_description=Failed+to+store+PKCE+challenge`,
- );
- }
+router.get(
+ '/oauth/openid',
+ preAuthTenantMiddleware,
+ requirePreAuthTenantContext,
+ requireOpenIdConfig,
+ async (req, res, next) => {
+ const state = generateState();
+ const cache = getLogStores(CacheKeys.ADMIN_OAUTH_EXCHANGE);
+ const stored = await storeAndStripChallenge(cache, req, state, 'openid');
+ if (!stored) {
+ return res.redirect(
+ `${getAdminPanelUrl()}/auth/openid/callback?error=pkce_store_failed&error_description=Failed+to+store+PKCE+challenge`,
+ );
+ }
- return passport.authenticate('openidAdmin', {
- session: false,
- state,
- })(req, res, next);
-});
+ return passport.authenticate('openidAdmin', {
+ session: false,
+ state,
+ })(req, res, next);
+ },
+);
router.get(
'/oauth/openid/callback',
+ preAuthTenantMiddleware,
+ createPreAuthTenantGuard({
+ failureRedirect: `${getAdminPanelUrl()}/auth/openid/callback?error=${TENANT_CONTEXT_REQUIRED}&error_description=Tenant+context+required+in+strict+isolation+mode`,
+ }),
(req, res, next) => {
req.oauthState = typeof req.query.state === 'string' ? req.query.state : undefined;
next();
@@ -271,24 +286,34 @@ router.get(
* SAML Admin Routes
* ────────────────────────────────────────────── */
-router.get('/oauth/saml', requireAdminStrategy('samlAdmin', 'SAML'), async (req, res, next) => {
- const state = generateState();
- const cache = getLogStores(CacheKeys.ADMIN_OAUTH_EXCHANGE);
- const stored = await storeAndStripChallenge(cache, req, state, 'saml');
- if (!stored) {
- return res.redirect(
- `${getAdminPanelUrl()}/auth/saml/callback?error=pkce_store_failed&error_description=Failed+to+store+PKCE+challenge`,
- );
- }
+router.get(
+ '/oauth/saml',
+ preAuthTenantMiddleware,
+ requirePreAuthTenantContext,
+ requireAdminStrategy('samlAdmin', 'SAML'),
+ async (req, res, next) => {
+ const state = generateState();
+ const cache = getLogStores(CacheKeys.ADMIN_OAUTH_EXCHANGE);
+ const stored = await storeAndStripChallenge(cache, req, state, 'saml');
+ if (!stored) {
+ return res.redirect(
+ `${getAdminPanelUrl()}/auth/saml/callback?error=pkce_store_failed&error_description=Failed+to+store+PKCE+challenge`,
+ );
+ }
- return passport.authenticate('samlAdmin', {
- session: false,
- additionalParams: { RelayState: state },
- })(req, res, next);
-});
+ return passport.authenticate('samlAdmin', {
+ session: false,
+ additionalParams: { RelayState: state },
+ })(req, res, next);
+ },
+);
router.post(
'/oauth/saml/callback',
+ preAuthTenantMiddleware,
+ createPreAuthTenantGuard({
+ failureRedirect: `${getAdminPanelUrl()}/auth/saml/callback?error=${TENANT_CONTEXT_REQUIRED}&error_description=Tenant+context+required+in+strict+isolation+mode`,
+ }),
(req, res, next) => {
req.oauthState = typeof req.body.RelayState === 'string' ? req.body.RelayState : undefined;
next();
@@ -313,6 +338,8 @@ router.post(
router.get(
'/oauth/google',
+ preAuthTenantMiddleware,
+ requirePreAuthTenantContext,
requireAdminStrategy('googleAdmin', 'Google'),
async (req, res, next) => {
const state = generateState();
@@ -336,6 +363,10 @@ router.get(
router.get(
'/oauth/google/callback',
+ preAuthTenantMiddleware,
+ createPreAuthTenantGuard({
+ failureRedirect: `${getAdminPanelUrl()}/auth/google/callback?error=${TENANT_CONTEXT_REQUIRED}&error_description=Tenant+context+required+in+strict+isolation+mode`,
+ }),
(req, res, next) => {
req.oauthState = typeof req.query.state === 'string' ? req.query.state : undefined;
next();
@@ -360,6 +391,8 @@ router.get(
router.get(
'/oauth/github',
+ preAuthTenantMiddleware,
+ requirePreAuthTenantContext,
requireAdminStrategy('githubAdmin', 'GitHub'),
async (req, res, next) => {
const state = generateState();
@@ -381,6 +414,10 @@ router.get(
router.get(
'/oauth/github/callback',
+ preAuthTenantMiddleware,
+ createPreAuthTenantGuard({
+ failureRedirect: `${getAdminPanelUrl()}/auth/github/callback?error=${TENANT_CONTEXT_REQUIRED}&error_description=Tenant+context+required+in+strict+isolation+mode`,
+ }),
(req, res, next) => {
req.oauthState = typeof req.query.state === 'string' ? req.query.state : undefined;
next();
@@ -405,6 +442,8 @@ router.get(
router.get(
'/oauth/discord',
+ preAuthTenantMiddleware,
+ requirePreAuthTenantContext,
requireAdminStrategy('discordAdmin', 'Discord'),
async (req, res, next) => {
const state = generateState();
@@ -426,6 +465,10 @@ router.get(
router.get(
'/oauth/discord/callback',
+ preAuthTenantMiddleware,
+ createPreAuthTenantGuard({
+ failureRedirect: `${getAdminPanelUrl()}/auth/discord/callback?error=${TENANT_CONTEXT_REQUIRED}&error_description=Tenant+context+required+in+strict+isolation+mode`,
+ }),
(req, res, next) => {
req.oauthState = typeof req.query.state === 'string' ? req.query.state : undefined;
next();
@@ -450,6 +493,8 @@ router.get(
router.get(
'/oauth/facebook',
+ preAuthTenantMiddleware,
+ requirePreAuthTenantContext,
requireAdminStrategy('facebookAdmin', 'Facebook'),
async (req, res, next) => {
const state = generateState();
@@ -471,6 +516,10 @@ router.get(
router.get(
'/oauth/facebook/callback',
+ preAuthTenantMiddleware,
+ createPreAuthTenantGuard({
+ failureRedirect: `${getAdminPanelUrl()}/auth/facebook/callback?error=${TENANT_CONTEXT_REQUIRED}&error_description=Tenant+context+required+in+strict+isolation+mode`,
+ }),
(req, res, next) => {
req.oauthState = typeof req.query.state === 'string' ? req.query.state : undefined;
next();
@@ -493,24 +542,34 @@ router.get(
* Apple Admin Routes (POST callback)
* ────────────────────────────────────────────── */
-router.get('/oauth/apple', requireAdminStrategy('appleAdmin', 'Apple'), async (req, res, next) => {
- const state = generateState();
- const cache = getLogStores(CacheKeys.ADMIN_OAUTH_EXCHANGE);
- const stored = await storeAndStripChallenge(cache, req, state, 'apple');
- if (!stored) {
- return res.redirect(
- `${getAdminPanelUrl()}/auth/apple/callback?error=pkce_store_failed&error_description=Failed+to+store+PKCE+challenge`,
- );
- }
+router.get(
+ '/oauth/apple',
+ preAuthTenantMiddleware,
+ requirePreAuthTenantContext,
+ requireAdminStrategy('appleAdmin', 'Apple'),
+ async (req, res, next) => {
+ const state = generateState();
+ const cache = getLogStores(CacheKeys.ADMIN_OAUTH_EXCHANGE);
+ const stored = await storeAndStripChallenge(cache, req, state, 'apple');
+ if (!stored) {
+ return res.redirect(
+ `${getAdminPanelUrl()}/auth/apple/callback?error=pkce_store_failed&error_description=Failed+to+store+PKCE+challenge`,
+ );
+ }
- return passport.authenticate('appleAdmin', {
- session: false,
- state,
- })(req, res, next);
-});
+ return passport.authenticate('appleAdmin', {
+ session: false,
+ state,
+ })(req, res, next);
+ },
+);
router.post(
'/oauth/apple/callback',
+ preAuthTenantMiddleware,
+ createPreAuthTenantGuard({
+ failureRedirect: `${getAdminPanelUrl()}/auth/apple/callback?error=${TENANT_CONTEXT_REQUIRED}&error_description=Tenant+context+required+in+strict+isolation+mode`,
+ }),
(req, res, next) => {
req.oauthState = typeof req.body.state === 'string' ? req.body.state : undefined;
next();
diff --git a/api/server/routes/admin/auth.refresh.test.js b/api/server/routes/admin/auth.refresh.test.js
index b14bf1312d..19468146c6 100644
--- a/api/server/routes/admin/auth.refresh.test.js
+++ b/api/server/routes/admin/auth.refresh.test.js
@@ -10,11 +10,16 @@ jest.mock('openid-client', () => ({
refreshTokenGrant: jest.fn(),
}));
-jest.mock('librechat-data-provider', () => ({
- CacheKeys: { ADMIN_OAUTH_EXCHANGE: 'admin-oauth-exchange' },
-}));
+jest.mock('librechat-data-provider', () => {
+ const actual = jest.requireActual('librechat-data-provider');
+ return {
+ ...actual,
+ CacheKeys: { ...actual.CacheKeys, ADMIN_OAUTH_EXCHANGE: 'admin-oauth-exchange' },
+ };
+});
jest.mock('@librechat/data-schemas', () => ({
+ ...jest.requireActual('@librechat/data-schemas'),
logger: {
debug: jest.fn(),
error: jest.fn(),
@@ -37,6 +42,7 @@ jest.mock('@librechat/api', () => {
}
return {
+ ...jest.requireActual('@librechat/api'),
isEnabled: jest.fn(),
getAdminPanelUrl: jest.fn(() => 'http://admin.example.com'),
exchangeAdminCode: jest.fn(),
diff --git a/api/server/routes/auth.2fa-ratelimit.test.js b/api/server/routes/auth.2fa-ratelimit.test.js
index a6b145a292..f4e87ac543 100644
--- a/api/server/routes/auth.2fa-ratelimit.test.js
+++ b/api/server/routes/auth.2fa-ratelimit.test.js
@@ -18,6 +18,7 @@ const mockAcknowledge2FASetup = jest.fn((req, res) => res.status(204).end());
const mockFinalize2FASetup = jest.fn((req, res) => res.status(204).end());
jest.mock('@librechat/api', () => ({
+ ...jest.requireActual('@librechat/api'),
limiterCache: jest.fn(() => undefined),
createTwoFactorManagementLimiter: (...args) =>
require('../../../packages/api/src/middleware/twoFactor').createTwoFactorManagementLimiter(
diff --git a/api/server/routes/auth.cloudfront.test.js b/api/server/routes/auth.cloudfront.test.js
index 84b7e6ddd3..e22e1e8969 100644
--- a/api/server/routes/auth.cloudfront.test.js
+++ b/api/server/routes/auth.cloudfront.test.js
@@ -4,6 +4,7 @@ const request = require('supertest');
const mockForceRefreshCloudFrontAuthCookies = jest.fn();
jest.mock('@librechat/api', () => ({
+ ...jest.requireActual('@librechat/api'),
limiterCache: jest.fn(),
createTwoFactorManagementLimiter: jest.fn(() => (req, res, next) => next()),
createSetBalanceConfig: jest.fn(() => (req, res, next) => next()),
diff --git a/api/server/routes/auth.js b/api/server/routes/auth.js
index 6557dd7cd2..d16cbbb287 100644
--- a/api/server/routes/auth.js
+++ b/api/server/routes/auth.js
@@ -1,6 +1,7 @@
const express = require('express');
const {
limiterCache,
+ requirePreAuthTenantContext,
createSetBalanceConfig,
requireTwoFactorSetupToken,
createTwoFactorManagementLimiter,
@@ -69,6 +70,7 @@ const ldapAuth = !!process.env.LDAP_URL && !!process.env.LDAP_USER_SEARCH_BASE;
router.post('/logout', middleware.requireJwtAuth, logoutController);
router.post(
'/login',
+ requirePreAuthTenantContext,
middleware.logHeaders,
middleware.requireSameOrigin,
middleware.loginLimiter,
@@ -94,6 +96,7 @@ router.post('/cloudfront/refresh', middleware.requireJwtAuth, (req, res) => {
});
router.post(
'/register',
+ requirePreAuthTenantContext,
middleware.registerLimiter,
middleware.checkBan,
middleware.checkInviteUser,
@@ -102,6 +105,7 @@ router.post(
);
router.post(
'/requestPasswordReset',
+ requirePreAuthTenantContext,
middleware.resetPasswordLimiter,
middleware.checkBan,
middleware.validatePasswordReset,
@@ -109,6 +113,7 @@ router.post(
);
router.post(
'/resetPassword',
+ requirePreAuthTenantContext,
middleware.resetPasswordSubmissionLimiter,
middleware.checkBan,
middleware.validatePasswordReset,
@@ -119,6 +124,7 @@ router.post('/2fa/enable', middleware.requireJwtAuth, twoFactorManagementLimiter
router.post('/2fa/verify', middleware.requireJwtAuth, twoFactorManagementLimiter, verify2FA);
router.post(
'/2fa/setup',
+ requirePreAuthTenantContext,
middleware.setTwoFactorTempUser,
middleware.twoFactorSetupLimiter,
middleware.checkBan,
@@ -128,6 +134,7 @@ router.post(
);
router.post(
'/2fa/setup/confirm',
+ requirePreAuthTenantContext,
middleware.setTwoFactorTempUser,
middleware.twoFactorTempLimiter,
middleware.checkBan,
@@ -137,6 +144,7 @@ router.post(
);
router.post(
'/2fa/setup/acknowledge',
+ requirePreAuthTenantContext,
middleware.setTwoFactorAcknowledgementTempUser,
middleware.twoFactorSetupLimiter,
middleware.checkBan,
@@ -145,6 +153,7 @@ router.post(
);
router.post(
'/2fa/setup/finalize',
+ requirePreAuthTenantContext,
middleware.setTwoFactorFinalizationTempUser,
middleware.twoFactorSetupLimiter,
middleware.checkBan,
@@ -153,6 +162,7 @@ router.post(
);
router.post(
'/2fa/verify-temp',
+ requirePreAuthTenantContext,
middleware.requireSameOrigin,
middleware.setTwoFactorTempUser,
middleware.twoFactorTempLimiter,
@@ -177,6 +187,7 @@ router.post(
/* Passkeys (WebAuthn) */
router.post(
'/passkey/login/options',
+ requirePreAuthTenantContext,
middleware.logHeaders,
middleware.passkeyLimiter,
middleware.checkBan,
@@ -184,6 +195,7 @@ router.post(
);
router.post(
'/passkey/login/verify',
+ requirePreAuthTenantContext,
middleware.logHeaders,
middleware.requireSameOrigin,
middleware.passkeyLimiter,
diff --git a/api/server/routes/auth.reset-password-ratelimit.test.js b/api/server/routes/auth.reset-password-ratelimit.test.js
index 4fe6bc23b2..2322d9620c 100644
--- a/api/server/routes/auth.reset-password-ratelimit.test.js
+++ b/api/server/routes/auth.reset-password-ratelimit.test.js
@@ -7,6 +7,7 @@ const mockValidatePasswordReset = jest.fn((req, res, next) => next());
const mockResetPasswordController = jest.fn((req, res) => res.status(204).end());
jest.mock('@librechat/api', () => ({
+ ...jest.requireActual('@librechat/api'),
limiterCache: jest.fn(),
createTwoFactorManagementLimiter: jest.fn(() => (req, res, next) => next()),
createSetBalanceConfig: jest.fn(() => (req, res, next) => next()),
diff --git a/api/server/routes/oauth.js b/api/server/routes/oauth.js
index 710fac1c63..4344e75709 100644
--- a/api/server/routes/oauth.js
+++ b/api/server/routes/oauth.js
@@ -6,6 +6,9 @@ const { logger } = require('@librechat/data-schemas');
const { ErrorTypes } = require('librechat-data-provider');
const {
buildOAuthFailureLog,
+ TENANT_CONTEXT_REQUIRED,
+ createPreAuthTenantGuard,
+ requirePreAuthTenantContext,
createOpenIDCallbackAuthenticator,
createSetBalanceConfig,
getOAuthFailureMessage,
@@ -43,6 +46,9 @@ router.use(logHeaders);
router.use(markOAuthNavigation);
router.use(loginLimiter);
+const requireCallbackTenant = createPreAuthTenantGuard({
+ failureRedirect: `${domains.client}/login?redirect=false&error=${ErrorTypes.AUTH_FAILED}&code=${TENANT_CONTEXT_REQUIRED}`,
+});
const oauthHandler = createOAuthHandler();
const authenticateOpenIDCallback = createOpenIDCallbackAuthenticator({
passport,
@@ -71,6 +77,7 @@ router.get('/error', (req, res) => {
*/
router.get(
'/google',
+ requirePreAuthTenantContext,
passport.authenticate('google', {
scope: ['openid', 'profile', 'email'],
session: false,
@@ -79,6 +86,7 @@ router.get(
router.get(
'/google/callback',
+ requireCallbackTenant,
passport.authenticate('google', {
failureRedirect: `${domains.client}/oauth/error`,
session: false,
@@ -94,6 +102,7 @@ router.get(
*/
router.get(
'/facebook',
+ requirePreAuthTenantContext,
passport.authenticate('facebook', {
scope: ['public_profile'],
profileFields: ['id', 'email', 'name'],
@@ -103,6 +112,7 @@ router.get(
router.get(
'/facebook/callback',
+ requireCallbackTenant,
passport.authenticate('facebook', {
failureRedirect: `${domains.client}/oauth/error`,
session: false,
@@ -117,7 +127,7 @@ router.get(
/**
* OpenID Routes
*/
-router.get('/openid', (req, res, next) => {
+router.get('/openid', requirePreAuthTenantContext, (req, res, next) => {
return passport.authenticate('openid', {
session: false,
state: randomState(),
@@ -126,6 +136,7 @@ router.get('/openid', (req, res, next) => {
router.get(
'/openid/callback',
+ requireCallbackTenant,
authenticateOpenIDCallback,
setBalanceConfig,
checkDomainAllowed,
@@ -137,6 +148,7 @@ router.get(
*/
router.get(
'/github',
+ requirePreAuthTenantContext,
passport.authenticate('github', {
scope: ['user:email', 'read:user'],
session: false,
@@ -145,6 +157,7 @@ router.get(
router.get(
'/github/callback',
+ requireCallbackTenant,
passport.authenticate('github', {
failureRedirect: `${domains.client}/oauth/error`,
session: false,
@@ -160,6 +173,7 @@ router.get(
*/
router.get(
'/discord',
+ requirePreAuthTenantContext,
passport.authenticate('discord', {
scope: ['identify', 'email'],
session: false,
@@ -168,6 +182,7 @@ router.get(
router.get(
'/discord/callback',
+ requireCallbackTenant,
passport.authenticate('discord', {
failureRedirect: `${domains.client}/oauth/error`,
session: false,
@@ -183,6 +198,7 @@ router.get(
*/
router.get(
'/apple',
+ requirePreAuthTenantContext,
passport.authenticate('apple', {
session: false,
}),
@@ -190,6 +206,7 @@ router.get(
router.post(
'/apple/callback',
+ requireCallbackTenant,
passport.authenticate('apple', {
failureRedirect: `${domains.client}/oauth/error`,
session: false,
@@ -204,6 +221,7 @@ router.post(
*/
router.get(
'/saml',
+ requirePreAuthTenantContext,
passport.authenticate('saml', {
session: false,
}),
@@ -211,6 +229,7 @@ router.get(
router.post(
'/saml/callback',
+ requireCallbackTenant,
passport.authenticate('saml', {
failureRedirect: `${domains.client}/oauth/error`,
failureMessage: true,
diff --git a/api/server/routes/oauth.test.js b/api/server/routes/oauth.test.js
index 9acf4d9278..0d34be5b8e 100644
--- a/api/server/routes/oauth.test.js
+++ b/api/server/routes/oauth.test.js
@@ -59,6 +59,7 @@ jest.mock('openid-client', () => ({
}));
jest.mock('@librechat/data-schemas', () => ({
+ ...jest.requireActual('@librechat/data-schemas'),
logger: mockLogger,
}));
@@ -70,6 +71,7 @@ jest.mock('librechat-data-provider', () => ({
}));
jest.mock('@librechat/api', () => ({
+ ...jest.requireActual('@librechat/api'),
buildOAuthFailureLog: (...args) => mockBuildOAuthFailureLog(...args),
createOpenIDCallbackAuthenticator: (...args) => mockCreateOpenIDCallbackAuthenticator(...args),
createSetBalanceConfig: jest.fn(() => (_req, _res, next) => next()),
diff --git a/api/server/routes/user.js b/api/server/routes/user.js
index c736976238..adb46b0ba8 100644
--- a/api/server/routes/user.js
+++ b/api/server/routes/user.js
@@ -1,5 +1,9 @@
const express = require('express');
-const { createUserPreferencesHandler } = require('@librechat/api');
+const {
+ createUserPreferencesHandler,
+ preAuthTenantMiddleware,
+ requirePreAuthTenantContext,
+} = require('@librechat/api');
const {
updateUserPluginsController,
resendVerificationController,
@@ -52,7 +56,19 @@ router.post(
emailChangeSubmissionLimiter,
confirmEmailChangeController,
);
-router.post('/verify', verifyEmailSubmissionLimiter, verifyEmailController);
-router.post('/verify/resend', verifyEmailLimiter, resendVerificationController);
+router.post(
+ '/verify',
+ preAuthTenantMiddleware,
+ requirePreAuthTenantContext,
+ verifyEmailSubmissionLimiter,
+ verifyEmailController,
+);
+router.post(
+ '/verify/resend',
+ preAuthTenantMiddleware,
+ requirePreAuthTenantContext,
+ verifyEmailLimiter,
+ resendVerificationController,
+);
module.exports = router;
diff --git a/api/server/services/start/__tests__/migration.spec.js b/api/server/services/start/__tests__/migration.spec.js
index ba4bfc32d8..efd10acd29 100644
--- a/api/server/services/start/__tests__/migration.spec.js
+++ b/api/server/services/start/__tests__/migration.spec.js
@@ -4,6 +4,7 @@ const mockCheckPromptPermissionsMigration = jest.fn();
jest.mock('@librechat/data-schemas', () => ({
logger: { error: jest.fn() },
+ runAsSystem: (fn) => fn(),
warnOnMissingSearchTokens: (...args) => mockWarnOnMissingSearchTokens(...args),
}));
jest.mock('@librechat/api', () => ({
@@ -14,6 +15,7 @@ jest.mock('@librechat/api', () => ({
}));
jest.mock('~/models', () => ({ findRoleByIdentifier: jest.fn() }));
+const { logger } = require('@librechat/data-schemas');
const { checkMigrations } = require('../migration');
describe('checkMigrations', () => {
@@ -35,3 +37,22 @@ describe('checkMigrations', () => {
expect(mockCheckPromptPermissionsMigration).toHaveBeenCalledTimes(1);
});
});
+
+it('labels permission check failures and still awaits the search probe', async () => {
+ const agentError = new Error('Agent check failed');
+ const promptError = new Error('Prompt check failed');
+ mockCheckAgentPermissionsMigration.mockRejectedValueOnce(agentError);
+ mockCheckPromptPermissionsMigration.mockRejectedValueOnce(promptError);
+ mockWarnOnMissingSearchTokens.mockResolvedValueOnce(undefined);
+
+ await expect(checkMigrations()).resolves.toBeUndefined();
+
+ expect(logger.error).toHaveBeenCalledWith(
+ '[checkMigrations] Failed to check agent permissions migration:',
+ agentError,
+ );
+ expect(logger.error).toHaveBeenCalledWith(
+ '[checkMigrations] Failed to check prompt permissions migration:',
+ promptError,
+ );
+});
diff --git a/api/server/services/start/__tests__/migration.strict.spec.js b/api/server/services/start/__tests__/migration.strict.spec.js
new file mode 100644
index 0000000000..874ee50573
--- /dev/null
+++ b/api/server/services/start/__tests__/migration.strict.spec.js
@@ -0,0 +1,144 @@
+const mongoose = require('mongoose');
+const { MongoMemoryServer } = require('mongodb-memory-server');
+const {
+ logger,
+ createModels,
+ createMethods,
+ runAsSystem,
+ tenantStorage,
+ getTenantId,
+} = require('@librechat/data-schemas');
+const { PrincipalType, ResourceType } = require('librechat-data-provider');
+
+jest.mock('../../../../../config/connect', () => jest.fn().mockResolvedValue(true));
+
+const { checkMigrations } = require('../migration');
+const {
+ migrateAgentPermissionsEnhanced,
+} = require('../../../../../config/migrate-agent-permissions');
+const {
+ migrateToPromptGroupPermissions,
+} = require('../../../../../config/migrate-prompt-permissions');
+
+let mongo;
+let methods;
+let resources;
+const originalStrict = process.env.TENANT_ISOLATION_STRICT;
+
+beforeAll(async () => {
+ process.env.TENANT_ISOLATION_STRICT = 'true';
+ mongo = await MongoMemoryServer.create({ instance: { args: ['--nounixsocket'] } });
+ await mongoose.connect(mongo.getUri());
+ createModels(mongoose);
+ methods = createMethods(mongoose);
+ await runAsSystem(async () => methods.seedDefaultRoles());
+});
+
+beforeEach(async () => {
+ await runAsSystem(async () => {
+ await Promise.all([
+ mongoose.models.Agent.deleteMany({}),
+ mongoose.models.PromptGroup.deleteMany({}),
+ mongoose.models.AclEntry.deleteMany({}),
+ mongoose.connection.db.collection('projects').deleteMany({}),
+ ]);
+ });
+ resources = [];
+ for (const tenantId of [undefined, 'tenant-a', 'tenant-b']) {
+ const create = async () => {
+ const author = new mongoose.Types.ObjectId();
+ const agent = await mongoose.models.Agent.create({
+ id: `agent-${tenantId ?? 'platform'}`,
+ name: 'Legacy agent',
+ author,
+ provider: 'openAI',
+ model: 'gpt-4',
+ isCollaborative: true,
+ });
+ const group = await mongoose.models.PromptGroup.create({
+ name: 'Legacy prompt group',
+ author,
+ authorName: 'Author',
+ productionId: new mongoose.Types.ObjectId(),
+ });
+ resources.push({ agent, group, tenantId, author });
+ };
+ if (tenantId) {
+ await tenantStorage.run({ tenantId }, create);
+ } else {
+ await runAsSystem(create);
+ }
+ }
+ await mongoose.connection.db.collection('projects').insertOne({
+ name: 'instance',
+ agentIds: resources.map(({ agent }) => agent.id),
+ promptGroupIds: resources.map(({ group }) => group._id),
+ });
+ jest.clearAllMocks();
+ jest.spyOn(console, 'log').mockImplementation(() => {});
+});
+
+afterAll(async () => {
+ await mongoose.disconnect();
+ await mongo?.stop();
+ if (originalStrict === undefined) {
+ delete process.env.TENANT_ISOLATION_STRICT;
+ } else {
+ process.env.TENANT_ISOLATION_STRICT = originalStrict;
+ }
+});
+
+it.each([undefined, 'tenant-a'])(
+ 'checks every tenant under strict isolation (caller: %s)',
+ async (tenantId) => {
+ const warn = jest.spyOn(logger, 'warn');
+ const error = jest.spyOn(logger, 'error');
+ await tenantStorage.run({ tenantId }, async () => {
+ await checkMigrations();
+ expect(getTenantId()).toBe(tenantId);
+ });
+
+ expect(warn).toHaveBeenCalledWith(
+ 'Agent permissions migration required',
+ expect.objectContaining({ totalToMigrate: 3, globalViewAccess: 3 }),
+ );
+ expect(warn).toHaveBeenCalledWith(
+ 'Prompt permissions migration required',
+ expect.objectContaining({ totalToMigrate: 3, globalViewAccess: 3 }),
+ );
+ expect(error).not.toHaveBeenCalled();
+ },
+);
+
+it.each([
+ ['agents', migrateAgentPermissionsEnhanced, ResourceType.AGENT, 'agent'],
+ ['prompt groups', migrateToPromptGroupPermissions, ResourceType.PROMPTGROUP, 'group'],
+])(
+ 'migrates %s into each resource tenant, not the system partition',
+ async (_name, migrate, resourceType, resourceKey) => {
+ const preview = await migrate({ dryRun: true });
+ expect(preview.summary.total).toBe(3);
+ expect(await runAsSystem(async () => mongoose.models.AclEntry.countDocuments({}))).toBe(0);
+
+ const result = await migrate({ dryRun: false });
+ expect(result).toMatchObject({ migrated: 3, errors: 0, ownerGrants: 3 });
+ for (const resource of resources) {
+ const entries = await runAsSystem(async () =>
+ mongoose.models.AclEntry.find({
+ resourceType,
+ resourceId: resource[resourceKey]._id,
+ }).lean(),
+ );
+ expect(entries).toHaveLength(2);
+ for (const entry of entries) {
+ expect(entry.tenantId).toBe(resource.tenantId);
+ }
+ expect(
+ entries.find((entry) => entry.principalType === PrincipalType.USER).principalId,
+ ).toEqual(resource.author);
+ expect(entries.some((entry) => entry.principalType === PrincipalType.PUBLIC)).toBe(true);
+ }
+ const rerun = await migrate({ dryRun: false });
+ expect(rerun).toMatchObject({ migrated: 0, errors: 0 });
+ },
+);
diff --git a/api/server/services/start/migration.js b/api/server/services/start/migration.js
index d170590168..497f08083e 100644
--- a/api/server/services/start/migration.js
+++ b/api/server/services/start/migration.js
@@ -1,5 +1,5 @@
const mongoose = require('mongoose');
-const { logger, warnOnMissingSearchTokens } = require('@librechat/data-schemas');
+const { logger, runAsSystem, warnOnMissingSearchTokens } = require('@librechat/data-schemas');
const {
logAgentMigrationWarning,
logPromptMigrationWarning,
@@ -25,7 +25,7 @@ async function checkMigrations() {
});
logAgentMigrationWarning(agentMigrationResult);
} catch (error) {
- logger.error('Failed to check agent permissions migration:', error);
+ logger.error('[checkMigrations] Failed to check agent permissions migration:', error);
}
try {
const promptMigrationResult = await checkPromptPermissionsMigration({
@@ -37,11 +37,11 @@ async function checkMigrations() {
});
logPromptMigrationWarning(promptMigrationResult);
} catch (error) {
- logger.error('Failed to check prompt permissions migration:', error);
+ logger.error('[checkMigrations] Failed to check prompt permissions migration:', error);
}
await searchTokens;
}
module.exports = {
- checkMigrations,
+ checkMigrations: () => runAsSystem(checkMigrations),
};
diff --git a/config/migrate-agent-permissions.js b/config/migrate-agent-permissions.js
index 01d04c48ca..12f08b540f 100644
--- a/config/migrate-agent-permissions.js
+++ b/config/migrate-agent-permissions.js
@@ -1,6 +1,6 @@
const path = require('path');
-const { logger } = require('@librechat/data-schemas');
-const { ensureRequiredCollectionsExist } = require('@librechat/api');
+const { logger, runAsSystem } = require('@librechat/data-schemas');
+const { ensureRequiredCollectionsExist, runResourceMigration } = require('@librechat/api');
const { AccessRoleIds, ResourceType, PrincipalType } = require('librechat-data-provider');
require('module-alias')({ base: path.resolve(__dirname, '..', 'api') });
@@ -53,7 +53,7 @@ async function migrateAgentPermissionsEnhanced({ dryRun = true, batchSize = 100
_id: { $nin: migratedAgentIds },
author: { $exists: true, $ne: null },
})
- .select('_id id name author isCollaborative')
+ .select('_id id name author isCollaborative tenantId')
.lean();
const categories = {
@@ -143,50 +143,52 @@ async function migrateAgentPermissionsEnhanced({ dryRun = true, batchSize = 100
for (const agent of batch) {
try {
- const isGlobal = globalAgentIds.has(agent.id);
- const isCollab = agent.isCollaborative;
-
- await grantPermission({
- principalType: PrincipalType.USER,
- principalId: agent.author,
- resourceType: ResourceType.AGENT,
- resourceId: agent._id,
- accessRoleId: AccessRoleIds.AGENT_OWNER,
- grantedBy: agent.author,
- });
- results.ownerGrants++;
-
- let publicRoleId = null;
- let description = 'Private';
-
- if (isGlobal) {
- if (isCollab) {
- publicRoleId = AccessRoleIds.AGENT_EDITOR;
- description = 'Global Edit';
- results.publicEditGrants++;
- } else {
- publicRoleId = AccessRoleIds.AGENT_VIEWER;
- description = 'Global View';
- results.publicViewGrants++;
- }
+ await runResourceMigration(agent, async () => {
+ const isGlobal = globalAgentIds.has(agent.id);
+ const isCollab = agent.isCollaborative;
await grantPermission({
- principalType: PrincipalType.PUBLIC,
- principalId: null,
+ principalType: PrincipalType.USER,
+ principalId: agent.author,
resourceType: ResourceType.AGENT,
resourceId: agent._id,
- accessRoleId: publicRoleId,
+ accessRoleId: AccessRoleIds.AGENT_OWNER,
grantedBy: agent.author,
});
- }
+ results.ownerGrants++;
+
+ let publicRoleId = null;
+ let description = 'Private';
+
+ if (isGlobal) {
+ if (isCollab) {
+ publicRoleId = AccessRoleIds.AGENT_EDITOR;
+ description = 'Global Edit';
+ results.publicEditGrants++;
+ } else {
+ publicRoleId = AccessRoleIds.AGENT_VIEWER;
+ description = 'Global View';
+ results.publicViewGrants++;
+ }
+
+ await grantPermission({
+ principalType: PrincipalType.PUBLIC,
+ principalId: null,
+ resourceType: ResourceType.AGENT,
+ resourceId: agent._id,
+ accessRoleId: publicRoleId,
+ grantedBy: agent.author,
+ });
+ }
- results.migrated++;
- logger.debug(`Migrated agent "${agent.name}" [${description}]`, {
- agentId: agent.id,
- author: agent.author,
- isGlobal,
- isCollab,
- publicRole: publicRoleId,
+ results.migrated++;
+ logger.debug(`Migrated agent "${agent.name}" [${description}]`, {
+ agentId: agent.id,
+ author: agent.author,
+ isGlobal,
+ isCollab,
+ publicRole: publicRoleId,
+ });
});
} catch (error) {
results.errors++;
@@ -210,7 +212,7 @@ if (require.main === module) {
const batchSize =
parseInt(process.argv.find((arg) => arg.startsWith('--batch-size='))?.split('=')[1]) || 100;
- migrateAgentPermissionsEnhanced({ dryRun, batchSize })
+ runAsSystem(() => migrateAgentPermissionsEnhanced({ dryRun, batchSize }))
.then((result) => {
if (dryRun) {
console.log('\n=== DRY RUN RESULTS ===');
@@ -250,4 +252,7 @@ if (require.main === module) {
});
}
-module.exports = { migrateAgentPermissionsEnhanced };
+module.exports = {
+ migrateAgentPermissionsEnhanced: (options) =>
+ runAsSystem(() => migrateAgentPermissionsEnhanced(options)),
+};
diff --git a/config/migrate-prompt-permissions.js b/config/migrate-prompt-permissions.js
index b9ed28746f..7d89178a1f 100644
--- a/config/migrate-prompt-permissions.js
+++ b/config/migrate-prompt-permissions.js
@@ -1,6 +1,6 @@
const path = require('path');
-const { logger } = require('@librechat/data-schemas');
-const { ensureRequiredCollectionsExist } = require('@librechat/api');
+const { logger, runAsSystem } = require('@librechat/data-schemas');
+const { ensureRequiredCollectionsExist, runResourceMigration } = require('@librechat/api');
const { AccessRoleIds, ResourceType, PrincipalType } = require('librechat-data-provider');
require('module-alias')({ base: path.resolve(__dirname, '..', 'api') });
@@ -54,7 +54,7 @@ async function migrateToPromptGroupPermissions({ dryRun = true, batchSize = 100
author: { $exists: true, $ne: null },
source: { $in: [null, 'native'] },
})
- .select('_id name author authorName category')
+ .select('_id name author authorName category tenantId')
.lean();
const categories = {
@@ -128,39 +128,41 @@ async function migrateToPromptGroupPermissions({ dryRun = true, batchSize = 100
for (const group of batch) {
try {
- const isGlobalGroup = globalPromptGroupIds.has(group._id.toString());
-
- await grantPermission({
- principalType: PrincipalType.USER,
- principalId: group.author,
- resourceType: ResourceType.PROMPTGROUP,
- resourceId: group._id,
- accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
- grantedBy: group.author,
- });
- results.ownerGrants++;
+ await runResourceMigration(group, async () => {
+ const isGlobalGroup = globalPromptGroupIds.has(group._id.toString());
- if (isGlobalGroup) {
await grantPermission({
- principalType: PrincipalType.PUBLIC,
- principalId: null,
+ principalType: PrincipalType.USER,
+ principalId: group.author,
resourceType: ResourceType.PROMPTGROUP,
resourceId: group._id,
- accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
+ accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
grantedBy: group.author,
});
- results.publicViewGrants++;
- }
-
- results.migrated++;
- logger.debug(
- `Migrated promptGroup "${group.name}" [${isGlobalGroup ? 'Global View' : 'Private'}]`,
- {
- groupId: group._id,
- author: group.author,
- isGlobalGroup,
- },
- );
+ results.ownerGrants++;
+
+ if (isGlobalGroup) {
+ await grantPermission({
+ principalType: PrincipalType.PUBLIC,
+ principalId: null,
+ resourceType: ResourceType.PROMPTGROUP,
+ resourceId: group._id,
+ accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
+ grantedBy: group.author,
+ });
+ results.publicViewGrants++;
+ }
+
+ results.migrated++;
+ logger.debug(
+ `Migrated promptGroup "${group.name}" [${isGlobalGroup ? 'Global View' : 'Private'}]`,
+ {
+ groupId: group._id,
+ author: group.author,
+ isGlobalGroup,
+ },
+ );
+ });
} catch (error) {
results.errors++;
logger.error(`Failed to migrate promptGroup "${group.name}"`, {
@@ -183,7 +185,7 @@ if (require.main === module) {
const batchSize =
parseInt(process.argv.find((arg) => arg.startsWith('--batch-size='))?.split('=')[1]) || 100;
- migrateToPromptGroupPermissions({ dryRun, batchSize })
+ runAsSystem(() => migrateToPromptGroupPermissions({ dryRun, batchSize }))
.then((result) => {
if (dryRun) {
console.log('\n=== DRY RUN RESULTS ===');
@@ -217,4 +219,7 @@ if (require.main === module) {
});
}
-module.exports = { migrateToPromptGroupPermissions };
+module.exports = {
+ migrateToPromptGroupPermissions: (options) =>
+ runAsSystem(() => migrateToPromptGroupPermissions(options)),
+};
diff --git a/packages/api/src/db/migration.spec.ts b/packages/api/src/db/migration.spec.ts
new file mode 100644
index 0000000000..5e9af05e1a
--- /dev/null
+++ b/packages/api/src/db/migration.spec.ts
@@ -0,0 +1,29 @@
+import { getTenantId, runAsSystem, tenantStorage, SYSTEM_TENANT_ID } from '@librechat/data-schemas';
+import { runResourceMigration } from './migration';
+
+it.each([undefined, null, '', 'tenant-a'])(
+ 'writes in the resource partition and restores the outer context (%s)',
+ async (tenantId) => {
+ await runAsSystem(async () => {
+ const result = await runResourceMigration({ tenantId }, async () => {
+ await Promise.resolve();
+ return getTenantId();
+ });
+ expect(result).toBe(tenantId || SYSTEM_TENANT_ID);
+ expect(getTenantId()).toBe(SYSTEM_TENANT_ID);
+ });
+ expect(getTenantId()).toBeUndefined();
+ },
+);
+
+it('preserves tracing metadata and restores context on failure', async () => {
+ await tenantStorage.run({ tenantId: 'tenant-a', requestId: 'migration' }, async () => {
+ await expect(
+ runResourceMigration({ tenantId: 'tenant-b' }, async () => {
+ expect(tenantStorage.getStore()).toEqual({ tenantId: 'tenant-b', requestId: 'migration' });
+ throw new Error('Write failed');
+ }),
+ ).rejects.toThrow('Write failed');
+ expect(getTenantId()).toBe('tenant-a');
+ });
+});
diff --git a/packages/api/src/db/migration.ts b/packages/api/src/db/migration.ts
new file mode 100644
index 0000000000..07418f69b8
--- /dev/null
+++ b/packages/api/src/db/migration.ts
@@ -0,0 +1,12 @@
+import { tenantStorage, SYSTEM_TENANT_ID } from '@librechat/data-schemas';
+
+/** Deploy-wide migrations read as system but write in each resource's partition. */
+export function runResourceMigration<T>(
+ resource: { tenantId?: string | null },
+ migrate: () => Promise<T>,
+): Promise<T> {
+ return tenantStorage.run(
+ { ...tenantStorage.getStore(), tenantId: resource.tenantId || SYSTEM_TENANT_ID },
+ async () => migrate(),
+ );
+}
diff --git a/packages/api/src/index.ts b/packages/api/src/index.ts
index a760e555ee..1da4b371ca 100644
--- a/packages/api/src/index.ts
+++ b/packages/api/src/index.ts
@@ -58,6 +58,7 @@ export * from './utils';
export { default as Tokenizer, countTokens } from './utils/tokenizer';
export type { EncodingName } from './utils/tokenizer';
export * from './db/utils';
+export * from './db/migration';
/* HTML */
export * from './html';
/* OAuth */
diff --git a/packages/api/src/middleware/__tests__/tenant.spec.ts b/packages/api/src/middleware/__tests__/tenant.spec.ts
index d21ad2cb2f..7247b215c2 100644
--- a/packages/api/src/middleware/__tests__/tenant.spec.ts
+++ b/packages/api/src/middleware/__tests__/tenant.spec.ts
@@ -6,14 +6,18 @@ import {
getRequestMethod,
getRequestPath,
SYSTEM_TENANT_ID,
+ tenantStorage,
logger,
} from '@librechat/data-schemas';
-import type { Response, NextFunction } from 'express';
+import type { Request, Response, NextFunction } from 'express';
import type { ServerRequest } from '~/types/http';
// Import directly from source file — _resetTenantMiddlewareStrictCache is intentionally
// excluded from the public barrel export (index.ts).
import {
tenantContextMiddleware,
+ requirePreAuthTenantContext,
+ createPreAuthTenantGuard,
+ TENANT_CONTEXT_REQUIRED,
requestContextMiddleware,
restoreTenantContextFromReq,
resolveRequestTenantId,
@@ -503,3 +507,70 @@ describe('resolveRequestTenantId', () => {
expect(resolveRequestTenantId(req)).toBe('tenant-user');
});
});
+
+describe('requirePreAuthTenantContext', () => {
+ const request = { headers: {} } as Request;
+ const originalStrict = process.env.TENANT_ISOLATION_STRICT;
+
+ afterEach(() => {
+ if (originalStrict === undefined) {
+ delete process.env.TENANT_ISOLATION_STRICT;
+ } else {
+ process.env.TENANT_ISOLATION_STRICT = originalStrict;
+ }
+ _resetTenantMiddlewareStrictCache();
+ });
+
+ it.each([undefined, '', ' ', SYSTEM_TENANT_ID, ` ${SYSTEM_TENANT_ID} `])(
+ 'refuses strict pre-auth lookups with tenant %s',
+ (tenantId) => {
+ process.env.TENANT_ISOLATION_STRICT = 'true';
+ _resetTenantMiddlewareStrictCache();
+ const res = mockRes();
+ const next = jest.fn();
+ tenantStorage.run({ tenantId }, () => {
+ requirePreAuthTenantContext(request, res, next);
+ });
+ expect(res.status).toHaveBeenCalledWith(403);
+ expect(res.json).toHaveBeenCalledWith({
+ message: 'Tenant context required in strict isolation mode',
+ code: TENANT_CONTEXT_REQUIRED,
+ });
+ expect(next).not.toHaveBeenCalled();
+ },
+ );
+
+ it('allows a strict request with a resolved tenant', () => {
+ process.env.TENANT_ISOLATION_STRICT = 'true';
+ _resetTenantMiddlewareStrictCache();
+ const next = jest.fn();
+ const res = mockRes();
+ tenantStorage.run({ tenantId: 'tenant-a' }, () => {
+ requirePreAuthTenantContext(request, res, next);
+ });
+ expect(next).toHaveBeenCalledTimes(1);
+ expect(res.status).not.toHaveBeenCalled();
+ });
+
+ it('preserves platform sign-in in non-strict mode', () => {
+ process.env.TENANT_ISOLATION_STRICT = 'false';
+ _resetTenantMiddlewareStrictCache();
+ const next = jest.fn();
+ const res = mockRes();
+ requirePreAuthTenantContext(request, res, next);
+ expect(next).toHaveBeenCalledTimes(1);
+ expect(res.status).not.toHaveBeenCalled();
+ });
+
+ it('redirects OAuth callbacks without exposing a database error', () => {
+ process.env.TENANT_ISOLATION_STRICT = 'true';
+ _resetTenantMiddlewareStrictCache();
+ const res = mockRes();
+ res.redirect = jest.fn();
+ const next = jest.fn();
+ createPreAuthTenantGuard({ failureRedirect: '/login?error=auth_failed' })(request, res, next);
+ expect(res.redirect).toHaveBeenCalledWith('/login?error=auth_failed');
+ expect(res.status).not.toHaveBeenCalled();
+ expect(next).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/api/src/middleware/index.ts b/packages/api/src/middleware/index.ts
index c261e2e11b..1a07fa05b7 100644
--- a/packages/api/src/middleware/index.ts
+++ b/packages/api/src/middleware/index.ts
@@ -11,6 +11,9 @@ export * from './sanitize';
export * from './capabilities';
export * from './auth';
export {
+ TENANT_CONTEXT_REQUIRED,
+ createPreAuthTenantGuard,
+ requirePreAuthTenantContext,
requestContextMiddleware,
tenantContextMiddleware,
restoreTenantContextFromReq,
diff --git a/packages/api/src/middleware/tenant.ts b/packages/api/src/middleware/tenant.ts
index 5b41edf9eb..9528deec0c 100644
--- a/packages/api/src/middleware/tenant.ts
+++ b/packages/api/src/middleware/tenant.ts
@@ -1,9 +1,9 @@
import { randomUUID } from 'crypto';
import { unlink } from 'fs/promises';
import { isMainThread } from 'worker_threads';
-import { tenantStorage, logger, SYSTEM_TENANT_ID } from '@librechat/data-schemas';
+import { tenantStorage, getTenantId, logger, SYSTEM_TENANT_ID } from '@librechat/data-schemas';
+import type { Response, NextFunction, RequestHandler } from 'express';
import type { TenantContext } from '@librechat/data-schemas';
-import type { Response, NextFunction } from 'express';
import type { ServerRequest } from '~/types/http';
import { buildSafeRequestLogContext } from './auth';
@@ -44,6 +44,31 @@ export function _resetTenantMiddlewareStrictCache(): void {
_strictMode = undefined;
}
+export const TENANT_CONTEXT_REQUIRED = 'TENANT_CONTEXT_REQUIRED';
+
+/** Refuses user lookups before authentication when strict isolation has no request tenant. */
+export function createPreAuthTenantGuard(
+ options: { failureRedirect?: string } = {},
+): RequestHandler {
+ return (_req, res, next): void => {
+ const tenantId = getTenantId()?.trim();
+ if (!isStrict() || (tenantId && tenantId !== SYSTEM_TENANT_ID)) {
+ next();
+ return;
+ }
+ if (options.failureRedirect) {
+ res.redirect(options.failureRedirect);
+ return;
+ }
+ res.status(403).json({
+ message: 'Tenant context required in strict isolation mode',
+ code: TENANT_CONTEXT_REQUIRED,
+ });
+ };
+}
+
+export const requirePreAuthTenantContext: RequestHandler = createPreAuthTenantGuard();
+
function normalizeContextValue(value?: string): string | undefined {
const trimmed = value?.trim();
return trimmed || undefined;
diff --git a/packages/data-schemas/src/methods/role.startup.spec.ts b/packages/data-schemas/src/methods/role.startup.spec.ts
new file mode 100644
index 0000000000..0d3f23b895
--- /dev/null
+++ b/packages/data-schemas/src/methods/role.startup.spec.ts
@@ -0,0 +1,132 @@
+import mongoose from 'mongoose';
+import { SystemRoles } from 'librechat-data-provider';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { _resetStrictCache } from '~/models/plugins/tenantIsolation';
+import { runAsSystem, tenantStorage } from '~/config/tenantContext';
+import { createModels } from '~/models';
+import { createMethods } from './index';
+
+let mongo: MongoMemoryServer;
+let methods: ReturnType<typeof createMethods>;
+const originalStrict = process.env.TENANT_ISOLATION_STRICT;
+
+beforeAll(async () => {
+ mongo = await MongoMemoryServer.create({ instance: { args: ['--nounixsocket'] } });
+ await mongoose.connect(mongo.getUri());
+ createModels(mongoose);
+ methods = createMethods(mongoose);
+});
+
+beforeEach(async () => {
+ process.env.TENANT_ISOLATION_STRICT = 'true';
+ _resetStrictCache();
+ await runAsSystem(async () => mongoose.models.Role.deleteMany({}));
+});
+
+afterAll(async () => {
+ if (originalStrict === undefined) {
+ delete process.env.TENANT_ISOLATION_STRICT;
+ } else {
+ process.env.TENANT_ISOLATION_STRICT = originalStrict;
+ }
+ _resetStrictCache();
+ await mongoose.disconnect();
+ await mongo?.stop();
+});
+
+it.each([undefined, 'tenant-a'])(
+ 'initializes platform roles without changing a tenant-only USER (caller: %s)',
+ async (tenantId) => {
+ const Role = mongoose.models.Role;
+ await tenantStorage.run({ tenantId: 'tenant-a' }, async () =>
+ Role.collection.insertOne({
+ name: SystemRoles.USER,
+ tenantId: 'tenant-a',
+ permissions: {
+ AGENTS: { SHARED_GLOBAL: false },
+ PROMPTS: { SHARED_GLOBAL: false },
+ },
+ }),
+ );
+ const before = await tenantStorage.run({ tenantId: 'tenant-a' }, async () =>
+ Role.collection.findOne({ name: SystemRoles.USER, tenantId: 'tenant-a' }),
+ );
+
+ await tenantStorage.run({ tenantId }, async () => methods.initializeRoles());
+
+ const roles = await runAsSystem(async () => Role.find({}).lean());
+ const platformRoles = roles.filter((role) => !role.tenantId);
+ expect(platformRoles.map((role) => role.name).sort()).toEqual([
+ SystemRoles.ADMIN,
+ SystemRoles.USER,
+ ]);
+ const after = await tenantStorage.run({ tenantId: 'tenant-a' }, async () =>
+ Role.collection.findOne({ name: SystemRoles.USER, tenantId: 'tenant-a' }),
+ );
+ expect(after).toEqual(before);
+ },
+);
+
+it.each([undefined, null, ''])(
+ 'migrates only platform legacy permissions (tenantId: %s)',
+ async (tenantId) => {
+ const Role = mongoose.models.Role;
+ await runAsSystem(async () =>
+ Role.collection.insertOne({
+ name: SystemRoles.USER,
+ ...(tenantId === undefined ? {} : { tenantId }),
+ permissions: { AGENTS: { SHARED_GLOBAL: false } },
+ }),
+ );
+
+ await runAsSystem(async () => methods.initializeRoles());
+
+ const platform = await runAsSystem(async () =>
+ Role.collection.findOne({ name: SystemRoles.USER }),
+ );
+ expect(platform?.permissions.AGENTS.SHARE).toBe(false);
+ expect(platform?.permissions.AGENTS).not.toHaveProperty('SHARED_GLOBAL');
+ },
+);
+
+it.each([undefined, 'tenant-a'])(
+ 'upgrades the platform USER when a tenant USER was inserted first (caller: %s)',
+ async (tenantId) => {
+ const Role = mongoose.models.Role;
+ const tenantRoleId = new mongoose.Types.ObjectId();
+ const platformRoleId = new mongoose.Types.ObjectId();
+ await runAsSystem(async () =>
+ Role.collection.insertMany([
+ {
+ _id: tenantRoleId,
+ name: SystemRoles.USER,
+ tenantId: 'tenant-a',
+ permissions: {
+ AGENTS: { SHARED_GLOBAL: true },
+ PROMPTS: { SHARED_GLOBAL: true },
+ },
+ },
+ {
+ _id: platformRoleId,
+ name: SystemRoles.USER,
+ permissions: {
+ AGENTS: { SHARED_GLOBAL: false },
+ PROMPTS: { SHARED_GLOBAL: false },
+ },
+ },
+ ]),
+ );
+ const before = await Role.collection.findOne({ _id: tenantRoleId });
+
+ await tenantStorage.run({ tenantId }, async () => methods.initializeRoles());
+
+ expect(await Role.collection.findOne({ _id: tenantRoleId })).toEqual(before);
+ const platform = await Role.collection.findOne({ _id: platformRoleId });
+ for (const permissionType of ['AGENTS', 'PROMPTS']) {
+ expect(platform?.permissions[permissionType].SHARE).toBe(false);
+ expect(platform?.permissions[permissionType]).not.toHaveProperty('SHARED_GLOBAL');
+ expect(platform?.permissions[permissionType].USE).toBeDefined();
+ }
+ expect(await runAsSystem(async () => Role.countDocuments({}))).toBe(3);
+ },
+);
diff --git a/packages/data-schemas/src/methods/role.ts b/packages/data-schemas/src/methods/role.ts
index 3074349265..80bded7f08 100644
--- a/packages/data-schemas/src/methods/role.ts
+++ b/packages/data-schemas/src/methods/role.ts
@@ -104,70 +104,76 @@ export function createRoleMethods(
}
/**
- * Initialize default roles in the system.
+ * Initialize platform default roles, never tenant copies, regardless of caller context.
* Creates the default roles (ADMIN, USER) if they don't exist in the database.
* Updates existing roles with new permission types if they're missing.
*/
async function initializeRoles(): Promise<void> {
- const Role = mongoose.models.Role;
+ return runAsSystem(async () => {
+ const Role = mongoose.models.Role;
- for (const roleName of [SystemRoles.ADMIN, SystemRoles.USER]) {
- // Strict mode hides off-schema SHARED_GLOBAL and won't $unset it on save; migrate it via the raw driver.
- // eslint-disable-next-line no-restricted-syntax -- Role is a global (non-tenant) collection; raw read is required to see the off-schema field.
- const legacyDoc = await Role.collection.findOne({ name: roleName });
- if (legacyDoc?.permissions) {
- const set: Record<string, unknown> = {};
- const unset: Record<string, ''> = {};
- for (const permType of ['PROMPTS', 'AGENTS']) {
- const block = legacyDoc.permissions[permType];
- if (block && 'SHARED_GLOBAL' in block) {
- if (!('SHARE' in block)) {
- set[`permissions.${permType}.SHARE`] = block.SHARED_GLOBAL;
+ for (const roleName of [SystemRoles.ADMIN, SystemRoles.USER]) {
+ // Strict mode hides off-schema SHARED_GLOBAL and won't $unset it on save; migrate it via the raw driver.
+ const filter = roleDocumentFilter(roleName, 'initializeRoles');
+ // eslint-disable-next-line no-restricted-syntax -- Platform-only filter; raw read exposes the off-schema field.
+ const legacyDoc = await Role.collection.findOne(filter);
+ if (legacyDoc?.permissions) {
+ const set: Record<string, unknown> = {};
+ const unset: Record<string, ''> = {};
+ for (const permType of ['PROMPTS', 'AGENTS']) {
+ const block = legacyDoc.permissions[permType];
+ if (block && 'SHARED_GLOBAL' in block) {
+ if (!('SHARE' in block)) {
+ set[`permissions.${permType}.SHARE`] = block.SHARED_GLOBAL;
+ }
+ unset[`permissions.${permType}.SHARED_GLOBAL`] = '';
}
- unset[`permissions.${permType}.SHARED_GLOBAL`] = '';
}
- }
- if (Object.keys(unset).length) {
- const update: Record<string, unknown> = { $unset: unset };
- if (Object.keys(set).length) {
- update.$set = set;
+ if (Object.keys(unset).length) {
+ const update: Record<string, unknown> = { $unset: unset };
+ if (Object.keys(set).length) {
+ update.$set = set;
+ }
+ // eslint-disable-next-line no-restricted-syntax -- Platform-only filter; raw $unset drops the off-schema field.
+ await Role.collection.updateOne({ ...filter, _id: legacyDoc._id }, update);
}
- // eslint-disable-next-line no-restricted-syntax -- Role is a global (non-tenant) collection; raw $unset is required to drop the off-schema field.
- await Role.collection.updateOne({ name: roleName }, update);
}
- }
- let role = await Role.findOne({ name: roleName });
- const defaultPerms = roleDefaults[roleName].permissions;
+ let role = await Role.findOne(filter);
+ const defaultPerms = roleDefaults[roleName].permissions;
- if (!role) {
- role = new Role({ ...roleDefaults[roleName], description: '' });
- } else {
- if (role.description == null) {
- role.description = '';
- }
- const permissions = role.toObject()?.permissions ?? {};
- role.permissions = role.permissions || {};
- for (const permType of Object.keys(defaultPerms)) {
- const defaultBlock = defaultPerms[permType as keyof typeof defaultPerms] as Record<
- string,
- unknown
- >;
- const existingBlock = permissions[permType] as Record<string, unknown> | null | undefined;
- if (existingBlock == null) {
- role.permissions[permType] = defaultBlock;
- continue;
+ if (!role) {
+ role = new Role({ ...roleDefaults[roleName], description: '' });
+ } else {
+ if (role.description == null) {
+ role.description = '';
}
- const mergedBlock: Record<string, unknown> = { ...existingBlock };
- for (const field of Object.keys(defaultBlock)) {
- if (mergedBlock[field] == null) {
- mergedBlock[field] = defaultBlock[field];
+ const permissions = role.toObject()?.permissions ?? {};
+ role.permissions = role.permissions || {};
+ for (const permType of Object.keys(defaultPerms)) {
+ const defaultBlock = defaultPerms[permType as keyof typeof defaultPerms] as Record<
+ string,
+ unknown
+ >;
+ const existingBlock = permissions[permType] as
+ | Record<string, unknown>
+ | null
+ | undefined;
+ if (existingBlock == null) {
+ role.permissions[permType] = defaultBlock;
+ continue;
}
+ const mergedBlock: Record<string, unknown> = { ...existingBlock };
+ for (const field of Object.keys(defaultBlock)) {
+ if (mergedBlock[field] == null) {
+ mergedBlock[field] = defaultBlock[field];
+ }
+ }
+ role.permissions[permType] = mergedBlock;
}
- role.permissions[permType] = mergedBlock;
}
+ await role.save();
}
- await role.save();
- }
+ });
}
/**