Wealth.com Compatibility Guide

import { v4 as uuidv4 } from 'uuid';
import { InheritDocument, Estate, Person, Asset, Trust } from '@openinherit/sdk';

/**
 * Fetch a Wealth.com client and convert to an INHERIT document.
 * Requires a valid Wealth.com OAuth2 access token.
 */
async function importFromWealth(
  clientId: string,
  accessToken: string
): Promise<InheritDocument> {
  const baseUrl = 'https://api.wealth.com/v1';
  const headers = {
    Authorization: `Bearer ${accessToken}`,
    'Content-Type': 'application/json',
  };

  // Fetch all entities in parallel
  const [clientRes, peopleRes, trustsRes, assetsRes, docsRes] =
    await Promise.all([
      fetch(`${baseUrl}/clients/${clientId}`, { headers }),
      fetch(`${baseUrl}/clients/${clientId}/people`, { headers }),
      fetch(`${baseUrl}/clients/${clientId}/trusts`, { headers }),
      fetch(`${baseUrl}/clients/${clientId}/assets`, { headers }),
      fetch(`${baseUrl}/clients/${clientId}/documents`, { headers }),
    ]);

  const client = await clientRes.json();
  const people = await peopleRes.json();
  const trusts = await trustsRes.json();
  const assets = await assetsRes.json();
  const docs = await docsRes.json();

  // Map the testator (client) to an INHERIT person
  const testatorId = uuidv4();
  const testator: Person = {
    id: testatorId,
    givenName: client.firstName,
    familyName: client.lastName,
    dateOfBirth: client.dateOfBirth, // Already ISO 8601
    roles: ['testator'],
    contact: {
      email: client.email,
      phone: client.phone,
      address: mapWealthAddress(client.address),
    },
    identity: {
      externalIds: [
        {
          system: 'wealth.com',
          value: clientId,
          type: 'platform_id',
        },
      ],
    },
  };

  // Map all people to INHERIT persons
  const persons: Person[] = [testator];
  const wealthIdToInheritId = new Map<string, string>();
  wealthIdToInheritId.set(clientId, testatorId);

  for (const p of people.data) {
    const personId = uuidv4();
    wealthIdToInheritId.set(p.id, personId);

    persons.push({
      id: personId,
      givenName: p.firstName,
      familyName: p.lastName,
      additionalName: p.middleName ?? undefined,
      dateOfBirth: p.dateOfBirth ?? undefined,
      roles: mapWealthRoles(p.relationshipType),
      contact: {
        email: p.email ?? undefined,
        phone: p.phone ?? undefined,
        address: p.address ? mapWealthAddress(p.address) : undefined,
      },
      identity: {
        externalIds: [
          {
            system: 'wealth.com',
            value: p.id,
            type: 'platform_id',
          },
        ],
      },
    });
  }

  // Map trusts
  const inheritTrusts: Trust[] = trusts.data.map((t: any) => ({
    id: uuidv4(),
    name: t.name,
    trustType: mapWealthTrustType(t.type),
    creationType: t.isTestamentary ? 'testamentary' : 'inter_vivos_revocable',
    revocability: t.revocable ? 'revocable' : 'irrevocable',
    isTestamentary: t.isTestamentary ?? false,
    settlor: testatorId,
    trustees: (t.trustees ?? []).map((tr: any) => ({
      personId: wealthIdToInheritId.get(tr.personId) ?? uuidv4(),
      role: 'trustee' as const,
    })),
    beneficiaries: (t.beneficiaries ?? []).map((b: any) => ({
      personId: wealthIdToInheritId.get(b.personId) ?? uuidv4(),
      interestType: 'discretionary' as const,
    })),
    governingLaw: { code: mapStateToIso(t.governingState) },
  }));

  // Map assets (convert dollars to minor units)
  const inheritAssets: Asset[] = assets.data.map((a: any) => ({
    id: uuidv4(),
    name: a.name ?? a.description,
    category: mapWealthAssetCategory(a.type),
    subcategory: a.subtype ?? undefined,
    estimatedValue: a.value
      ? { amount: Math.round(a.value * 100), currency: 'USD' }
      : undefined,
    location: a.institution ?? undefined,
    identifiers: a.accountNumber
      ? [{ system: a.institution ?? 'unknown', value: a.accountNumber, type: 'account_number' }]
      : [],
    notes: a.notes ?? undefined,
  }));

  // Build the INHERIT document
  const now = new Date().toISOString();
  const estate: Estate = {
    id: uuidv4(),
    testatorPersonId: testatorId,
    status: client.status === 'deceased' ? 'pre_probate' : 'planning',
    domicile: { code: mapStateToIso(client.stateOfResidence) },
    primaryInstrument: mapPlanType(client.planType),
    createdAt: client.createdAt ?? now,
    lastModifiedAt: now,
  };

  return {
    $schema: 'https://openinherit.org/v3/inherit-document.json',
    estate,
    persons,
    trusts: inheritTrusts,
    assets: inheritAssets,
    documents: docs.data.map((d: any) => ({
      id: uuidv4(),
      type: mapWealthDocType(d.type),
      title: d.name ?? d.title,
      fileFormat: d.fileExtension?.toLowerCase() ?? 'pdf',
      createdAt: d.createdAt ?? now,
      storageRef: d.downloadUrl ?? undefined,
      notes: d.notes ?? undefined,
    })),
  };
}

// --- Helper functions ---

function mapWealthRoles(relationshipType: string): string[] {
  const roleMap: Record<string, string[]> = {
    spouse: ['beneficiary'],
    child: ['beneficiary'],
    executor: ['executor'],
    trustee: ['trustee'],
    guardian: ['guardian'],
    attorney: ['attorney'],
    beneficiary: ['beneficiary'],
    witness: ['witness'],
  };
  return roleMap[relationshipType?.toLowerCase()] ?? ['beneficiary'];
}

function mapWealthTrustType(type: string): string {
  const typeMap: Record<string, string> = {
    revocable_living: 'discretionary',
    irrevocable: 'discretionary',
    testamentary: 'discretionary',
    charitable: 'charitable',
    special_needs: 'disabled_persons',
  };
  return typeMap[type?.toLowerCase()] ?? 'other';
}

function mapWealthAssetCategory(type: string): string {
  const catMap: Record<string, string> = {
    bank_account: 'financial',
    investment: 'financial',
    retirement: 'financial',
    insurance: 'financial',
    vehicle: 'vehicle',
    personal_property: 'property_contents',
    business: 'business',
    digital: 'digital',
    real_estate: 'other', // Real estate uses property.json, not asset.json
  };
  return catMap[type?.toLowerCase()] ?? 'other';
}

function mapWealthDocType(type: string): string {
  const docMap: Record<string, string> = {
    will: 'will',
    trust_agreement: 'trust_deed',
    power_of_attorney: 'power_of_attorney',
    death_certificate: 'death_certificate',
    insurance_policy: 'insurance_policy',
  };
  return docMap[type?.toLowerCase()] ?? 'other';
}

function mapPlanType(planType: string): string {
  const map: Record<string, string> = {
    will: 'will',
    trust: 'revocable_trust',
    both: 'both',
  };
  return map[planType?.toLowerCase()] ?? 'will';
}

function mapStateToIso(state: string): string {
  // Convert US state abbreviation to ISO 3166-2 code
  return `US-${state?.toUpperCase()}`;
}

function mapWealthAddress(addr: any): any {
  return {
    streetAddress: addr.line1,
    addressLocality: addr.city,
    addressRegion: addr.state,
    postalCode: addr.zip,
    addressCountry: 'US',
  };
}

import { InheritDocument, Person, Trust, Asset } from '@openinherit/sdk';

/**
 * Push an INHERIT document to Wealth.com, creating or updating
 * the client, people, trusts, and assets.
 * Requires a valid Wealth.com OAuth2 access token.
 */
async function exportToWealth(
  doc: InheritDocument,
  accessToken: string
): Promise<{ clientId: string }> {
  const baseUrl = 'https://api.wealth.com/v1';
  const headers = {
    Authorization: `Bearer ${accessToken}`,
    'Content-Type': 'application/json',
  };

  // Find the testator
  const testator = doc.persons.find(
    (p) => p.id === doc.estate.testatorPersonId
  );
  if (!testator) {
    throw new Error('Testator person record not found in INHERIT document');
  }

  // Create or update the Wealth.com client
  const clientPayload = {
    firstName: testator.givenName,
    lastName: testator.familyName,
    email: testator.contact?.email,
    phone: testator.contact?.phone,
    dateOfBirth: testator.dateOfBirth,
    stateOfResidence: extractStateFromJurisdiction(doc.estate.domicile),
    address: testator.contact?.address
      ? mapToWealthAddress(testator.contact.address)
      : undefined,
  };

  const clientRes = await fetch(`${baseUrl}/clients`, {
    method: 'POST',
    headers,
    body: JSON.stringify(clientPayload),
  });
  const client = await clientRes.json();
  const clientId = client.id;

  // Create people (excluding the testator, who is already the client)
  const nonTestatorPersons = doc.persons.filter(
    (p) => p.id !== doc.estate.testatorPersonId
  );

  for (const person of nonTestatorPersons) {
    await fetch(`${baseUrl}/clients/${clientId}/people`, {
      method: 'POST',
      headers,
      body: JSON.stringify({
        firstName: person.givenName,
        lastName: person.familyName,
        middleName: person.additionalName,
        email: person.contact?.email,
        phone: person.contact?.phone,
        dateOfBirth: person.dateOfBirth,
        relationshipType: mapInheritRolesToWealth(person.roles),
        address: person.contact?.address
          ? mapToWealthAddress(person.contact.address)
          : undefined,
      }),
    });
  }

  // Create trusts
  for (const trust of doc.trusts ?? []) {
    await fetch(`${baseUrl}/clients/${clientId}/trusts`, {
      method: 'POST',
      headers,
      body: JSON.stringify({
        name: trust.name,
        type: mapInheritTrustTypeToWealth(trust.trustType, trust.creationType),
        revocable: trust.revocability === 'revocable',
        isTestamentary: trust.isTestamentary ?? false,
        governingState: extractStateFromJurisdiction(trust.governingLaw),
      }),
    });
  }

  // Create assets (convert minor units back to dollars)
  for (const asset of doc.assets ?? []) {
    await fetch(`${baseUrl}/clients/${clientId}/assets`, {
      method: 'POST',
      headers,
      body: JSON.stringify({
        name: asset.name,
        type: mapInheritCategoryToWealth(asset.category),
        subtype: asset.subcategory,
        value: asset.estimatedValue
          ? asset.estimatedValue.amount / 100
          : undefined,
        institution: asset.location,
        accountNumber: asset.identifiers?.[0]?.value,
        notes: asset.notes,
      }),
    });
  }

  // Upload documents
  for (const document of doc.documents ?? []) {
    await fetch(`${baseUrl}/clients/${clientId}/documents`, {
      method: 'POST',
      headers,
      body: JSON.stringify({
        name: document.title,
        type: mapInheritDocTypeToWealth(document.type),
        notes: document.notes,
      }),
    });
  }

  return { clientId };
}

// --- Helper functions ---

function extractStateFromJurisdiction(jurisdiction: any): string | undefined {
  const code = jurisdiction?.code;
  if (code?.startsWith('US-')) {
    return code.substring(3);
  }
  return undefined;
}

function mapToWealthAddress(addr: any): any {
  return {
    line1: addr.streetAddress,
    city: addr.addressLocality,
    state: addr.addressRegion,
    zip: addr.postalCode,
    country: addr.addressCountry ?? 'US',
  };
}

function mapInheritRolesToWealth(roles: string[]): string {
  // Wealth.com uses a single relationship type; pick the primary role
  if (roles.includes('executor')) return 'executor';
  if (roles.includes('trustee')) return 'trustee';
  if (roles.includes('guardian')) return 'guardian';
  if (roles.includes('attorney')) return 'attorney';
  if (roles.includes('witness')) return 'witness';
  return 'beneficiary';
}

function mapInheritTrustTypeToWealth(
  trustType: string,
  creationType?: string
): string {
  if (creationType === 'testamentary') return 'testamentary';
  if (trustType === 'charitable') return 'charitable';
  if (trustType === 'disabled_persons') return 'special_needs';
  return 'revocable_living';
}

function mapInheritCategoryToWealth(category: string): string {
  const catMap: Record<string, string> = {
    financial: 'investment',
    vehicle: 'vehicle',
    property_contents: 'personal_property',
    business: 'business',
    digital: 'digital',
  };
  return catMap[category] ?? 'personal_property';
}

function mapInheritDocTypeToWealth(type: string): string {
  const docMap: Record<string, string> = {
    will: 'will',
    trust_deed: 'trust_agreement',
    power_of_attorney: 'power_of_attorney',
    death_certificate: 'death_certificate',
    insurance_policy: 'insurance_policy',
  };
  return docMap[type] ?? 'other';
}