Merge duplicates

COEVERA_BASE="https://{region}.api.coevera.com/api/v100/rest/spaces/{space_id}"

const base = `https://{region}.api.coevera.com/api/v100/rest/spaces/{space_id}`;
const auth = Buffer.from(`${env.COEVERA_API_KEY}:${env.COEVERA_API_SECRET}`).toString("base64");

async function coevera(path: string, init: { method?: string; body?: unknown } = {}) {
  const res = await fetch(`${base}${path}`, {
    method: init.method ?? "GET",
    headers: { Authorization: `Basic ${auth}`, "Content-Type": "application/json" },
    body: init.body === undefined ? undefined : JSON.stringify(init.body),
  });
  const body = await res.json();
  if (!res.ok) throw new Error(`HTTP ${res.status} ${body.name}: ${String(body.message).trim()}`);
  return body;
}

BASE = "https://{region}.api.coevera.com/api/v100/rest/spaces/{space_id}"
session = requests.Session()
session.auth = (os.environ["COEVERA_API_KEY"], os.environ["COEVERA_API_SECRET"])


def coevera(method, path, **kwargs):
    response = session.request(method, f"{BASE}{path}", timeout=30, **kwargs)
    body = response.json()
    if not response.ok:
        sys.exit(f"HTTP {response.status_code} {body.get('name')}: {str(body.get('message')).strip()}")
    return body

COEVERA_GRAPHQL="https://{region}.api.coevera.com/api/v100/app/space/{space_id}/graphql/public"

# gql: POST the GraphQL request read from stdin. GraphQL reports errors in the body, often
# with HTTP 200, so fail on those too.
gql() {
  local response
  response=$(curl -sS --fail-with-body "$COEVERA_GRAPHQL" \
    -u "$COEVERA_API_KEY:$COEVERA_API_SECRET" \
    -H "Content-Type: application/json" \
    -d @-)
  if jq -e '.errors' <<<"$response" >/dev/null; then
    echo "$response" >&2
    return 1
  fi
  echo "$response"
}

const endpoint = `https://{region}.api.coevera.com/api/v100/app/space/{space_id}/graphql/public`;
const auth = Buffer.from(`${env.COEVERA_API_KEY}:${env.COEVERA_API_SECRET}`).toString("base64");

// gql: one GraphQL request. GraphQL reports errors in the body, often with HTTP 200.
async function gql(query: string, variables: object = {}) {
  const res = await fetch(endpoint, {
    method: "POST",
    headers: { Authorization: `Basic ${auth}`, "Content-Type": "application/json" },
    body: JSON.stringify({ query, variables }),
  });
  const body = await res.json();
  if (!res.ok || body.errors) throw new Error(`HTTP ${res.status}: ${JSON.stringify(body.errors ?? body)}`);
  return body.data;
}

ENDPOINT = (
    "https://{region}.api.coevera.com/api/v100/app/space/"
    "{space_id}/graphql/public"
)
session = requests.Session()
session.auth = (os.environ["COEVERA_API_KEY"], os.environ["COEVERA_API_SECRET"])


def gql(query, variables=None):
    """One GraphQL request. GraphQL reports errors in the body, often with HTTP 200."""
    response = session.post(ENDPOINT, json={"query": query, "variables": variables or {}}, timeout=30)
    body = response.json()
    if not response.ok or body.get("errors"):
        sys.exit(f"HTTP {response.status_code}: {json.dumps(body.get('errors', body))}")
    return body["data"]

owner=$(curl -sS --fail-with-body -G "$COEVERA_BASE/entities/Clients" \
  --data-urlencode "filter[email]=dana.whitfield@example.com" \
  -d load-only=id,name \
  -u "$COEVERA_API_KEY:$COEVERA_API_SECRET")
echo "$owner"
OWNER_ID=$(jq -er '.data[0].id' <<<"$owner")

const owners = await coevera(
  `/entities/Clients?${new URLSearchParams({ "filter[email]": "dana.whitfield@example.com", "load-only": "id,name" })}`,
);
const ownerId: string | undefined = owners.data[0]?.id;
if (!ownerId) throw new Error("No user with that e-mail in this space.");
console.log("Owner:", owners.data[0].name, ownerId);

owners = coevera(
    "GET",
    "/entities/Clients",
    params={"filter[email]": "dana.whitfield@example.com", "load-only": "id,name"},
)
if not owners["data"]:
    sys.exit("No user with that e-mail in this space.")
owner_id = owners["data"][0]["id"]
print("Owner:", owners["data"][0]["name"], owner_id)

owner=$(jq -n '{
  query: "{ entities { client { getByCriteria(first: 1, filter: { email: { eq: [\"dana.whitfield@example.com\"] } }) { edges { node { id name } } } } } }"
}' | gql)
echo "$owner"
OWNER_ID=$(jq -er '.data.entities.client.getByCriteria.edges[0].node.id' <<<"$owner")

const owners = await gql(`{
  entities {
    client {
      getByCriteria(first: 1, filter: { email: { eq: ["dana.whitfield@example.com"] } }) {
        edges { node { id name } }
      }
    }
  }
}`);
const ownerId: string | undefined = owners.entities.client.getByCriteria.edges[0]?.node.id;
if (!ownerId) throw new Error("No user with that e-mail in this space.");
console.log("Owner:", owners.entities.client.getByCriteria.edges[0].node.name, ownerId);

owners = gql("""
{
  entities {
    client {
      getByCriteria(first: 1, filter: { email: { eq: ["dana.whitfield@example.com"] } }) {
        edges { node { id name } }
      }
    }
  }
}
""")
edges = owners["entities"]["client"]["getByCriteria"]["edges"]
if not edges:
    sys.exit("No user with that e-mail in this space.")
owner_id = edges[0]["node"]["id"]
print("Owner:", edges[0]["node"]["name"], owner_id)

# Two records for one company, each with values the other lacks. This one is kept.
master=$(curl -sS --fail-with-body "$COEVERA_BASE/entities/Accounts" \
  -u "$COEVERA_API_KEY:$COEVERA_API_SECRET" \
  -H "Content-Type: application/json" \
  -d @- <<JSON
{
  "name": "Wide World Importers", "owner_id": "$OWNER_ID",
  "email1": "wideworld.sales@example.com", "phone1": "+1 206 555 0120"
}
JSON
)
echo "$master"
MASTER_ID=$(jq -er '.data.id' <<<"$master")

// Two records for one company, each with values the other lacks. This one is kept.
const keep = await coevera("/entities/Accounts", {
  method: "POST",
  body: { name: "Wide World Importers", owner_id: ownerId, email1: "wideworld.sales@example.com", phone1: "+1 206 555 0120" },
});
const masterId: string = keep.data.id;
console.log("Master:", masterId);

# Two records for one company, each with values the other lacks. This one is kept.
keep = coevera(
    "POST",
    "/entities/Accounts",
    json={
        "name": "Wide World Importers",
        "owner_id": owner_id,
        "email1": "wideworld.sales@example.com",
        "phone1": "+1 206 555 0120",
    },
)
master_id = keep["data"]["id"]
print("Master:", master_id)

# Two records for one company, each with values the other lacks. This one is kept.
master=$(jq -n --arg owner "$OWNER_ID" '{
  query: "mutation CreateAccount($input: CreateAccountInput!) { createAccount(input: $input) { account { id name } } }",
  variables: {
    input: { name: "Wide World Importers", ownerId: $owner,
      email1: "wideworld.sales@example.com", phone1: "+1 206 555 0120" }
  }
}' | gql)
echo "$master"
MASTER_ID=$(jq -er '.data.createAccount.account.id' <<<"$master")

// Two records for one company, each with values the other lacks. This one is kept.
const CREATE_ACCOUNT = `mutation CreateAccount($input: CreateAccountInput!) {
  createAccount(input: $input) { account { id name } }
}`;
const keep = await gql(CREATE_ACCOUNT, {
  input: { name: "Wide World Importers", ownerId, email1: "wideworld.sales@example.com", phone1: "+1 206 555 0120" },
});
const masterId: string = keep.createAccount.account.id;
console.log("Master:", masterId);

# Two records for one company, each with values the other lacks. This one is kept.
CREATE_ACCOUNT = """
mutation CreateAccount($input: CreateAccountInput!) {
  createAccount(input: $input) { account { id name } }
}
"""
keep = gql(
    CREATE_ACCOUNT,
    {
        "input": {
            "name": "Wide World Importers",
            "ownerId": owner_id,
            "email1": "wideworld.sales@example.com",
            "phone1": "+1 206 555 0120",
        }
    },
)
master_id = keep["createAccount"]["account"]["id"]
print("Master:", master_id)

duplicate=$(curl -sS --fail-with-body "$COEVERA_BASE/entities/Accounts" \
  -u "$COEVERA_API_KEY:$COEVERA_API_SECRET" \
  -H "Content-Type: application/json" \
  -d @- <<JSON
{
  "name": "Wide World Importers Inc.", "owner_id": "$OWNER_ID",
  "email1": "buying.wideworld@example.com", "phone1": "+1 206 555 0129",
  "city": "Salem", "comments": "Imported from the trade-show list."
}
JSON
)
echo "$duplicate"
SECONDARY_ID=$(jq -er '.data.id' <<<"$duplicate")

const duplicate = await coevera("/entities/Accounts", {
  method: "POST",
  body: {
    name: "Wide World Importers Inc.",
    owner_id: ownerId,
    email1: "buying.wideworld@example.com",
    phone1: "+1 206 555 0129",
    city: "Salem",
    comments: "Imported from the trade-show list.",
  },
});
const secondaryId: string = duplicate.data.id;
console.log("Duplicate:", secondaryId);

duplicate = coevera(
    "POST",
    "/entities/Accounts",
    json={
        "name": "Wide World Importers Inc.",
        "owner_id": owner_id,
        "email1": "buying.wideworld@example.com",
        "phone1": "+1 206 555 0129",
        "city": "Salem",
        "comments": "Imported from the trade-show list.",
    },
)
secondary_id = duplicate["data"]["id"]
print("Duplicate:", secondary_id)

duplicate=$(jq -n --arg owner "$OWNER_ID" '{
  query: "mutation CreateAccount($input: CreateAccountInput!) { createAccount(input: $input) { account { id name } } }",
  variables: {
    input: { name: "Wide World Importers Inc.", ownerId: $owner,
      email1: "buying.wideworld@example.com", phone1: "+1 206 555 0129",
      city: "Salem", comments: "Imported from the trade-show list." }
  }
}' | gql)
echo "$duplicate"
SECONDARY_ID=$(jq -er '.data.createAccount.account.id' <<<"$duplicate")

const duplicate = await gql(CREATE_ACCOUNT, {
  input: {
    name: "Wide World Importers Inc.",
    ownerId,
    email1: "buying.wideworld@example.com",
    phone1: "+1 206 555 0129",
    city: "Salem",
    comments: "Imported from the trade-show list.",
  },
});
const secondaryId: string = duplicate.createAccount.account.id;
console.log("Duplicate:", secondaryId);

duplicate = gql(
    CREATE_ACCOUNT,
    {
        "input": {
            "name": "Wide World Importers Inc.",
            "ownerId": owner_id,
            "email1": "buying.wideworld@example.com",
            "phone1": "+1 206 555 0129",
            "city": "Salem",
            "comments": "Imported from the trade-show list.",
        }
    },
)
secondary_id = duplicate["createAccount"]["account"]["id"]
print("Duplicate:", secondary_id)

contact=$(curl -sS --fail-with-body "$COEVERA_BASE/entities/Contacts" \
  -u "$COEVERA_API_KEY:$COEVERA_API_SECRET" \
  -H "Content-Type: application/json" \
  -d @- <<JSON
{
  "first_name": "Jonas", "last_name": "Berg",
  "email1": "jonas.berg@example.com",
  "owner_id": "$OWNER_ID",
  "account_relations": [{ "account_id": "$SECONDARY_ID", "position": "Buyer", "is_primary": true }]
}
JSON
)
echo "$contact"
CONTACT_ID=$(jq -er '.data.id' <<<"$contact")

const contact = await coevera("/entities/Contacts", {
  method: "POST",
  body: {
    first_name: "Jonas",
    last_name: "Berg",
    email1: "jonas.berg@example.com",
    owner_id: ownerId,
    account_relations: [{ account_id: secondaryId, position: "Buyer", is_primary: true }],
  },
});
const contactId: string = contact.data.id;
console.log("Contact on the secondary:", contactId);

contact = coevera(
    "POST",
    "/entities/Contacts",
    json={
        "first_name": "Jonas",
        "last_name": "Berg",
        "email1": "jonas.berg@example.com",
        "owner_id": owner_id,
        "account_relations": [{"account_id": secondary_id, "position": "Buyer", "is_primary": True}],
    },
)
contact_id = contact["data"]["id"]
print("Contact on the secondary:", contact_id)

contact=$(jq -n --arg owner "$OWNER_ID" --arg account "$SECONDARY_ID" '{
  query: "mutation AddContact($input: CreateContactInput!) { createContact(input: $input) { contact { id } } }",
  variables: {
    input: {
      firstName: "Jonas", lastName: "Berg",
      email1: "jonas.berg@example.com",
      ownerId: $owner,
      accountRelations: [{ accountId: $account, position: "Buyer", isPrimary: true }]
    }
  }
}' | gql)
echo "$contact"
CONTACT_ID=$(jq -er '.data.createContact.contact.id' <<<"$contact")

const contact = await gql(
  `mutation AddContact($input: CreateContactInput!) {
    createContact(input: $input) { contact { id } }
  }`,
  {
    input: {
      firstName: "Jonas",
      lastName: "Berg",
      email1: "jonas.berg@example.com",
      ownerId,
      accountRelations: [{ accountId: secondaryId, position: "Buyer", isPrimary: true }],
    },
  },
);
const contactId: string = contact.createContact.contact.id;
console.log("Contact on the secondary:", contactId);

contact = gql(
    """
    mutation AddContact($input: CreateContactInput!) {
      createContact(input: $input) { contact { id } }
    }
    """,
    {
        "input": {
            "firstName": "Jonas",
            "lastName": "Berg",
            "email1": "jonas.berg@example.com",
            "ownerId": owner_id,
            "accountRelations": [{"accountId": secondary_id, "position": "Buyer", "isPrimary": True}],
        }
    },
)
contact_id = contact["createContact"]["contact"]["id"]
print("Contact on the secondary:", contact_id)

# master names the record to keep and carries the values that must win; the secondary
# records in secondary_ids are merged into it.
curl -sS --fail-with-body "$COEVERA_BASE/entities/Accounts/merge" \
  -u "$COEVERA_API_KEY:$COEVERA_API_SECRET" \
  -H "Content-Type: application/json" \
  -d @- <<JSON
{
  "master": { "id": "$MASTER_ID", "email1": "orders.wideworld@example.com" },
  "secondary_ids": ["$SECONDARY_ID"]
}
JSON
echo

// master names the record to keep and carries the values that must win; the secondary
// records in secondary_ids are merged into it.
const merged = await coevera("/entities/Accounts/merge", {
  method: "POST",
  body: { master: { id: masterId, email1: "orders.wideworld@example.com" }, secondary_ids: [secondaryId] },
});
console.log("Merged into:", merged.data.id);

# master names the record to keep and carries the values that must win; the secondary
# records in secondary_ids are merged into it.
merged = coevera(
    "POST",
    "/entities/Accounts/merge",
    json={"master": {"id": master_id, "email1": "orders.wideworld@example.com"}, "secondary_ids": [secondary_id]},
)
print("Merged into:", merged["data"]["id"])

# master names the record to keep and carries the values that must win; slaveId is the one
# secondary record merged into it.
jq -n --arg master "$MASTER_ID" --arg secondary "$SECONDARY_ID" '{
  query: "mutation Merge($input: MergeAccountInput!) { mergeAccount(input: $input) { result { id name } } }",
  variables: { input: { master: { id: $master, email1: "orders.wideworld@example.com" }, slaveId: $secondary } }
}' | gql

// master names the record to keep and carries the values that must win; slaveId is the one
// secondary record merged into it.
const merged = await gql(
  `mutation Merge($input: MergeAccountInput!) {
    mergeAccount(input: $input) { result { id name } }
  }`,
  { input: { master: { id: masterId, email1: "orders.wideworld@example.com" }, slaveId: secondaryId } },
);
console.log("Merged into:", merged.mergeAccount.result.id);

# master names the record to keep and carries the values that must win; slaveId is the one
# secondary record merged into it.
merged = gql(
    """
    mutation Merge($input: MergeAccountInput!) {
      mergeAccount(input: $input) { result { id name } }
    }
    """,
    {"input": {"master": {"id": master_id, "email1": "orders.wideworld@example.com"}, "slaveId": secondary_id}},
)
print("Merged into:", merged["mergeAccount"]["result"]["id"])

curl -sS --fail-with-body -G "$COEVERA_BASE/entities/Accounts" \
  -d "filter[id]=$MASTER_ID" \
  -d load-only=id,name,email1,phone1,city,comments,modified \
  -u "$COEVERA_API_KEY:$COEVERA_API_SECRET"
echo

const master = await coevera(
  `/entities/Accounts?filter[id]=${masterId}&load-only=id,name,email1,phone1,city,comments,modified`,
);
console.log("Master:", JSON.stringify(master.data[0], null, 2));

master = coevera(
    "GET",
    "/entities/Accounts",
    params={"filter[id]": master_id, "load-only": "id,name,email1,phone1,city,comments,modified"},
)
print("Master:", json.dumps(master["data"][0], indent=2))

jq -n --arg id "$MASTER_ID" '{
  query: "query ReadMaster($id: ID!) { entities { account { getById(entityId: $id) { id name email1 phone1 city comments modified } } } }",
  variables: { id: $id }
}' | gql

const master = await gql(
  `query ReadMaster($id: ID!) {
    entities { account { getById(entityId: $id) { id name email1 phone1 city comments modified } } }
  }`,
  { id: masterId },
);
console.log("Master:", JSON.stringify(master.entities.account.getById, null, 2));

master = gql(
    """
    query ReadMaster($id: ID!) {
      entities { account { getById(entityId: $id) { id name email1 phone1 city comments modified } } }
    }
    """,
    {"id": master_id},
)
print("Master:", json.dumps(master["entities"]["account"]["getById"], indent=2))

# The secondary is soft-deleted: list calls show it only with include-deleted=true.
curl -sS --fail-with-body -G "$COEVERA_BASE/entities/Accounts" \
  -d "filter[id]=$SECONDARY_ID" -d include-deleted=true \
  -d load-only=id,name,email1,phone1,city,is_deleted \
  -u "$COEVERA_API_KEY:$COEVERA_API_SECRET"
echo

// The secondary is soft-deleted: list calls show it only with include-deleted=true.
const secondary = await coevera(
  `/entities/Accounts?filter[id]=${secondaryId}&include-deleted=true&load-only=id,name,email1,phone1,city,is_deleted`,
);
console.log("Secondary:", JSON.stringify(secondary.data[0], null, 2));

# The secondary is soft-deleted: list calls show it only with include-deleted=true.
secondary = coevera(
    "GET",
    "/entities/Accounts",
    params={
        "filter[id]": secondary_id,
        "include-deleted": "true",
        "load-only": "id,name,email1,phone1,city,is_deleted",
    },
)
print("Secondary:", json.dumps(secondary["data"][0], indent=2))

# The secondary is soft-deleted: it shows only with includeDeleted: true.
jq -n --arg id "$SECONDARY_ID" '{
  query: "query ReadSecondary($id: String!) { entities { account { getByCriteria(includeDeleted: true, filter: { id: { eq: [$id] } }) { edges { node { id name email1 phone1 city isDeleted } } } } } }",
  variables: { id: $id }
}' | gql

// The secondary is soft-deleted: it shows only with includeDeleted: true.
const secondary = await gql(
  `query ReadSecondary($id: String!) {
    entities {
      account {
        getByCriteria(includeDeleted: true, filter: { id: { eq: [$id] } }) {
          edges { node { id name email1 phone1 city isDeleted } }
        }
      }
    }
  }`,
  { id: secondaryId },
);
console.log("Secondary:", JSON.stringify(secondary.entities.account.getByCriteria.edges, null, 2));

# The secondary is soft-deleted: it shows only with includeDeleted: true.
secondary = gql(
    """
    query ReadSecondary($id: String!) {
      entities {
        account {
          getByCriteria(includeDeleted: true, filter: { id: { eq: [$id] } }) {
            edges { node { id name email1 phone1 city isDeleted } }
          }
        }
      }
    }
    """,
    {"id": secondary_id},
)
print("Secondary:", json.dumps(secondary["entities"]["account"]["getByCriteria"]["edges"], indent=2))

# The contact's relation now points at the master, with its old modified.
curl -sS --fail-with-body -G "$COEVERA_BASE/entities/ContactAccountRelations" \
  -d "filter[contact_id]=$CONTACT_ID" \
  -d load-only=id,account_id,position,is_primary,modified \
  -u "$COEVERA_API_KEY:$COEVERA_API_SECRET"

// The contact's relation now points at the master, with its old modified.
const relations = await coevera(
  `/entities/ContactAccountRelations?filter[contact_id]=${contactId}&load-only=id,account_id,position,is_primary,modified`,
);
console.log("Relation:", JSON.stringify(relations.data, null, 2));

# The contact's relation now points at the master, with its old modified.
relations = coevera(
    "GET",
    "/entities/ContactAccountRelations",
    params={"filter[contact_id]": contact_id, "load-only": "id,account_id,position,is_primary,modified"},
)
print("Relation:", json.dumps(relations["data"], indent=2))

# The contact's relation now points at the master, with its old modified.
jq -n --arg contact "$CONTACT_ID" '{
  query: "query ReadRelation($contact: String!) { entities { contactAccountRelation { getByCriteria(filter: { contactId: { eq: [$contact] } }) { edges { node { id accountId position isPrimary modified } } } } } }",
  variables: { contact: $contact }
}' | gql

// The contact's relation now points at the master, with its old modified.
const relations = await gql(
  `query ReadRelation($contactId: String!) {
    entities {
      contactAccountRelation {
        getByCriteria(filter: { contactId: { eq: [$contactId] } }) {
          edges { node { id accountId position isPrimary modified } }
        }
      }
    }
  }`,
  { contactId },
);
console.log("Relation:", JSON.stringify(relations.entities.contactAccountRelation.getByCriteria.edges, null, 2));

# The contact's relation now points at the master, with its old modified.
relations = gql(
    """
    query ReadRelation($contactId: String!) {
      entities {
        contactAccountRelation {
          getByCriteria(filter: { contactId: { eq: [$contactId] } }) {
            edges { node { id accountId position isPrimary modified } }
          }
        }
      }
    }
    """,
    {"contactId": contact_id},
)
print("Relation:", json.dumps(relations["entities"]["contactAccountRelation"]["getByCriteria"]["edges"], indent=2))