Skip to content

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

TypeScript

test(external-rest-api): cover invitation error mappings

Josuéd79ba48238b6
diff --git a/external-rest-api/package-lock.json b/external-rest-api/package-lock.json
index 0208396c1..9df13ec7f 100644
--- a/external-rest-api/package-lock.json
+++ b/external-rest-api/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "clerum-external-rest-api",
- "version": "0.1.114",
+ "version": "0.1.115",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "clerum-external-rest-api",
- "version": "0.1.114",
+ "version": "0.1.115",
"dependencies": {
"@clerum/jwt-key-policy": "file:../packages/jwt-key-policy",
"cors": "^2.8.5",
diff --git a/external-rest-api/package.json b/external-rest-api/package.json
index a81c39f9b..d29b621ad 100644
--- a/external-rest-api/package.json
+++ b/external-rest-api/package.json
@@ -1,6 +1,6 @@
{
"name": "clerum-external-rest-api",
- "version": "0.1.114",
+ "version": "0.1.115",
"description": "External REST API for profile, team management, and RPC token brokerage",
"main": "dist/main.js",
"engines": {
diff --git a/external-rest-api/src/releaseManifest.ts b/external-rest-api/src/releaseManifest.ts
index c11ff3a41..f9b75168b 100644
--- a/external-rest-api/src/releaseManifest.ts
+++ b/external-rest-api/src/releaseManifest.ts
@@ -8,7 +8,7 @@ export type ReleaseManifest = {
export const releaseManifest: ReleaseManifest = {
releaseId: 'v0.11.0',
- externalRestApiVersion: '0.1.114',
+ externalRestApiVersion: '0.1.115',
rpcProxyVersion: '0.1.126',
desktopVersion: '0.11.0',
minimumDesktopVersion: '0.1.252',
diff --git a/external-rest-api/test/r6.invitationProducerMappings.contract.test.ts b/external-rest-api/test/r6.invitationProducerMappings.contract.test.ts
new file mode 100644
index 000000000..0b5321d16
--- /dev/null
+++ b/external-rest-api/test/r6.invitationProducerMappings.contract.test.ts
@@ -0,0 +1,224 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import express from 'express'
+import type { Server } from 'node:http'
+import request from 'supertest'
+import { requireInternalToken } from '../../control-api/src/middleware/internalServiceAuth.js'
+import { createExternalInvitationsRouter } from '../../control-api/src/routes/external/invitations.js'
+import { PasswordAdmissionError } from '../../control-api/src/services/auth/passwordCredentialVerification.js'
+import { config as externalConfig } from '../src/config.js'
+import { createInvitationsRouter } from '../src/routes/invitations.js'
+
+const internalServiceToken = 'Synthetic-R6-Producer-Contract-Token'
+const producerConfig = vi.hoisted(() => ({
+ internalServiceTokens: { 'external-rest-api': 'Synthetic-R6-Producer-Contract-Token' },
+ approvalRlExternalClientIpPerMin: 100,
+ approvalRlExternalEdgePerMin: 100,
+}))
+const flow = vi.hoisted(() => ({ validateInvitationFlowToken: vi.fn() }))
+const directory = vi.hoisted(() => ({
+ acceptInvitationForEmail: vi.fn(),
+ getInvitationByToken: vi.fn(),
+ listPendingInvitations: vi.fn(),
+ setInvitationPasswordForEmail: vi.fn(),
+ setInvitationPasswordForUser: vi.fn(),
+ verifyUserPassword: vi.fn(),
+}))
+const desktopFlow = vi.hoisted(() => ({ storeDesktopAuthorizationToken: vi.fn() }))
+
+vi.mock('../../control-api/src/config.js', () => ({ config: producerConfig }))
+vi.mock('../../control-api/src/utils/auth/externalSessionAuthToken.js', () => ({
+ signExternalSessionToken: () => 'synthetic-producer-session',
+}))
+vi.mock('../../control-api/src/services/directory/index.js', () => directory)
+vi.mock('../../control-api/src/services/invitationFlowRegistrationService.js', () => ({
+ ...flow,
+ ...desktopFlow,
+}))
+vi.mock('../../control-api/src/middleware/rateLimitMiddleware.js', async importOriginal => {
+ const real =
+ await importOriginal<typeof import('../../control-api/src/middleware/rateLimitMiddleware.js')>()
+ return {
+ ...real,
+ rateLimitMiddleware:
+ () => (_req: express.Request, _res: express.Response, next: express.NextFunction) =>
+ next(),
+ }
+})
+vi.mock('../../control-api/src/middleware/externalSessionAuth.js', () => ({
+ rejectBodyUserTeamMismatch: (
+ _req: express.Request,
+ _res: express.Response,
+ next: express.NextFunction
+ ) => next(),
+ requireValidExternalSessionToken: (
+ req: express.Request,
+ _res: express.Response,
+ next: express.NextFunction
+ ) => {
+ ;(req as express.Request & { externalAuth?: unknown }).externalAuth = {
+ userId: 'r6-user',
+ email: '[email protected]',
+ teamId: null,
+ role: 'member',
+ authGeneration: 1,
+ }
+ next()
+ },
+}))
+vi.mock('../src/authToken.js', () => ({
+ verifyToken: () => ({
+ userId: 'r6-user',
+ email: '[email protected]',
+ teamId: '',
+ role: 'member',
+ exp: 4_102_444_800,
+ }),
+}))
+
+const preview = {
+ id: 'r6-reset-row',
+ email: '[email protected]',
+ purpose: 'password_reset',
+ status: 'pending',
+ userId: 'r6-user',
+ teamId: null,
+ teamName: null,
+}
+
+let producerServer: Server
+let previousControlApiBaseUrl: string
+let previousControlApiServiceToken: string
+let previousControlApiServiceName: string
+
+function publicApp() {
+ const app = express()
+ app.use(express.json())
+ app.use(createInvitationsRouter())
+ app.use((error: unknown, _req: express.Request, res: express.Response, _next: unknown) => {
+ res.status(500).json({ error: 'Internal Server Error' })
+ })
+ return app
+}
+
+function producerResponseApp() {
+ const app = express()
+ app.use(express.json())
+ app.use('/api/v1', requireInternalToken, createExternalInvitationsRouter())
+ return app
+}
+
+describe('R6 invitation/password producer response mappings', () => {
+ beforeAll(async () => {
+ previousControlApiBaseUrl = externalConfig.controlApiBaseUrl
+ previousControlApiServiceToken = externalConfig.controlApiServiceToken
+ previousControlApiServiceName = externalConfig.controlApiServiceName
+ producerServer = producerResponseApp().listen(0, '127.0.0.1')
+ await new Promise<void>((resolve, reject) => {
+ producerServer.once('error', reject)
+ producerServer.once('listening', resolve)
+ })
+ const address = producerServer.address()
+ if (!address || typeof address === 'string') throw new Error('producer did not bind TCP')
+ externalConfig.controlApiBaseUrl = `http://127.0.0.1:${address.port}/api/v1`
+ externalConfig.controlApiServiceToken = internalServiceToken
+ externalConfig.controlApiServiceName = 'external-rest-api'
+ })
+
+ afterAll(async () => {
+ externalConfig.controlApiBaseUrl = previousControlApiBaseUrl
+ externalConfig.controlApiServiceToken = previousControlApiServiceToken
+ externalConfig.controlApiServiceName = previousControlApiServiceName
+ if (producerServer) {
+ producerServer.closeAllConnections()
+ await new Promise<void>((resolve, reject) =>
+ producerServer.close(error => (error ? reject(error) : resolve()))
+ )
+ }
+ })
+
+ beforeEach(() => {
+ vi.clearAllMocks()
+ flow.validateInvitationFlowToken.mockImplementation(
+ async (token: string, claimedEmail?: string) => {
+ if (token !== 'r6-reset-proof') throw new Error('invalid proof')
+ if (claimedEmail && claimedEmail.toLowerCase() !== preview.email) {
+ throw new Error('wrong email')
+ }
+ return { email: preview.email, invitationUuid: 'r6-producer-invitation-token' }
+ }
+ )
+ directory.getInvitationByToken.mockResolvedValue(preview)
+ })
+
+ it.each([
+ [
+ 'invalid password',
+ { error: 'invalid_password' },
+ 400,
+ { error: 'Password must be between 8 and 256 characters' },
+ ],
+ ['invalid proof', { error: 'invalid_invitation' }, 400, { error: 'invalid_invitation' }],
+ ['retired member', { error: 'user_retired' }, 400, { error: 'invalid_invitation' }],
+ [
+ 'wrong invitation binding',
+ { error: 'forbidden' },
+ 403,
+ { error: 'Invitation is invalid or unavailable' },
+ ],
+ ['missing invitation', { error: 'not_found' }, 404, { error: 'Invitation not found' }],
+ [
+ 'redeemed invitation',
+ { error: 'not_pending' },
+ 409,
+ { error: 'Invitation has already been used' },
+ ],
+ ['expired invitation', { error: 'expired' }, 410, { error: 'Invitation has expired' }],
+ ])(
+ 'maps the producer %s domain response to the public contract',
+ async (label, result, status, body) => {
+ if (label === 'invalid proof') {
+ flow.validateInvitationFlowToken.mockRejectedValue(new Error('invalid proof'))
+ } else {
+ directory.setInvitationPasswordForEmail.mockResolvedValue(result)
+ }
+
+ const response = await request(publicApp()).post('/invitations/password').send({
+ token: 'r6-reset-proof',
+ email: preview.email,
+ invitationId: preview.id,
+ password: 'R6-synthetic-valid-password',
+ })
+
+ expect(response.status).toBe(status)
+ expect(response.body).toEqual(body)
+ expect(response.headers['set-cookie']).toBeUndefined()
+ expect(JSON.stringify(response.body)).not.toMatch(
+ /r6-reset-proof|producer-invitation|sql|stack/i
+ )
+ if (label !== 'invalid proof') {
+ expect(directory.setInvitationPasswordForEmail).toHaveBeenCalledOnce()
+ } else {
+ expect(directory.setInvitationPasswordForEmail).not.toHaveBeenCalled()
+ }
+ }
+ )
+
+ it('preserves bounded admission responses from the real Control API route', async () => {
+ directory.setInvitationPasswordForEmail.mockRejectedValueOnce(
+ new PasswordAdmissionError(429, 17, 'verification_busy')
+ )
+
+ const response = await request(publicApp()).post('/invitations/password').send({
+ token: 'r6-reset-proof',
+ email: preview.email,
+ invitationId: preview.id,
+ password: 'R6-synthetic-valid-password',
+ })
+
+ expect(response.status).toBe(429)
+ expect(response.body).toEqual({ error: 'rate_limited', retryAfterSeconds: 17 })
+ expect(response.headers['retry-after']).toBe('17')
+ expect(response.headers['set-cookie']).toBeUndefined()
+ expect(JSON.stringify(response.body)).not.toMatch(/verification_busy|r6-|sql|stack/i)
+ })
+})