Migrate provider linking (link-providers) from v1

curl --request POST "https://api.brellium.com/v2/email_recipients" \
  --header "Authorization: Bearer $BRELLIUM_ACCESS_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{
    "first_name": "Jordan",
    "last_name": "Rivera",
    "email": "Jordan.Rivera@example.com",
    "metadata": {}
  }' \
  --write-out "HTTP %{http_code}\n"

const res = await fetch("https://api.brellium.com/v2/email_recipients", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.BRELLIUM_ACCESS_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    first_name: "Jordan",
    last_name: "Rivera",
    email: "Jordan.Rivera@example.com",
    metadata: {},
  }),
});
if (!res.ok)
  throw new Error(`HTTP ${res.status} ${JSON.stringify((await res.json()).error)}`);
console.log(await res.json());
console.log(`HTTP ${res.status}`);

import BrelliumClient from "@brellium/api-client";

const client = new BrelliumClient({ oAuth2: process.env.BRELLIUM_ACCESS_TOKEN });

const emailRecipient = await client.emailRecipients.create({
  first_name: "Jordan",
  last_name: "Rivera",
  email: "Jordan.Rivera@example.com",
  metadata: {},
});
console.log(emailRecipient);

import os

from brellium_api_client import BrelliumClient

client = BrelliumClient(o_auth2=os.environ["BRELLIUM_ACCESS_TOKEN"])

email_recipient = client.email_recipients.create(
    first_name="Jordan",
    last_name="Rivera",
    email="Jordan.Rivera@example.com",
    metadata={},
)
print(email_recipient.to_json())

// Keep credentials on the server; never in a browser or mobile app.
import { readFileSync } from "node:fs";

const token = process.env.BRELLIUM_ACCESS_TOKEN;
if (!token) throw new Error("BRELLIUM_ACCESS_TOKEN is not set");

const BASE_URL = "https://api.brellium.com";
const HEADERS = {
  Authorization: `Bearer ${token}`,
  "Content-Type": "application/json",
};

type EmailRecipient = {
  person_id: string;
  first_name: string;
  last_name: string;
  email: string | null;
  metadata: Record<string, unknown>;
};
type ApiError = { error: { code: string; message: string; request_id: string } };
type Row = { first_name: string; last_name: string; email: string };

// Same parsing as v1: header row required, columns by name, blank lines dropped.
function parseCsv(path: string): Row[] {
  const lines = readFileSync(path, "utf8")
    .split(/\r?\n/)
    .filter((line) => line.trim() !== "");
  const header = lines[0].split(",").map((cell) => cell.trim());
  const columnOf = (name: string) => {
    const index = header.indexOf(name);
    if (index === -1) throw new Error(`CSV is missing the "${name}" column`);
    return index;
  };
  const firstNameColumn = columnOf("first_name");
  const lastNameColumn = columnOf("last_name");
  const emailColumn = columnOf("email");
  return lines.slice(1).map((line) => {
    const cells = line.split(",").map((cell) => cell.trim());
    return {
      first_name: cells[firstNameColumn] ?? "",
      last_name: cells[lastNameColumn] ?? "",
      email: cells[emailColumn] ?? "",
    };
  });
}

// On 429, waits Retry-After seconds and sends the request again, up to three
// times; the third 429 is returned for the caller to report.
async function call(path: string, init: RequestInit): Promise<Response> {
  for (let attempt = 1; ; attempt++) {
    const res = await fetch(`${BASE_URL}${path}`, { ...init, headers: HEADERS });
    if (res.status !== 429 || attempt === 3) return res;
    const wait = Number(res.headers.get("Retry-After") ?? "1");
    await new Promise((r) => setTimeout(r, wait * 1000));
  }
}

async function failure(res: Response): Promise<Error> {
  const { error } = (await res.json()) as ApiError;
  return new Error(
    `${res.status} ${error.code}: ${error.message} (request_id ` +
      `${error.request_id})`,
  );
}

async function linkRow(row: Row): Promise<"created" | "updated" | "skipped"> {
  const created = await call("/v2/email_recipients", {
    method: "POST",
    body: JSON.stringify({ ...row, metadata: {} }),
  });
  if (created.status === 201) return "created";
  if (created.status !== 409) throw await failure(created);

  // 409 EMAIL_RECIPIENT_EXISTS: someone already has this address.
  const found = await call(
    `/v2/email_recipients?email=${encodeURIComponent(row.email)}`,
    { method: "GET" },
  );
  if (!found.ok) throw await failure(found);
  const existing = ((await found.json()) as { data: EmailRecipient[] }).data[0];
  // not listed yet; lists can take a few seconds to include it
  if (!existing) return "skipped";
  if (
    existing.first_name === row.first_name &&
    existing.last_name === row.last_name
  )
    return "skipped";

  const updated = await call(`/v2/email_recipients/${existing.person_id}`, {
    method: "PATCH",
    // PATCH replaces all four fields: send the saved email and metadata back.
    body: JSON.stringify({
      first_name: row.first_name,
      last_name: row.last_name,
      email: existing.email ?? row.email,
      metadata: existing.metadata,
    }),
  });
  if (!updated.ok) throw await failure(updated);
  return "updated";
}

async function main() {
  const summary = { created: 0, updated: 0, skipped: 0, failed: 0 };
  for (const row of parseCsv(process.argv[2] ?? "providers.csv")) {
    if (!row.first_name || !row.last_name || !row.email) {
      // v1 skipped these with "Missing required fields."; v2 would answer 400
      summary.skipped++;
      continue;
    }
    try {
      summary[await linkRow(row)]++;
    } catch (err) {
      summary.failed++;
      console.error(row.email, (err as Error).message);
    }
  }
  console.log(summary);
}

main();

// Keep credentials on the server; never in a browser or mobile app.
import { readFileSync } from "node:fs";
import BrelliumClient, { APIError } from "@brellium/api-client";

const token = process.env.BRELLIUM_ACCESS_TOKEN;
if (!token) throw new Error("BRELLIUM_ACCESS_TOKEN is not set");

// On a 429 the client waits Retry-After and sends the request again, twice by
// default, so the script adds no retry of its own.
const client = new BrelliumClient({ oAuth2: token });

type Row = { first_name: string; last_name: string; email: string };

// Same parsing as v1: header row required, columns by name, blank lines dropped.
function parseCsv(path: string): Row[] {
  const lines = readFileSync(path, "utf8")
    .split(/\r?\n/)
    .filter((line) => line.trim() !== "");
  const header = lines[0].split(",").map((cell) => cell.trim());
  const columnOf = (name: string) => {
    const index = header.indexOf(name);
    if (index === -1) throw new Error(`CSV is missing the "${name}" column`);
    return index;
  };
  const firstNameColumn = columnOf("first_name");
  const lastNameColumn = columnOf("last_name");
  const emailColumn = columnOf("email");
  return lines.slice(1).map((line) => {
    const cells = line.split(",").map((cell) => cell.trim());
    return {
      first_name: cells[firstNameColumn] ?? "",
      last_name: cells[lastNameColumn] ?? "",
      email: cells[emailColumn] ?? "",
    };
  });
}

async function linkRow(row: Row): Promise<"created" | "updated" | "skipped"> {
  try {
    await client.emailRecipients.create({ ...row, metadata: {} });
    return "created";
  } catch (err) {
    if (!(err instanceof APIError) || err.status !== 409) throw err;
  }

  // 409 EMAIL_RECIPIENT_EXISTS: someone already has this address.
  const existing = (await client.emailRecipients.list({ email: row.email }))
    .data[0];
  // not listed yet; lists can take a few seconds to include it
  if (!existing) return "skipped";
  if (
    existing.first_name === row.first_name &&
    existing.last_name === row.last_name
  )
    return "skipped";

  // PATCH replaces all four fields: send the saved email and metadata back.
  await client.emailRecipients.update(existing.person_id, {
    first_name: row.first_name,
    last_name: row.last_name,
    email: existing.email ?? row.email,
    metadata: existing.metadata,
  });
  return "updated";
}

async function main() {
  const summary = { created: 0, updated: 0, skipped: 0, failed: 0 };
  for (const row of parseCsv(process.argv[2] ?? "providers.csv")) {
    if (!row.first_name || !row.last_name || !row.email) {
      // v1 skipped these with "Missing required fields."; v2 would answer 400
      summary.skipped++;
      continue;
    }
    try {
      summary[await linkRow(row)]++;
    } catch (err) {
      summary.failed++;
      console.error(row.email, (err as Error).message);
    }
  }
  console.log(summary);
}

main();

# Keep credentials on the server; never in a browser or mobile app.
import os
import sys
from typing import Dict, List

from brellium_api_client import APIStatusError, BrelliumClient

token = os.environ.get("BRELLIUM_ACCESS_TOKEN")
if not token:
    raise SystemExit("BRELLIUM_ACCESS_TOKEN is not set")

# On a 429 the client waits Retry-After and sends the request again, twice by
# default, so the script adds no retry of its own.
client = BrelliumClient(o_auth2=token)


# Same parsing as v1: header row required, columns by name, blank lines dropped.
def parse_csv(path: str) -> List[Dict[str, str]]:
    with open(path, encoding="utf-8") as file:
        lines = [line for line in file.read().splitlines() if line.strip()]
    header = [cell.strip() for cell in lines[0].split(",")]

    def column_of(name: str) -> int:
        if name not in header:
            raise SystemExit(f'CSV is missing the "{name}" column')
        return header.index(name)

    columns = {
        name: column_of(name) for name in ("first_name", "last_name", "email")
    }
    rows = []
    for line in lines[1:]:
        cells = [cell.strip() for cell in line.split(",")]
        rows.append(
            {
                name: cells[i] if i < len(cells) else ""
                for name, i in columns.items()
            }
        )
    return rows


def link_row(row: Dict[str, str]) -> str:
    try:
        client.email_recipients.create(
            first_name=row["first_name"],
            last_name=row["last_name"],
            email=row["email"],
            metadata={},
        )
        return "created"
    except APIStatusError as err:
        if err.status_code != 409:
            raise

    # 409 EMAIL_RECIPIENT_EXISTS: someone already has this address.
    found = client.email_recipients.list(email=row["email"]).data
    if not found:
        return "skipped"  # not listed yet; lists can lag a few seconds
    existing = found[0]
    if (
        existing.first_name == row["first_name"]
        and existing.last_name == row["last_name"]
    ):
        return "skipped"

    # PATCH replaces all four fields: send the saved email and metadata back.
    client.email_recipients.update(
        existing.person_id,
        first_name=row["first_name"],
        last_name=row["last_name"],
        email=existing.email or row["email"],
        metadata=existing.metadata,
    )
    return "updated"


def main() -> None:
    summary = {"created": 0, "updated": 0, "skipped": 0, "failed": 0}
    path = sys.argv[1] if len(sys.argv) > 1 else "providers.csv"
    for row in parse_csv(path):
        if not row["first_name"] or not row["last_name"] or not row["email"]:
            # v1 skipped these with "Missing required fields."; v2 would answer 400
            summary["skipped"] += 1
            continue
        try:
            summary[link_row(row)] += 1
        except Exception as err:
            summary["failed"] += 1
            print(row["email"], err, file=sys.stderr)
    print(summary)


main()

#!/usr/bin/env bash
# Creates one email recipient per CSV row; a 409 counts as "already there".
# Needs jq. Expects the columns first_name,last_name,email in that order.
set -euo pipefail
: "${BRELLIUM_ACCESS_TOKEN:?BRELLIUM_ACCESS_TOKEN is not set}"

tail -n +2 "${1:-providers.csv}" | tr -d '\r' |
while IFS=, read -r first last email _; do
  [ -z "$first$last$email" ] && continue
  body=$(jq -n --arg f "$first" --arg l "$last" --arg e "$email" \
    '{first_name: $f, last_name: $l, email: $e, metadata: {}}')
  status=$(curl --request POST "https://api.brellium.com/v2/email_recipients" \
    --silent --output /tmp/recipient.json --write-out "%{http_code}" \
    --header "Authorization: Bearer $BRELLIUM_ACCESS_TOKEN" \
    --header "Content-Type: application/json" \
    --data "$body")
  case "$status" in
    201) echo "created $email $(jq -r .person_id /tmp/recipient.json)" ;;
    409) echo "exists  $email" ;;
    *)
      code=$(jq -r .error.code /tmp/recipient.json)
      echo "failed  $email HTTP $status $code"
      ;;
  esac
done