Open source alternative to Semrush and Ahrefs
TypeScript backlink-analysisgoogle-search-console-mcpkeyword-researchmcpseoseo-agentseo-auditseo-automationseo-skillsseo-toolssite-audit
import { z } from "zod";
import {
buildStoredLighthouseIssues,
buildStoredLighthouseMetrics,
type RawLighthouseAudit,
type RawLighthouseCategory,
scoreToPercent,
type StoredLighthousePayload,
storedLighthousePayloadSchema,
} from "@/server/lib/lighthouseStoredPayload";
export const requestCategories = [
"performance",
"accessibility",
"best_practices",
"seo",
] as const;
export type LighthouseStrategy = "mobile" | "desktop";
const lighthouseResponseSchema = z.object({
requestedUrl: z.string().optional(),
finalUrl: z.string().optional(),
lighthouseVersion: z.string().optional(),
// Only the key map is copied here, so the multi-MB category/audit bodies stay
// as the provider's own objects. Deep-parsing them cloned the whole report a
// second time and pushed the audit worker over its memory limit.
categories: z
.record(z.string(), z.custom<RawLighthouseCategory>())
.optional(),
audits: z.record(z.string(), z.custom<RawLighthouseAudit>()).optional(),
});
const dataforseoTaskSchema = z.object({
id: z.string().optional(),
cost: z.number().optional(),
status_code: z.number().optional(),
status_message: z.string().optional(),
result: z.array(lighthouseResponseSchema).optional(),
});
const dataforseoLighthouseResponseSchema = z.object({
status_code: z.number().optional(),
status_message: z.string().optional(),
tasks: z.array(dataforseoTaskSchema).optional(),
});
function summarizeZodIssues(error: z.ZodError, maxIssues = 3): string {
return error.issues
.slice(0, maxIssues)
.map((issue) => {
const path = issue.path.length > 0 ? issue.path.join(".") : "<root>";
return `${path}: ${issue.message}`;
})
.join("; ");
}
export function parseDataforseoLighthousePayload(
payload: unknown,
input: { url: string; strategy: LighthouseStrategy },
): StoredLighthousePayload {
// Only the envelope scalars are validated up front. The report is reduced
// straight into the compact stored payload, which is then validated in full
// below — the same fields the old whole-report schema checked, at kilobyte
// size instead of multi-megabyte.
const parsed = dataforseoLighthouseResponseSchema.safeParse(payload);
if (!parsed.success) {
throw new Error(
`DataForSEO Lighthouse returned an invalid response: ${summarizeZodIssues(parsed.error)}`,
);
}
if (parsed.data.status_code !== 20000) {
throw new Error(
parsed.data.status_message ?? "DataForSEO Lighthouse request failed",
);
}
const task = parsed.data.tasks?.[0];
if (!task) {
throw new Error("DataForSEO Lighthouse response missing task");
}
if (task.status_code !== 20000) {
throw new Error(task.status_message ?? "DataForSEO Lighthouse task failed");
}
const result = task.result?.[0];
if (!result) {
throw new Error("DataForSEO Lighthouse response missing result");
}
const fetchedAt = new Date().toISOString();
const categories = result.categories ?? {};
const audits = result.audits ?? {};
const issueReport = buildStoredLighthouseIssues({ audits, categories });
const metrics = buildStoredLighthouseMetrics({ audits });
const storedPayload: StoredLighthousePayload = {
version: 2,
source: "dataforseo-lighthouse",
hasIssueDetails: issueReport.hasIssueDetails,
metadata: {
requestedUrl: result.requestedUrl ?? input.url,
finalUrl: result.finalUrl ?? input.url,
strategy: input.strategy,
fetchedAt,
lighthouseVersion: result.lighthouseVersion ?? null,
taskId: task.id ?? null,
cost: task.cost ?? null,
},
scores: {
performance: scoreToPercent(categories.performance?.score),
accessibility: scoreToPercent(categories.accessibility?.score),
"best-practices": scoreToPercent(categories["best-practices"]?.score),
seo: scoreToPercent(categories.seo?.score),
},
metrics,
issues: issueReport.issues,
};
const allScoresMissing = Object.values(storedPayload.scores).every(
(score) => score == null,
);
if (allScoresMissing) {
throw new Error(
`DataForSEO Lighthouse returned no category scores for ${storedPayload.metadata.finalUrl}`,
);
}
// Without this, an off-spec provider field (a numeric audit title, say) would
// be stored and then fail to parse on read, silently blanking the page's
// whole Lighthouse view instead of failing the check.
const validated = storedLighthousePayloadSchema.safeParse(storedPayload);
if (!validated.success) {
throw new Error(
`DataForSEO Lighthouse returned an invalid report: ${summarizeZodIssues(validated.error)}`,
);
}
return storedPayload;
}