webdev-pipeline/convex/audits.ts

import { v } from "convex/values";

import { normalizeListLimit } from "./domain";
import { internalMutation, mutation, query } from "./_generated/server";

const auditStatus = v.union(
  v.literal("draft"),
  v.literal("approved"),
  v.literal("published"),
  v.literal("deactivated"),
);
const usedSkillsValidator = v.array(
  v.object({
    name: v.string(),
    category: v.string(),
    version: v.optional(v.string()),
    source: v.optional(v.string()),
  }),
);
const skillSummaryValidator = v.array(
  v.object({
    name: v.string(),
    purpose: v.string(),
    summary: v.string(),
  }),
);

export const create = mutation({
  args: {
    leadId: v.id("leads"),
    slug: v.string(),
    checkedDomain: v.string(),
    checkedPages: v.array(v.string()),
    usedSkills: v.optional(usedSkillsValidator),
    status: v.optional(auditStatus),
    internalSummary: v.optional(v.string()),
    publicSummary: v.optional(v.string()),
    publicBody: v.optional(v.string()),
    ctaType: v.optional(v.string()),
  },
  handler: async (ctx, args) => {
    const now = Date.now();
    const existing = await ctx.db
      .query("audits")
      .withIndex("by_slug", (q) => q.eq("slug", args.slug))
      .take(1);

    if (existing.length > 0) {
      throw new Error("Audit slug already exists.");
    }

    return await ctx.db.insert("audits", {
      ...args,
      status: args.status ?? "draft",
      createdAt: now,
      updatedAt: now,
    });
  },
});

export const getDetail = query({
  args: { id: v.id("audits") },
  handler: async (ctx, args) => {
    const audit = await ctx.db.get(args.id);
    if (!audit) {
      return null;
    }

    const lead = await ctx.db.get(audit.leadId);
    return { audit, lead };
  },
});

export const get = query({
  args: { id: v.id("audits") },
  handler: async (ctx, args) => {
    return await ctx.db.get(args.id);
  },
});

export const upsertFromAuditGeneration = internalMutation({
  args: {
    leadId: v.id("leads"),
    runId: v.id("agentRuns"),
    auditId: v.optional(v.id("audits")),
    checkedDomain: v.string(),
    checkedPages: v.array(v.string()),
    internalSummary: v.optional(v.string()),
    multimodalSummary: v.optional(v.string()),
    publicSummary: v.optional(v.string()),
    publicBody: v.optional(v.string()),
    usedSkills: v.optional(usedSkillsValidator),
    skillSummaries: v.optional(skillSummaryValidator),
  },
  handler: async (ctx, args) => {
    const now = Date.now();
    const lead = await ctx.db.get(args.leadId);
    if (!lead) {
      throw new Error("Lead wurde nicht gefunden.");
    }

    if (args.auditId) {
      const existing = await ctx.db.get(args.auditId);
      if (!existing) {
        throw new Error("Audit wurde nicht gefunden.");
      }

      await ctx.db.patch(args.auditId, {
        checkedDomain: args.checkedDomain,
        checkedPages: args.checkedPages,
        internalSummary: args.internalSummary,
        multimodalSummary: args.multimodalSummary,
        publicSummary: args.publicSummary,
        publicBody: args.publicBody,
        usedSkills: args.usedSkills,
        skillSummaries: args.skillSummaries,
        updatedAt: now,
      });

      return args.auditId;
    }

    const safeCheckedDomain = args.checkedDomain.trim().toLowerCase();
    const domainTag = safeCheckedDomain.length > 0
      ? safeCheckedDomain.replace(/[^a-z0-9]+/g, "-").slice(0, 50)
      : "lead";
    let slug = `audit-${domainTag}-${args.leadId}-${now}`;

    const slugCandidates = await ctx.db
      .query("audits")
      .withIndex("by_slug", (q) => q.eq("slug", slug))
      .take(1);

    if (slugCandidates.length > 0) {
      slug = `${slug}-${Math.floor(now / 1_000)}`;
    }

    return await ctx.db.insert("audits", {
      leadId: args.leadId,
      status: "draft",
      slug,
      checkedDomain: args.checkedDomain,
      checkedPages: args.checkedPages,
      internalSummary: args.internalSummary,
      multimodalSummary: args.multimodalSummary,
      publicSummary: args.publicSummary,
      publicBody: args.publicBody,
      usedSkills: args.usedSkills,
      skillSummaries: args.skillSummaries,
      createdAt: now,
      updatedAt: now,
    });
  },
});

export const getBySlug = query({
  args: { slug: v.string() },
  handler: async (ctx, args) => {
    const audits = await ctx.db
      .query("audits")
      .withIndex("by_slug", (q) => q.eq("slug", args.slug))
      .take(1);

    return audits[0] ?? null;
  },
});

export const list = query({
  args: {
    leadId: v.optional(v.id("leads")),
    status: v.optional(auditStatus),
    limit: v.optional(v.number()),
  },
  handler: async (ctx, args) => {
    const limit = normalizeListLimit(args.limit);

    if (args.leadId) {
      const leadId = args.leadId;

      return await ctx.db
        .query("audits")
        .withIndex("by_leadId", (q) => q.eq("leadId", leadId))
        .order("desc")
        .take(limit);
    }

    if (args.status) {
      const status = args.status;

      return await ctx.db
        .query("audits")
        .withIndex("by_status", (q) => q.eq("status", status))
        .order("desc")
        .take(limit);
    }

    return await ctx.db.query("audits").order("desc").take(limit);
  },
});