create-crm-starter 0.1.0

package/template/extras/estimates-invoices/drizzle/src/db/schema/invoices.ts

@@ -0,0 +1,59 @@
+import { integer, jsonb, pgEnum, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+import { customers } from './customers';
+import { jobs } from './jobs';
+import { estimates } from './estimates';
+
+export const invoiceStatus = pgEnum('invoice_status', [
+  'draft', 'sent', 'partial', 'paid', 'overdue', 'void',
+]);
+
+export const paymentMethod = pgEnum('payment_method', [
+  'card', 'ach', 'cash', 'check', 'manual', 'stripe',
+]);
+
+interface LineItemJson {
+  description: string;
+  qty: number;
+  unitPrice: number; // cents
+  taxable?: boolean;
+}
+
+export const invoices = pgTable('invoices', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  invoiceNumber: text('invoice_number').notNull().unique(),
+  customerId: uuid('customer_id').notNull().references(() => customers.id, { onDelete: 'restrict' }),
+  jobId: uuid('job_id').references(() => jobs.id, { onDelete: 'set null' }),
+  estimateId: uuid('estimate_id').references(() => estimates.id, { onDelete: 'set null' }),
+  status: invoiceStatus('status').notNull().default('draft'),
+  lineItems: jsonb('line_items').$type<LineItemJson[]>().notNull().default([]),
+  subtotal: integer('subtotal').notNull().default(0),  // cents
+  total: integer('total').notNull().default(0),
+  amountPaid: integer('amount_paid').notNull().default(0),
+  // Stripe metadata key for webhook reconciliation. Each invoice gets a
+  // random public token used both as the Stripe metadata link AND for the
+  // public payment page at /i/[publicToken] (Phase 18.5 ships that page).
+  publicToken: text('public_token').notNull().unique(),
+  notes: text('notes'),
+  dueDate: timestamp('due_date'),
+  sentAt: timestamp('sent_at'),
+  paidAt: timestamp('paid_at'),
+  createdAt: timestamp('created_at').notNull().defaultNow(),
+  updatedAt: timestamp('updated_at').notNull().defaultNow(),
+});
+
+export const invoicePayments = pgTable('invoice_payments', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  invoiceId: uuid('invoice_id').notNull().references(() => invoices.id, { onDelete: 'cascade' }),
+  amount: integer('amount').notNull(),                // cents
+  method: paymentMethod('method').notNull(),
+  stripeSessionId: text('stripe_session_id'),         // links back to Stripe Checkout Session
+  stripePaymentIntentId: text('stripe_payment_intent_id'),
+  note: text('note'),
+  recordedAt: timestamp('recorded_at').notNull().defaultNow(),
+  createdAt: timestamp('created_at').notNull().defaultNow(),
+});
+
+export type InvoiceRow = typeof invoices.$inferSelect;
+export type NewInvoice = typeof invoices.$inferInsert;
+export type InvoicePaymentRow = typeof invoicePayments.$inferSelect;
+export type NewInvoicePayment = typeof invoicePayments.$inferInsert;

package/template/extras/estimates-invoices/drizzle/src/lib/estimates/actions.ts

@@ -0,0 +1,110 @@
+'use server';
+
+import { eq } from 'drizzle-orm';
+import { redirect } from 'next/navigation';
+import { revalidatePath } from 'next/cache';
+import { db } from '@/db/client';
+import { estimates, jobs } from '@/db/schema';
+import type { EstimateLineItem, EstimateStatus } from './types';
+
+export interface CreateEstimateInput {
+  customerId: string;
+  status: EstimateStatus;
+  lineItems: EstimateLineItem[];
+  notes: string | null;
+  validUntil: string | null; // ISO
+}
+
+export async function createEstimate(input: CreateEstimateInput): Promise<void> {
+  if (!input.customerId) throw new Error('Customer is required');
+
+  const subtotal = input.lineItems.reduce((acc, li) => acc + li.qty * li.unitPrice, 0);
+  const totalCost = input.lineItems.reduce(
+    (acc, li) => acc + li.qty * (li.unitCost ?? 0),
+    0,
+  );
+
+  const [row] = await db
+    .insert(estimates)
+    .values({
+      customerId: input.customerId,
+      status: input.status,
+      lineItems: input.lineItems,
+      subtotal,
+      total: subtotal, // no tax/discount yet — Phase 22 wires those in
+      totalCost,
+      notes: input.notes ?? null,
+      validUntil: input.validUntil ? new Date(input.validUntil) : null,
+      sentAt: input.status === 'sent' ? new Date() : null,
+    })
+    .returning({ id: estimates.id });
+
+  revalidatePath('/estimates');
+  redirect(`/estimates/${row.id}`);
+}
+
+export async function setEstimateStatus(estimateId: string, status: EstimateStatus): Promise<void> {
+  const updates: {
+    status: EstimateStatus;
+    updatedAt: Date;
+    sentAt?: Date;
+    approvedAt?: Date;
+  } = {
+    status,
+    updatedAt: new Date(),
+  };
+  if (status === 'sent') updates.sentAt = new Date();
+  if (status === 'approved') updates.approvedAt = new Date();
+  await db.update(estimates).set(updates).where(eq(estimates.id, estimateId));
+  revalidatePath(`/estimates/${estimateId}`);
+  revalidatePath('/estimates');
+}
+
+/**
+ * Server action — clones an approved estimate into a new job (status =
+ * scheduled, line items copied over), marks the estimate as converted, and
+ * redirects to the new job detail page.
+ */
+export async function convertEstimateToJob(estimateId: string): Promise<void> {
+  const [estimate] = await db.select().from(estimates).where(eq(estimates.id, estimateId)).limit(1);
+  if (!estimate) throw new Error('Estimate not found');
+  if (estimate.status !== 'approved') {
+    throw new Error('Only approved estimates can be converted');
+  }
+  if (estimate.convertedJobId) {
+    redirect(`/jobs/${estimate.convertedJobId}`);
+  }
+
+  const lineItems = estimate.lineItems as EstimateLineItem[];
+  const [newJob] = await db
+    .insert(jobs)
+    .values({
+      customerId: estimate.customerId,
+      serviceType: 'From estimate',
+      status: 'scheduled',
+      priority: 'normal',
+      assigneeIds: [],
+      lineItems: lineItems.map((li) => ({
+        description: li.description,
+        qty: li.qty,
+        unitPrice: li.unitPrice,
+      })),
+      total: estimate.total,
+      notes: estimate.notes,
+    })
+    .returning({ id: jobs.id });
+
+  await db
+    .update(estimates)
+    .set({
+      status: 'converted',
+      convertedJobId: newJob.id,
+      updatedAt: new Date(),
+    })
+    .where(eq(estimates.id, estimateId));
+
+  revalidatePath('/estimates');
+  revalidatePath('/jobs');
+  revalidatePath(`/estimates/${estimateId}`);
+  redirect(`/jobs/${newJob.id}`);
+}

package/template/extras/estimates-invoices/drizzle/src/lib/estimates/data.ts

@@ -0,0 +1,57 @@
+import { desc, eq } from 'drizzle-orm';
+import { db } from '@/db/client';
+import { estimates as estimatesTable, customers as customersTable } from '@/db/schema';
+import type { Estimate, EstimateLineItem, EstimateStatus } from './types';
+
+interface JoinedRow {
+  estimate: typeof estimatesTable.$inferSelect;
+  customer: typeof customersTable.$inferSelect | null;
+}
+
+function toEstimate(row: JoinedRow): Estimate {
+  const e = row.estimate;
+  const lineItems = e.lineItems as EstimateLineItem[];
+  const totalCost = lineItems.reduce(
+    (acc, li) => acc + (li.unitCost ?? 0) * li.qty,
+    0,
+  );
+  const margin = e.total - totalCost;
+  const marginPct = e.total > 0 ? Math.round((margin / e.total) * 100) : 0;
+  return {
+    id: e.id,
+    customerId: e.customerId,
+    customerName: row.customer?.name ?? '(deleted)',
+    status: e.status as EstimateStatus,
+    lineItems,
+    subtotal: e.subtotal,
+    total: e.total,
+    totalCost,
+    margin,
+    marginPct,
+    notes: e.notes ?? undefined,
+    validUntil: e.validUntil?.toISOString(),
+    sentAt: e.sentAt?.toISOString(),
+    approvedAt: e.approvedAt?.toISOString(),
+    convertedJobId: e.convertedJobId ?? undefined,
+    createdAt: e.createdAt.toISOString(),
+  };
+}
+
+export async function getEstimates(): Promise<Estimate[]> {
+  const rows = await db
+    .select({ estimate: estimatesTable, customer: customersTable })
+    .from(estimatesTable)
+    .leftJoin(customersTable, eq(estimatesTable.customerId, customersTable.id))
+    .orderBy(desc(estimatesTable.createdAt));
+  return rows.map(toEstimate);
+}
+
+export async function getEstimate(id: string): Promise<Estimate | null> {
+  const [row] = await db
+    .select({ estimate: estimatesTable, customer: customersTable })
+    .from(estimatesTable)
+    .leftJoin(customersTable, eq(estimatesTable.customerId, customersTable.id))
+    .where(eq(estimatesTable.id, id))
+    .limit(1);
+  return row ? toEstimate(row) : null;
+}

package/template/extras/estimates-invoices/drizzle/src/lib/invoices/actions.ts

@@ -0,0 +1,199 @@
+'use server';
+
+import crypto from 'node:crypto';
+import { eq, sql } from 'drizzle-orm';
+import { headers } from 'next/headers';
+import { redirect } from 'next/navigation';
+import { revalidatePath } from 'next/cache';
+import { db } from '@/db/client';
+import { invoices, invoicePayments, jobs, customers } from '@/db/schema';
+import { stripe, isStripeConfigured } from '@/lib/stripe';
+import type { InvoiceLineItem, PaymentMethod } from './types';
+
+function genInvoiceNumber(): string {
+  const year = new Date().getUTCFullYear();
+  const random = crypto.randomBytes(3).toString('hex').toUpperCase();
+  return `INV-${year}-${random}`;
+}
+
+export interface CreateInvoiceFromJobInput {
+  jobId: string;
+  dueDateDays?: number; // days from now; default 30
+  customNote?: string;
+}
+
+/**
+ * Server action — generates an invoice from a Finished/Completed job.
+ * Copies the job's line items + total + customer. Status defaults to
+ * 'sent' so the customer can pay immediately.
+ */
+export async function createInvoiceFromJob(input: CreateInvoiceFromJobInput): Promise<void> {
+  const [job] = await db.select().from(jobs).where(eq(jobs.id, input.jobId)).limit(1);
+  if (!job) throw new Error('Job not found');
+
+  const lineItems = (job.lineItems as InvoiceLineItem[]).map((li) => ({
+    description: li.description,
+    qty: li.qty,
+    unitPrice: li.unitPrice,
+    taxable: true,
+  }));
+  const total = lineItems.reduce((acc, li) => acc + li.qty * li.unitPrice, 0);
+  if (total <= 0) {
+    throw new Error('Job has no priced line items — add some before invoicing.');
+  }
+
+  const dueDate = new Date();
+  dueDate.setDate(dueDate.getDate() + (input.dueDateDays ?? 30));
+
+  const [row] = await db
+    .insert(invoices)
+    .values({
+      invoiceNumber: genInvoiceNumber(),
+      customerId: job.customerId,
+      jobId: job.id,
+      status: 'sent',
+      lineItems,
+      subtotal: total,
+      total,
+      amountPaid: 0,
+      publicToken: crypto.randomBytes(16).toString('hex'),
+      notes: input.customNote ?? null,
+      dueDate,
+      sentAt: new Date(),
+    })
+    .returning({ id: invoices.id });
+
+  revalidatePath('/invoices');
+  revalidatePath(`/jobs/${input.jobId}`);
+  redirect(`/invoices/${row.id}`);
+}
+
+export interface RecordPaymentInput {
+  invoiceId: string;
+  amount: number; // cents
+  method: PaymentMethod;
+  note?: string;
+  stripeSessionId?: string;
+  stripePaymentIntentId?: string;
+}
+
+/**
+ * Records a payment against an invoice. Re-computes amountPaid + transitions
+ * status to 'paid' if fully covered or 'partial' otherwise. Safe to call
+ * from both UI (manual entry) and the Stripe webhook (idempotency via
+ * stripeSessionId uniqueness check).
+ */
+export async function recordInvoicePayment(input: RecordPaymentInput): Promise<void> {
+  // Idempotency: if a payment with the same stripeSessionId already exists,
+  // bail. Stripe retries webhooks; we don't want to double-record.
+  if (input.stripeSessionId) {
+    const existing = await db
+      .select({ id: invoicePayments.id })
+      .from(invoicePayments)
+      .where(eq(invoicePayments.stripeSessionId, input.stripeSessionId))
+      .limit(1);
+    if (existing.length > 0) return;
+  }
+
+  await db.insert(invoicePayments).values({
+    invoiceId: input.invoiceId,
+    amount: input.amount,
+    method: input.method,
+    note: input.note ?? null,
+    stripeSessionId: input.stripeSessionId ?? null,
+    stripePaymentIntentId: input.stripePaymentIntentId ?? null,
+  });
+
+  // Recompute amountPaid by summing payment rows.
+  const [{ paid }] = await db
+    .select({ paid: sql<number>`COALESCE(SUM(${invoicePayments.amount}), 0)::int` })
+    .from(invoicePayments)
+    .where(eq(invoicePayments.invoiceId, input.invoiceId));
+
+  const [invoice] = await db
+    .select({ total: invoices.total })
+    .from(invoices)
+    .where(eq(invoices.id, input.invoiceId))
+    .limit(1);
+  if (!invoice) return;
+
+  const fullyPaid = paid >= invoice.total;
+  await db
+    .update(invoices)
+    .set({
+      amountPaid: paid,
+      status: fullyPaid ? 'paid' : 'partial',
+      paidAt: fullyPaid ? new Date() : null,
+      updatedAt: new Date(),
+    })
+    .where(eq(invoices.id, input.invoiceId));
+
+  revalidatePath(`/invoices/${input.invoiceId}`);
+  revalidatePath('/invoices');
+}
+
+/**
+ * Server action — creates a Stripe Checkout Session for an invoice's
+ * remaining amount due and redirects the user to Stripe-hosted checkout.
+ * Session metadata.invoiceId + metadata.publicToken are read by the
+ * webhook handler to record the payment.
+ */
+export async function createCheckoutForInvoice(invoiceId: string): Promise<void> {
+  if (!isStripeConfigured) {
+    throw new Error('Stripe is not configured. Set STRIPE_SECRET_KEY in .env.local.');
+  }
+
+  // Fetch the invoice + customer email for the Stripe receipt.
+  const [row] = await db
+    .select({ invoice: invoices, customerEmail: customers.emails })
+    .from(invoices)
+    .leftJoin(customers, eq(invoices.customerId, customers.id))
+    .where(eq(invoices.id, invoiceId))
+    .limit(1);
+  if (!row) throw new Error('Invoice not found');
+  const { invoice } = row;
+  const amountDue = Math.max(0, invoice.total - invoice.amountPaid);
+  if (amountDue <= 0) throw new Error('Invoice has nothing left to pay');
+
+  const h = await headers();
+  const host = h.get('host') ?? 'localhost:3000';
+  const proto = h.get('x-forwarded-proto') ?? (host.startsWith('localhost') ? 'http' : 'https');
+  const origin = `${proto}://${host}`;
+  const customerEmail = Array.isArray(row.customerEmail) ? row.customerEmail[0] : undefined;
+
+  const session = await stripe.checkout.sessions.create({
+    mode: 'payment',
+    customer_email: customerEmail,
+    line_items: [
+      {
+        price_data: {
+          currency: 'usd',
+          product_data: { name: `Invoice ${invoice.invoiceNumber}` },
+          unit_amount: amountDue,
+        },
+        quantity: 1,
+      },
+    ],
+    success_url: `${origin}/invoices/${invoice.id}?paid=true`,
+    cancel_url: `${origin}/invoices/${invoice.id}?cancelled=true`,
+    metadata: {
+      invoiceId: invoice.id,
+      invoiceNumber: invoice.invoiceNumber,
+      publicToken: invoice.publicToken,
+    },
+  });
+
+  if (!session.url) throw new Error('Stripe did not return a checkout URL');
+  redirect(session.url);
+}
+
+/**
+ * Public-page variant — accepts a publicToken (used in the customer-facing
+ * /i/[token] page so no internal invoiceId leaks into URLs). Resolves the
+ * token to an invoice and forwards to createCheckoutForInvoice.
+ */
+export async function payByPublicToken(token: string): Promise<void> {
+  const [row] = await db.select().from(invoices).where(eq(invoices.publicToken, token)).limit(1);
+  if (!row) throw new Error('Invoice not found');
+  await createCheckoutForInvoice(row.id);
+}

package/template/extras/estimates-invoices/drizzle/src/lib/invoices/data.ts

@@ -0,0 +1,99 @@
+import { desc, eq } from 'drizzle-orm';
+import { db } from '@/db/client';
+import {
+  invoices as invoicesTable,
+  invoicePayments as paymentsTable,
+  customers as customersTable,
+} from '@/db/schema';
+import type { Invoice, InvoiceLineItem, InvoicePayment, InvoiceStatus, PaymentMethod } from './types';
+
+interface InvoiceRow {
+  invoice: typeof invoicesTable.$inferSelect;
+  customer: typeof customersTable.$inferSelect | null;
+}
+
+function toInvoice(row: InvoiceRow, payments: (typeof paymentsTable.$inferSelect)[]): Invoice {
+  const i = row.invoice;
+  const lineItems = i.lineItems as InvoiceLineItem[];
+  const amountDue = Math.max(0, i.total - i.amountPaid);
+  const isOverdue =
+    i.dueDate !== null &&
+    amountDue > 0 &&
+    new Date(i.dueDate) < new Date() &&
+    (i.status === 'sent' || i.status === 'partial');
+  return {
+    id: i.id,
+    invoiceNumber: i.invoiceNumber,
+    customerId: i.customerId,
+    customerName: row.customer?.name ?? '(deleted)',
+    jobId: i.jobId ?? undefined,
+    estimateId: i.estimateId ?? undefined,
+    status: (isOverdue ? 'overdue' : i.status) as InvoiceStatus,
+    lineItems,
+    subtotal: i.subtotal,
+    total: i.total,
+    amountPaid: i.amountPaid,
+    amountDue,
+    dueDate: i.dueDate?.toISOString(),
+    sentAt: i.sentAt?.toISOString(),
+    paidAt: i.paidAt?.toISOString(),
+    notes: i.notes ?? undefined,
+    createdAt: i.createdAt.toISOString(),
+    payments: payments.map(
+      (p): InvoicePayment => ({
+        id: p.id,
+        amount: p.amount,
+        method: p.method as PaymentMethod,
+        recordedAt: p.recordedAt.toISOString(),
+        note: p.note ?? undefined,
+      }),
+    ),
+  };
+}
+
+export async function getInvoices(): Promise<Invoice[]> {
+  const rows = await db
+    .select({ invoice: invoicesTable, customer: customersTable })
+    .from(invoicesTable)
+    .leftJoin(customersTable, eq(invoicesTable.customerId, customersTable.id))
+    .orderBy(desc(invoicesTable.createdAt));
+  // List page doesn't need full payment history — pass empty for perf.
+  return rows.map((r) => toInvoice(r, []));
+}
+
+export async function getInvoice(id: string): Promise<Invoice | null> {
+  const [row] = await db
+    .select({ invoice: invoicesTable, customer: customersTable })
+    .from(invoicesTable)
+    .leftJoin(customersTable, eq(invoicesTable.customerId, customersTable.id))
+    .where(eq(invoicesTable.id, id))
+    .limit(1);
+  if (!row) return null;
+  const payments = await db
+    .select()
+    .from(paymentsTable)
+    .where(eq(paymentsTable.invoiceId, id))
+    .orderBy(desc(paymentsTable.recordedAt));
+  return toInvoice(row, payments);
+}
+
+/**
+ * Public-page lookup keyed by the random per-invoice publicToken.
+ * The token is the security boundary: anyone with the token can VIEW
+ * and PAY the invoice. No login required.
+ */
+export async function getInvoiceByPublicToken(token: string): Promise<Invoice | null> {
+  const [row] = await db
+    .select({ invoice: invoicesTable, customer: customersTable })
+    .from(invoicesTable)
+    .leftJoin(customersTable, eq(invoicesTable.customerId, customersTable.id))
+    .where(eq(invoicesTable.publicToken, token))
+    .limit(1);
+  if (!row) return null;
+  const payments = await db
+    .select()
+    .from(paymentsTable)
+    .where(eq(paymentsTable.invoiceId, row.invoice.id))
+    .orderBy(desc(paymentsTable.recordedAt));
+  return toInvoice(row, payments);
+}

package/template/extras/estimates-invoices/drizzle/src/lib/invoices/email-actions.ts

@@ -0,0 +1,102 @@
+'use server';
+
+import { headers } from 'next/headers';
+import { eq } from 'drizzle-orm';
+import { revalidatePath } from 'next/cache';
+import { db } from '@/db/client';
+import { invoices, customers } from '@/db/schema';
+import { business } from '@/lib/business';
+
+/**
+ * Sends an invoice email via Resend's REST API. We hit the API directly
+ * (no SDK dep) so this works whether or not the comms-email module is
+ * installed.
+ *
+ * Requires RESEND_API_KEY and EMAIL_FROM env vars. Errors surface to the
+ * UI via the calling component's error state.
+ */
+export async function sendInvoiceEmail(invoiceId: string): Promise<{ ok: true; messageId: string }> {
+  const apiKey = process.env.RESEND_API_KEY;
+  const from = process.env.EMAIL_FROM;
+  if (!apiKey || !from) {
+    throw new Error(
+      'Resend not configured. Set RESEND_API_KEY and EMAIL_FROM in .env.local.',
+    );
+  }
+
+  const [row] = await db
+    .select({ invoice: invoices, customerEmails: customers.emails, customerName: customers.name })
+    .from(invoices)
+    .leftJoin(customers, eq(invoices.customerId, customers.id))
+    .where(eq(invoices.id, invoiceId))
+    .limit(1);
+  if (!row) throw new Error('Invoice not found');
+  const customerEmail = Array.isArray(row.customerEmails) ? row.customerEmails[0] : null;
+  if (!customerEmail) throw new Error('Customer has no email on file');
+
+  const h = await headers();
+  const host = h.get('host') ?? 'localhost:3000';
+  const proto = h.get('x-forwarded-proto') ?? (host.startsWith('localhost') ? 'http' : 'https');
+  const publicUrl = `${proto}://${host}/i/${row.invoice.publicToken}`;
+  const amountDue = Math.max(0, row.invoice.total - row.invoice.amountPaid);
+  const amountFmt = new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' }).format(
+    amountDue / 100,
+  );
+
+  const subject = `Invoice ${row.invoice.invoiceNumber} from ${business.name}`;
+  const html = `
+    <div style="font-family: ui-sans-serif, system-ui, sans-serif; max-width: 520px; margin: 0 auto; padding: 24px;">
+      <h1 style="font-size: 20px; margin: 0 0 8px;">${escapeHtml(business.name)}</h1>
+      <p style="color: #6b7280; margin: 0 0 24px;">Invoice <strong>${escapeHtml(row.invoice.invoiceNumber)}</strong></p>
+      <p>Hi ${escapeHtml(row.customerName ?? 'there')},</p>
+      <p>Your invoice for ${amountFmt} is ready. Click below to view details or pay online — it takes about 30 seconds.</p>
+      <p style="margin: 24px 0;">
+        <a href="${publicUrl}" style="display: inline-block; background: hsl(160 84% 39%); color: white; padding: 12px 24px; border-radius: 6px; text-decoration: none; font-weight: 600;">View & pay ${amountFmt}</a>
+      </p>
+      <p style="color: #6b7280; font-size: 13px;">Or copy this link: <br><a href="${publicUrl}">${publicUrl}</a></p>
+      ${business.phone ? `<p style="color: #6b7280; font-size: 13px;">Questions? Call us at <a href="tel:${business.phone}">${business.phone}</a>.</p>` : ''}
+      <hr style="border: none; border-top: 1px solid #e5e7eb; margin: 32px 0;">
+      <p style="color: #9ca3af; font-size: 11px;">${escapeHtml(business.legalName)}${business.address ? ` · ${escapeHtml(business.address)}` : ''}</p>
+    </div>
+  `;
+
+  const resp = await fetch('https://api.resend.com/emails', {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      from,
+      to: customerEmail,
+      subject,
+      html,
+    }),
+  });
+
+  if (!resp.ok) {
+    const errBody = await resp.text();
+    throw new Error(`Resend API ${resp.status}: ${errBody}`);
+  }
+  const result = (await resp.json()) as { id?: string };
+
+  // Mark the invoice as sent if it was still in draft.
+  if (row.invoice.status === 'draft') {
+    await db
+      .update(invoices)
+      .set({ status: 'sent', sentAt: new Date(), updatedAt: new Date() })
+      .where(eq(invoices.id, invoiceId));
+  }
+
+  revalidatePath(`/invoices/${invoiceId}`);
+  return { ok: true, messageId: result.id ?? '' };
+}
+
+function escapeHtml(s: string): string {
+  return s
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}

package/template/extras/inspection-checklists/src/app/(dashboard)/inspections/page.tsx

@@ -0,0 +1,60 @@
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { Badge } from '@/components/ui/badge';
+
+const CHECKLISTS = [
+  {
+    id: 'cl_panel',
+    name: 'Panel upgrade inspection',
+    items: [
+      'Main breaker rating verified',
+      'Grounding electrode bonded',
+      'Service entrance conductors sized correctly',
+      'Working clearance meets code',
+      'GFCI/AFCI protection installed',
+      'Panel directory labeled',
+      'Permit number posted on-site',
+    ],
+  },
+  {
+    id: 'cl_outlet',
+    name: 'Outlet/circuit inspection',
+    items: [
+      'GFCI tested with built-in test button',
+      'Polarity verified',
+      'Junction box covers in place',
+      'Wire gauge matches breaker rating',
+      'No double-tapped breakers',
+    ],
+  },
+];
+
+export default function InspectionsPage() {
+  return (
+    <div className="space-y-6">
+      <div>
+        <h1 className="text-3xl font-bold tracking-tight">Inspection checklists</h1>
+        <p className="text-muted-foreground mt-1 text-sm">
+          Pre-built lists technicians complete in the field. Customize per service type.
+        </p>
+      </div>
+      <div className="grid grid-cols-1 gap-4 md:grid-cols-2">
+        {CHECKLISTS.map((cl) => (
+          <Card key={cl.id}>
+            <CardHeader className="flex flex-row items-center justify-between space-y-0">
+              <CardTitle className="text-base">{cl.name}</CardTitle>
+              <Badge variant="outline">{cl.items.length} items</Badge>
+            </CardHeader>
+            <CardContent className="space-y-2">
+              {cl.items.map((item, i) => (
+                <div key={i} className="flex items-start gap-2 text-sm">
+                  <input type="checkbox" disabled className="mt-1" />
+                  <span>{item}</span>
+                </div>
+              ))}
+            </CardContent>
+          </Card>
+        ))}
+      </div>
+    </div>
+  );
+}