tryassay 0.20.3 → 0.21.1

package/dist/runtime/functional-tester.js

@@ -0,0 +1,775 @@
+// ============================================================
+// Functional Tester — HTTP-level testing of generated apps
+// Starts the dev server, generates tests from the architecture plan,
+// runs them via fetch(), and feeds failures to CodeAgent for repair.
+// ============================================================
+import { spawn } from 'node:child_process';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { CodeAgent } from './agents/code-agent.js';
+import { MessageBus } from './message-bus.js';
+// ── Functional Tester ────────────────────────────────────────
+export class FunctionalTester {
+    projectPath;
+    plan;
+    maxRepairAttempts;
+    testTimeoutMs;
+    serverStartTimeoutMs;
+    codeModel;
+    framework;
+    constructor(projectPath, plan, options) {
+        this.projectPath = projectPath;
+        this.plan = plan;
+        this.maxRepairAttempts = options?.maxRepairAttempts ?? 3;
+        this.testTimeoutMs = options?.testTimeoutMs ?? 10_000;
+        this.serverStartTimeoutMs = options?.serverStartTimeoutMs ?? 30_000;
+        this.codeModel = options?.codeModel;
+        this.framework = (options?.framework ?? 'next.js').toLowerCase();
+    }
+    /** Run functional tests with repair loop. */
+    async test() {
+        const start = Date.now();
+        // Skip for Electron (no HTTP server)
+        if (this.framework === 'electron') {
+            return {
+                status: 'skipped',
+                tests: [],
+                passedCount: 0,
+                failedCount: 0,
+                repairAttempts: [],
+                serverPort: null,
+                totalDurationMs: Date.now() - start,
+            };
+        }
+        // Generate test cases from the plan
+        const tests = this.generateTests();
+        if (tests.length === 0) {
+            return {
+                status: 'skipped',
+                tests: [],
+                passedCount: 0,
+                failedCount: 0,
+                repairAttempts: [],
+                serverPort: null,
+                totalDurationMs: Date.now() - start,
+            };
+        }
+        // Start dev server
+        let serverProcess = null;
+        let port = null;
+        try {
+            const serverInfo = await this.startDevServer();
+            serverProcess = serverInfo.process;
+            port = serverInfo.port;
+        }
+        catch (err) {
+            // Server failed to start — return fail with no tests run
+            return {
+                status: 'fail',
+                tests: [],
+                passedCount: 0,
+                failedCount: 0,
+                repairAttempts: [],
+                serverPort: null,
+                totalDurationMs: Date.now() - start,
+            };
+        }
+        try {
+            // Run tests
+            let executions = await this.runTests(tests, port);
+            const repairAttempts = [];
+            let failures = executions.filter(e => e.status !== 'pass');
+            let attempt = 0;
+            // Repair loop
+            while (failures.length > 0 && attempt < this.maxRepairAttempts) {
+                attempt++;
+                const repairStart = Date.now();
+                const repairResult = await this.runRepair(failures, port);
+                repairAttempts.push({
+                    attempt,
+                    failures,
+                    filesModified: repairResult.filesModified,
+                    repairSucceeded: repairResult.filesModified.length > 0,
+                    durationMs: Date.now() - repairStart,
+                });
+                if (repairResult.filesModified.length === 0) {
+                    break; // Repair couldn't modify anything, stop trying
+                }
+                // Re-run only failed tests
+                const failedTests = failures.map(f => f.test);
+                executions = [
+                    ...executions.filter(e => e.status === 'pass'),
+                    ...await this.runTests(failedTests, port),
+                ];
+                failures = executions.filter(e => e.status !== 'pass');
+            }
+            const passedCount = executions.filter(e => e.status === 'pass').length;
+            const failedCount = executions.filter(e => e.status !== 'pass').length;
+            const status = failedCount === 0 ? (repairAttempts.length > 0 ? 'repaired' : 'pass') : 'fail';
+            return {
+                status,
+                tests: executions,
+                passedCount,
+                failedCount,
+                repairAttempts,
+                serverPort: port,
+                totalDurationMs: Date.now() - start,
+            };
+        }
+        finally {
+            // Always kill the server
+            if (serverProcess) {
+                serverProcess.kill('SIGTERM');
+                // Give it a moment, then force kill
+                setTimeout(() => {
+                    if (serverProcess && !serverProcess.killed) {
+                        serverProcess.kill('SIGKILL');
+                    }
+                }, 3000);
+            }
+        }
+    }
+    // ── Test Generation ──────────────────────────────────────────
+    /** Generate test cases from the architecture plan. */
+    generateTests() {
+        const tests = [];
+        // API route tests
+        for (const route of this.plan.apiRoutes) {
+            const body = route.method !== 'GET' && route.method !== 'DELETE'
+                ? this.generateSamplePayload(route.path, route.featureId)
+                : undefined;
+            tests.push({
+                id: `api-${route.method.toLowerCase()}-${route.path.replace(/\//g, '-')}`,
+                type: 'api_route',
+                name: `${route.method} ${route.path}`,
+                method: route.method,
+                path: route.path,
+                body,
+                expectedStatusRange: [200, 499], // 2xx-4xx are valid responses; 5xx = server error
+                errorPatterns: [
+                    'Internal Server Error',
+                    'TypeError',
+                    'ReferenceError',
+                    'Cannot read properties of',
+                    'is not a function',
+                    'ECONNREFUSED',
+                    'MODULE_NOT_FOUND',
+                ],
+                featureId: route.featureId,
+            });
+        }
+        // Page load tests
+        for (const page of this.plan.pages) {
+            tests.push({
+                id: `page-${page.path.replace(/\//g, '-') || 'root'}`,
+                type: 'page_load',
+                name: `GET ${page.path || '/'}`,
+                method: 'GET',
+                path: page.path || '/',
+                expectedStatusRange: [200, 399], // Pages should return 2xx or redirect
+                errorPatterns: [
+                    'Internal Server Error',
+                    'Application error',
+                    'Error: ',
+                    'TypeError',
+                    'Unhandled Runtime Error',
+                    'Module not found',
+                    '500',
+                ],
+                featureId: page.featureId,
+            });
+        }
+        // Auth flow tests (if auth is configured)
+        if (this.plan.authPlan) {
+            // Test signup route exists and doesn't crash
+            const signupRoutes = this.plan.apiRoutes.filter(r => r.path.includes('signup') || r.path.includes('register'));
+            for (const route of signupRoutes) {
+                tests.push({
+                    id: `auth-signup-${route.path.replace(/\//g, '-')}`,
+                    type: 'auth_flow',
+                    name: `Auth: POST ${route.path}`,
+                    method: 'POST',
+                    path: route.path,
+                    body: {
+                        email: 'test@example.com',
+                        password: 'TestPassword123!',
+                    },
+                    expectedStatusRange: [200, 499], // Auth may return 4xx for duplicate etc
+                    errorPatterns: [
+                        'Internal Server Error',
+                        'TypeError',
+                        'Cannot read properties of',
+                        'ECONNREFUSED',
+                    ],
+                    featureId: route.featureId,
+                });
+            }
+            // Test login route
+            const loginRoutes = this.plan.apiRoutes.filter(r => r.path.includes('login') || r.path.includes('signin'));
+            for (const route of loginRoutes) {
+                tests.push({
+                    id: `auth-login-${route.path.replace(/\//g, '-')}`,
+                    type: 'auth_flow',
+                    name: `Auth: POST ${route.path}`,
+                    method: 'POST',
+                    path: route.path,
+                    body: {
+                        email: 'test@example.com',
+                        password: 'TestPassword123!',
+                    },
+                    expectedStatusRange: [200, 499],
+                    errorPatterns: [
+                        'Internal Server Error',
+                        'TypeError',
+                        'Cannot read properties of',
+                        'ECONNREFUSED',
+                    ],
+                    featureId: route.featureId,
+                });
+            }
+        }
+        // Data persistence tests: POST → GET to verify data was saved
+        for (const route of this.plan.apiRoutes) {
+            if (route.method !== 'POST')
+                continue;
+            const getRoute = this.findCorrespondingGetRoute(route.path, this.plan.apiRoutes);
+            if (!getRoute)
+                continue;
+            const body = this.generateSamplePayload(route.path, route.featureId);
+            tests.push({
+                id: `persist-${route.path.replace(/\//g, '-')}`,
+                type: 'data_persistence',
+                name: `Persist: POST ${route.path} → GET ${getRoute}`,
+                method: 'POST',
+                path: route.path,
+                body,
+                expectedStatusRange: [200, 499],
+                errorPatterns: [
+                    'Internal Server Error',
+                    'TypeError',
+                    'ReferenceError',
+                    'Cannot read properties of',
+                ],
+                featureId: route.featureId,
+                verifyPath: getRoute,
+                idField: this.guessIdField(route.path),
+            });
+        }
+        return tests;
+    }
+    /** Generate a minimal sample payload for a POST/PUT route based on schema. */
+    generateSamplePayload(routePath, featureId) {
+        // Try to find the schema entity for this feature
+        if (featureId) {
+            const feature = this.plan.features.find(f => f.id === featureId);
+            if (feature && feature.schemaEntities.length > 0) {
+                const entityName = feature.schemaEntities[0];
+                const entity = this.plan.schema.find(e => e.name === entityName);
+                if (entity) {
+                    const payload = {};
+                    for (const field of entity.fields) {
+                        if (field.primaryKey)
+                            continue; // Skip auto-generated IDs
+                        if (field.name === 'created_at' || field.name === 'updated_at')
+                            continue;
+                        payload[field.name] = this.sampleValueForType(field.type, field.name);
+                    }
+                    return payload;
+                }
+            }
+        }
+        // Fallback: extract resource name from path
+        const parts = routePath.split('/').filter(Boolean);
+        const resource = parts[parts.length - 1] ?? 'item';
+        return {
+            name: `Test ${resource}`,
+            description: `Test ${resource} description`,
+        };
+    }
+    /** Generate a sample value for a schema field type. */
+    sampleValueForType(type, name) {
+        const t = type.toLowerCase();
+        if (t.includes('int') || t.includes('number') || t.includes('decimal') || t.includes('float'))
+            return 42;
+        if (t.includes('bool'))
+            return true;
+        if (t.includes('date') || t.includes('timestamp'))
+            return new Date().toISOString();
+        if (t.includes('json') || t.includes('object'))
+            return {};
+        if (t.includes('array'))
+            return [];
+        // String types
+        if (name.includes('email'))
+            return 'test@example.com';
+        if (name.includes('url'))
+            return 'https://example.com';
+        if (name.includes('phone'))
+            return '+12025551234';
+        return `test-${name}`;
+    }
+    // ── Server Management ────────────────────────────────────────
+    /** Start the dev server and detect the port. */
+    startDevServer() {
+        return new Promise((resolve, reject) => {
+            const command = this.framework.includes('next') ? 'npx' : 'npm';
+            const args = this.framework.includes('next')
+                ? ['next', 'dev', '--port', '0'] // port 0 = auto-assign
+                : ['run', 'dev'];
+            const proc = spawn(command, args, {
+                cwd: this.projectPath,
+                env: { ...process.env, NODE_ENV: 'development', PORT: '0' },
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            let stdout = '';
+            let stderr = '';
+            let resolved = false;
+            const timeout = setTimeout(() => {
+                if (!resolved) {
+                    resolved = true;
+                    proc.kill('SIGTERM');
+                    reject(new Error(`Server failed to start within ${this.serverStartTimeoutMs}ms. stdout: ${stdout.slice(-500)}, stderr: ${stderr.slice(-500)}`));
+                }
+            }, this.serverStartTimeoutMs);
+            const tryExtractPort = (data) => {
+                if (resolved)
+                    return;
+                // Match common patterns: "localhost:3000", "port 3000", ":3000"
+                const portMatch = data.match(/(?:localhost|127\.0\.0\.1|0\.0\.0\.0):(\d+)/i)
+                    ?? data.match(/port\s+(\d+)/i)
+                    ?? data.match(/:(\d{4,5})\b/);
+                if (portMatch) {
+                    const port = parseInt(portMatch[1], 10);
+                    if (port > 0 && port < 65536) {
+                        resolved = true;
+                        clearTimeout(timeout);
+                        resolve({ process: proc, port });
+                    }
+                }
+            };
+            proc.stdout?.on('data', (chunk) => {
+                const data = chunk.toString();
+                stdout += data;
+                tryExtractPort(data);
+            });
+            proc.stderr?.on('data', (chunk) => {
+                const data = chunk.toString();
+                stderr += data;
+                tryExtractPort(data);
+            });
+            proc.on('error', (err) => {
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    reject(err);
+                }
+            });
+            proc.on('exit', (code) => {
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    reject(new Error(`Server exited with code ${code} before starting. stderr: ${stderr.slice(-500)}`));
+                }
+            });
+        });
+    }
+    // ── Test Execution ───────────────────────────────────────────
+    /** Run a batch of functional tests against the running server. */
+    async runTests(tests, port) {
+        const results = [];
+        for (const test of tests) {
+            const execution = await this.runSingleTest(test, port);
+            results.push(execution);
+        }
+        return results;
+    }
+    /** Run a single functional test. */
+    async runSingleTest(test, port) {
+        if (test.type === 'data_persistence') {
+            return this.runPersistenceVerification(test, port);
+        }
+        const url = `http://localhost:${port}${test.path}`;
+        const start = Date.now();
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), this.testTimeoutMs);
+            const fetchOptions = {
+                method: test.method ?? 'GET',
+                signal: controller.signal,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json, text/html',
+                },
+            };
+            if (test.body && test.method !== 'GET') {
+                fetchOptions.body = JSON.stringify(test.body);
+            }
+            const response = await fetch(url, fetchOptions);
+            clearTimeout(timeoutId);
+            const statusCode = response.status;
+            let responseBody;
+            try {
+                responseBody = await response.text();
+            }
+            catch {
+                responseBody = '';
+            }
+            // Check status code range
+            const [minStatus, maxStatus] = test.expectedStatusRange;
+            if (statusCode < minStatus || statusCode > maxStatus) {
+                return {
+                    test,
+                    status: 'fail',
+                    statusCode,
+                    responseBody: responseBody.slice(0, 2000),
+                    errorMatch: `Status ${statusCode} outside expected range [${minStatus}, ${maxStatus}]`,
+                    durationMs: Date.now() - start,
+                };
+            }
+            // Check for 5xx errors specifically (server bugs)
+            if (statusCode >= 500) {
+                return {
+                    test,
+                    status: 'fail',
+                    statusCode,
+                    responseBody: responseBody.slice(0, 2000),
+                    errorMatch: `Server error: ${statusCode}`,
+                    durationMs: Date.now() - start,
+                };
+            }
+            // Check response body for error patterns
+            for (const pattern of test.errorPatterns) {
+                if (responseBody.includes(pattern)) {
+                    return {
+                        test,
+                        status: 'fail',
+                        statusCode,
+                        responseBody: responseBody.slice(0, 2000),
+                        errorMatch: `Response contains error pattern: "${pattern}"`,
+                        durationMs: Date.now() - start,
+                    };
+                }
+            }
+            return {
+                test,
+                status: 'pass',
+                statusCode,
+                responseBody: responseBody.slice(0, 500),
+                durationMs: Date.now() - start,
+            };
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === 'AbortError') {
+                return {
+                    test,
+                    status: 'timeout',
+                    statusCode: null,
+                    responseBody: '',
+                    errorMatch: `Request timed out after ${this.testTimeoutMs}ms`,
+                    durationMs: Date.now() - start,
+                };
+            }
+            return {
+                test,
+                status: 'error',
+                statusCode: null,
+                responseBody: '',
+                errorMatch: err instanceof Error ? err.message : String(err),
+                durationMs: Date.now() - start,
+            };
+        }
+    }
+    // ── Repair Loop ──────────────────────────────────────────────
+    /** Feed test failures to CodeAgent for repair. */
+    async runRepair(failures, port) {
+        const filesModified = [];
+        // Group failures by feature to batch repairs
+        const failuresByFeature = new Map();
+        for (const failure of failures) {
+            const featureId = failure.test.featureId ?? 'unknown';
+            const existing = failuresByFeature.get(featureId) ?? [];
+            existing.push(failure);
+            failuresByFeature.set(featureId, existing);
+        }
+        for (const [featureId, featureFailures] of failuresByFeature) {
+            // Build the repair goal with failure details
+            const failureDetails = featureFailures.map(f => {
+                return `- ${f.test.name}: ${f.status} — ${f.errorMatch ?? 'Unknown error'}
+  Status code: ${f.statusCode ?? 'N/A'}
+  Response: ${f.responseBody.slice(0, 500)}`;
+            }).join('\n');
+            // Try to read the source files for the failing routes/pages
+            const sourceContext = await this.readFailingSourceFiles(featureFailures);
+            const repairGoal = `Fix functional test failures in the generated application.
+
+The following HTTP tests failed against the running dev server:
+
+${failureDetails}
+
+${sourceContext ? `Current source code for the failing endpoints:\n\n${sourceContext}` : ''}
+
+Fix the code so these endpoints return valid responses without server errors.
+Do NOT add placeholder stubs — implement the actual logic.
+The dev server is running at http://localhost:${port}.`;
+            const messageBus = new MessageBus();
+            const codeAgent = new CodeAgent(messageBus, { model: this.codeModel });
+            try {
+                const result = await codeAgent.executeTask({
+                    taskId: `repair-${featureId}-${randomUUID().slice(0, 8)}`,
+                    goal: repairGoal,
+                    constraints: [
+                        `Framework: ${this.framework}`,
+                        'Fix the actual bug — do not add stubs or TODO comments',
+                    ],
+                    dependencies: [],
+                    contextRefs: [],
+                });
+                if (result.status === 'completed' && result.artifacts.length > 0) {
+                    for (const artifact of result.artifacts) {
+                        if (!artifact.path)
+                            continue;
+                        const absPath = join(this.projectPath, artifact.path);
+                        try {
+                            await mkdir(dirname(absPath), { recursive: true });
+                            await writeFile(absPath, artifact.content, 'utf-8');
+                            filesModified.push(artifact.path);
+                        }
+                        catch {
+                            // Best-effort write
+                        }
+                    }
+                }
+            }
+            catch {
+                // Repair agent failed — continue with remaining features
+            }
+        }
+        return { filesModified };
+    }
+    /** Read source files for failing test endpoints. */
+    async readFailingSourceFiles(failures) {
+        const sections = [];
+        for (const failure of failures) {
+            const path = failure.test.path;
+            const filePath = this.routeToFilePath(path);
+            try {
+                const content = await readFile(join(this.projectPath, filePath), 'utf-8');
+                sections.push(`--- ${filePath} ---\n${content}\n`);
+            }
+            catch {
+                // File doesn't exist
+            }
+        }
+        return sections.join('\n');
+    }
+    /** Map a route path to its expected file path (mirrors orchestrator logic). */
+    routeToFilePath(routePath) {
+        if (this.framework.includes('next')) {
+            return `app${routePath}/route.ts`;
+        }
+        const parts = routePath.replace(/^\/api/, '').replace(/^\//, '');
+        return `src/routes/${parts || 'index'}.ts`;
+    }
+    // ── Data Persistence Helpers ──────────────────────────────────
+    /** Run a persistence verification: POST data, then GET to confirm it was saved. */
+    async runPersistenceVerification(test, port) {
+        const baseUrl = `http://localhost:${port}`;
+        const start = Date.now();
+        try {
+            // Step 1: POST the data
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), this.testTimeoutMs);
+            const postResponse = await fetch(`${baseUrl}${test.path}`, {
+                method: 'POST',
+                signal: controller.signal,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                },
+                body: JSON.stringify(test.body),
+            });
+            clearTimeout(timeoutId);
+            const postStatus = postResponse.status;
+            let postBody;
+            try {
+                postBody = await postResponse.text();
+            }
+            catch {
+                postBody = '';
+            }
+            // If POST itself fails with 5xx, report that
+            if (postStatus >= 500) {
+                return {
+                    test,
+                    status: 'fail',
+                    statusCode: postStatus,
+                    responseBody: postBody.slice(0, 2000),
+                    errorMatch: `POST returned server error: ${postStatus}`,
+                    durationMs: Date.now() - start,
+                };
+            }
+            // If POST returned a client error (4xx), it's not a persistence failure
+            if (postStatus >= 400) {
+                return {
+                    test,
+                    status: 'fail',
+                    statusCode: postStatus,
+                    responseBody: postBody.slice(0, 2000),
+                    errorMatch: `POST returned client error: ${postStatus}`,
+                    durationMs: Date.now() - start,
+                };
+            }
+            // Step 2: Extract ID from POST response
+            let postJson;
+            try {
+                postJson = JSON.parse(postBody);
+            }
+            catch {
+                return {
+                    test,
+                    status: 'fail',
+                    statusCode: postStatus,
+                    responseBody: postBody.slice(0, 2000),
+                    errorMatch: 'POST response is not valid JSON — cannot extract ID',
+                    durationMs: Date.now() - start,
+                };
+            }
+            const idField = test.idField ?? 'id';
+            const id = this.extractNestedValue(postJson, idField)
+                ?? this.extractNestedValue(postJson, 'id');
+            if (id === undefined || id === null) {
+                return {
+                    test,
+                    status: 'fail',
+                    statusCode: postStatus,
+                    responseBody: postBody.slice(0, 2000),
+                    errorMatch: `Could not extract ID from POST response using field "${idField}"`,
+                    durationMs: Date.now() - start,
+                };
+            }
+            // Step 3: GET to verify persistence
+            const verifyPath = (test.verifyPath ?? '').replace(/\[id\]|:id|\{id\}/g, String(id));
+            const getController = new AbortController();
+            const getTimeoutId = setTimeout(() => getController.abort(), this.testTimeoutMs);
+            const getResponse = await fetch(`${baseUrl}${verifyPath}`, {
+                method: 'GET',
+                signal: getController.signal,
+                headers: { 'Accept': 'application/json' },
+            });
+            clearTimeout(getTimeoutId);
+            const getStatus = getResponse.status;
+            let getBody;
+            try {
+                getBody = await getResponse.text();
+            }
+            catch {
+                getBody = '';
+            }
+            if (getStatus === 404) {
+                return {
+                    test,
+                    status: 'fail',
+                    statusCode: getStatus,
+                    responseBody: `POST ${postStatus}: ${postBody.slice(0, 500)}\nGET ${getStatus}: ${getBody.slice(0, 500)}`,
+                    errorMatch: 'Data did not persist — POST succeeded but GET returned 404',
+                    durationMs: Date.now() - start,
+                };
+            }
+            if (getStatus >= 200 && getStatus < 300) {
+                return {
+                    test,
+                    status: 'pass',
+                    statusCode: getStatus,
+                    responseBody: `POST ${postStatus} → GET ${getStatus}: ${getBody.slice(0, 500)}`,
+                    durationMs: Date.now() - start,
+                };
+            }
+            return {
+                test,
+                status: 'fail',
+                statusCode: getStatus,
+                responseBody: `POST ${postStatus}: ${postBody.slice(0, 500)}\nGET ${getStatus}: ${getBody.slice(0, 500)}`,
+                errorMatch: `GET verification returned unexpected status: ${getStatus}`,
+                durationMs: Date.now() - start,
+            };
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === 'AbortError') {
+                return {
+                    test,
+                    status: 'timeout',
+                    statusCode: null,
+                    responseBody: '',
+                    errorMatch: `Persistence test timed out after ${this.testTimeoutMs}ms`,
+                    durationMs: Date.now() - start,
+                };
+            }
+            return {
+                test,
+                status: 'error',
+                statusCode: null,
+                responseBody: '',
+                errorMatch: err instanceof Error ? err.message : String(err),
+                durationMs: Date.now() - start,
+            };
+        }
+    }
+    /** Find a GET route that matches a POST route path with an ID segment appended. */
+    findCorrespondingGetRoute(postPath, allRoutes) {
+        const getRoutes = allRoutes.filter(r => r.method === 'GET');
+        // Try common dynamic segment patterns: [id], :id, {id}, [slug]
+        const candidates = [
+            `${postPath}/[id]`,
+            `${postPath}/:id`,
+            `${postPath}/{id}`,
+            `${postPath}/[slug]`,
+        ];
+        for (const candidate of candidates) {
+            const match = getRoutes.find(r => r.path === candidate);
+            if (match)
+                return match.path;
+        }
+        // Also try: if POST is /api/foods, look for GET /api/foods/[foodId] etc.
+        const parts = postPath.split('/').filter(Boolean);
+        const resource = parts[parts.length - 1];
+        if (resource) {
+            const singular = resource.endsWith('s') ? resource.slice(0, -1) : resource;
+            const extraCandidates = [
+                `${postPath}/[${singular}Id]`,
+                `${postPath}/:${singular}Id`,
+                `${postPath}/[${singular}_id]`,
+            ];
+            for (const candidate of extraCandidates) {
+                const match = getRoutes.find(r => r.path === candidate);
+                if (match)
+                    return match.path;
+            }
+        }
+        return null;
+    }
+    /** Guess the ID field name from a route path (e.g., /api/foods → food.id). */
+    guessIdField(postPath) {
+        const parts = postPath.split('/').filter(Boolean);
+        const resource = parts[parts.length - 1];
+        if (!resource)
+            return 'id';
+        const singular = resource.endsWith('s') ? resource.slice(0, -1) : resource;
+        return `${singular}.id`;
+    }
+    /** Extract a nested value from an object using a dotted path (e.g., "food.id"). */
+    extractNestedValue(obj, dottedPath) {
+        if (obj === null || obj === undefined || typeof obj !== 'object')
+            return undefined;
+        const segments = dottedPath.split('.');
+        let current = obj;
+        for (const segment of segments) {
+            if (current === null || current === undefined || typeof current !== 'object') {
+                return undefined;
+            }
+            current = current[segment];
+        }
+        return current;
+    }
+}
+//# sourceMappingURL=functional-tester.js.map