From b83bcdc57247ff0bcb3b66137a1157fd1003129d Mon Sep 17 00:00:00 2001 From: Dustin Healy <54083382+dustinhealy@users.noreply.github.com> Date: Tue, 10 Nov 2026 21:04:07 -0800 Subject: [PATCH] =?UTF-8?q?=F0=9F=97=84=EF=B8=8F=20fix:=20Restore=20Transa?= =?UTF-8?q?ction=20Capability=20Detection=20(#17735)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix: restore transaction capability detection * fix: keep authorization and response reads on the primary --- .../accessControlService.transactions.spec.ts | 166 ++++++++++++++++++ packages/api/src/acl/accessControlService.ts | 13 +- .../data-schemas/src/methods/accessRole.ts | 38 +++- packages/data-schemas/src/methods/response.ts | 8 +- .../responseScope.transactions.spec.ts | 152 ++++++++++++++++ .../data-schemas/src/methods/responseScope.ts | 8 +- packages/data-schemas/src/models/response.ts | 3 +- .../data-schemas/src/models/responseScope.ts | 3 +- .../src/utils/transactions.spec.ts | 125 ++++++++++++- .../data-schemas/src/utils/transactions.ts | 13 +- 10 files changed, 503 insertions(+), 26 deletions(-) create mode 100644 packages/api/src/acl/accessControlService.transactions.spec.ts create mode 100644 packages/data-schemas/src/methods/responseScope.transactions.spec.ts diff --git a/packages/api/src/acl/accessControlService.transactions.spec.ts b/packages/api/src/acl/accessControlService.transactions.spec.ts new file mode 100644 index 0000000000..f3eb9e60b7 --- /dev/null +++ b/packages/api/src/acl/accessControlService.transactions.spec.ts @@ -0,0 +1,166 @@ +import mongoose from 'mongoose'; +import { randomUUID } from 'node:crypto'; +import { MongoMemoryServer, MongoMemoryReplSet } from 'mongodb-memory-server'; +import { ResourceType, AccessRoleIds, PrincipalType } from 'librechat-data-provider'; +import { + createModels, + createMethods, + supportsTransactions, + tenantStorage, + RoleBits, +} from '@librechat/data-schemas'; +import { AccessControlService } from './accessControlService'; + +const backends = ['standalone', 'replica', ...(process.env.FERRETDB_URI ? ['ferret'] : [])]; + +describe.each(backends)('ACL updates on %s with secondaryPreferred defaults', (backend) => { + const db = new mongoose.Mongoose(); + let server: MongoMemoryServer | MongoMemoryReplSet | undefined; + let service: AccessControlService; + const roleReads: Array<{ address: string; inTransaction: boolean }> = []; + const resourceId = new mongoose.Types.ObjectId(); + const userId = new mongoose.Types.ObjectId(); + const grantedBy = new mongoose.Types.ObjectId(); + const request = { + resourceType: ResourceType.AGENT, + resourceId, + grantedBy, + updatedPrincipals: [ + { + type: PrincipalType.USER, + id: userId.toString(), + accessRoleId: AccessRoleIds.AGENT_VIEWER, + }, + ], + }; + + beforeAll(async () => { + if (backend !== 'ferret') { + server = + backend === 'replica' + ? await MongoMemoryReplSet.create({ replSet: { count: 2 } }) + : await MongoMemoryServer.create(); + } + await db.connect(server?.getUri() ?? process.env.FERRETDB_URI!, { + dbName: `acl_transactions_${randomUUID().replaceAll('-', '')}`, + readPreference: 'secondaryPreferred', + autoIndex: false, + monitorCommands: true, + }); + createModels(db); + await Promise.all( + ['AclEntry', 'AccessRole', 'Role', 'ResourceLock'].map((name) => + db.model(name).createIndexes(), + ), + ); + await createMethods(db).seedDefaultRoles(); + service = new AccessControlService(db); + db.connection.getClient().on('commandStarted', (event) => { + if ( + event.commandName === 'find' && + event.command.find === db.model('AccessRole').collection.name + ) { + roleReads.push({ + address: event.address, + inTransaction: event.command.autocommit === false, + }); + } + }); + }, 60000); + + beforeEach(async () => { + await db.model('AclEntry').deleteMany({}); + roleReads.length = 0; + }); + + afterAll(async () => { + if (db.connection.readyState === 1) await db.connection.dropDatabase(); + await db.disconnect(); + await server?.stop(); + }); + + it('detects the real capability and commits a permission update', async () => { + await expect(supportsTransactions(db)).resolves.toBe(backend === 'replica'); + await service.bulkUpdateResourcePermissions(request); + expect( + await db + .model('AclEntry') + .countDocuments({ resourceId, principalId: userId }) + .read('primary'), + ).toBe(1); + if (backend === 'replica') { + const hello = await db.connection + .db!.admin() + .command({ hello: 1 }, { readPreference: 'primary' }); + expect(roleReads).toEqual([{ address: hello.primary, inTransaction: true }]); + } + }); + + it('keeps the existing permission when the audited write is refused', async () => { + await service.bulkUpdateResourcePermissions(request); + await expect( + service.bulkUpdateResourcePermissions({ + resourceType: ResourceType.AGENT, + resourceId, + grantedBy, + revokedPrincipals: [{ type: PrincipalType.USER, id: userId.toString() }], + beforeWrite: async () => { + throw new Error('audit unavailable'); + }, + }), + ).rejects.toThrow('audit unavailable'); + expect( + await db + .model('AclEntry') + .countDocuments({ resourceId, principalId: userId }) + .read('primary'), + ).toBe(1); + }); + + if (backend === 'replica') { + it('leaves a caller-owned transaction open for rollback', async () => { + const session = await db.startSession(); + session.startTransaction({ readPreference: 'primary' }); + try { + await service.bulkUpdateResourcePermissions({ ...request, session }); + expect(session.inTransaction()).toBe(true); + expect(await db.model('AclEntry').countDocuments({ resourceId }).read('primary')).toBe(0); + await session.abortTransaction(); + expect(await db.model('AclEntry').countDocuments({ resourceId }).read('primary')).toBe(0); + } finally { + await session.endSession(); + } + }); + it('resolves a tenant role override inside the caller-owned transaction', async () => { + const tenantId = 'role-transaction'; + const session = await db.startSession(); + session.startTransaction({ readPreference: 'primary' }); + try { + await tenantStorage.run({ tenantId }, async () => { + await db.model('AccessRole').create( + [ + { + accessRoleId: AccessRoleIds.AGENT_VIEWER, + name: 'Tenant viewer override', + resourceType: ResourceType.AGENT, + permBits: RoleBits.EDITOR, + tenantId, + }, + ], + { session }, + ); + await service.bulkUpdateResourcePermissions({ ...request, session }); + const entry = await db + .model('AclEntry') + .findOne({ resourceId, principalId: userId }) + .session(session); + expect(entry?.permBits).toBe(RoleBits.EDITOR); + expect(session.inTransaction()).toBe(true); + }); + } finally { + await session.abortTransaction(); + await session.endSession(); + } + }); + } +}); diff --git a/packages/api/src/acl/accessControlService.ts b/packages/api/src/acl/accessControlService.ts index 8eba61c282..3d8ea68588 100644 --- a/packages/api/src/acl/accessControlService.ts +++ b/packages/api/src/acl/accessControlService.ts @@ -573,7 +573,7 @@ export class AccessControlService { } if (!localSession && supportsTransactions) { localSession = await this._mongoose.startSession(); - localSession.startTransaction(); + localSession.startTransaction({ readPreference: 'primary' }); shouldEndSession = true; } const sessionOptions = localSession ? { session: localSession } : {}; @@ -607,8 +607,8 @@ export class AccessControlService { /** An invalid id is reported per principal below. */ } } - const [roles, currentEntries] = await Promise.all([ - this._dbMethods.findRolesByResourceType(resourceType), + const loadRoles = () => this._dbMethods.findRolesByResourceType(resourceType, localSession); + const loadEntries = () => affectedPrincipals.length > 0 ? this._dbMethods.findEntriesByPrincipalsAndResource( affectedPrincipals, @@ -617,8 +617,11 @@ export class AccessControlService { localSession, true, ) - : Promise.resolve([]), - ]); + : Promise.resolve([]); + // A transaction cannot run parallel operations on its session. + const [roles, currentEntries] = localSession?.inTransaction() + ? ([await loadRoles(), await loadEntries()] as const) + : await Promise.all([loadRoles(), loadEntries()]); const rolesMap = new Map(roles.map((role) => [role.accessRoleId, role])); const results: BulkPermissionUpdateResult = { granted: [], diff --git a/packages/data-schemas/src/methods/accessRole.ts b/packages/data-schemas/src/methods/accessRole.ts index b471ea0fec..7aa3f3dd86 100644 --- a/packages/data-schemas/src/methods/accessRole.ts +++ b/packages/data-schemas/src/methods/accessRole.ts @@ -1,5 +1,5 @@ import { AccessRoleIds, ResourceType } from 'librechat-data-provider'; -import type { Model, Types, DeleteResult } from 'mongoose'; +import type { Model, Types, ClientSession, DeleteResult } from 'mongoose'; import type { IAccessRole } from '~/types'; import { getTenantId, runAsSystem, SYSTEM_TENANT_ID } from '~/config/tenantContext'; import { RoleBits } from '~/common'; @@ -12,8 +12,14 @@ export function createAccessRoleMethods(mongoose: typeof import('mongoose')): { ) => Promise; deleteRole: (accessRoleId: string | Types.ObjectId) => Promise; seedDefaultRoles: () => Promise>; - findRoleByIdentifier: (accessRoleId: string | Types.ObjectId) => Promise; - findRolesByResourceType: (resourceType: string) => Promise; + findRoleByIdentifier: ( + accessRoleId: string | Types.ObjectId, + session?: ClientSession, + ) => Promise; + findRolesByResourceType: ( + resourceType: string, + session?: ClientSession, + ) => Promise; } { /** True inside a tenant's own context; false with no context or a system one. */ function inTenantScope(): boolean { @@ -41,7 +47,7 @@ export function createAccessRoleMethods(mongoose: typeof import('mongoose')): { * * The unique index on `(accessRoleId, tenantId)` makes the substitution unambiguous. */ - async function visibleTenantRoles(): Promise { + async function visibleTenantRoles(session?: ClientSession): Promise { const tenantId = getTenantId(); const AccessRole = mongoose.models.AccessRole as Model; @@ -49,6 +55,8 @@ export function createAccessRoleMethods(mongoose: typeof import('mongoose')): { * query inside it. MongoDB's null match includes absent tenantId fields. */ const roles = await runAsSystem(async () => AccessRole.find({ tenantId: { $in: [tenantId, null] } }) + .session(session ?? null) + .read('primary') .lean() .exec(), ); @@ -70,12 +78,17 @@ export function createAccessRoleMethods(mongoose: typeof import('mongoose')): { */ async function findRoleByIdentifier( accessRoleId: string | Types.ObjectId, + session?: ClientSession, ): Promise { const AccessRole = mongoose.models.AccessRole as Model; if (!inTenantScope()) { - return await AccessRole.findOne({ accessRoleId }).lean().exec(); + return await AccessRole.findOne({ accessRoleId }) + .session(session ?? null) + .read('primary') + .lean() + .exec(); } - const roles = await visibleTenantRoles(); + const roles = await visibleTenantRoles(session); return roles.find((role) => String(role.accessRoleId) === String(accessRoleId)) ?? null; } @@ -88,16 +101,23 @@ export function createAccessRoleMethods(mongoose: typeof import('mongoose')): { * @param resourceType - The type of resource ('agent', 'project', 'file') * @returns Array of role documents */ - async function findRolesByResourceType(resourceType: string): Promise { + async function findRolesByResourceType( + resourceType: string, + session?: ClientSession, + ): Promise { const AccessRole = mongoose.models.AccessRole as Model; if (!inTenantScope()) { - return await AccessRole.find({ resourceType }).lean().exec(); + return await AccessRole.find({ resourceType }) + .session(session ?? null) + .read('primary') + .lean() + .exec(); } /** Filtered after the merge, so a tenant copy that moves an identifier to another * resource type withdraws the global row from this list instead of leaving it * visible — and callers such as `bulkUpdatePermissions`, which key this result by * `accessRoleId`, cannot grant bits the tenant has superseded. */ - const roles = await visibleTenantRoles(); + const roles = await visibleTenantRoles(session); return roles.filter((role) => role.resourceType === resourceType); } diff --git a/packages/data-schemas/src/methods/response.ts b/packages/data-schemas/src/methods/response.ts index 79f10d76ef..2c066c46da 100644 --- a/packages/data-schemas/src/methods/response.ts +++ b/packages/data-schemas/src/methods/response.ts @@ -346,7 +346,9 @@ export function createResponseStorage( if (!current) return conflict; const keys = responseScopeKeys(owner, current.conversationId); await initializeResponseScopes(mongoose, keys); - const session = await mongoose.startSession(); + const session = await mongoose.startSession({ + defaultTransactionOptions: { readPreference: 'primary' }, + }); try { let result = conflict; await session.withTransaction(async () => { @@ -757,7 +759,9 @@ export function createResponseStorage( const prior = await model.findOne(filter).select('conversationId').lean(); const keys = responseScopeKeys(input, prior?.conversationId ?? input.conversationId); await initializeResponseScopes(mongoose, keys); - const session = await mongoose.startSession(); + const session = await mongoose.startSession({ + defaultTransactionOptions: { readPreference: 'primary' }, + }); try { let result: ResponseReservationResult | undefined; await session.withTransaction(async () => { diff --git a/packages/data-schemas/src/methods/responseScope.transactions.spec.ts b/packages/data-schemas/src/methods/responseScope.transactions.spec.ts new file mode 100644 index 0000000000..3d1947ff31 --- /dev/null +++ b/packages/data-schemas/src/methods/responseScope.transactions.spec.ts @@ -0,0 +1,152 @@ +import mongoose from 'mongoose'; +import { MongoMemoryReplSet } from 'mongodb-memory-server'; +import { + createResponseRetention, + createResponseConversationReplacement, + closeResponseScopes, +} from './responseScope'; +import { tenantStorage } from '~/config/tenantContext'; +import { createResponseStorage } from './response'; +import { createModels } from '~/models'; + +describe('Response transaction owners with secondaryPreferred defaults', () => { + const db = new mongoose.Mongoose(); + const owner = { userId: 'owner', tenantId: 'tenant' }; + const scoped = (work: () => Promise) => + tenantStorage.run({ tenantId: owner.tenantId }, work); + let mongo: MongoMemoryReplSet; + let secondary: mongoose.mongo.MongoClient; + + async function withReplicationPaused(work: () => Promise): Promise { + await db.connection + .db!.collection('replication_barrier') + .insertOne({}, { writeConcern: { w: 'majority' } }); + const admin = secondary.db('admin'); + const configured = await admin.command({ + configureFailPoint: 'stopReplProducer', + mode: 'alwaysOn', + }); + try { + await admin.command({ + waitForFailPoint: 'stopReplProducer', + timesEntered: configured.count + 1, + maxTimeMS: 10000, + }); + return await work(); + } finally { + await admin.command({ configureFailPoint: 'stopReplProducer', mode: 'off' }); + } + } + + beforeAll(async () => { + mongo = await MongoMemoryReplSet.create({ + replSet: { count: 2 }, + instanceOpts: [ + { args: ['--setParameter', 'enableTestCommands=1'] }, + { args: ['--setParameter', 'enableTestCommands=1'] }, + ], + }); + await db.connect(mongo.getUri(), { + readPreference: 'secondaryPreferred', + autoIndex: false, + writeConcern: { w: 1 }, + }); + createModels(db); + await Promise.all( + [ + 'StoredResponse', + 'ResponseScope', + 'ChannelReply', + 'ChannelFeedback', + 'ChannelFeedbackEvent', + ].map((name) => db.model(name).createCollection()), + ); + await db.model('StoredResponse').createIndexes(); + const hello = await db.connection + .db!.admin() + .command({ hello: 1 }, { readPreference: 'primary' }); + const address = (hello.hosts as string[]).find((host) => host !== hello.primary); + if (!address) throw new Error('Missing secondary fixture'); + secondary = new mongoose.mongo.MongoClient(`mongodb://${address}`, { + directConnection: true, + readPreference: 'secondary', + }); + await secondary.connect(); + }, 60000); + + afterAll(async () => { + await secondary?.close(); + await db.disconnect(); + await mongo?.stop(); + }); + + it('reserves, mutates and retains a response through its real owned transactions', async () => + scoped(() => + withReplicationPaused(async () => { + const storage = createResponseStorage(db); + const result = await storage.reserve({ + ...owner, + dispatch: true, + responseId: 'resp_reader_default', + requestKey: 'reader-default', + fingerprint: 'same-request', + agentId: 'agent', + requestJSON: JSON.stringify({ model: 'agent', input: 'hello', background: true }), + conversationId: 'conversation', + parentMessageId: 'root', + }); + expect(result.ok).toBe(true); + expect( + await secondary + .db(db.connection.name) + .collection(db.model('StoredResponse').collection.name) + .findOne({ responseId: 'resp_reader_default' }), + ).toBeNull(); + expect( + await storage.settleDispatch(owner, 'resp_reader_default', { + kind: 'create', + id: 'resp_reader_default', + }), + ).toBe(true); + expect( + (await storage.requestCancellation(owner, 'resp_reader_default', 123)) + ?.cancellationRequestedAt, + ).toBe(123); + const expiry = new Date(Date.now() + 60000); + await createResponseRetention(db)(owner, 'conversation', expiry); + expect((await storage.read(owner, 'resp_reader_default'))?.expiredAt).toEqual(expiry); + expect(await createResponseConversationReplacement(db)(owner, 'conversation')).toBe(false); + expect(await createResponseConversationReplacement(db)(owner, 'unused-conversation')).toBe( + true, + ); + }), + )); + + it('observes closure even while the secondary still exposes the live response', async () => + scoped(async () => { + const storage = createResponseStorage(db); + await storage.reserve({ + ...owner, + responseId: 'resp_closure', + requestKey: 'closure', + fingerprint: 'closure', + agentId: 'agent', + requestJSON: '{}', + conversationId: 'closed-conversation', + parentMessageId: 'root', + }); + await withReplicationPaused(async () => { + await closeResponseScopes(db, owner, ['closed-conversation']); + expect( + await secondary + .db(db.connection.name) + .collection(db.model('StoredResponse').collection.name) + .findOne({ responseId: 'resp_closure' }), + ).not.toBeNull(); + expect(await storage.read(owner, 'resp_closure')).toBeNull(); + expect((await storage.readCleanupIdentity(owner, 'resp_closure'))?.retirement).toBe( + 'conversation_deleted', + ); + }); + })); +}); diff --git a/packages/data-schemas/src/methods/responseScope.ts b/packages/data-schemas/src/methods/responseScope.ts index d0c6a0b973..e4a1a36a2c 100644 --- a/packages/data-schemas/src/methods/responseScope.ts +++ b/packages/data-schemas/src/methods/responseScope.ts @@ -29,7 +29,9 @@ export function createResponseConversationReplacement( } const key = responseScopeKeys(owner, conversationId)[1]; await initializeResponseScopes(mongoose, [key]); - const session = await mongoose.startSession(); + const session = await mongoose.startSession({ + defaultTransactionOptions: { readPreference: 'primary' }, + }); try { let allowed = false; await session.withTransaction(async () => { @@ -123,7 +125,9 @@ export function createResponseRetention( }; if (parentSession) return apply(parentSession); if (!supported) return apply(); - const session = await mongoose.startSession(); + const session = await mongoose.startSession({ + defaultTransactionOptions: { readPreference: 'primary' }, + }); try { await session.withTransaction(() => apply(session)); } finally { diff --git a/packages/data-schemas/src/models/response.ts b/packages/data-schemas/src/models/response.ts index 0526d3930b..3402f457e2 100644 --- a/packages/data-schemas/src/models/response.ts +++ b/packages/data-schemas/src/models/response.ts @@ -213,7 +213,8 @@ export function createStoredResponseModel( required: false, }, }, - { timestamps: true, minimize: false }, + // This journal drives admission and recovery; stale replica reads are not authoritative. + { timestamps: true, minimize: false, read: 'primary' }, ); schema.index({ tenantId: 1, userId: 1, responseId: 1 }, { unique: true }); schema.index({ expiredAt: 1 }, { expireAfterSeconds: 0 }); diff --git a/packages/data-schemas/src/models/responseScope.ts b/packages/data-schemas/src/models/responseScope.ts index a705b8d227..2d31cea8d0 100644 --- a/packages/data-schemas/src/models/responseScope.ts +++ b/packages/data-schemas/src/models/responseScope.ts @@ -20,7 +20,8 @@ export function createResponseScopeModel( revision: { type: Number, required: true, default: 0 }, expiredAt: Date, }, - { versionKey: false }, + // Closure and retention must be observed before any durable data is disclosed or mutated. + { versionKey: false, read: 'primary' }, ); return mongoose.model('ResponseScope', schema); } diff --git a/packages/data-schemas/src/utils/transactions.spec.ts b/packages/data-schemas/src/utils/transactions.spec.ts index 7013bd2a45..d198da9420 100644 --- a/packages/data-schemas/src/utils/transactions.spec.ts +++ b/packages/data-schemas/src/utils/transactions.spec.ts @@ -1,4 +1,8 @@ -import { getTransactionSupport } from './transactions'; +import mongoose from 'mongoose'; +import { MongoMemoryServer, MongoMemoryReplSet } from 'mongodb-memory-server'; +import { getTransactionSupport, supportsTransactions } from './transactions'; + +jest.mock('~/config/winston', () => ({ debug: jest.fn() })); describe('getTransactionSupport', () => { // The cache-hit path does not touch the database, so a stub mongoose is fine. @@ -9,3 +13,122 @@ describe('getTransactionSupport', () => { await expect(getTransactionSupport(mongoose, false)).resolves.toBe(false); }); }); + +describe('transaction capability against real MongoDB', () => { + const standalone = new mongoose.Mongoose(); + const replica = new mongoose.Mongoose(); + let mongo: MongoMemoryServer; + let repl: MongoMemoryReplSet; + + beforeAll(async () => { + [mongo, repl] = await Promise.all([ + MongoMemoryServer.create(), + MongoMemoryReplSet.create({ replSet: { count: 1 } }), + ]); + await Promise.all([ + standalone.connect(mongo.getUri()), + replica.connect(repl.getUri(), { readPreference: 'secondaryPreferred' }), + ]); + }, 60000); + + afterEach(() => jest.restoreAllMocks()); + + afterAll(async () => { + await Promise.all([standalone.disconnect(), replica.disconnect()]); + await Promise.all([mongo?.stop(), repl?.stop()]); + }); + + it('returns false for standalone MongoDB without writing probe data', async () => { + await expect(supportsTransactions(standalone)).resolves.toBe(false); + expect( + await standalone.connection.db!.collection('__transaction_test__').countDocuments(), + ).toBe(0); + }); + + it('supports transactions despite a secondaryPreferred client default', async () => { + await expect(supportsTransactions(replica)).resolves.toBe(true); + }); + + it('shares an inflight probe only within the same connection', async () => { + const replicaSessions = jest.spyOn(replica, 'startSession'); + const standaloneSessions = jest.spyOn(standalone, 'startSession'); + await expect( + Promise.all([ + getTransactionSupport(replica, null), + getTransactionSupport(replica, null), + getTransactionSupport(standalone, null), + ]), + ).resolves.toEqual([true, true, false]); + expect(replicaSessions).toHaveBeenCalledTimes(1); + expect(standaloneSessions).toHaveBeenCalledTimes(1); + }); + + it('propagates a failed shared probe and retries after recovery', async () => { + const failure = new mongoose.mongo.MongoNetworkError('probe connection lost'); + const sessions = jest.spyOn(replica, 'startSession').mockRejectedValueOnce(failure); + const results = await Promise.allSettled([ + getTransactionSupport(replica, null), + getTransactionSupport(replica, null), + ]); + expect(results).toEqual([ + { status: 'rejected', reason: failure }, + { status: 'rejected', reason: failure }, + ]); + expect(sessions).toHaveBeenCalledTimes(1); + await expect(getTransactionSupport(replica, null)).resolves.toBe(true); + expect(sessions).toHaveBeenCalledTimes(2); + }); + + it.each([ + [59, "no such command: 'commitTransaction'", false], + [59, "no such command: 'find'", true], + [20, 'an unrelated illegal operation', true], + [13, 'not authorized', true], + [18, 'authentication failed', true], + ])( + 'classifies commit failure %i (%s) without hiding operational errors', + async (code, errmsg, throws) => { + const session = await replica.startSession(); + jest.spyOn(replica, 'startSession').mockResolvedValueOnce(session); + const end = jest.spyOn(session, 'endSession'); + const error = new mongoose.mongo.MongoServerError({ code, errmsg }); + jest.spyOn(session, 'commitTransaction').mockRejectedValueOnce(error); + if (throws) await expect(supportsTransactions(replica)).rejects.toBe(error); + else await expect(supportsTransactions(replica)).resolves.toBe(false); + expect(end).toHaveBeenCalledTimes(1); + }, + ); + + it('retries a missing DocumentDB probe namespace after concurrent initialization', async () => { + const session = await replica.startSession(); + const starts = jest.spyOn(replica, 'startSession').mockResolvedValueOnce(session); + jest.spyOn(session, 'commitTransaction').mockRejectedValueOnce( + new mongoose.mongo.MongoServerError({ + code: 263, + errmsg: 'non-existent collection in transaction', + }), + ); + const create = jest + .spyOn(replica.connection.db!, 'createCollection') + .mockRejectedValueOnce( + new mongoose.mongo.MongoServerError({ code: 48, errmsg: 'namespace already exists' }), + ); + await expect(supportsTransactions(replica)).resolves.toBe(true); + expect(create).toHaveBeenCalledWith('__transaction_test__'); + expect(starts).toHaveBeenCalledTimes(2); + }); + + it('does not hide operational failure while creating the probe namespace', async () => { + const session = await replica.startSession(); + jest.spyOn(replica, 'startSession').mockResolvedValueOnce(session); + jest.spyOn(session, 'commitTransaction').mockRejectedValueOnce( + new mongoose.mongo.MongoServerError({ + code: 263, + errmsg: 'non-existent collection in transaction', + }), + ); + const error = new mongoose.mongo.MongoServerError({ code: 13, errmsg: 'not authorized' }); + jest.spyOn(replica.connection.db!, 'createCollection').mockRejectedValueOnce(error); + await expect(supportsTransactions(replica)).rejects.toBe(error); + }); +}); diff --git a/packages/data-schemas/src/utils/transactions.ts b/packages/data-schemas/src/utils/transactions.ts index aeb2b6295d..8bccde74ea 100644 --- a/packages/data-schemas/src/utils/transactions.ts +++ b/packages/data-schemas/src/utils/transactions.ts @@ -4,17 +4,20 @@ export const CANCEL_RATE = 1.15; const TRANSACTION_PROBE_COLLECTION = '__transaction_test__'; function unsupportedTransaction(error: unknown, mongoose: typeof import('mongoose')): boolean { + if (!(error instanceof mongoose.mongo.MongoServerError)) return false; return ( - error instanceof mongoose.mongo.MongoServerError && - error.code === 20 && - /Transaction numbers are only allowed on a replica set member or mongos/i.test(error.message) + (error.code === 20 && + /Transaction numbers are only allowed on a replica set member or mongos/i.test( + error.message, + )) || + (error.code === 59 && /^no such command: ['"]commitTransaction['"]$/i.test(error.message)) ); } async function probeTransaction(mongoose: typeof import('mongoose')): Promise { const session = await mongoose.startSession(); try { - session.startTransaction(); + session.startTransaction({ readPreference: 'primary' }); const db = mongoose.connection.db; if (!db) throw new Error('Transaction capability probe requires a connected database'); await db.collection(TRANSACTION_PROBE_COLLECTION).findOne({}, { session }); @@ -33,7 +36,7 @@ async function probeTransaction(mongoose: typeof import('mongoose')): Promise => {