Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript

fix(control-api): preserve unknown commit outcomes for r3-m1

Josué2bd8eaf9347e
diff --git a/control-api/package-lock.json b/control-api/package-lock.json
index da78ca66e..1b6d7666c 100644
--- a/control-api/package-lock.json
+++ b/control-api/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "clerum-control-api",
- "version": "0.1.751",
+ "version": "0.1.752",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "clerum-control-api",
- "version": "0.1.751",
+ "version": "0.1.752",
"dependencies": {
"@clerum/display-field": "file:../packages/display-field",
"@clerum/grok-provider-attempt-contract": "file:../packages/grok-provider-attempt-contract",
diff --git a/control-api/package.json b/control-api/package.json
index 62fe86662..f24fe4a2f 100644
--- a/control-api/package.json
+++ b/control-api/package.json
@@ -1,6 +1,6 @@
{
"name": "clerum-control-api",
- "version": "0.1.751",
+ "version": "0.1.752",
"description": "Internal Clerum control plane REST API + UI for managing CRDs and secrets",
"main": "dist/main.js",
"engines": {
diff --git a/control-api/src/db.ts b/control-api/src/db.ts
index a050a7ca6..264264f68 100644
--- a/control-api/src/db.ts
+++ b/control-api/src/db.ts
@@ -6738,14 +6738,17 @@ export type DbTransactionOptions = {
onCommitOutcomeUnknown?: () => void
}
-function isPostgresErrorResponse(error: unknown): boolean {
+const UNKNOWN_COMMIT_OUTCOME_SQLSTATES = new Set(['08007', '40003'])
+
+function isDefinitivePostgresCommitErrorResponse(error: unknown): boolean {
if (!error || typeof error !== 'object') return false
const response = error as { name?: unknown; code?: unknown; severity?: unknown }
return (
response.name === 'error' &&
typeof response.code === 'string' &&
/^[0-9A-Z]{5}$/.test(response.code) &&
- typeof response.severity === 'string'
+ typeof response.severity === 'string' &&
+ !UNKNOWN_COMMIT_OUTCOME_SQLSTATES.has(response.code)
)
}
@@ -6902,9 +6905,11 @@ export async function withTransaction<T>(
releaseError = rollbackError instanceof Error ? rollbackError : true
}
}
- // A PostgreSQL ErrorResponse proves COMMIT failed. Only a lost transport or
- // malformed response leaves the durable outcome unknown after COMMIT was sent.
- if (commitSent && !transactionFinished && !isPostgresErrorResponse(error)) {
+ // Most PostgreSQL ErrorResponses prove COMMIT failed, but SQLSTATE 08007
+ // (transaction_resolution_unknown) and 40003 (statement_completion_unknown)
+ // explicitly leave the durable outcome uncertain. Lost transport and malformed
+ // responses are uncertain as well.
+ if (commitSent && !transactionFinished && !isDefinitivePostgresCommitErrorResponse(error)) {
options.onCommitOutcomeUnknown?.()
}
signal?.throwIfAborted()
diff --git a/control-api/test/r2h2.passwordResetLostCommit.realPostgres.integration.test.ts b/control-api/test/r2h2.passwordResetLostCommit.realPostgres.integration.test.ts
index 64f49c630..ca7e22984 100644
--- a/control-api/test/r2h2.passwordResetLostCommit.realPostgres.integration.test.ts
+++ b/control-api/test/r2h2.passwordResetLostCommit.realPostgres.integration.test.ts
@@ -293,4 +293,110 @@ realPg('R2-H2 lost password-reset COMMIT acknowledgement on PostgreSQL 16', () =
})
expect(await bcrypt.compare(newPassword, recovered.rows[0].password_hash as string)).toBe(true)
}, 20_000)
+
+ it.each([
+ { sqlState: '08007', name: 'transaction resolution unknown' },
+ { sqlState: '40003', name: 'statement completion unknown' },
+ ])(
+ 'surfaces PostgreSQL $name at COMMIT as an unknown reset outcome',
+ async ({ sqlState }) => {
+ holder.pool = normalPool
+ holder.unknownCommitOutcomes = 0
+ const caseId = sqlState.replace(/[^0-9A-Z]/g, '_')
+ const sequenceName = `r3m1_commit_attempts_${caseId}`
+ const functionName = `reject_r3m1_commit_${caseId}`
+ const triggerName = `reject_r3m1_update_${caseId}`
+ const retryEmail = `r3m1-${caseId}-${randomBytes(8).toString('hex')}@example.invalid`
+ const retryUserHash = await bcrypt.hash(oldPassword, 12)
+ const retryUser = await normalPool.query(
+ 'INSERT INTO users(email, password_hash) VALUES ($1, $2) RETURNING id',
+ [retryEmail, retryUserHash]
+ )
+ const retryUserId = retryUser.rows[0].id as string
+ const reset = await createSilentInvitationForTeams({
+ inviteeName: 'Synthetic R3-M1 member',
+ email: retryEmail,
+ purpose: 'password_reset',
+ teamAssignments: [],
+ fallbackRole: 'member',
+ })
+ const sibling = await createSilentInvitationForTeams({
+ inviteeName: 'Synthetic R3-M1 member',
+ email: retryEmail,
+ purpose: 'password_reset',
+ teamAssignments: [],
+ fallbackRole: 'member',
+ })
+
+ await normalPool.query(`CREATE SEQUENCE ${sequenceName}`)
+ await normalPool.query(`
+ CREATE FUNCTION ${functionName}() RETURNS trigger AS $$
+ BEGIN
+ PERFORM nextval('${sequenceName}');
+ RAISE EXCEPTION 'synthetic ambiguous commit outcome' USING ERRCODE = '${sqlState}';
+ END;
+ $$ LANGUAGE plpgsql
+ `)
+ await normalPool.query(`
+ CREATE CONSTRAINT TRIGGER ${triggerName}
+ AFTER UPDATE ON users DEFERRABLE INITIALLY DEFERRED
+ FOR EACH ROW EXECUTE FUNCTION ${functionName}()
+ `)
+
+ let resetError: unknown
+ try {
+ await setInvitationPasswordForEmail(retryEmail, reset.id, newPassword, retryUserId)
+ } catch (error) {
+ resetError = error
+ }
+ expect(resetError).toMatchObject({
+ status: 503,
+ reason: 'authority_failure',
+ publicError: 'recovery_outcome_unknown',
+ })
+ expect(holder.unknownCommitOutcomes).toBe(1)
+
+ const publicApp = express()
+ publicApp.post('/password-reset', (_req, res) => {
+ if (!sendPasswordAdmissionError(resetError, res)) {
+ res.status(500).json({ error: 'unexpected response contract' })
+ }
+ })
+ const publicResponse = await request(publicApp).post('/password-reset').send({})
+ expect(publicResponse.status).toBe(503)
+ expect(publicResponse.body).toEqual({
+ error: 'recovery_outcome_unknown',
+ retryAfterSeconds: 2,
+ })
+ expect(publicResponse.headers['retry-after']).toBe('2')
+ expect(publicResponse.headers['cache-control']).toBe('no-store')
+ expect(publicResponse.headers['set-cookie']).toBeUndefined()
+
+ const unchanged = await observer.query(
+ `SELECT i.status AS reset_status, sibling.status AS sibling_status,
+ u.password_hash, (SELECT COUNT(*)::int FROM password_verification_work) AS owners
+ FROM invitations i
+ JOIN invitations sibling ON sibling.id = $2
+ JOIN users u ON u.id = $3
+ WHERE i.id = $1`,
+ [reset.id, sibling.id, retryUserId]
+ )
+ expect(unchanged.rows[0]).toMatchObject({
+ reset_status: 'pending',
+ sibling_status: 'pending',
+ owners: 0,
+ password_hash: retryUserHash,
+ })
+ expect(await bcrypt.compare(newPassword, unchanged.rows[0].password_hash as string)).toBe(
+ false
+ )
+ const commitAttempts = await observer.query(`SELECT last_value FROM ${sequenceName}`)
+ expect(Number(commitAttempts.rows[0].last_value)).toBe(1)
+
+ await normalPool.query(`DROP TRIGGER ${triggerName} ON users`)
+ await normalPool.query(`DROP FUNCTION ${functionName}()`)
+ await normalPool.query(`DROP SEQUENCE ${sequenceName}`)
+ },
+ 20_000
+ )
})