marketing_campaign_enabled: boolean('marketing_campaign_enabled').notNull().default(true),
  marketing_unsubscribed: boolean('marketing_unsubscribed').notNull().default(false),
  marketing_campaign_disabled_by: uuid('marketing_campaign_disabled_by'),
  marketing_campaign_disabled_at: timestamp('marketing_campaign_disabled_at', { withTimezone: true }),
  marketing_campaign_disabled_reason: text('marketing_campaign_disabled_reason'),
  activated_at: timestamp('activated_at', { withTimezone: true }),  // skip if column already exists

  email_marketing_opt_out: boolean('email_marketing_opt_out').notNull().default(false),

import { pgTable, uuid, text, timestamp, uniqueIndex, index } from 'drizzle-orm/pg-core';
import { clinics } from './clinics';
import { users } from './users';

export const clinicCampaignLog = pgTable(
  'clinic_campaign_log',
  {
    id: uuid('id').primaryKey().defaultRandom(),
    clinic_id: uuid('clinic_id').notNull().references(() => clinics.id, { onDelete: 'cascade' }),
    user_id: uuid('user_id').notNull().references(() => users.id),
    campaign_key: text('campaign_key').notNull(),
    subject: text('subject').notNull(),
    sent_at: timestamp('sent_at', { withTimezone: true }).notNull().defaultNow(),
    opened_at: timestamp('opened_at', { withTimezone: true }),
    clicked_at: timestamp('clicked_at', { withTimezone: true }),
    replied_at: timestamp('replied_at', { withTimezone: true }),
    zepto_message_id: text('zepto_message_id'),
  },
  (table) => ({
    uniqClinicKey: uniqueIndex('uniq_clinic_campaign_key').on(table.clinic_id, table.campaign_key),
    idxClinic: index('idx_campaign_log_clinic').on(table.clinic_id),
    idxKey: index('idx_campaign_log_key').on(table.campaign_key),
    idxSent: index('idx_campaign_log_sent').on(table.sent_at),
  })
);

export type ClinicCampaignLog = typeof clinicCampaignLog.$inferSelect;
export type NewClinicCampaignLog = typeof clinicCampaignLog.$inferInsert;

import { describe, it, expect } from 'vitest';
import { clinics } from '../../schema/clinics';
import { users } from '../../schema/users';
import { clinicCampaignLog } from '../../schema/campaign-log';

describe('campaign schema', () => {
  it('clinics has marketing_campaign_enabled column', () => {
    expect(clinics.marketing_campaign_enabled).toBeDefined();
  });
  it('clinics has marketing_unsubscribed column', () => {
    expect(clinics.marketing_unsubscribed).toBeDefined();
  });
  it('users has email_marketing_opt_out column', () => {
    expect(users.email_marketing_opt_out).toBeDefined();
  });
  it('clinicCampaignLog table is defined with required columns', () => {
    expect(clinicCampaignLog.clinic_id).toBeDefined();
    expect(clinicCampaignLog.campaign_key).toBeDefined();
    expect(clinicCampaignLog.sent_at).toBeDefined();
  });
});

git add server/src/schema/clinics.ts server/src/schema/users.ts server/src/schema/campaign-log.ts server/src/schema/index.ts server/src/campaigns/__tests__/schema.test.ts
git commit -m "feat(campaign): add clinic_campaign_log table + marketing columns

Adds clinic-level campaign toggle (marketing_campaign_enabled), user-level
marketing opt-out, and the dedupe log table with UNIQUE(clinic_id,
campaign_key)."

export type Phase = 'trial' | 'paid';

export type Signals = {
  patients: number;
  appointments: number;
  chartEntries: number;
  clinicalNotes: number;
  invoices: number;
  prescriptions: number;
  labCases: number;
  insuranceClaims: number;
  ipdVisits: number;
  aiReportsViewed: number;
  userCount: number;
  whatsappEnabled: boolean;
  financeEnabled: boolean;
  rxEnabled: boolean;
  labEnabled: boolean;
  insuranceEnabled: boolean;
  aiEnabled: boolean;
  ipdEnabled: boolean;
  mobileSessions: number;
  bulkToolsUsed: boolean;
  lastAppActivityAt: Date | null;
  dayInTrial: number;
  dayInPaid: number;
};

export type ClinicCtx = {
  id: string;
  name: string;
  subscriptionStatus: 'trial' | 'active' | 'suspended' | 'cancelled';
  trialEndDate: Date | null;
  activatedAt: Date | null;
  createdAt: Date;
  /** Most recently-added patient's first name, used by first_patient_added template */
  mostRecentPatientName?: string;
};

export type AdminRecipient = {
  userId: string;
  email: string;
  firstName: string;
};

export type LessonKey =
  | 'welcome' | 'first_patient_added' | 'first_appointment' | 'whatsapp_off'
  | 'dental_charting' | 'clinical_notes' | 'invite_staff' | 'mobile_app'
  | 'first_invoice' | 'first_prescription' | 'trial_thank_you'
  | 'paid_welcome' | 'lab_tracking' | 'insurance_claims'
  | 'ai_insights' | 'scale_milestone' | 'ipd_module';

export type TemplateProps = {
  firstName: string;
  clinicName: string;
  patientName?: string;
  patientCount?: number;
};

export type Lesson = {
  key: LessonKey;
  phase: Phase;
  priority: number;
  articleUrl: string;
  subject: string;
  trigger: (s: Signals, c: ClinicCtx) => boolean;
  render: (props: TemplateProps) => Promise<{ html: string; text: string }>;
};

git add server/src/campaigns/types.ts
git commit -m "feat(campaign): add lesson, signals, and recipient types"

import { describe, it, expect, beforeEach } from 'vitest';
import { db } from '../../db';
import { getActivationSignals } from '../signals';
import { clinics } from '../../schema/clinics';
import { patients } from '../../schema/patients';
import { eq } from 'drizzle-orm';

// Helper to create a fresh clinic for each test
async function makeClinic() {
  const [c] = await db.insert(clinics).values({
    name: 'Test Clinic',
    subscription_status: 'trial',
    trial_end_date: new Date(Date.now() + 14 * 86400e3),
    is_test_account: true,
  }).returning();
  return c;
}

describe('getActivationSignals', () => {
  it('returns zero counts for a fresh clinic', async () => {
    const c = await makeClinic();
    const s = await getActivationSignals(c.id);
    expect(s.patients).toBe(0);
    expect(s.appointments).toBe(0);
    expect(s.chartEntries).toBe(0);
    expect(s.dayInTrial).toBe(0);
    await db.delete(clinics).where(eq(clinics.id, c.id));
  });

  it('counts patients correctly', async () => {
    const c = await makeClinic();
    await db.insert(patients).values([
      { clinic_id: c.id, first_name: 'A', last_name: 'X' },
      { clinic_id: c.id, first_name: 'B', last_name: 'Y' },
    ]);
    const s = await getActivationSignals(c.id);
    expect(s.patients).toBe(2);
    await db.delete(clinics).where(eq(clinics.id, c.id));
  });

  it('computes dayInTrial from clinic createdAt', async () => {
    const c = await makeClinic();
    await db.update(clinics).set({ createdAt: new Date(Date.now() - 5 * 86400e3) }).where(eq(clinics.id, c.id));
    const s = await getActivationSignals(c.id);
    expect(s.dayInTrial).toBeGreaterThanOrEqual(5);
    await db.delete(clinics).where(eq(clinics.id, c.id));
  });
});

import { db } from '../db';
import { sql, eq, and, desc } from 'drizzle-orm';
import { clinics } from '../schema/clinics';
import { patients } from '../schema/patients';
import { appointments } from '../schema/appointments';
import { clinicModules } from '../schema/clinic_modules';
// Add other imports as needed; if a table doesn't exist for a count
// (e.g. ipd_visits when IPD module hasn't been built), use 0 as the value
// and add a TODO comment to wire it once the table lands.
import type { Signals, ClinicCtx } from './types';

export async function getActivationSignals(clinicId: string): Promise<Signals> {
  // Single batched query using Postgres parallel aggregates.
  // Each subquery returns one number; we wrap them in a single SELECT.
  const row = await db.execute<{
    patients: number; appointments: number; chart_entries: number;
    clinical_notes: number; invoices: number; prescriptions: number;
    lab_cases: number; insurance_claims: number; ipd_visits: number;
    ai_reports_viewed: number; user_count: number;
    mobile_sessions: number; bulk_tools_used: boolean;
    last_app_activity_at: Date | null;
    day_in_trial: number; day_in_paid: number;
    whatsapp_enabled: boolean; finance_enabled: boolean;
    rx_enabled: boolean; lab_enabled: boolean;
    insurance_enabled: boolean; ai_enabled: boolean; ipd_enabled: boolean;
  }>(sql`
    SELECT
      COALESCE((SELECT COUNT(*)::int FROM patients WHERE clinic_id = ${clinicId} AND deleted_at IS NULL), 0) AS patients,
      COALESCE((SELECT COUNT(*)::int FROM appointments WHERE clinic_id = ${clinicId}), 0) AS appointments,
      COALESCE((SELECT COUNT(*)::int FROM dental_chart_entries WHERE clinic_id = ${clinicId}), 0) AS chart_entries,
      COALESCE((SELECT COUNT(*)::int FROM clinical_notes WHERE clinic_id = ${clinicId}), 0) AS clinical_notes,
      COALESCE((SELECT COUNT(*)::int FROM invoices WHERE clinic_id = ${clinicId}), 0) AS invoices,
      COALESCE((SELECT COUNT(*)::int FROM prescriptions WHERE clinic_id = ${clinicId}), 0) AS prescriptions,
      COALESCE((SELECT COUNT(*)::int FROM lab_cases WHERE clinic_id = ${clinicId}), 0) AS lab_cases,
      COALESCE((SELECT COUNT(*)::int FROM insurance_claims WHERE clinic_id = ${clinicId}), 0) AS insurance_claims,
      COALESCE((SELECT COUNT(*)::int FROM ipd_visits WHERE clinic_id = ${clinicId}), 0) AS ipd_visits,
      COALESCE((SELECT COUNT(*)::int FROM ai_report_views WHERE clinic_id = ${clinicId}), 0) AS ai_reports_viewed,
      COALESCE((SELECT COUNT(*)::int FROM users WHERE clinic_id = ${clinicId} AND deleted_at IS NULL), 0) AS user_count,
      COALESCE((SELECT COUNT(DISTINCT session_id)::int FROM mobile_sessions WHERE clinic_id = ${clinicId}), 0) AS mobile_sessions,
      EXISTS(SELECT 1 FROM bulk_operations WHERE clinic_id = ${clinicId}) AS bulk_tools_used,
      (SELECT MAX(occurred_at) FROM app_activity WHERE clinic_id = ${clinicId}) AS last_app_activity_at,
      GREATEST(EXTRACT(DAY FROM (NOW() - (SELECT created_at FROM clinics WHERE id = ${clinicId})))::int, 0) AS day_in_trial,
      GREATEST(EXTRACT(DAY FROM (NOW() - (SELECT activated_at FROM clinics WHERE id = ${clinicId})))::int, 0) AS day_in_paid,
      COALESCE((SELECT (clinic_modules->>'whatsapp')::boolean FROM clinics WHERE id = ${clinicId}), false) AS whatsapp_enabled,
      COALESCE((SELECT (clinic_modules->>'finance')::boolean FROM clinics WHERE id = ${clinicId}), false) AS finance_enabled,
      COALESCE((SELECT (clinic_modules->>'prescriptions')::boolean FROM clinics WHERE id = ${clinicId}), false) AS rx_enabled,
      COALESCE((SELECT (clinic_modules->>'lab')::boolean FROM clinics WHERE id = ${clinicId}), false) AS lab_enabled,
      COALESCE((SELECT (clinic_modules->>'insurance')::boolean FROM clinics WHERE id = ${clinicId}), false) AS insurance_enabled,
      COALESCE((SELECT (clinic_modules->>'ai')::boolean FROM clinics WHERE id = ${clinicId}), false) AS ai_enabled,
      COALESCE((SELECT (clinic_modules->>'ipd')::boolean FROM clinics WHERE id = ${clinicId}), false) AS ipd_enabled
  `);

  const r = (row as any).rows ? (row as any).rows[0] : (row as any)[0];

  return {
    patients: r.patients,
    appointments: r.appointments,
    chartEntries: r.chart_entries,
    clinicalNotes: r.clinical_notes,
    invoices: r.invoices,
    prescriptions: r.prescriptions,
    labCases: r.lab_cases,
    insuranceClaims: r.insurance_claims,
    ipdVisits: r.ipd_visits,
    aiReportsViewed: r.ai_reports_viewed,
    userCount: r.user_count,
    mobileSessions: r.mobile_sessions,
    bulkToolsUsed: r.bulk_tools_used,
    lastAppActivityAt: r.last_app_activity_at,
    dayInTrial: r.day_in_trial,
    dayInPaid: r.day_in_paid,
    whatsappEnabled: r.whatsapp_enabled,
    financeEnabled: r.finance_enabled,
    rxEnabled: r.rx_enabled,
    labEnabled: r.lab_enabled,
    insuranceEnabled: r.insurance_enabled,
    aiEnabled: r.ai_enabled,
    ipdEnabled: r.ipd_enabled,
  };
}

export async function getClinicCtx(clinicId: string): Promise<ClinicCtx | null> {
  const [c] = await db.select().from(clinics).where(eq(clinics.id, clinicId)).limit(1);
  if (!c) return null;

  const [p] = await db
    .select({ first_name: patients.first_name })
    .from(patients)
    .where(eq(patients.clinic_id, clinicId))
    .orderBy(desc(patients.created_at))
    .limit(1);

  return {
    id: c.id,
    name: c.name,
    subscriptionStatus: c.subscription_status as ClinicCtx['subscriptionStatus'],
    trialEndDate: c.trial_end_date ?? null,
    activatedAt: c.activated_at ?? null,
    createdAt: c.created_at,
    mostRecentPatientName: p?.first_name,
  };
}

git add server/src/campaigns/signals.ts server/src/campaigns/__tests__/signals.test.ts
git commit -m "feat(campaign): add getActivationSignals batched query"

import { describe, it, expect } from 'vitest';
import * as T from '../triggers';
import type { Signals, ClinicCtx } from '../types';

const baseSignals: Signals = {
  patients: 0, appointments: 0, chartEntries: 0, clinicalNotes: 0,
  invoices: 0, prescriptions: 0, labCases: 0, insuranceClaims: 0,
  ipdVisits: 0, aiReportsViewed: 0, userCount: 1, mobileSessions: 0,
  bulkToolsUsed: false, lastAppActivityAt: null, dayInTrial: 0, dayInPaid: 0,
  whatsappEnabled: false, financeEnabled: false, rxEnabled: false,
  labEnabled: false, insuranceEnabled: false, aiEnabled: false, ipdEnabled: false,
};

const baseClinic: ClinicCtx = {
  id: 'c1', name: 'Test', subscriptionStatus: 'trial',
  trialEndDate: new Date(Date.now() + 14 * 86400e3),
  activatedAt: null, createdAt: new Date(),
};

describe('lesson triggers', () => {
  it('welcome fires when patients = 0', () => {
    expect(T.welcomeTrigger({ ...baseSignals, patients: 0 }, baseClinic)).toBe(true);
    expect(T.welcomeTrigger({ ...baseSignals, patients: 1 }, baseClinic)).toBe(false);
  });

  it('first_patient_added fires when patients ≥ 1', () => {
    expect(T.firstPatientAddedTrigger({ ...baseSignals, patients: 1 }, baseClinic)).toBe(true);
    expect(T.firstPatientAddedTrigger({ ...baseSignals, patients: 0 }, baseClinic)).toBe(false);
  });

  it('first_appointment fires when patients ≥ 3 AND appointments = 0', () => {
    expect(T.firstAppointmentTrigger({ ...baseSignals, patients: 3, appointments: 0 }, baseClinic)).toBe(true);
    expect(T.firstAppointmentTrigger({ ...baseSignals, patients: 2, appointments: 0 }, baseClinic)).toBe(false);
    expect(T.firstAppointmentTrigger({ ...baseSignals, patients: 5, appointments: 1 }, baseClinic)).toBe(false);
  });

  it('whatsapp_off fires when day ≥ 3, !whatsapp, patients ≥ 5', () => {
    expect(T.whatsappOffTrigger({ ...baseSignals, dayInTrial: 3, patients: 5, whatsappEnabled: false }, baseClinic)).toBe(true);
    expect(T.whatsappOffTrigger({ ...baseSignals, dayInTrial: 3, patients: 5, whatsappEnabled: true }, baseClinic)).toBe(false);
    expect(T.whatsappOffTrigger({ ...baseSignals, dayInTrial: 2, patients: 5 }, baseClinic)).toBe(false);
  });

  it('dental_charting fires when appointments ≥ 1 AND chartEntries = 0', () => {
    expect(T.dentalChartingTrigger({ ...baseSignals, appointments: 1, chartEntries: 0 }, baseClinic)).toBe(true);
    expect(T.dentalChartingTrigger({ ...baseSignals, appointments: 0, chartEntries: 0 }, baseClinic)).toBe(false);
  });

  it('clinical_notes fires when appointments ≥ 1, notes = 0, day ≥ 4', () => {
    expect(T.clinicalNotesTrigger({ ...baseSignals, appointments: 1, clinicalNotes: 0, dayInTrial: 4 }, baseClinic)).toBe(true);
    expect(T.clinicalNotesTrigger({ ...baseSignals, appointments: 1, clinicalNotes: 0, dayInTrial: 3 }, baseClinic)).toBe(false);
  });

  it('invite_staff fires when userCount = 1 AND day ≥ 5', () => {
    expect(T.inviteStaffTrigger({ ...baseSignals, userCount: 1, dayInTrial: 5 }, baseClinic)).toBe(true);
    expect(T.inviteStaffTrigger({ ...baseSignals, userCount: 2, dayInTrial: 5 }, baseClinic)).toBe(false);
  });

  it('mobile_app fires when no mobile session AND day ≥ 6', () => {
    expect(T.mobileAppTrigger({ ...baseSignals, mobileSessions: 0, dayInTrial: 6 }, baseClinic)).toBe(true);
    expect(T.mobileAppTrigger({ ...baseSignals, mobileSessions: 1, dayInTrial: 6 }, baseClinic)).toBe(false);
  });

  it('first_invoice fires when finance on AND invoices = 0 AND day ≥ 5', () => {
    expect(T.firstInvoiceTrigger({ ...baseSignals, financeEnabled: true, invoices: 0, dayInTrial: 5 }, baseClinic)).toBe(true);
    expect(T.firstInvoiceTrigger({ ...baseSignals, financeEnabled: false, invoices: 0, dayInTrial: 5 }, baseClinic)).toBe(false);
  });

  it('first_prescription fires when rx on AND prescriptions = 0 AND day ≥ 6', () => {
    expect(T.firstPrescriptionTrigger({ ...baseSignals, rxEnabled: true, prescriptions: 0, dayInTrial: 6 }, baseClinic)).toBe(true);
  });

  it('trial_thank_you fires when subscriptionStatus = active AND activatedAt within 24h', () => {
    const c: ClinicCtx = { ...baseClinic, subscriptionStatus: 'active', activatedAt: new Date(Date.now() - 1 * 3600e3) };
    expect(T.trialThankYouTrigger(baseSignals, c)).toBe(true);
    const tooOld: ClinicCtx = { ...c, activatedAt: new Date(Date.now() - 48 * 3600e3) };
    expect(T.trialThankYouTrigger(baseSignals, tooOld)).toBe(false);
  });

  it('paid_welcome fires 24h after conversion', () => {
    const c: ClinicCtx = { ...baseClinic, subscriptionStatus: 'active', activatedAt: new Date(Date.now() - 25 * 3600e3) };
    expect(T.paidWelcomeTrigger({ ...baseSignals, dayInPaid: 1 }, c)).toBe(true);
  });

  it('lab_tracking fires when lab on AND no cases', () => {
    expect(T.labTrackingTrigger({ ...baseSignals, labEnabled: true, labCases: 0 }, baseClinic)).toBe(true);
  });

  it('insurance_claims fires when insurance on AND no claims', () => {
    expect(T.insuranceClaimsTrigger({ ...baseSignals, insuranceEnabled: true, insuranceClaims: 0 }, baseClinic)).toBe(true);
  });

  it('ai_insights fires when ai on AND no reports viewed', () => {
    expect(T.aiInsightsTrigger({ ...baseSignals, aiEnabled: true, aiReportsViewed: 0 }, baseClinic)).toBe(true);
  });

  it('scale_milestone fires when patients ≥ 100 AND no bulk tools used', () => {
    expect(T.scaleMilestoneTrigger({ ...baseSignals, patients: 100, bulkToolsUsed: false }, baseClinic)).toBe(true);
    expect(T.scaleMilestoneTrigger({ ...baseSignals, patients: 99, bulkToolsUsed: false }, baseClinic)).toBe(false);
  });

  it('ipd_module fires when ipd on, no visits, day ≥ 14', () => {
    expect(T.ipdModuleTrigger({ ...baseSignals, ipdEnabled: true, ipdVisits: 0, dayInPaid: 14 }, baseClinic)).toBe(true);
  });
});

import type { Signals, ClinicCtx } from './types';

const hours = (n: number) => n * 3600 * 1000;

export const welcomeTrigger = (s: Signals, _c: ClinicCtx) =>
  s.patients === 0;

export const firstPatientAddedTrigger = (s: Signals, _c: ClinicCtx) =>
  s.patients >= 1;

export const firstAppointmentTrigger = (s: Signals, _c: ClinicCtx) =>
  s.patients >= 3 && s.appointments === 0;

export const whatsappOffTrigger = (s: Signals, _c: ClinicCtx) =>
  s.dayInTrial >= 3 && !s.whatsappEnabled && s.patients >= 5;

export const dentalChartingTrigger = (s: Signals, _c: ClinicCtx) =>
  s.appointments >= 1 && s.chartEntries === 0;

export const clinicalNotesTrigger = (s: Signals, _c: ClinicCtx) =>
  s.appointments >= 1 && s.clinicalNotes === 0 && s.dayInTrial >= 4;

export const inviteStaffTrigger = (s: Signals, _c: ClinicCtx) =>
  s.userCount === 1 && s.dayInTrial >= 5;

export const mobileAppTrigger = (s: Signals, _c: ClinicCtx) =>
  s.mobileSessions === 0 && s.dayInTrial >= 6;

export const firstInvoiceTrigger = (s: Signals, _c: ClinicCtx) =>
  s.financeEnabled && s.invoices === 0 && s.dayInTrial >= 5;

export const firstPrescriptionTrigger = (s: Signals, _c: ClinicCtx) =>
  s.rxEnabled && s.prescriptions === 0 && s.dayInTrial >= 6;

export const trialThankYouTrigger = (_s: Signals, c: ClinicCtx) =>
  c.subscriptionStatus === 'active' &&
  c.activatedAt !== null &&
  Date.now() - c.activatedAt.getTime() <= hours(24);

export const paidWelcomeTrigger = (s: Signals, c: ClinicCtx) =>
  c.subscriptionStatus === 'active' && s.dayInPaid >= 1;

export const labTrackingTrigger = (s: Signals, _c: ClinicCtx) =>
  s.labEnabled && s.labCases === 0;

export const insuranceClaimsTrigger = (s: Signals, _c: ClinicCtx) =>
  s.insuranceEnabled && s.insuranceClaims === 0;

export const aiInsightsTrigger = (s: Signals, _c: ClinicCtx) =>
  s.aiEnabled && s.aiReportsViewed === 0;

export const scaleMilestoneTrigger = (s: Signals, _c: ClinicCtx) =>
  s.patients >= 100 && !s.bulkToolsUsed;

export const ipdModuleTrigger = (s: Signals, _c: ClinicCtx) =>
  s.ipdEnabled && s.ipdVisits === 0 && s.dayInPaid >= 14;

git add server/src/campaigns/triggers.ts server/src/campaigns/__tests__/triggers.test.ts
git commit -m "feat(campaign): add 17 lesson trigger functions with unit tests"

import { describe, it, expect } from 'vitest';
import { render } from '@react-email/render';
import { CampaignEmail } from '../CampaignEmail';

describe('CampaignEmail layout', () => {
  it('renders the header logo, body paragraphs, CTA, and footer', async () => {
    const html = await render(
      <CampaignEmail
        previewText="Welcome"
        headerLogo="email"
        paragraphs={['Hi Aisha,', 'Welcome to OdontoX.']}
        cta={{ text: 'Get started →', href: 'https://q.odontox.io/guides/welcome' }}
        postscript="P.S. Backups at 2am PKT."
      />
    );
    expect(html).toContain('email.png');           // header logo image
    expect(html).toContain('Welcome to OdontoX');  // body copy
    expect(html).toContain('q.odontox.io/guides/welcome'); // CTA href
    expect(html).toContain('— Sarmad, OdontoX');   // sign-off
    expect(html).toContain('logo.png');            // footer logo
    expect(html).toContain('P.S. Backups');         // postscript
    expect(html).toContain('Unsubscribe');         // footer link
  });

  it('uses ruby.png when headerLogo = "ruby"', async () => {
    const html = await render(
      <CampaignEmail
        previewText="Ruby"
        headerLogo="ruby"
        paragraphs={['Hi.']}
        cta={{ text: 'See →', href: 'https://q.odontox.io/guides/ruby-reports' }}
        postscript="P.S."
      />
    );
    expect(html).toContain('ruby.png');
    expect(html).not.toContain('email.png');
  });
});

import * as React from 'react';
import {
  Html, Head, Preview, Body, Container, Section, Text, Link, Img, Hr,
} from '@react-email/components';

const ASSET_BASE = process.env.PUBLIC_ASSET_BASE || 'https://go.odontox.io';

const styles = {
  body: {
    backgroundColor: '#ffffff',
    fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif',
    color: '#111111',
    margin: 0,
    padding: 0,
    WebkitFontSmoothing: 'antialiased' as const,
  },
  container: {
    maxWidth: '560px',
    margin: '0 auto',
    padding: '40px 24px 32px',
  },
  logoHeader: { marginBottom: '32px' },
  logoHeaderImg: { height: '36px', width: 'auto', display: 'block' as const },
  paragraph: {
    fontSize: '16px',
    lineHeight: '1.65',
    color: '#111111',
    margin: '0 0 18px',
    letterSpacing: '-0.005em',
  },
  cta: {
    color: '#0C8C5E',
    fontSize: '16px',
    textDecoration: 'underline',
    textUnderlineOffset: '4px',
    fontWeight: 400,
  },
  ctaWrap: { margin: '8px 0 28px' },
  signoff: { fontSize: '16px', color: '#111', margin: '32px 0 0' },
  ps: {
    fontStyle: 'italic' as const,
    fontSize: '14px',
    color: '#9a9a9a',
    margin: '24px 0 0',
    lineHeight: '1.55',
  },
  footerSection: {
    borderTop: '1px solid #ececec',
    padding: '28px 24px 24px',
    textAlign: 'center' as const,
    backgroundColor: '#fafafb',
    marginTop: '32px',
  },
  footerLogo: { height: '20px', opacity: 0.65, display: 'inline-block' as const },
  footerText: {
    fontSize: '11px',
    color: '#9a9a9a',
    letterSpacing: '0.04em',
    margin: '14px 0 0',
  },
  footerLink: { color: '#9a9a9a', textDecoration: 'underline' },
};

export type CampaignEmailProps = {
  previewText: string;
  headerLogo: 'email' | 'ruby';
  paragraphs: string[];
  cta: { text: string; href: string };
  postscript: string;
  unsubscribeUrl?: string;
  preferencesUrl?: string;
};

export const CampaignEmail: React.FC<CampaignEmailProps> = ({
  previewText, headerLogo, paragraphs, cta, postscript,
  unsubscribeUrl = `${ASSET_BASE}/email/unsubscribe`,
  preferencesUrl = `${ASSET_BASE}/settings/email`,
}) => (
  <Html>
    <Head />
    <Preview>{previewText}</Preview>
    <Body style={styles.body}>
      <Container style={styles.container}>
        <Section style={styles.logoHeader}>
          <Img
            src={`${ASSET_BASE}/${headerLogo === 'ruby' ? 'ruby.png' : 'email.png'}`}
            alt={headerLogo === 'ruby' ? 'Ruby' : 'OdontoX'}
            style={styles.logoHeaderImg}
          />
        </Section>
        {paragraphs.map((p, i) => (
          <Text key={i} style={styles.paragraph}>{p}</Text>
        ))}
        <Section style={styles.ctaWrap}>
          <Link href={cta.href} style={styles.cta}>{cta.text}</Link>
        </Section>
        <Text style={styles.signoff}>— Sarmad, OdontoX</Text>
        <Text style={styles.ps}>P.S. {postscript}</Text>
      </Container>
      <Section style={styles.footerSection}>
        <Img src={`${ASSET_BASE}/logo.png`} alt="OdontoX" style={styles.footerLogo} />
        <Text style={styles.footerText}>
          OdontoX · Karachi ·{' '}
          <Link href={unsubscribeUrl} style={styles.footerLink}>Unsubscribe</Link>{' '}
          ·{' '}
          <Link href={preferencesUrl} style={styles.footerLink}>Email preferences</Link>
        </Text>
      </Section>
    </Body>
  </Html>
);

git add server/src/emails/campaign/CampaignEmail.tsx server/src/emails/campaign/__tests__/CampaignEmail.test.tsx
git commit -m "feat(campaign): add shared CampaignEmail React Email layout"

import { describe, it, expect } from 'vitest';
import { render } from '@react-email/render';
import * as templates from '../index';

const baseProps = { firstName: 'Aisha', clinicName: 'Khan Clinic', patientName: 'Hammad', patientCount: 6 };

const expectations: Record<string, { copyContains: string; ctaHref: string }> = {
  welcome:             { copyContains: 'Welcome to OdontoX',                  ctaHref: 'q.odontox.io/guides/welcome' },
  firstPatientAdded:   { copyContains: 'Hammad is in the system',             ctaHref: 'q.odontox.io/guides/appointments' },
  firstAppointment:    { copyContains: 'patients in the system',              ctaHref: 'q.odontox.io/guides/appointments' },
  whatsappOff:         { copyContains: 'WhatsApp is the highest-leverage',    ctaHref: 'q.odontox.io/guides/whatsapp-setup' },
  dentalCharting:      { copyContains: 'dental chart',                        ctaHref: 'q.odontox.io/guides/dental-chart' },
  clinicalNotes:       { copyContains: 'Most clinics dread writing notes',    ctaHref: 'q.odontox.io/guides/clinical-notes' },
  inviteStaff:         { copyContains: 'driving OdontoX solo',                ctaHref: 'q.odontox.io/guides/invite-staff' },
  mobileApp:           { copyContains: 'on a phone',                          ctaHref: 'q.odontox.io/guides/mobile-app' },
  firstInvoice:        { copyContains: 'Finance module',                      ctaHref: 'q.odontox.io/guides/invoices' },
  firstPrescription:   { copyContains: 'medicine library',                    ctaHref: 'q.odontox.io/guides/prescriptions' },
  trialThankYou:       { copyContains: 'upgraded to Pro today',               ctaHref: 'q.odontox.io/guides/pro-overview' },
  paidWelcome:         { copyContains: 'advanced parts of OdontoX',           ctaHref: 'q.odontox.io/guides/pro-roadmap' },
  labTracking:         { copyContains: 'Lab cases get tracked',               ctaHref: 'q.odontox.io/guides/lab-tracking' },
  insuranceClaims:     { copyContains: 'Insurance claims',                    ctaHref: 'q.odontox.io/guides/insurance-claims' },
  aiInsights:          { copyContains: 'Ruby is the part of OdontoX',         ctaHref: 'q.odontox.io/guides/ruby-reports' },
  scaleMilestone:      { copyContains: '100 patients',                        ctaHref: 'q.odontox.io/guides/scale-tips' },
  ipdModule:           { copyContains: 'In-Patient Department',               ctaHref: 'q.odontox.io/guides/ipd' },
};

describe('campaign templates', () => {
  for (const [name, exp] of Object.entries(expectations)) {
    it(`${name} renders with expected copy + CTA`, async () => {
      const Component = (templates as any)[name];
      expect(Component, `${name} not exported from index`).toBeDefined();
      const html = await render(<Component {...baseProps} />);
      expect(html).toContain(exp.copyContains);
      expect(html).toContain(exp.ctaHref);
      expect(html).toContain('Aisha');             // firstName interpolated
      expect(html).toContain('— Sarmad, OdontoX'); // sign-off always present
    });
  }

  it('aiInsights uses ruby.png in the header', async () => {
    const html = await render(<templates.aiInsights {...baseProps} />);
    expect(html).toContain('ruby.png');
  });
});

import * as React from 'react';
import { CampaignEmail } from './CampaignEmail';
import type { TemplateProps } from '../../campaigns/types';

export const welcome: React.FC<TemplateProps> = ({ firstName }) => (
  <CampaignEmail
    previewText="Welcome to OdontoX — your first step is one patient."
    headerLogo="email"
    paragraphs={[
      `Hi ${firstName},`,
      "Welcome to OdontoX. Over the next few days we'll send a small number of short emails — one feature at a time, only when there's something useful to cover.",
      "The first step is the foundation: adding a patient. Once a patient record exists, everything else in OdontoX — appointments, charting, prescriptions, invoices — builds from it.",
      "The guide walks through it in about a minute.",
    ]}
    cta={{ text: 'Adding your first patient →', href: 'https://q.odontox.io/guides/welcome' }}
    postscript="Your clinic data is backed up every night at 2am PKT."
  />
);

export const welcomeSubject = 'Welcome to OdontoX';

import * as React from 'react';
import { CampaignEmail } from './CampaignEmail';
import type { TemplateProps } from '../../campaigns/types';

export const firstPatientAdded: React.FC<TemplateProps> = ({ firstName, patientName = 'your first patient' }) => (
  <CampaignEmail
    previewText="Your first patient is in. Next, book them in."
    headerLogo="email"
    paragraphs={[
      `Hi ${firstName},`,
      `${patientName} is in the system. That's the foundation built — everything else in OdontoX layers on top of a patient record.`,
      `The next thirty seconds: open the Appointments tab and drag ${patientName} onto a time slot. That's how bookings work.`,
    ]}
    cta={{ text: 'Booking appointments →', href: 'https://q.odontox.io/guides/appointments' }}
    postscript="⌘K opens a search bar from any page in the app. Fastest way around."
  />
);

export const firstPatientAddedSubject = 'Your first patient is in';

import * as React from 'react';
import { CampaignEmail } from './CampaignEmail';
import type { TemplateProps } from '../../campaigns/types';

export const firstAppointment: React.FC<TemplateProps> = ({ firstName, patientCount = 0 }) => (
  <CampaignEmail
    previewText="Time to start booking. Appointments work like a calendar."
    headerLogo="email"
    paragraphs={[
      `Hi ${firstName},`,
      `${patientCount} patients in the system — time to start booking.`,
      "Appointments work like a calendar you can drag patients onto. Each booking carries a confirmation message, an automatic 24-hour reminder, and a post-visit follow-up — sent over WhatsApp when you've connected it. (We'll cover that one separately.)",
    ]}
    cta={{ text: 'How appointments work →', href: 'https://q.odontox.io/guides/appointments' }}
    postscript="The dots on each slot are status: green confirmed, amber tentative, red cancelled."
  />
);

export const firstAppointmentSubject = 'Booking your first appointment';

import * as React from 'react';
import { CampaignEmail } from './CampaignEmail';
import type { TemplateProps } from '../../campaigns/types';

export const whatsappOff: React.FC<TemplateProps> = ({ firstName }) => (
  <CampaignEmail
    previewText="Most clinics connect WhatsApp by day 3. No-shows drop ~40%."
    headerLogo="email"
    paragraphs={[
      `Hi ${firstName},`,
      "WhatsApp is the highest-leverage integration most OdontoX clinics turn on. Once connected, appointment confirmations, 24-hour reminders, and post-visit follow-ups go out automatically from your clinic's own number.",
      "Across clinics we've watched configure it, no-shows drop by around 40% in the first month.",
      "The WhatsApp module was rebuilt this month — delivery and read receipts now show on every message, and templates render Markdown.",
    ]}
    cta={{ text: 'Connecting WhatsApp →', href: 'https://q.odontox.io/guides/whatsapp-setup' }}
    postscript={'Patients see "via WhatsApp Business," not "via OdontoX." Your clinic stays the face.'}
  />
);

export const whatsappOffSubject = 'Connect WhatsApp to cut no-shows by 40%';

import * as React from 'react';
import { CampaignEmail } from './CampaignEmail';
import type { TemplateProps } from '../../campaigns/types';

export const dentalCharting: React.FC<TemplateProps> = ({ firstName }) => (
  <CampaignEmail
    previewText="Tap a tooth, mark a condition. The chart flows everywhere."
    headerLogo="email"
    paragraphs={[
      `Hi ${firstName},`,
      "The dental chart is one of the more visual parts of OdontoX. Open any patient, switch to the Chart tab, select a tooth, mark a condition, save.",
      "Anything you record flows into the treatment plan, prescription, and invoice automatically — you never enter the same data twice.",
    ]}
    cta={{ text: 'How the chart works →', href: 'https://q.odontox.io/guides/dental-chart' }}
    postscript="Adult, child, and mixed dentition layouts switch automatically based on the patient's age."
  />
);

export const dentalChartingSubject = 'Using the dental chart';

import * as React from 'react';
import { CampaignEmail } from './CampaignEmail';
import type { TemplateProps } from '../../campaigns/types';

export const clinicalNotes: React.FC<TemplateProps> = ({ firstName }) => (
  <CampaignEmail
    previewText="SOAP-style template, voice-to-text, two clicks from the appointment."
    headerLogo="email"
    paragraphs={[
      `Hi ${firstName},`,
      "Most clinics dread writing notes. OdontoX has a SOAP-style template that autosaves, voice-to-text on mobile, and templates you can reuse across patients.",
      'From the appointment screen, click "Add note" — two clicks, then dictate.',
    ]}
    cta={{ text: 'Writing clinical notes →', href: 'https://q.odontox.io/guides/clinical-notes' }}
    postscript="Voice transcription works in Urdu and English."
  />
);

export const clinicalNotesSubject = 'Clinical notes, the fast way';

import * as React from 'react';
import { CampaignEmail } from './CampaignEmail';
import type { TemplateProps } from '../../campaigns/types';

export const inviteStaff: React.FC<TemplateProps> = ({ firstName }) => (
  <CampaignEmail
    previewText="OdontoX works better with the whole clinic on it."
    headerLogo="email"
    paragraphs={[
      `Hi ${firstName},`,
      "You've been driving OdontoX solo so far. The app works better with the whole clinic on it: receptionists handle bookings and reminders, doctors stay in clinical mode, you get a real audit trail of who did what.",
      "Each role sees only what it should — receptionists don't see clinical notes, doctors don't see the finance ledger.",
    ]}
    cta={{ text: 'Inviting staff →', href: 'https://q.odontox.io/guides/invite-staff' }}
    postscript="Adding a teammate takes thirty seconds and doesn't change your billing during the trial."
  />
);

export const inviteStaffSubject = 'Add your team to OdontoX';

import * as React from 'react';
import { CampaignEmail } from './CampaignEmail';
import type { TemplateProps } from '../../campaigns/types';

export const mobileApp: React.FC<TemplateProps> = ({ firstName }) => (
  <CampaignEmail
    previewText="Pull up a patient between cases. Native app, not a webview."
    headerLogo="email"
    paragraphs={[
      `Hi ${firstName},`,
      "The mobile app does the things you'd actually want to do on a phone: pull up a patient between cases, check tomorrow's schedule, reply to a WhatsApp thread, write a quick note.",
      "It's a real native app, not a webview wrapper.",
    ]}
    cta={{ text: 'Getting the mobile app →', href: 'https://q.odontox.io/guides/mobile-app' }}
    postscript="iOS first, Android a few weeks behind on a couple of features. Both work today."
  />
);

export const mobileAppSubject = 'OdontoX on iOS and Android';

import * as React from 'react';
import { CampaignEmail } from './CampaignEmail';
import type { TemplateProps } from '../../campaigns/types';

export const firstInvoice: React.FC<TemplateProps> = ({ firstName }) => (
  <CampaignEmail
    previewText="Two clicks: treatment plan into invoice. PKR or USD."
    headerLogo="email"
    paragraphs={[
      `Hi ${firstName},`,
      "The Finance module turns a treatment plan into an invoice in two clicks. PKR or USD, WhatsApp the PDF or share a payment link.",
      "Receipts and installment plans work the same way — every transaction stays linked to the patient's record.",
    ]}
    cta={{ text: 'Creating invoices →', href: 'https://q.odontox.io/guides/invoices' }}
    postscript="Year-to-date revenue, by doctor, by service — Reports → Finance."
  />
);

export const firstInvoiceSubject = 'Sending your first invoice';

import * as React from 'react';
import { CampaignEmail } from './CampaignEmail';
import type { TemplateProps } from '../../campaigns/types';

export const firstPrescription: React.FC<TemplateProps> = ({ firstName }) => (
  <CampaignEmail
    previewText="Type two letters. Drug autocompletes with standard dosage."
    headerLogo="email"
    paragraphs={[
      `Hi ${firstName},`,
      "Prescriptions in OdontoX use a pre-loaded medicine library that covers local brand and generic names. Type two letters, the drug autocompletes with the standard dosage. Add it to the patient and the PDF is ready to print or WhatsApp.",
    ]}
    cta={{ text: 'Writing prescriptions →', href: 'https://q.odontox.io/guides/prescriptions' }}
    postscript="Your custom dosing presets persist across patients."
  />
);

export const firstPrescriptionSubject = 'Writing a prescription';

import * as React from 'react';
import { CampaignEmail } from './CampaignEmail';
import type { TemplateProps } from '../../campaigns/types';

export const trialThankYou: React.FC<TemplateProps> = ({ firstName }) => (
  <CampaignEmail
    previewText="Thank you. Welcome to OdontoX Pro."
    headerLogo="email"
    paragraphs={[
      `Hi ${firstName},`,
      "You upgraded to Pro today — thank you. That means a great deal to a small team.",
      "We'll keep writing every so often to walk you through the more advanced parts of OdontoX as they become relevant — lab tracking, insurance claims, Ruby Reports, and so on. You can adjust which emails you receive any time in Settings.",
    ]}
    cta={{ text: "What's included with Pro →", href: 'https://q.odontox.io/guides/pro-overview' }}
    postscript="Welcome."
  />
);

export const trialThankYouSubject = 'Welcome to OdontoX Pro';

import * as React from 'react';
import { CampaignEmail } from './CampaignEmail';
import type { TemplateProps } from '../../campaigns/types';

export const paidWelcome: React.FC<TemplateProps> = ({ firstName }) => (
  <CampaignEmail
    previewText="Now that the basics are running, the advanced parts of OdontoX become relevant."
    headerLogo="email"
    paragraphs={[
      `Hi ${firstName},`,
      "Now that the basics are running, the advanced parts of OdontoX become relevant — lab tracking, insurance claims, Ruby Reports, inventory, and a few more.",
      "We'll send a short email when each of those is worth a look. You can also browse them yourself.",
    ]}
    cta={{ text: 'The Pro roadmap →', href: 'https://q.odontox.io/guides/pro-roadmap' }}
    postscript="Pro pricing locks in for as long as your subscription stays active."
  />
);

export const paidWelcomeSubject = "What's next, now that you're on Pro";

import * as React from 'react';
import { CampaignEmail } from './CampaignEmail';
import type { TemplateProps } from '../../campaigns/types';

export const labTracking: React.FC<TemplateProps> = ({ firstName }) => (
  <CampaignEmail
    previewText="Stop chasing the lab. Sent, expected, returned, all tracked."
    headerLogo="email"
    paragraphs={[
      `Hi ${firstName},`,
      "Lab cases get tracked end-to-end in OdontoX — sent date, expected return, actual return, attached prosthetic photos, patient linkage. No more WhatsApp threads with the lab to keep track of crowns.",
    ]}
    cta={{ text: 'Tracking lab cases →', href: 'https://q.odontox.io/guides/lab-tracking' }}
    postscript="Overdue cases get flagged on the dashboard. You'll never have to chase a lab again."
  />
);

export const labTrackingSubject = 'Lab tracking in OdontoX';

import * as React from 'react';
import { CampaignEmail } from './CampaignEmail';
import type { TemplateProps } from '../../campaigns/types';

export const insuranceClaims: React.FC<TemplateProps> = ({ firstName }) => (
  <CampaignEmail
    previewText="Insurance claims pull from the treatment plan. No re-typing."
    headerLogo="email"
    paragraphs={[
      `Hi ${firstName},`,
      "Insurance claims in OdontoX pull from the treatment plan automatically — no re-typing procedures, codes, or costs. Generate the claim form, attach photos and notes, send to the insurer.",
      "The status tracker shows when claims are submitted, in review, approved, or denied.",
    ]}
    cta={{ text: 'Submitting claims →', href: 'https://q.odontox.io/guides/insurance-claims' }}
    postscript="Common insurer templates are pre-loaded. Add your own from Settings → Insurance."
  />
);

export const insuranceClaimsSubject = 'Submitting insurance claims';

import * as React from 'react';
import { CampaignEmail } from './CampaignEmail';
import type { TemplateProps } from '../../campaigns/types';

export const aiInsights: React.FC<TemplateProps> = ({ firstName }) => (
  <CampaignEmail
    previewText="Your weekly clinic report. Overdue patients, slipping treatments, lost revenue."
    headerLogo="ruby"
    paragraphs={[
      `Hi ${firstName},`,
      "Ruby is the part of OdontoX we don't talk about enough.",
      "She reviews your clinic's data and writes a short report every Monday morning — overdue patients, slipping treatments, days you're losing revenue to no-shows. Ten seconds to read, one click to act on.",
    ]}
    cta={{ text: 'How Ruby Reports work →', href: 'https://q.odontox.io/guides/ruby-reports' }}
    postscript="Ruby's report is written, not generated. We were careful about the tone."
  />
);

export const aiInsightsSubject = 'Meet Ruby — your weekly clinic report';

import * as React from 'react';
import { CampaignEmail } from './CampaignEmail';
import type { TemplateProps } from '../../campaigns/types';

export const scaleMilestone: React.FC<TemplateProps> = ({ firstName, patientCount = 100 }) => (
  <CampaignEmail
    previewText="Bulk tools, tags, segments — features for clinics at scale."
    headerLogo="email"
    paragraphs={[
      `Hi ${firstName},`,
      `Crossing ${patientCount} patients changes how you'll use OdontoX. A few features worth knowing:`,
      "• Bulk import and export from Settings → Data\n• Patient tags and segments for recall campaigns\n• Saved views in the appointments calendar",
    ]}
    cta={{ text: 'Features for scale →', href: 'https://q.odontox.io/guides/scale-tips' }}
    postscript="We've seen clinics break 1,000 patients without performance issues. Don't worry about the ceiling."
  />
);

export const scaleMilestoneSubject = 'You have 100 patients in OdontoX';

import * as React from 'react';
import { CampaignEmail } from './CampaignEmail';
import type { TemplateProps } from '../../campaigns/types';

export const ipdModule: React.FC<TemplateProps> = ({ firstName }) => (
  <CampaignEmail
    previewText="IPD: admissions, ward rounds, discharge summaries — structured."
    headerLogo="email"
    paragraphs={[
      `Hi ${firstName},`,
      "In-Patient Department is for clinics that admit patients overnight — common in larger maxillofacial and surgical practices.",
      "If you handle admissions, ward rounds, and discharge summaries, the IPD module turns those into structured records that link back to the patient and the billing.",
    ]}
    cta={{ text: 'Using IPD →', href: 'https://q.odontox.io/guides/ipd' }}
    postscript="Most clinics don't need this. If you do, it'll save you a notebook."
  />
);

export const ipdModuleSubject = 'The IPD module: when you need it';

export * from './welcome';
export * from './firstPatientAdded';
export * from './firstAppointment';
export * from './whatsappOff';
export * from './dentalCharting';
export * from './clinicalNotes';
export * from './inviteStaff';
export * from './mobileApp';
export * from './firstInvoice';
export * from './firstPrescription';
export * from './trialThankYou';
export * from './paidWelcome';
export * from './labTracking';
export * from './insuranceClaims';
export * from './aiInsights';
export * from './scaleMilestone';
export * from './ipdModule';

git add server/src/emails/campaign/
git commit -m "feat(campaign): add 17 React Email templates + smoke tests"

import { describe, it, expect } from 'vitest';
import { LESSONS } from '../lessons';

describe('lesson registry', () => {
  it('exports 17 lessons', () => {
    expect(LESSONS).toHaveLength(17);
  });
  it('all lesson keys are unique', () => {
    const keys = LESSONS.map((l) => l.key);
    expect(new Set(keys).size).toBe(17);
  });
  it('priorities are integers between 1 and 100', () => {
    for (const l of LESSONS) {
      expect(Number.isInteger(l.priority)).toBe(true);
      expect(l.priority).toBeGreaterThanOrEqual(1);
      expect(l.priority).toBeLessThanOrEqual(100);
    }
  });
  it('every lesson has a render function and trigger', () => {
    for (const l of LESSONS) {
      expect(typeof l.render).toBe('function');
      expect(typeof l.trigger).toBe('function');
    }
  });
  it('phase is either trial or paid', () => {
    for (const l of LESSONS) {
      expect(['trial', 'paid']).toContain(l.phase);
    }
  });
});