Connections & OAuth

detail = client.applications.get("slack")
for m in detail.authentication_methods:
    print(m.authentication_id, m.authentication_name, m.requires_o_auth_sign_in)

const detail = await client.applications.get("slack");
for (const m of detail.authenticationMethods) {
  console.log(m.authenticationId, m.authenticationName, m.requiresOAuthSignIn);
}

created = client.connections.create(
    "slack", "Sales workspace", authentication_id=2,
    fields={"token": "xoxb-..."},
)
connection_id = created.connection_id
alive = client.connections.check(connection_id)

const created = await client.connections.create(
  "slack", "Sales workspace", 2,
  { token: "xoxb-..." },
);
const alive = await client.connections.check(created.connectionId);

import time, webbrowser

# 1. Start the sign-in
resp = client.connections.get_sign_in_url("outlook", authentication_id=0)
webbrowser.open(resp.sign_in_url)          # or show resp.sign_in_url to your user
state = resp.state

# 2. Poll until the user completes the sign-in
while True:
    token = client.connections.get_access_token(state)
    if token is None:
        raise RuntimeError("Sign-in state could not be resolved - start a new sign-in.")
    status = (token.status or "").lower()
    if status in {"completed", "complete", "success", "succeeded"}:
        break
    if status in {"failed", "error", "cancelled", "canceled", "denied"}:
        raise RuntimeError(token.error_message or "OAuth sign-in failed.")
    time.sleep(2)                           # empty status = still pending - keep polling

# 3. Create the connection - pass the sign-in's state; the server looks up its own
#    record of the sign-in and derives the credentials itself, so `fields` carries
#    nothing here
created = client.connections.create("outlook", "My Outlook", 0, {}, oauth_state=state)

// 1. Start the sign-in
const resp = await client.connections.getSignInUrl("outlook", 0);
console.log("Authorize here:", resp.signInUrl);
const state = resp.state;

// 2. Poll until the user completes the sign-in
let token;
for (;;) {
  token = await client.connections.getAccessToken(state);
  if (!token) {
    throw new Error("Sign-in state could not be resolved - start a new sign-in.");
  }
  const status = (token.status ?? "").toLowerCase();
  if (["completed", "complete", "success", "succeeded"].includes(status)) break;
  if (["failed", "error", "cancelled", "canceled", "denied"].includes(status))
    throw new Error(token.errorMessage ?? "OAuth sign-in failed.");
  await new Promise((r) => setTimeout(r, 2000)); // empty status = still pending
}

// 3. Create the connection - pass the sign-in's state; the server looks up its own
//    record of the sign-in and derives the credentials itself, so `fields` carries
//    nothing here
const created = await client.connections.create("outlook", "My Outlook", 0, {}, { oauthState: state });

fo = token.field_options   # reuse the loop's own poll that saw status "success" - don't poll again
options = fo["ApiVersionUrl"].to_dict() if "ApiVersionUrl" in fo else None
# {"/services/data/v60.0": "60.0", "/services/data/v59.0": "59.0", ...}

const options = token.fieldOptions?.["ApiVersionUrl"]; // reuse the loop's own poll - don't poll again
// {"/services/data/v60.0": "60.0", "/services/data/v59.0": "59.0", ...}

created = client.connections.create(
    "salesforce", "Prod org", authentication_id=0,
    fields={"ApiVersionUrl": "/services/data/v60.0"},   # the key, never the label
    oauth_state=state,
)

const created = await client.connections.create(
  "salesforce", "Prod org", 0,
  { ApiVersionUrl: "/services/data/v60.0" },   // the key, never the label
  { oauthState: state },
);

keys = client.connections.list(kind="Key")
for conn in keys:
    print(conn.connection_id, conn.connection_name, conn.kind)

const keys = await client.connections.list(undefined, "Key");
for (const conn of keys) {
  console.log(conn.connectionId, conn.connectionName, conn.kind);
}

client.connections.update(481, name="prod key")
client.connections.update(481, fields={"apiKey": "sk-new"})

await client.connections.update(481, { name: "prod key" });
await client.connections.update(481, { fields: { apiKey: "sk-new" } });

resp = client.connections.get_sign_in_url("outlook", authentication_id=0)
# user authorizes at resp.sign_in_url, then you poll get_access_token(resp.state) as above
client.connections.update(481, oauth_state=resp.state)

const resp = await client.connections.getSignInUrl("outlook", 0);
// user authorizes at resp.signInUrl, then you poll getAccessToken(resp.state) as above
await client.connections.update(481, { oauthState: resp.state });

client.connections.replace(
    workflow_id=903, original_connection_id=481, new_connection_id=482
)

await client.connections.replace({
  workflowId: 903,
  originalConnectionId: 481,
  newConnectionId: 482,
});

client.connections.refresh(connection_id)                       # fire the async job
status = client.connections.wait_for_refresh(connection_id)     # polls refresh-status (300s timeout, 2s interval)

objs = client.connections.objects(connection_id)
client.connections.select_objects(connection_id, [o.object_id for o in objs[:5]])
client.connections.wait_for_refresh(connection_id)              # selection triggers another refresh

await client.connections.refresh(connectionId);
const status = await client.connections.waitForRefresh(connectionId); // 300s timeout, 2s interval

const objs = await client.connections.objects(connectionId);
await client.connections.selectObjects(connectionId, objs.slice(0, 5).map((o) => o.objectId));
await client.connections.waitForRefresh(connectionId);

client.connections.set_default(connection_id)
client.connections.defaults()               # one entry per application
client.connections.clear_default("slack")
conn_id = client.connections.resolve("slack", "Sales workspace")   # name -> id

await client.connections.setDefault(connectionId);
await client.connections.defaults();
await client.connections.clearDefault("slack");
const connId = await client.connections.resolve("slack", "Sales workspace");