Migrating from Doola to Naive

// Server-side REST. Doola's primary interface is GraphQL (POST /graphql); the REST
// surface (POST /v1/companies) is shown for parity. Field names are illustrative —
// verify against your partner docs at developers.doola.com.
const DOOLA = "https://api.doola.com/v1";
const headers = {
  Authorization: `Bearer ${process.env.DOOLA_API_KEY!}`,
  "Content-Type": "application/json",
  "Idempotency-Key": crypto.randomUUID(), // doola supports idempotent creates
};

// 1. Create the customer (onboarding record). No KYC required for formation.
const customer = await fetch(`${DOOLA}/customers`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    email: "founder@acme.com",
    first_name: "Alice",
    last_name: "Smith",
  }),
}).then((r) => r.json());

// 2. Submit the company formation → returns an order id; filing happens async.
const company = await fetch(`${DOOLA}/companies`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    customer_id: customer.id,
    entity_type: "LLC",          // doola also supports "C_CORP" / "DAO_LLC"
    state: "WY",
    name_options: ["Acme Tech LLC", "Acme Technologies LLC"],
    founders: [{ customer_id: customer.id, ownership_percentage: 100 }],
  }),
}).then((r) => r.json());
// → company.order_id ; progress arrives on signed webhooks
//   ("Formation Filed", "Formation Completed", "Registered Agent Assigned")

import { Naive } from "@usenaive-sdk/server";

const naive = new Naive({ apiKey: process.env.NAIVE_API_KEY! });

// 1. The "customer" is a tenant user — but it owns the WHOLE stack, not just formation.
const acme = await naive.users.create({ external_id: dbCompany.id, email: "founder@acme.com" });
const client = naive.forUser(acme.id);

// 1a. KYC the founders first — formation is gated on ready_for_formation (Doola skips this).
const v = await client.verification.start({
  members: [
    {
      first_name: "Alice",
      last_name: "Smith",
      email: "founder@acme.com",
      ownership_percentage: 100,
      role: "primary",
      is_responsible_party: true,
    },
  ],
});
// hand v.primary_link to the founder; poll until v.ready_for_formation === true

const nv = { Authorization: `Bearer ${process.env.NAIVE_API_KEY!}`, "Content-Type": "application/json" };

// 2. Submit the formation → returns a $349 checkout_url. PII never touches your DB.
//    Pick a naics_code_id from GET /v1/formation/naics-codes first.
const { naics_codes } = await fetch("https://api.usenaive.ai/v1/formation/naics-codes", { headers: nv })
  .then((r) => r.json());
const formation = await client.formation.submit({
  verification_id: v.id,
  entity_type: "LLC",
  state: "WY",
  naics_code_id: naics_codes[0].id,
  description: "AI-powered business automation platform",
  name_options: [
    { name: "Acme Tech", entity_type_ending: "LLC" },
    { name: "Acme Technologies", entity_type_ending: "LLC" },
  ],
});
// → formation.id, formation.status: "awaiting_payment", formation.checkout_url

// 3. After the founder pays the checkout_url, dispatch the filing, then poll to documents.
await fetch(`https://api.usenaive.ai/v1/formation/${formation.id}/submit`, { method: "POST", headers: nv });
const status = await fetch(`https://api.usenaive.ai/v1/formation/${formation.id}`, { headers: nv })
  .then((r) => r.json());
// → status.status: "submitted" → "formation_completed"; then GET .../documents

// One call submits; doola handles payment (per your partner agreement) and files async.
const company = await fetch(`${DOOLA}/companies`, {
  method: "POST", headers,
  body: JSON.stringify({ customer_id, entity_type: "LLC", state: "WY", name_options: ["Acme LLC"] }),
}).then((r) => r.json());
// → company.order_id ; "Formation Filed" / "Formation Completed" webhooks fire later

// Submit creates a $349 checkout; the filing dispatches only after you execute on a paid record.
const formation = await client.formation.submit({
  verification_id, entity_type: "LLC", state: "WY",
  naics_code_id, description: "…", name_options: [{ name: "Acme", entity_type_ending: "LLC" }],
});
// → open formation.checkout_url (founder pays $349), then:
//   POST /v1/formation/{id}/submit  → status: "submitted" (PII pulled from vault, filed)
//   GET  /v1/formation/{id}         → poll to "formation_completed"

// One customer per founder; isolates the company filing, and only that.
const customer = await createDoolaCustomer({ email: founder.email });
await createDoolaCompany({ customer_id: customer.id, entity_type: "LLC", state: "WY" });

// The founders' KYC, the inbox, the secrets, the virtual card, the phone number for
// this company's agent live in entirely separate systems with their own tenancy,
// re-keyed to the order id by hand.

import { isPendingApproval } from "@usenaive-sdk/server";

// One tenant user per company; isolates *every* primitive.
const acme = await naive.users.create({ external_id: dbCompany.id, email: founder.email });
const client = naive.forUser(acme.id);

// 1. KYC the founders → 2. the SAME identity forms the LLC (PII pulled from the vault).
const v = await client.verification.start({ members: [/* founders */] });
const formation = await client.formation.submit({
  verification_id: v.id, entity_type: "LLC", state: "WY",
  naics_code_id, description: "AI-powered business automation",
  name_options: [{ name: "Acme Tech", entity_type_ending: "LLC" }],
});
if (isPendingApproval(formation)) { /* surface formation.approval_id to a human */ }

// 3. …and the SAME identity owns the company's card, phone, email, and vault — one handle.
await client.cards.create({ name: "Ops", spending_limit_cents: 25_000, provider: "managed_virtual" });
await client.phone.provision({ ein: "12-3456789", area_code: "415" });
await client.email.createInbox({ local_part: "founders" });
await client.vault.put("internal.api_key", "key_xyz");