attio 0.0.1-experimental.20240926.1 → 0.0.1-experimental.20240927

package/lib/api/handle-error.js

@@ -5,7 +5,14 @@ const serverErrorSchema = z.object({
 export async function handleError(response) {
     if (response.ok)
         return;
-    const json = await response.json();
+    const text = await response.text();
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch (error) {
+        throw new Error(`Error parsing JSON: ${JSON.stringify(text)}`);
+    }
     const error = serverErrorSchema.parse(json);
     throw new Error(error.message);
 }

package/lib/api/remove-connection-definition.js

@@ -1,9 +1,8 @@
 import { API } from "../env.js";
 import { handleError } from "./handle-error.js";
 import { makeHeaders } from "./make-headers.js";
-export async function removeConnectionDefinition({ token, devSlug, appId, }) {
-    const major = 1;
-    const response = await fetch(`${API}/developer-portal/accounts/${devSlug}/apps/${appId}/versions/${major}/connection-definitions`, {
+export async function removeConnectionDefinition({ token, devSlug, appId, slug, major, }) {
+    const response = await fetch(`${API}/developer-portal/accounts/${devSlug}/apps/${appId}/versions/${major}/connection-definitions/${slug}`, {
         method: "DELETE",
         headers: makeHeaders(token),
     });

package/lib/commands/connection/list.js

@@ -0,0 +1,52 @@
+import { useMachine } from "@xstate/react";
+import { Box, Text } from "ink";
+import Spinner from "ink-spinner";
+import { option } from "pastel";
+import React from "react";
+import { z } from "zod";
+import { InitialInstructions } from "../../components/InitialInstructions.js";
+import { Logo } from "../../components/Logo.js";
+import { Table } from "../../components/Table.js";
+import { listConnectionsMachine } from "../../machines/list-connections-machine.js";
+export const description = "List all connections for the current major version of your Attio app";
+export const options = z.object({
+    dev: z
+        .boolean()
+        .default(false)
+        .describe(option({ description: "Run in development mode (additional debugging info)" })),
+});
+const connectionTypeNames = {
+    "oauth2-code": "OAuth 2.0",
+    "secret": "Secret",
+};
+export default function ListConnections({ options: { dev } }) {
+    const [snapshot] = useMachine(listConnectionsMachine);
+    return (React.createElement(Box, { flexDirection: "column" },
+        dev && (React.createElement(Box, null,
+            React.createElement(Text, null, JSON.stringify(snapshot.value, null, 2)))),
+        React.createElement(Logo, null),
+        snapshot.matches("Show config instructions") && (React.createElement(InitialInstructions, { reason: snapshot.context.configError })),
+        snapshot.matches("No Connections") && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, null,
+                React.createElement(Text, { color: "redBright" }, "This app has no connections."),
+                React.createElement(Text, null, " To add one, use:")),
+            React.createElement(Box, { flexDirection: "column", borderStyle: "round", width: 27, paddingX: 1, marginBottom: 1 },
+                React.createElement(Text, null, "attio connection add")))),
+        snapshot.matches("Loading Connections") && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, null,
+                React.createElement(Text, null, "Loading connections... "),
+                React.createElement(Text, { color: "green" },
+                    React.createElement(Spinner, { type: "dots" }))))),
+        snapshot.matches("Error") && (React.createElement(Box, null,
+            React.createElement(Text, { color: "red" }, snapshot.context.error))),
+        snapshot.matches("Display Connections") &&
+            snapshot.context.connections &&
+            snapshot.context.connections && (React.createElement(Box, null,
+            React.createElement(Table, { rows: Object.entries(snapshot.context.connections).map(([slug, connection]) => ({
+                    "Slug": slug,
+                    "Label": connection.label,
+                    "Global": connection.global ? "Yes" : "No",
+                    "Allow Multiple": connection.allow_multiple ? "Yes" : "No",
+                    "Type": connectionTypeNames[connection.connection_type],
+                })) })))));
+}

package/lib/commands/connection/remove.js

@@ -6,6 +6,7 @@ import React from "react";
 import { z } from "zod";
 import { InitialInstructions } from "../../components/InitialInstructions.js";
 import { Logo } from "../../components/Logo.js";
+import { Select } from "../../components/Select.js";
 import { removeConnectionMachine } from "../../machines/remove-connection-machine.js";
 export const description = "Remove a connection from your Attio app";
 export const options = z.object({
@@ -15,27 +16,53 @@ export const options = z.object({
         .describe(option({ description: "Run in development mode (additional debugging info)" })),
 });
 export default function RemoveConnection({ options: { dev } }) {
-    const [snapshot] = useMachine(removeConnectionMachine);
+    const [snapshot, send] = useMachine(removeConnectionMachine);
     return (React.createElement(Box, { flexDirection: "column" },
         dev && (React.createElement(Box, null,
             React.createElement(Text, null, JSON.stringify(snapshot.value, null, 2)))),
         React.createElement(Logo, null),
         snapshot.matches("Show config instructions") && (React.createElement(InitialInstructions, { reason: snapshot.context.configError })),
-        snapshot.matches("No connection to remove") && (React.createElement(Box, { flexDirection: "column" },
+        snapshot.matches("No Connections") && (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, null,
                 React.createElement(Text, { color: "redBright" }, "This app has no connections to remove."),
                 React.createElement(Text, null, " To add one, use:")),
             React.createElement(Box, { flexDirection: "column", borderStyle: "round", width: 27, paddingX: 1, marginBottom: 1 },
                 React.createElement(Text, null, "attio connection add")))),
-        snapshot.matches("Removing connection definition") && (React.createElement(Box, { flexDirection: "column" },
+        snapshot.matches("Loading Connections") && (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, null,
-                React.createElement(Text, null, "Removing connection definition..."),
+                React.createElement(Text, null, "Loading connections... "),
                 React.createElement(Text, { color: "green" },
                     React.createElement(Spinner, { type: "dots" }))))),
-        snapshot.matches("Success") && (React.createElement(Box, { flexDirection: "column" },
+        snapshot.matches("Choosing a Connection") && snapshot.context.connections && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, null,
+                React.createElement(Text, null, "Which connection would you like to remove?")),
             React.createElement(Box, null,
-                React.createElement(Text, { color: "green" }, "SUCCESS!! \uD83C\uDF89 Your connection has been removed.")))),
-        snapshot.matches("Error") && (React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Select, { items: Object.entries(snapshot.context.connections).map(([slug, value]) => ({
+                        value: slug,
+                        label: value.label,
+                    })), onSelect: (slug) => send({ type: "Connection Chosen", slug }) })))),
+        snapshot.matches("Confirm Removal") &&
+            snapshot.context.chosenConnectionSlug &&
+            snapshot.context.connections && (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, null,
-                React.createElement(Text, { color: "red" }, snapshot.context.error))))));
+                React.createElement(Text, null,
+                    "Are you sure you want to remove \"",
+                    snapshot.context.connections[snapshot.context.chosenConnectionSlug].label,
+                    "\"?")),
+            React.createElement(Box, null,
+                React.createElement(Select, { items: [
+                        { value: "Confirm", label: "Yes, remove it" },
+                        { value: "Cancel", label: "Cancel" },
+                    ], onSelect: (type) => send({ type }) })))),
+        snapshot.matches("Removing connection definition") && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, null,
+                React.createElement(Text, null, "Removing connection definition..."),
+                React.createElement(Text, { color: "green" },
+                    React.createElement(Spinner, { type: "dots" }))))),
+        snapshot.matches("Cancelled") && (React.createElement(Box, null,
+            React.createElement(Text, null, "No connections have been removed."))),
+        snapshot.matches("Success") && (React.createElement(Box, null,
+            React.createElement(Text, { color: "green" }, "SUCCESS!! \uD83C\uDF89 Your connection has been removed."))),
+        snapshot.matches("Error") && (React.createElement(Box, null,
+            React.createElement(Text, { color: "red" }, snapshot.context.error)))));
 }

package/lib/machines/list-connections-machine.js

@@ -0,0 +1,119 @@
+import { assign, setup, fromCallback } from "xstate";
+import { fetchConnections } from "../api/fetch-connections.js";
+import { emptyConfig } from "../schema.js";
+import { loadAppConfig, loadDeveloperConfig } from "./actors.js";
+export const listConnectionsMachine = setup({
+    types: {
+        context: {},
+        events: {},
+    },
+    actors: {
+        loadDeveloperConfig,
+        loadAppConfig,
+        loadConnections: fromCallback(({ sendBack, input }) => {
+            fetchConnections({
+                token: input.developer.token,
+                devSlug: input.developer.slug,
+                appId: input.config.id,
+                major: input.config.major,
+            })
+                .then((connections) => sendBack({ type: "Connections Loaded", connections }))
+                .catch((error) => sendBack({ type: "Error", error: error.message }));
+        }),
+    },
+    actions: {
+        setError: assign({
+            error: (_, params) => params.error,
+        }),
+        setDeveloperConfig: assign({
+            developer: (_, params) => params,
+        }),
+        setConfigError: assign({
+            configError: (_, params) => params.configError,
+        }),
+        setConfig: assign({
+            config: (_, params) => params.config,
+        }),
+        setConnections: assign({
+            connections: (_, params) => params.connections,
+        }),
+    },
+    guards: {
+        "have connections": (_, params) => Boolean(params.connections && Object.keys(params.connections).length > 0),
+    },
+}).createMachine({
+    context: ({ input }) => ({
+        developer: { slug: "", token: "" },
+        config: emptyConfig,
+        ...input,
+    }),
+    id: "List Connections Machine",
+    states: {
+        "Loading Developer Config": {
+            invoke: {
+                src: "loadDeveloperConfig",
+            },
+            on: {
+                "Developer Config Loaded": {
+                    target: "Loading App Config",
+                    actions: { type: "setDeveloperConfig", params: ({ event }) => event },
+                },
+                "No Developer Config": {
+                    target: "Show config instructions",
+                    actions: { type: "setConfigError", params: ({ event }) => event },
+                },
+            },
+        },
+        "Show config instructions": {
+            type: "final",
+        },
+        "Loading App Config": {
+            invoke: {
+                src: "loadAppConfig",
+            },
+            on: {
+                "Error": {
+                    target: "Error",
+                    actions: { type: "setError", params: ({ event }) => event },
+                },
+                "App Config Loaded": {
+                    target: "Loading Connections",
+                    actions: { type: "setConfig", params: ({ event }) => event },
+                },
+            },
+        },
+        "Error": {
+            type: "final",
+        },
+        "Loading Connections": {
+            invoke: {
+                src: "loadConnections",
+                input: ({ context }) => context,
+            },
+            on: {
+                "Connections Loaded": [
+                    {
+                        target: "Display Connections",
+                        actions: { type: "setConnections", params: ({ event }) => event },
+                        guard: {
+                            type: "have connections",
+                            params: ({ event }) => event,
+                        },
+                    },
+                    "No Connections",
+                ],
+                "Error": {
+                    target: "Error",
+                    actions: { type: "setError", params: ({ event }) => event },
+                },
+            },
+        },
+        "No Connections": {
+            type: "final",
+        },
+        "Display Connections": {
+            type: "final",
+        },
+    },
+    initial: "Loading Developer Config",
+});

package/lib/machines/remove-connection-machine.js

@@ -1,4 +1,5 @@
 import { assign, setup, fromCallback } from "xstate";
+import { fetchConnections } from "../api/fetch-connections.js";
 import { removeConnectionDefinition } from "../api/remove-connection-definition.js";
 import { emptyConfig } from "../schema.js";
 import { updateAppConfig } from "../util/app-config.js";
@@ -16,6 +17,8 @@ export const removeConnectionMachine = setup({
                         token: input.developer.token,
                         devSlug: input.developer.slug,
                         appId: input.config.id,
+                        slug: input.chosenConnectionSlug,
+                        major: input.config.major,
                     });
                     updateAppConfig((config) => ({
                         ...config,
@@ -31,6 +34,16 @@ export const removeConnectionMachine = setup({
         }),
         loadDeveloperConfig,
         loadAppConfig,
+        loadConnections: fromCallback(({ sendBack, input }) => {
+            fetchConnections({
+                token: input.developer.token,
+                devSlug: input.developer.slug,
+                appId: input.config.id,
+                major: input.config.major,
+            })
+                .then((connections) => sendBack({ type: "Connections Loaded", connections }))
+                .catch((error) => sendBack({ type: "Error", error: error.message }));
+        }),
     },
     actions: {
         clearError: assign({
@@ -45,12 +58,22 @@ export const removeConnectionMachine = setup({
         setConfigError: assign({
             configError: (_, params) => params.configError,
         }),
-        setAppConfig: assign({
+        setConfig: assign({
             config: (_, params) => params.config,
         }),
+        setConnections: assign({
+            connections: (_, params) => params.connections,
+        }),
+        setConnection: assign({
+            chosenConnectionSlug: (_, params) => params.slug,
+        }),
+        setOnlyConnection: assign({
+            chosenConnectionSlug: (_, params) => Object.keys(params.connections)[0],
+        }),
     },
     guards: {
-        "have a connection": (_, params) => Boolean(params.config.connection),
+        "have more than one connection": (_, params) => Boolean(params.connections && Object.keys(params.connections).length > 1),
+        "have only one connection": (_, params) => Boolean(params.connections && Object.keys(params.connections).length === 1),
     },
 }).createMachine({
     context: ({ input }) => ({
@@ -88,9 +111,8 @@ export const removeConnectionMachine = setup({
                     actions: { type: "setError", params: ({ event }) => event },
                 },
                 "App Config Loaded": {
-                    target: "Do we have a connection?",
-                    actions: { type: "setAppConfig", params: ({ event }) => event },
-                    reenter: true,
+                    target: "Loading Connections",
+                    actions: { type: "setConfig", params: ({ event }) => event },
                 },
             },
         },
@@ -100,7 +122,11 @@ export const removeConnectionMachine = setup({
         "Removing connection definition": {
             invoke: {
                 src: "removeConnectionDefinition",
-                input: ({ context }) => context,
+                input: ({ context }) => ({
+                    developer: context.developer,
+                    config: context.config,
+                    chosenConnectionSlug: context.chosenConnectionSlug,
+                }),
             },
             on: {
                 Success: "Success",
@@ -113,32 +139,67 @@ export const removeConnectionMachine = setup({
         "Success": {
             type: "final",
         },
-        "Do we have a connection?": {
-            always: [
-                {
-                    target: "Removing connection definition",
-                    guard: { type: "have a connection", params: ({ context }) => context },
-                    reenter: true,
-                },
-                {
-                    target: "Removing connection definition (just in case)",
-                    reenter: true,
+        "Loading Connections": {
+            invoke: {
+                src: "loadConnections",
+                input: ({ context }) => context,
+            },
+            on: {
+                "Connections Loaded": [
+                    {
+                        target: "Choosing a Connection",
+                        actions: { type: "setConnections", params: ({ event }) => event },
+                        guard: {
+                            type: "have more than one connection",
+                            params: ({ event }) => event,
+                        },
+                    },
+                    {
+                        target: "Confirm Removal",
+                        guard: {
+                            type: "have only one connection",
+                            params: ({ event }) => event,
+                        },
+                        reenter: true,
+                        actions: [
+                            {
+                                type: "setConnections",
+                                params: ({ event }) => event,
+                            },
+                            {
+                                type: "setOnlyConnection",
+                                params: ({ event }) => event,
+                            },
+                        ],
+                    },
+                    "No Connections",
+                ],
+                "Error": {
+                    target: "Error",
+                    actions: { type: "setError", params: ({ event }) => event },
                 },
-            ],
+            },
         },
-        "No connection to remove": {
+        "No Connections": {
             type: "final",
         },
-        "Removing connection definition (just in case)": {
-            invoke: {
-                src: "removeConnectionDefinition",
-                input: ({ context }) => context,
+        "Choosing a Connection": {
+            on: {
+                "Connection Chosen": {
+                    target: "Confirm Removal",
+                    actions: { type: "setConnection", params: ({ event }) => event },
+                    reenter: true,
+                },
             },
+        },
+        "Confirm Removal": {
             on: {
-                Error: "No connection to remove",
-                Success: "Success",
+                Confirm: "Removing connection definition",
+                Cancel: "Cancelled",
             },
-            description: `In case our local config is out of date with the server, let's go ahead and send the removal request to the server just in case.`,
+        },
+        "Cancelled": {
+            type: "final",
         },
     },
     initial: "Loading Developer Config",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attio",
-  "version": "0.0.1-experimental.20240926.1",
+  "version": "0.0.1-experimental.20240927",
   "bin": "lib/attio.js",
   "type": "module",
   "files": [