seed.ts

/**
 * SchemeAI Database Seeder
 * Populates the official source registry and the verified scheme
 * reference database. Idempotent — safe to run multiple times.
 *
 *   bun scripts/seed.ts
 */
import { PrismaClient } from "@prisma/client";
import { ALL_SEED_SCHEMES, ALL_SEED_SOURCES } from "../src/lib/schemes";

const db = new PrismaClient();

function slugKey(slug: string) {
  return slug;
}

async function seedSources() {
  for (const s of ALL_SEED_SOURCES) {
    await db.governmentSource.upsert({
      where: { domain: s.domain },
      create: {
        name: s.name,
        domain: s.domain,
        jurisdiction: s.jurisdiction,
        department: s.department,
        accessMethod: s.accessMethod,
        automationSupported: s.automationSupported,
        reliability: s.reliability,
        notes: s.notes,
        accessStatus: "UNKNOWN",
      },
      update: {
        name: s.name,
        jurisdiction: s.jurisdiction,
        department: s.department,
        accessMethod: s.accessMethod,
        automationSupported: s.automationSupported,
        reliability: s.reliability,
        notes: s.notes,
        // accessStatus / lastCheckedAt are only updated by REAL checks
      },
    });
  }
  console.log(`[seed] sources: ${ALL_SEED_SOURCES.length} upserted`);
}

async function seedSchemes() {
  let created = 0;
  let updated = 0;

  for (const s of ALL_SEED_SCHEMES) {
    const source = await db.governmentSource.findFirst({
      where: { name: s.sourceName },
    });

    const existing = await db.scheme.findUnique({ where: { slug: s.slug } });

    const baseData = {
      slug: s.slug,
      name: s.name,
      nameHi: s.nameHi,
      shortDescription: s.shortDescription,
      shortDescriptionHi: s.shortDescriptionHi,
      description: s.description,
      category: s.category,
      ministry: s.ministry,
      department: s.department,
      jurisdiction: s.jurisdiction,
      state: s.state ?? null,
      beneficiaryType: s.beneficiaryType,
      benefits: s.benefits,
      benefitAmount: s.benefitAmount,
      applicationUrl: s.applicationUrl,
      infoUrl: s.infoUrl,
      applicationWindow: s.applicationWindow,
      applicationDeadline: s.applicationDeadline,
      documentsJson: JSON.stringify(s.documents),
      processJson: JSON.stringify(s.process),
      keywords: s.keywords,
      confidence: s.confidence,
      extractionMethod: "SEED_REFERENCE",
      sourceId: source?.id,
      // NOTE: verificationStatus stays as-is if a real live check has already
      // upgraded it — we never overwrite real verification with seed state.
    };

    let schemeId: string;
    if (existing) {
      const upd = await db.scheme
        .update({ where: { slug: s.slug }, data: baseData })
        .catch(() => db.scheme.create({
          data: {
            ...baseData,
            id: slugKey(s.slug),
            verificationStatus: "REFERENCE",
            dataCompiledAt: new Date(),
          },
        }));
      schemeId = upd.id;
      updated++;
    } else {
      const cr = await db.scheme.create({
        data: {
          ...baseData,
          id: slugKey(s.slug),
          verificationStatus: "REFERENCE",
          dataCompiledAt: new Date(),
        },
      });
      schemeId = cr.id;
      created++;
    }

    // --- eligibility rules ---
    await db.schemeEligibilityRule.deleteMany({ where: { schemeId: schemeId } });
    for (const r of s.rules) {
      await db.schemeEligibilityRule.create({
        data: {
          schemeId: schemeId,
          attribute: r.attribute,
          operator: r.operator,
          value: JSON.stringify(r.value ?? null),
          required: r.required ?? true,
          label: r.label,
          labelHi: r.labelHi,
          ruleGroup: r.ruleGroup ?? null,
        },
      });
    }

    // --- evidence (refresh excerpts, keep real LIVE_FETCH evidence) ---
    await db.sourceEvidence.deleteMany({
      where: { schemeId: schemeId, evidenceType: "GUIDELINE_EXCERPT" },
    });
    for (const e of s.evidence) {
      await db.sourceEvidence.create({
        data: {
          schemeId: schemeId,
          sourceUrl: e.sourceUrl,
          excerpt: e.excerpt,
          evidenceType: e.evidenceType ?? "GUIDELINE_EXCERPT",
          note: e.note,
        },
      });
    }
  }

  console.log(`[seed] schemes: ${created} created, ${updated} updated`);
}

async function main() {
  console.log("[seed] starting…");
  await seedSources();
  await seedSchemes();

  const counts = {
    sources: await db.governmentSource.count(),
    schemes: await db.scheme.count(),
    rules: await db.schemeEligibilityRule.count(),
    evidence: await db.sourceEvidence.count(),
  };
  console.log("[seed] done:", counts);
}

main()
  .catch((e) => {
    console.error("[seed] FAILED:", e);
    process.exit(1);
  })
  .finally(() => db.$disconnect());