315 lines
8.0 KiB
TypeScript
315 lines
8.0 KiB
TypeScript
import { internal } from "./_generated/api";
|
|
import type { Doc, Id } from "./_generated/dataModel";
|
|
import { internalMutation } from "./_generated/server";
|
|
import { v } from "convex/values";
|
|
|
|
const PAGE_SPEED_COUNTER_TEMPLATE = {
|
|
leadsFound: 1,
|
|
leadsCreated: 0,
|
|
auditsCreated: 1,
|
|
outreachPrepared: 0,
|
|
errors: 0,
|
|
};
|
|
|
|
type PageSpeedLead = Pick<
|
|
Doc<"leads">,
|
|
"_id" | "contactStatus"
|
|
> & {
|
|
websiteUrl: string;
|
|
};
|
|
|
|
const runStatus = v.union(
|
|
v.literal("pending"),
|
|
v.literal("running"),
|
|
v.literal("succeeded"),
|
|
v.literal("failed"),
|
|
v.literal("canceled"),
|
|
);
|
|
const pageSpeedStrategy = v.union(v.literal("mobile"), v.literal("desktop"));
|
|
const pageSpeedResultStatus = v.union(
|
|
v.literal("succeeded"),
|
|
v.literal("failed"),
|
|
);
|
|
const pageSpeedErrorType = v.union(
|
|
v.literal("quota"),
|
|
v.literal("timeout"),
|
|
v.literal("unavailable"),
|
|
v.literal("invalid_url"),
|
|
v.literal("api_error"),
|
|
v.literal("unknown"),
|
|
);
|
|
|
|
export const queueLeadPageSpeedAudit = internalMutation({
|
|
args: {
|
|
leadId: v.id("leads"),
|
|
parentRunId: v.optional(v.id("agentRuns")),
|
|
},
|
|
returns: v.union(v.id("agentRuns"), v.null()),
|
|
handler: async (ctx, args): Promise<Id<"agentRuns"> | null> => {
|
|
const now = Date.now();
|
|
const lead = await ctx.db.get(args.leadId);
|
|
|
|
if (!lead || lead.priority === "blocked" || lead.priority === "defer") {
|
|
return null;
|
|
}
|
|
|
|
if (!lead.websiteUrl) {
|
|
return null;
|
|
}
|
|
|
|
const existingPending = await ctx.db
|
|
.query("agentRuns")
|
|
.withIndex("by_type_and_status_and_leadId", (q) =>
|
|
q.eq("type", "audit").eq("status", "pending").eq("leadId", args.leadId),
|
|
)
|
|
.take(1);
|
|
|
|
const existingRunning = await ctx.db
|
|
.query("agentRuns")
|
|
.withIndex("by_type_and_status_and_leadId", (q) =>
|
|
q.eq("type", "audit").eq("status", "running").eq("leadId", args.leadId),
|
|
)
|
|
.take(1);
|
|
|
|
if (existingPending.length > 0) {
|
|
return existingPending[0]._id;
|
|
}
|
|
if (existingRunning.length > 0) {
|
|
return existingRunning[0]._id;
|
|
}
|
|
|
|
const runId = await ctx.db.insert("agentRuns", {
|
|
type: "audit",
|
|
leadId: args.leadId,
|
|
status: "pending",
|
|
currentStep: "pagespeed_insights",
|
|
counters: PAGE_SPEED_COUNTER_TEMPLATE,
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
});
|
|
|
|
await ctx.db.insert("agentRunEvents", {
|
|
runId,
|
|
level: "info",
|
|
message: "PageSpeed-Analyse wurde in die Warteschlange gesetzt.",
|
|
details: [
|
|
{ label: "Lead", value: args.leadId },
|
|
...(args.parentRunId ? [{ label: "Parent-Run", value: args.parentRunId }] : []),
|
|
],
|
|
createdAt: now,
|
|
});
|
|
|
|
await ctx.scheduler.runAfter(
|
|
0,
|
|
internal.pageSpeedAction.processPageSpeedAudit,
|
|
{
|
|
runId,
|
|
},
|
|
);
|
|
|
|
return runId;
|
|
},
|
|
});
|
|
|
|
export const startPageSpeedAuditRun = internalMutation({
|
|
args: {
|
|
runId: v.id("agentRuns"),
|
|
},
|
|
returns: v.union(
|
|
v.object({
|
|
lead: v.object({
|
|
_id: v.id("leads"),
|
|
websiteUrl: v.string(),
|
|
contactStatus: v.union(
|
|
v.literal("new"),
|
|
v.literal("missing_contact"),
|
|
v.literal("audit_ready"),
|
|
v.literal("outreach_ready"),
|
|
v.literal("contacted"),
|
|
v.literal("replied"),
|
|
v.literal("do_not_contact"),
|
|
),
|
|
}),
|
|
auditId: v.optional(v.id("audits")),
|
|
}),
|
|
v.null(),
|
|
),
|
|
handler: async (ctx, args): Promise<
|
|
{ lead: PageSpeedLead; auditId?: Id<"audits"> } | null
|
|
> => {
|
|
const now = Date.now();
|
|
const run = await ctx.db.get(args.runId);
|
|
|
|
if (!run) {
|
|
return null;
|
|
}
|
|
|
|
if (run.type !== "audit") {
|
|
return null;
|
|
}
|
|
|
|
if (run.status !== "pending") {
|
|
return null;
|
|
}
|
|
|
|
if (!run.leadId) {
|
|
await ctx.db.patch(args.runId, {
|
|
status: "failed",
|
|
currentStep: "pagespeed_insights",
|
|
errorSummary: "Run hat keine Lead-ID.",
|
|
updatedAt: now,
|
|
finishedAt: now,
|
|
});
|
|
|
|
await ctx.db.insert("agentRunEvents", {
|
|
runId: args.runId,
|
|
level: "error",
|
|
message:
|
|
"PageSpeed-Analyse konnte nicht gestartet werden: Kein Lead verknüpft.",
|
|
details: [{ label: "Lead-ID", value: "unbekannt" }],
|
|
createdAt: now,
|
|
});
|
|
|
|
return null;
|
|
}
|
|
|
|
const lead = await ctx.db.get(run.leadId);
|
|
if (!lead) {
|
|
await ctx.db.patch(args.runId, {
|
|
status: "failed",
|
|
currentStep: "pagespeed_insights",
|
|
errorSummary: "Lead wurde nicht gefunden.",
|
|
updatedAt: now,
|
|
finishedAt: now,
|
|
});
|
|
|
|
await ctx.db.insert("agentRunEvents", {
|
|
runId: args.runId,
|
|
level: "error",
|
|
message:
|
|
"PageSpeed-Analyse konnte nicht gestartet werden: Kein Lead mit Website-URL.",
|
|
details: [{ label: "Lead-ID", value: run.leadId }],
|
|
createdAt: now,
|
|
});
|
|
|
|
return null;
|
|
}
|
|
|
|
if (!lead.websiteUrl) {
|
|
await ctx.db.patch(args.runId, {
|
|
status: "failed",
|
|
currentStep: "pagespeed_insights",
|
|
errorSummary: "Lead hat keine Website-URL.",
|
|
updatedAt: now,
|
|
finishedAt: now,
|
|
});
|
|
|
|
await ctx.db.insert("agentRunEvents", {
|
|
runId: args.runId,
|
|
level: "error",
|
|
message:
|
|
"PageSpeed-Analyse konnte nicht gestartet werden: Kein Lead mit Website-URL.",
|
|
details: [{ label: "Lead-ID", value: lead._id }],
|
|
createdAt: now,
|
|
});
|
|
|
|
return null;
|
|
}
|
|
|
|
await ctx.db.patch(args.runId, {
|
|
status: "running",
|
|
currentStep: "pagespeed_insights",
|
|
startedAt: now,
|
|
updatedAt: now,
|
|
errorSummary: undefined,
|
|
});
|
|
|
|
await ctx.db.insert("agentRunEvents", {
|
|
runId: args.runId,
|
|
level: "info",
|
|
message: "PageSpeed-Analyse gestartet.",
|
|
details: [{ label: "Lead-ID", value: lead._id }],
|
|
createdAt: now,
|
|
});
|
|
|
|
return {
|
|
lead: {
|
|
_id: lead._id,
|
|
websiteUrl: lead.websiteUrl,
|
|
contactStatus: lead.contactStatus,
|
|
},
|
|
...(run.auditId ? { auditId: run.auditId } : {}),
|
|
};
|
|
},
|
|
});
|
|
|
|
export const persistPageSpeedResult = internalMutation({
|
|
args: {
|
|
leadId: v.id("leads"),
|
|
auditId: v.optional(v.id("audits")),
|
|
runId: v.id("agentRuns"),
|
|
strategy: pageSpeedStrategy,
|
|
status: pageSpeedResultStatus,
|
|
sourceUrl: v.string(),
|
|
finalUrl: v.optional(v.string()),
|
|
rawStorageId: v.optional(v.id("_storage")),
|
|
errorType: v.optional(pageSpeedErrorType),
|
|
errorSummary: v.optional(v.string()),
|
|
fetchedAt: v.number(),
|
|
normalized: v.optional(
|
|
v.object({
|
|
scores: v.optional(
|
|
v.object({
|
|
performance: v.optional(v.number()),
|
|
accessibility: v.optional(v.number()),
|
|
bestPractices: v.optional(v.number()),
|
|
seo: v.optional(v.number()),
|
|
}),
|
|
),
|
|
metrics: v.optional(
|
|
v.object({
|
|
firstContentfulPaintMs: v.optional(v.number()),
|
|
largestContentfulPaintMs: v.optional(v.number()),
|
|
cumulativeLayoutShift: v.optional(v.number()),
|
|
totalBlockingTimeMs: v.optional(v.number()),
|
|
speedIndexMs: v.optional(v.number()),
|
|
}),
|
|
),
|
|
opportunities: v.optional(v.array(v.string())),
|
|
implications: v.optional(v.array(v.string())),
|
|
}),
|
|
),
|
|
},
|
|
returns: v.id("pageSpeedResults"),
|
|
handler: async (ctx, args): Promise<Id<"pageSpeedResults">> => {
|
|
return await ctx.db.insert("pageSpeedResults", {
|
|
...args,
|
|
createdAt: Date.now(),
|
|
});
|
|
},
|
|
});
|
|
|
|
export const finishPageSpeedAuditRun = internalMutation({
|
|
args: {
|
|
runId: v.id("agentRuns"),
|
|
status: runStatus,
|
|
errorSummary: v.optional(v.string()),
|
|
errors: v.optional(v.number()),
|
|
},
|
|
handler: async (ctx, args) => {
|
|
const now = Date.now();
|
|
|
|
await ctx.db.patch(args.runId, {
|
|
status: args.status,
|
|
updatedAt: now,
|
|
finishedAt: now,
|
|
currentStep: "pagespeed_insights",
|
|
errorSummary: args.errorSummary,
|
|
counters: {
|
|
...PAGE_SPEED_COUNTER_TEMPLATE,
|
|
errors: args.errors ?? 0,
|
|
},
|
|
});
|
|
},
|
|
});
|