firecrawl-api / apps /api /src /controllers /v2 /search-feedback.ts
s-eto-hub's picture
Commit de nettoyage des binaires
097eaf0
Raw History Blame Contribute Delete
11.5 kB
import { Response } from "express";
import { v7 as uuidv7 } from "uuid";
import { z } from "zod";
import { config } from "../../config";
import { logger as _logger } from "../../lib/logger";
import { autumnService } from "../../services/autumn/autumn.service";
import {
isPostgrestNoRowsError,
supabase_service,
supabase_rr_service,
} from "../../services/supabase";
import { captureExceptionWithZdrCheck } from "../../services/sentry";
import {
RequestWithAuth,
SearchFeedbackErrorCode,
SearchFeedbackRequest,
SearchFeedbackResponse,
searchFeedbackSchema,
} from "./types";
const SEARCH_FEEDBACK_REFUND_CREDITS = 1;
// Must match the previewTeamId in services/logging/log_job.ts.
const PREVIEW_TEAM_ID = "3adefd26-77ec-5968-8dcf-c94b5630d1de";
const POSTGRES_UNIQUE_VIOLATION = "23505";
// logSearch in the search controller is fire-and-forget; this retry covers
// the gap when feedback arrives before the searches row has been inserted.
const SEARCH_LOOKUP_RACE_RETRY_MS = 250;
type FailReason = {
status: number;
code: SearchFeedbackErrorCode;
error: string;
};
function fail(
res: Response<SearchFeedbackResponse>,
reason: FailReason,
): Response<SearchFeedbackResponse> {
return res.status(reason.status).json({
success: false,
error: reason.error,
feedbackErrorCode: reason.code,
});
}
function isPreviewTeam(teamId: string): boolean {
return teamId === "preview" || teamId.startsWith("preview_");
}
function normalizeTeamId(teamId: string): string {
return isPreviewTeam(teamId) ? PREVIEW_TEAM_ID : teamId;
}
type SearchRowForFeedback = {
id: string;
team_id: string;
credits_cost: number | null;
created_at: string;
is_successful: boolean | null;
};
async function lookupSearchRow(
searchId: string,
dbTeamId: string,
): Promise<SearchRowForFeedback | null> {
const { data, error } = await supabase_rr_service
.from("searches")
.select("id, team_id, credits_cost, created_at, is_successful")
.eq("id", searchId)
.eq("team_id", dbTeamId)
.single();
if (error) {
if (isPostgrestNoRowsError(error)) return null;
throw error;
}
return data as SearchRowForFeedback | null;
}
function startOfUtcDay(now: Date = new Date()): Date {
const start = new Date(now.getTime());
start.setUTCHours(0, 0, 0, 0);
return start;
}
// Best-effort: on DB error we return 0 rather than block legitimate
// refunds; overshoot is bounded by the rate limiter.
async function sumTeamCreditsRefundedToday(
dbTeamId: string,
logger: ReturnType<typeof _logger.child>,
): Promise<number> {
const since = startOfUtcDay().toISOString();
const { data, error } = await supabase_rr_service
.from("search_feedback")
.select("credits_refunded")
.eq("team_id", dbTeamId)
.gte("created_at", since);
if (error) {
logger.warn(
"Failed to compute today's refund total; allowing refund this call",
{ error },
);
return 0;
}
return (data ?? []).reduce(
(sum, row: { credits_refunded: number | null }) =>
sum + (row.credits_refunded ?? 0),
0,
);
}
export async function searchFeedbackController(
req: RequestWithAuth<
{ jobId: string },
SearchFeedbackResponse,
SearchFeedbackRequest
>,
res: Response<SearchFeedbackResponse>,
) {
const searchId = req.params.jobId;
const logger = _logger.child({
module: "api/v2",
method: "searchFeedbackController",
searchId,
teamId: req.auth.team_id,
});
let parsedBody: SearchFeedbackRequest;
try {
parsedBody = searchFeedbackSchema.parse(req.body);
} catch (error) {
if (error instanceof z.ZodError) {
logger.warn("Invalid feedback body", { error: error.issues });
return res.status(400).json({
success: false,
error: "Invalid request body",
details: error.issues,
feedbackErrorCode: "INVALID_BODY",
});
}
throw error;
}
if (config.USE_DB_AUTHENTICATION !== true) {
return fail(res, {
status: 503,
code: "DB_DISABLED",
error:
"Search feedback requires database authentication and is unavailable on this deployment.",
});
}
// Preview tenants share one team_id in the searches table, so one
// preview agent could otherwise submit feedback on another's searches.
if (isPreviewTeam(req.auth.team_id)) {
return fail(res, {
status: 403,
code: "PREVIEW_TEAM_NOT_ALLOWED",
error: "Search feedback is not available for preview teams.",
});
}
if (req.acuc?.flags?.searchFeedbackOptOut === true) {
logger.info("Rejected feedback: team opted out");
return fail(res, {
status: 403,
code: "TEAM_OPTED_OUT",
error:
"Search feedback is disabled for this team. Contact support@firecrawl.com to re-enable.",
});
}
const dbTeamId = normalizeTeamId(req.auth.team_id);
try {
let searchRow: SearchRowForFeedback | null;
try {
searchRow = await lookupSearchRow(searchId, dbTeamId);
if (!searchRow) {
await new Promise(resolve =>
setTimeout(resolve, SEARCH_LOOKUP_RACE_RETRY_MS),
);
searchRow = await lookupSearchRow(searchId, dbTeamId);
}
} catch (lookupErr) {
logger.error("Failed to look up search for feedback", {
error: lookupErr,
});
return fail(res, {
status: 500,
code: "INTERNAL",
error: "Failed to look up search.",
});
}
if (!searchRow) {
return fail(res, {
status: 404,
code: "SEARCH_NOT_FOUND",
error: "Search not found for this team.",
});
}
if (searchRow.is_successful === false) {
return fail(res, {
status: 409,
code: "SEARCH_FAILED",
error: "Cannot submit feedback for a search that did not succeed.",
});
}
const maxAgeMs = config.SEARCH_FEEDBACK_MAX_AGE_SEC * 1000;
const createdAtMs = new Date(searchRow.created_at).getTime();
if (Number.isNaN(createdAtMs)) {
logger.warn("Search row had unparseable created_at", {
created_at: searchRow.created_at,
});
} else {
const ageMs = Date.now() - createdAtMs;
if (ageMs > maxAgeMs) {
logger.info("Rejected feedback outside time window", {
ageMs,
maxAgeMs,
});
return fail(res, {
status: 409,
code: "FEEDBACK_WINDOW_EXPIRED",
error: `Search feedback must be submitted within ${config.SEARCH_FEEDBACK_MAX_AGE_SEC} seconds of the search.`,
});
}
}
const feedbackId = uuidv7();
const { error: insertErr } = await supabase_service
.from("search_feedback")
.insert({
id: feedbackId,
search_id: searchId,
team_id: dbTeamId,
overall_rating: parsedBody.rating,
valuable_sources: parsedBody.valuableSources ?? [],
missing_content: parsedBody.missingContent ?? [],
query_suggestions: parsedBody.querySuggestions ?? null,
integration: parsedBody.integration ?? null,
origin: parsedBody.origin ?? null,
credits_refunded: 0,
});
if (insertErr) {
if ((insertErr as { code?: string }).code === POSTGRES_UNIQUE_VIOLATION) {
const { data: existing } = await supabase_rr_service
.from("search_feedback")
.select("id, credits_refunded")
.eq("search_id", searchId)
.single();
const dailyCapForResponse = config.SEARCH_FEEDBACK_DAILY_CAP_CREDITS;
const refundedTodayForResponse = await sumTeamCreditsRefundedToday(
dbTeamId,
logger,
);
return res.status(200).json({
success: true,
feedbackId: existing?.id ?? "",
creditsRefunded: 0,
alreadySubmitted: true,
creditsRefundedToday: refundedTodayForResponse,
dailyRefundCap: dailyCapForResponse,
warning:
"Feedback was already submitted for this search; no additional refund issued.",
});
}
logger.error("Failed to insert search feedback", { error: insertErr });
return fail(res, {
status: 500,
code: "INTERNAL",
error: "Failed to record feedback.",
});
}
// The just-inserted row has credits_refunded=0, so reading the SUM
// here is safe whether or not it shows up in the read replica yet.
const dailyCap = config.SEARCH_FEEDBACK_DAILY_CAP_CREDITS;
const refundedTodayBefore = await sumTeamCreditsRefundedToday(
dbTeamId,
logger,
);
const remainingDailyCap = Math.max(0, dailyCap - refundedTodayBefore);
let creditsRefunded = 0;
let dailyCapReached = false;
const billedCredits = searchRow.credits_cost ?? 0;
const desiredRefund = Math.min(
SEARCH_FEEDBACK_REFUND_CREDITS,
billedCredits,
);
const cappedRefund = Math.min(desiredRefund, remainingDailyCap);
if (billedCredits > 0 && desiredRefund > 0 && cappedRefund === 0) {
dailyCapReached = true;
logger.info(
"Daily refund cap reached for team; feedback recorded with zero refund",
{
dailyCap,
refundedTodayBefore,
},
);
} else if (cappedRefund > 0) {
try {
await autumnService.refundCredits({
teamId: req.auth.team_id,
value: cappedRefund,
properties: {
source: "search_feedback",
endpoint: "search",
jobId: searchId,
feedbackId,
rating: parsedBody.rating,
},
});
creditsRefunded = cappedRefund;
} catch (error) {
logger.error("Search feedback refund failed; feedback retained", {
error,
});
}
if (creditsRefunded > 0) {
const { error: updateErr } = await supabase_service
.from("search_feedback")
.update({ credits_refunded: creditsRefunded })
.eq("id", feedbackId);
if (updateErr) {
logger.warn(
"Failed to persist credits_refunded on search_feedback row",
{ error: updateErr, feedbackId, creditsRefunded },
);
}
}
}
const creditsRefundedToday = refundedTodayBefore + creditsRefunded;
if (!dailyCapReached && creditsRefundedToday >= dailyCap && dailyCap > 0) {
dailyCapReached = true;
}
logger.info("Search feedback recorded", {
feedbackId,
creditsRefunded,
rating: parsedBody.rating,
valuableSourcesCount: parsedBody.valuableSources?.length ?? 0,
missingContentCount: parsedBody.missingContent?.length ?? 0,
hasQuerySuggestions: !!parsedBody.querySuggestions,
creditsRefundedToday,
dailyRefundCap: dailyCap,
dailyCapReached,
});
return res.status(200).json({
success: true,
feedbackId,
creditsRefunded,
creditsRefundedToday,
dailyRefundCap: dailyCap,
...(dailyCapReached
? {
dailyCapReached: true,
warning: `Daily refund cap of ${dailyCap} credits reached for this team (UTC day). Feedback was recorded; further /feedback calls today will not refund credits.`,
}
: {}),
});
} catch (error) {
captureExceptionWithZdrCheck(error);
logger.error("Unhandled error in search feedback controller", { error });
return fail(res, {
status: 500,
code: "INTERNAL",
error: error instanceof Error ? error.message : "Unknown error",
});
}
}