318 lines
10 KiB
TypeScript
318 lines
10 KiB
TypeScript
import { NextRequest, NextResponse } from 'next/server'
|
|
import { convexAuthNextjsToken, isAuthenticatedNextjs } from "@convex-dev/auth/nextjs/server";
|
|
import { fetchMutation, fetchQuery } from "convex/nextjs";
|
|
import { api } from "@/convex/_generated/api";
|
|
import { z } from 'zod'
|
|
import { generateSearchQueries, getDefaultPlatforms } from '@/lib/query-generator'
|
|
import { executeSearches, scoreOpportunities } from '@/lib/search-executor'
|
|
import type { EnhancedProductAnalysis, SearchConfig, PlatformConfig } from '@/lib/types'
|
|
import { logServer } from "@/lib/server-logger";
|
|
|
|
const searchSchema = z.object({
|
|
projectId: z.string(),
|
|
jobId: z.optional(z.string()),
|
|
config: z.object({
|
|
platforms: z.array(z.object({
|
|
id: z.string(),
|
|
name: z.string(),
|
|
icon: z.string().optional(),
|
|
enabled: z.boolean(),
|
|
searchTemplate: z.string().optional(),
|
|
rateLimit: z.number(),
|
|
site: z.string().optional(),
|
|
custom: z.boolean().optional()
|
|
})),
|
|
strategies: z.array(z.string()),
|
|
maxResults: z.number().default(50),
|
|
minAgeDays: z.number().min(0).max(365).optional(),
|
|
maxAgeDays: z.number().min(0).max(365).optional()
|
|
})
|
|
})
|
|
|
|
export async function POST(request: NextRequest) {
|
|
let jobId: string | undefined
|
|
try {
|
|
const requestId = request.headers.get("x-request-id") ?? undefined;
|
|
if (!(await isAuthenticatedNextjs())) {
|
|
const redirectUrl = new URL("/auth", request.url);
|
|
const referer = request.headers.get("referer");
|
|
const nextPath = referer ? new URL(referer).pathname + new URL(referer).search : "/";
|
|
redirectUrl.searchParams.set("next", nextPath);
|
|
return NextResponse.redirect(redirectUrl);
|
|
}
|
|
|
|
const body = await request.json()
|
|
const parsed = searchSchema.parse(body)
|
|
const { projectId, config } = parsed
|
|
jobId = parsed.jobId
|
|
const ageFilters = {
|
|
minAgeDays: config.minAgeDays,
|
|
maxAgeDays: config.maxAgeDays,
|
|
}
|
|
|
|
if (!process.env.SERPER_API_KEY) {
|
|
const errorMessage = "SERPER_API_KEY is not configured. Add it to your environment to run searches."
|
|
await logServer({
|
|
level: "warn",
|
|
message: "Serper API key missing",
|
|
labels: ["api", "opportunities", "config", "warn"],
|
|
payload: { projectId },
|
|
requestId,
|
|
source: "api/opportunities",
|
|
});
|
|
if (jobId) {
|
|
await fetchMutation(
|
|
api.searchJobs.update,
|
|
{ jobId: jobId as any, status: "failed", error: errorMessage },
|
|
{ token: await convexAuthNextjsToken() }
|
|
)
|
|
}
|
|
return NextResponse.json({ error: errorMessage }, { status: 400 })
|
|
}
|
|
|
|
const token = await convexAuthNextjsToken();
|
|
if (jobId) {
|
|
await fetchMutation(
|
|
api.searchJobs.update,
|
|
{ jobId: jobId as any, status: "running", progress: 10 },
|
|
{ token }
|
|
);
|
|
}
|
|
const searchContext = await fetchQuery(
|
|
api.projects.getSearchContext,
|
|
{ projectId: projectId as any },
|
|
{ token }
|
|
);
|
|
|
|
if (!searchContext.context) {
|
|
if (jobId) {
|
|
await fetchMutation(
|
|
api.searchJobs.update,
|
|
{ jobId: jobId as any, status: "failed", error: "No analysis available." },
|
|
{ token }
|
|
);
|
|
}
|
|
return NextResponse.json(
|
|
{ error: 'No analysis available for selected sources.' },
|
|
{ status: 400 }
|
|
);
|
|
}
|
|
|
|
const analysis = searchContext.context as EnhancedProductAnalysis
|
|
|
|
await logServer({
|
|
level: "info",
|
|
message: "Starting opportunity search",
|
|
labels: ["api", "opportunities", "start"],
|
|
payload: {
|
|
projectId,
|
|
productName: analysis.productName,
|
|
platforms: config.platforms.filter((p) => p.enabled).map((p) => p.name),
|
|
strategies: config.strategies,
|
|
filters: ageFilters,
|
|
},
|
|
requestId,
|
|
source: "api/opportunities",
|
|
});
|
|
|
|
// Generate queries
|
|
await logServer({
|
|
level: "info",
|
|
message: "Generating search queries",
|
|
labels: ["api", "opportunities", "queries"],
|
|
payload: { projectId },
|
|
requestId,
|
|
source: "api/opportunities",
|
|
});
|
|
const enforcedConfig: SearchConfig = {
|
|
...(config as SearchConfig),
|
|
maxResults: Math.min((config as SearchConfig).maxResults || 50, 50),
|
|
}
|
|
const queries = generateSearchQueries(analysis as EnhancedProductAnalysis, enforcedConfig)
|
|
await logServer({
|
|
level: "info",
|
|
message: "Generated search queries",
|
|
labels: ["api", "opportunities", "queries"],
|
|
payload: { projectId, count: queries.length },
|
|
requestId,
|
|
source: "api/opportunities",
|
|
});
|
|
if (jobId) {
|
|
await fetchMutation(
|
|
api.searchJobs.update,
|
|
{ jobId: jobId as any, status: "running", progress: 40 },
|
|
{ token }
|
|
);
|
|
}
|
|
|
|
// Execute searches
|
|
await logServer({
|
|
level: "info",
|
|
message: "Executing searches",
|
|
labels: ["api", "opportunities", "search"],
|
|
payload: { projectId, queryCount: queries.length },
|
|
requestId,
|
|
source: "api/opportunities",
|
|
});
|
|
const searchResults = await executeSearches(queries, ageFilters)
|
|
await logServer({
|
|
level: "info",
|
|
message: "Searches complete",
|
|
labels: ["api", "opportunities", "search"],
|
|
payload: { projectId, rawResults: searchResults.length },
|
|
requestId,
|
|
source: "api/opportunities",
|
|
});
|
|
if (jobId) {
|
|
await fetchMutation(
|
|
api.searchJobs.update,
|
|
{ jobId: jobId as any, status: "running", progress: 70 },
|
|
{ token }
|
|
);
|
|
}
|
|
|
|
const resultUrls = Array.from(
|
|
new Set(searchResults.map((result) => result.url).filter(Boolean))
|
|
)
|
|
const existingUrls = await fetchQuery(
|
|
api.seenUrls.listExisting,
|
|
{ projectId: projectId as any, urls: resultUrls },
|
|
{ token }
|
|
)
|
|
const existingSet = new Set(existingUrls)
|
|
const newUrls = resultUrls.filter((url) => !existingSet.has(url))
|
|
const filteredResults = searchResults.filter((result) => !existingSet.has(result.url))
|
|
|
|
// Score and rank
|
|
await logServer({
|
|
level: "info",
|
|
message: "Scoring opportunities",
|
|
labels: ["api", "opportunities", "score"],
|
|
payload: { projectId, candidateResults: filteredResults.length },
|
|
requestId,
|
|
source: "api/opportunities",
|
|
});
|
|
const opportunities = scoreOpportunities(filteredResults, analysis as EnhancedProductAnalysis)
|
|
await logServer({
|
|
level: "info",
|
|
message: "Opportunities scored",
|
|
labels: ["api", "opportunities", "score"],
|
|
payload: { projectId, scored: opportunities.length },
|
|
requestId,
|
|
source: "api/opportunities",
|
|
});
|
|
if (jobId) {
|
|
await fetchMutation(
|
|
api.searchJobs.update,
|
|
{ jobId: jobId as any, status: "running", progress: 90 },
|
|
{ token }
|
|
);
|
|
}
|
|
|
|
if (jobId) {
|
|
await fetchMutation(
|
|
api.searchJobs.update,
|
|
{ jobId: jobId as any, status: "completed", progress: 100 },
|
|
{ token }
|
|
);
|
|
}
|
|
|
|
if (newUrls.length > 0) {
|
|
await fetchMutation(
|
|
api.seenUrls.markSeenBatch,
|
|
{ projectId: projectId as any, urls: newUrls, source: "search" },
|
|
{ token }
|
|
);
|
|
}
|
|
|
|
return NextResponse.json({
|
|
success: true,
|
|
data: {
|
|
opportunities: opportunities.slice(0, 50),
|
|
stats: {
|
|
queriesGenerated: queries.length,
|
|
rawResults: filteredResults.length,
|
|
opportunitiesFound: opportunities.length
|
|
},
|
|
queries: queries.map(q => ({
|
|
query: q.query,
|
|
platform: q.platform,
|
|
strategy: q.strategy,
|
|
priority: q.priority
|
|
})),
|
|
missingSources: searchContext.missingSources ?? []
|
|
}
|
|
})
|
|
|
|
} catch (error: any) {
|
|
const errorMessage =
|
|
error instanceof Error ? error.message : typeof error === "string" ? error : "Search failed"
|
|
await logServer({
|
|
level: "error",
|
|
message: "Opportunity search error",
|
|
labels: ["api", "opportunities", "error"],
|
|
payload: { message: errorMessage },
|
|
requestId: request.headers.get("x-request-id") ?? undefined,
|
|
source: "api/opportunities",
|
|
});
|
|
|
|
if (jobId) {
|
|
try {
|
|
const token = await convexAuthNextjsToken();
|
|
await fetchMutation(
|
|
api.searchJobs.update,
|
|
{
|
|
jobId: jobId as any,
|
|
status: "failed",
|
|
error: errorMessage
|
|
},
|
|
{ token }
|
|
);
|
|
} catch {
|
|
// Best-effort job update only.
|
|
}
|
|
}
|
|
|
|
if (error?.name === 'ZodError') {
|
|
return NextResponse.json(
|
|
{ error: 'Invalid request format', details: error?.errors },
|
|
{ status: 400 }
|
|
)
|
|
}
|
|
|
|
return NextResponse.json(
|
|
{ error: errorMessage || 'Failed to search for opportunities' },
|
|
{ status: 500 }
|
|
)
|
|
}
|
|
}
|
|
|
|
// Get default configuration
|
|
export async function GET(request: NextRequest) {
|
|
if (!(await isAuthenticatedNextjs())) {
|
|
const redirectUrl = new URL("/auth", request.url);
|
|
const referer = request.headers.get("referer");
|
|
const nextPath = referer ? new URL(referer).pathname + new URL(referer).search : "/";
|
|
redirectUrl.searchParams.set("next", nextPath);
|
|
return NextResponse.redirect(redirectUrl);
|
|
}
|
|
|
|
const defaultPlatforms = getDefaultPlatforms()
|
|
|
|
return NextResponse.json({
|
|
platforms: Object.entries(defaultPlatforms).map(([id, config]) => ({
|
|
id,
|
|
...config
|
|
})),
|
|
strategies: [
|
|
{ id: 'direct-keywords', name: 'Direct Keywords', description: 'Search for people looking for your product category' },
|
|
{ id: 'problem-pain', name: 'Problem/Pain', description: 'Find people experiencing problems you solve' },
|
|
{ id: 'competitor-alternative', name: 'Competitor Alternatives', description: 'People looking to switch from competitors' },
|
|
{ id: 'how-to', name: 'How-To/Tutorials', description: 'People learning about solutions' },
|
|
{ id: 'emotional-frustrated', name: 'Frustration Posts', description: 'Emotional posts about pain points' },
|
|
{ id: 'comparison', name: 'Comparisons', description: '"X vs Y" comparison posts' },
|
|
{ id: 'recommendation', name: 'Recommendations', description: '"What do you use" recommendation requests' }
|
|
]
|
|
})
|
|
}
|