attio 0.0.1-experimental.20241011.3 → 0.0.1-experimental.20241011.5

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

@@ -7,11 +7,10 @@ const addConnectionSchema = z.object({
     app_id: z.string(),
     connection_definition_id: z.string(),
 });
-export async function addConnectionDefinition({ token, devSlug, appId, key, label, description, global, connectionType, clientId, clientSecret, authorizeUrl, accessTokenUrl, major, scopes, }) {
+export async function addConnectionDefinition({ token, devSlug, appId, label, description, global, connectionType, clientId, clientSecret, authorizeUrl, accessTokenUrl, major, scopes, }) {
     const connectionDefinitionId = uuid();
     const body = {
         connection_type: connectionType,
-        slug: key,
         label,
         description,
         global,

package/lib/api/fetch-connections.js

@@ -3,7 +3,7 @@ import { API } from "../env.js";
 import { handleError } from "./handle-error.js";
 import { makeHeaders } from "./make-headers.js";
 const connectionDefinitionsResponseSchema = z.object({
-    connection_definitions: z.record(z.string(), z.object({
+    values: z.array(z.object({
         label: z.string(),
         connection_type: z.enum(["oauth2-code", "secret"]),
         description: z.string().nullable(),
@@ -16,5 +16,5 @@ export async function fetchConnections({ token, devSlug, appId, major, }) {
         headers: makeHeaders(token),
     });
     await handleError(response);
-    return connectionDefinitionsResponseSchema.parse(await response.json()).connection_definitions;
+    return connectionDefinitionsResponseSchema.parse(await response.json()).values;
 }

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

@@ -1,8 +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, slug, major, }) {
-    const response = await fetch(`${API}/developer-portal/accounts/${devSlug}/apps/${appId}/versions/${major}/connection-definitions/${slug}`, {
+export async function removeConnectionDefinition({ token, devSlug, appId, global, major, }) {
+    const response = await fetch(`${API}/developer-portal/accounts/${devSlug}/apps/${appId}/versions/${major}/connection-definitions/${global ? "workspace" : "user"}/remove`, {
         method: "DELETE",
         headers: makeHeaders(token),
     });

package/lib/commands/connection/add.js

@@ -11,10 +11,6 @@ import { Select } from "../../components/Select.js";
 import { addConnectionMachine, connectionTypes } from "../../machines/add-connection-machine.js";
 export const description = "Create a new connection for your Attio app";
 export const options = z.object({
-    key: z
-        .string()
-        .optional()
-        .describe(option({ description: "A unique key for your connection" })),
     label: z
         .string()
         .optional()
@@ -61,10 +57,9 @@ export const options = z.object({
         .default(false)
         .describe(option({ description: "Run in development mode (additional debugging info)" })),
 });
-export default function AddConnection({ options: { key, label, description, type: connectionType, authorizeUrl, accessTokenUrl, scopes, clientId, clientSecret, dev, }, }) {
+export default function AddConnection({ options: { label, description, type: connectionType, authorizeUrl, accessTokenUrl, scopes, clientId, clientSecret, dev, }, }) {
     const [snapshot, send] = useMachine(addConnectionMachine, {
         input: {
-            key,
             label,
             description,
             connectionType,
@@ -90,9 +85,6 @@ export default function AddConnection({ options: { key, label, description, type
                 snapshot.context.label && !snapshot.matches("Ask for label") && (React.createElement(Box, null,
                     React.createElement(Text, null, "Label: "),
                     React.createElement(Text, { color: "green" }, snapshot.context.label))),
-                snapshot.context.key && !snapshot.matches("Ask for key") && (React.createElement(Box, null,
-                    React.createElement(Text, null, "Connection Key: "),
-                    React.createElement(Text, { color: "green" }, snapshot.context.key))),
                 snapshot.context.description && !snapshot.matches("Ask for description") && (React.createElement(Box, null,
                     React.createElement(Text, null, "Description: "),
                     React.createElement(Text, { color: "green" }, snapshot.context.description))),
@@ -124,51 +116,6 @@ export default function AddConnection({ options: { key, label, description, type
                         !snapshot.matches("Ask for Client ID") && (React.createElement(Box, null,
                         React.createElement(Text, null, "Client ID: "),
                         React.createElement(Text, { color: "green" }, snapshot.context.clientId)))))),
-            snapshot.matches("Ask for key") && (React.createElement(React.Fragment, null,
-                React.createElement(Box, { flexDirection: "column" },
-                    React.createElement(Box, { flexDirection: "column", margin: 1, borderStyle: "round", padding: 1 },
-                        React.createElement(Text, null,
-                            "import ",
-                            "{",
-                            " connections ",
-                            "}",
-                            " from \"attio/server\""),
-                        React.createElement(Box, { marginY: 1 },
-                            React.createElement(Text, null, "...")),
-                        React.createElement(Text, null,
-                            "const response = await fetch(\"https://api.yourdomain.com/your-endpoint\", ",
-                            "{"),
-                        React.createElement(Text, null,
-                            "  ",
-                            "method: \"GET\","),
-                        React.createElement(Text, null,
-                            "  ",
-                            "headers: ",
-                            "{"),
-                        React.createElement(Text, null,
-                            "    ",
-                            "\"Content-Type\": \"application/json\","),
-                        React.createElement(Box, { flexWrap: "wrap" },
-                            React.createElement(Text, null,
-                                "    ",
-                                "Authorization: `Bearer $",
-                                "{",
-                                "connections"),
-                            React.createElement(Text, null, snapshot.context.key?.includes("-") ? '["' : "."),
-                            React.createElement(Text, { color: "yellowBright" }, snapshot.context.key),
-                            snapshot.context.key?.includes("-") && React.createElement(Text, null, "\"]"),
-                            React.createElement(Text, null,
-                                "}",
-                                "`,")),
-                        React.createElement(Box, { marginLeft: 41 + (snapshot.context.key?.includes("-") ? 1 : 0) },
-                            React.createElement(Text, { color: "cyan" }, "^".repeat(snapshot.context.key?.length ?? 0))),
-                        React.createElement(Text, null, "  }"),
-                        React.createElement(Text, null,
-                            "}",
-                            ");")),
-                    React.createElement(Box, null,
-                        React.createElement(Text, null, "Unique Connection Key: "),
-                        React.createElement(TextInput, { value: snapshot.context.key ?? "", onChange: (key) => send({ type: "Update Key", key }), onSubmit: () => send({ type: "Submit" }) }))))),
             snapshot.matches("Ask for label") && (React.createElement(React.Fragment, null,
                 React.createElement(Box, null,
                     React.createElement(Text, null, "Provide a label for your connection. This is what your users will see.")),

package/lib/commands/connection/list.js

@@ -42,8 +42,7 @@ export default function ListConnections({ options: { dev } }) {
         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,
+            React.createElement(Table, { rows: snapshot.context.connections.map((connection) => ({
                     Label: connection.label,
                     Global: connection.global ? "Yes" : "No",
                     Type: connectionTypeNames[connection.connection_type],

package/lib/commands/connection/remove.js

@@ -37,17 +37,17 @@ export default function RemoveConnection({ options: { dev } }) {
             React.createElement(Box, null,
                 React.createElement(Text, null, "Which connection would you like to remove?")),
             React.createElement(Box, null,
-                React.createElement(Select, { items: Object.entries(snapshot.context.connections).map(([slug, value]) => ({
-                        value: slug,
-                        label: value.label,
-                    })), onSelect: (slug) => send({ type: "Connection Chosen", slug }) })))),
+                React.createElement(Select, { items: snapshot.context.connections.map((connection) => ({
+                        value: connection.global,
+                        label: connection.label,
+                    })), onSelect: (global) => send({ type: "Connection Chosen", global }) })))),
         snapshot.matches("Confirm Removal") &&
-            snapshot.context.chosenConnectionSlug &&
+            snapshot.context.global !== undefined &&
             snapshot.context.connections && (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, null,
                 React.createElement(Text, null,
                     "Are you sure you want to remove \"",
-                    snapshot.context.connections[snapshot.context.chosenConnectionSlug].label,
+                    snapshot.context.connections.find(({ global }) => global === snapshot.context.global).label,
                     "\"?")),
             React.createElement(Box, null,
                 React.createElement(Select, { items: [

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

@@ -3,8 +3,6 @@ import { assign, setup, fromCallback } from "xstate";
 import { addConnectionDefinition } from "../api/add-connection-definition.js";
 import { fetchConnections } from "../api/fetch-connections.js";
 import { options } from "../commands/connection/add.js";
-import { updateAppConfig } from "../util/app-config.js";
-import { slugifyExtension } from "../util/slugify-extension.js";
 import { loadAppConfig, loadDeveloperConfig } from "./actors.js";
 export const connectionTypes = [
     { value: "secret", label: "Secret" },
@@ -17,7 +15,7 @@ export const addConnectionMachine = setup({
         input: {},
     },
     actors: {
-        "createConnectionDefinition": fromCallback(({ sendBack, input: { developer: { token, slug: devSlug }, config, connectionType: connection_type, key, label, description, global, authorizeUrl, accessTokenUrl, clientId, clientSecret, scopes, }, }) => {
+        "createConnectionDefinition": fromCallback(({ sendBack, input: { developer: { token, slug: devSlug }, config, connectionType: connection_type, label, description, global, authorizeUrl, accessTokenUrl, clientId, clientSecret, scopes, }, }) => {
             const add = async () => {
                 try {
                     await addConnectionDefinition({
@@ -26,7 +24,6 @@ export const addConnectionMachine = setup({
                         appId: config.id,
                         major: config.major,
                         connectionType: connection_type,
-                        key,
                         label,
                         description,
                         global,
@@ -36,10 +33,6 @@ export const addConnectionMachine = setup({
                         clientSecret,
                         scopes,
                     });
-                    updateAppConfig((config) => ({
-                        ...config,
-                        connectionType: connection_type,
-                    }));
                     sendBack({ type: "Success" });
                 }
                 catch (error) {
@@ -77,18 +70,18 @@ export const addConnectionMachine = setup({
                 }
             };
         }),
-        "validateKey": fromCallback(({ sendBack, input: { key, developer, config } }) => {
+        "validateGlobal": fromCallback(({ sendBack, input: { developer, config, global } }) => {
             fetchConnections({
                 token: developer.token,
                 devSlug: developer.slug,
                 appId: config.id,
                 major: config.major,
             }).then((connections) => {
-                if (connections[key]) {
-                    sendBack({ type: "Key Taken" });
+                if (connections.some((connection) => connection.global === global)) {
+                    sendBack({ type: "Global Taken" });
                 }
                 else {
-                    sendBack({ type: "Valid Key" });
+                    sendBack({ type: "Valid Global" });
                 }
             });
         }),
@@ -136,9 +129,6 @@ export const addConnectionMachine = setup({
         setDeveloperConfig: assign({
             developer: (_, params) => params,
         }),
-        setKey: assign({
-            key: (_, params) => slugifyExtension(params.key, false),
-        }),
         setInvalidAuthorizeUrl: assign({
             error: (_, params) => {
                 const result = options.shape.authorizeUrl
@@ -190,16 +180,12 @@ export const addConnectionMachine = setup({
         setAppConfig: assign({
             config: (_, params) => params.config,
         }),
-        setKeyTaken: assign({
-            error: () => "Key taken",
-        }),
-        slugifyLabel: assign({
-            key: (_, params) => slugifyExtension(params.label, true),
+        setGlobalTaken: assign({
+            error: () => "Global taken",
         }),
     },
     guards: {
         "have connection type": (_, params) => Boolean(params.connectionType),
-        "have key": (_, params) => Boolean(params.key),
         "have label": (_, params) => Boolean(params.label),
         "have description": (_, params) => Boolean(params.description),
         "have authorize url": (_, params) => params.connectionType === "secret" ||
@@ -274,7 +260,6 @@ export const addConnectionMachine = setup({
                     global: context.global,
                     label: context.label,
                     description: context.description,
-                    key: context.key,
                 }),
             },
             on: {
@@ -454,52 +439,6 @@ export const addConnectionMachine = setup({
                 },
             ],
         },
-        "Do we have a key?": {
-            always: [
-                {
-                    target: "Validating Key",
-                    guard: { type: "have key", params: ({ context }) => context },
-                },
-                {
-                    target: "Ask for key",
-                    actions: {
-                        type: "slugifyLabel",
-                        params: ({ context }) => ({ label: context.label }),
-                    },
-                },
-            ],
-        },
-        "Validating Key": {
-            on: {
-                "Key Taken": {
-                    target: "Ask for key",
-                    actions: "setKeyTaken",
-                },
-                "Valid Key": {
-                    target: "Do we have a description?",
-                    reenter: true,
-                    actions: "clearError",
-                },
-            },
-            invoke: {
-                src: "validateKey",
-                input: ({ context }) => ({
-                    key: context.key,
-                    developer: context.developer,
-                    config: context.config,
-                }),
-            },
-        },
-        "Ask for key": {
-            on: {
-                "Update Key": {
-                    actions: { type: "setKey", params: ({ event }) => event },
-                },
-                "Submit": "Validating Key",
-                "Previous": "Ask for label",
-                "Next": "Validating Key",
-            },
-        },
         "Do we have a connection type?": {
             always: [
                 {
@@ -537,7 +476,7 @@ export const addConnectionMachine = setup({
         "Do we have a label?": {
             always: [
                 {
-                    target: "Do we have a key?",
+                    target: "Do we have a description?",
                     guard: { type: "have label", params: ({ context }) => context },
                     reenter: true,
                 },
@@ -560,7 +499,7 @@ export const addConnectionMachine = setup({
         "Do we have global?": {
             always: [
                 {
-                    target: "Split on connection type",
+                    target: "Validating Global",
                     guard: { type: "have global", params: ({ context }) => context },
                     reenter: true,
                 },
@@ -572,7 +511,7 @@ export const addConnectionMachine = setup({
         "Ask for label": {
             on: {
                 "Submit": {
-                    target: "Do we have a key?",
+                    target: "Do we have a description?",
                     guard: { type: "have label", params: ({ context }) => context },
                     reenter: true,
                 },
@@ -581,7 +520,7 @@ export const addConnectionMachine = setup({
                 },
                 "Previous": "Ask for connection type",
                 "Next": {
-                    target: "Ask for key",
+                    target: "Ask for description",
                     guard: { type: "have label", params: ({ context }) => context },
                 },
             },
@@ -602,7 +541,7 @@ export const addConnectionMachine = setup({
                     guard: { type: "have description", params: ({ context }) => context },
                     actions: "clearError",
                 },
-                "Previous": "Ask for key",
+                "Previous": "Ask for label",
                 "Next": {
                     target: "Ask for global",
                     guard: { type: "have description", params: ({ context }) => context },
@@ -612,18 +551,38 @@ export const addConnectionMachine = setup({
         "Ask for global": {
             on: {
                 "Choose Global": {
-                    target: "Split on connection type",
+                    target: "Validating Global",
                     actions: { type: "setGlobal", params: ({ event }) => event },
                     reenter: true,
                 },
                 "Previous": "Ask for description",
                 "Next": {
-                    target: "Split on connection type",
+                    target: "Validating Global",
                     guard: { type: "have global", params: ({ context }) => context },
                     reenter: true,
                 },
             },
         },
+        "Validating Global": {
+            on: {
+                "Global Taken": {
+                    target: "Ask for global",
+                    actions: "setGlobalTaken",
+                },
+                "Valid Global": {
+                    target: "Split on connection type",
+                    reenter: true,
+                },
+            },
+            invoke: {
+                src: "validateGlobal",
+                input: ({ context }) => ({
+                    global: context.global,
+                    developer: context.developer,
+                    config: context.config,
+                }),
+            },
+        },
     },
     initial: "Loading Developer Config",
     invoke: {

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

@@ -39,7 +39,7 @@ export const listConnectionsMachine = setup({
         }),
     },
     guards: {
-        "have connections": (_, params) => Boolean(params.connections && Object.keys(params.connections).length > 0),
+        "have connections": (_, params) => Boolean(params.connections && params.connections.length > 0),
     },
 }).createMachine({
     context: ({ input }) => ({

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

@@ -2,7 +2,6 @@ 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";
 import { loadAppConfig, loadDeveloperConfig } from "./actors.js";
 export const removeConnectionMachine = setup({
     types: {
@@ -17,13 +16,9 @@ export const removeConnectionMachine = setup({
                         token: input.developer.token,
                         devSlug: input.developer.slug,
                         appId: input.config.id,
-                        slug: input.chosenConnectionSlug,
+                        global: input.global,
                         major: input.config.major,
                     });
-                    updateAppConfig((config) => ({
-                        ...config,
-                        connection: null,
-                    }));
                     sendBack({ type: "Success" });
                 }
                 catch (error) {
@@ -64,16 +59,16 @@ export const removeConnectionMachine = setup({
         setConnections: assign({
             connections: (_, params) => params.connections,
         }),
-        setConnection: assign({
-            chosenConnectionSlug: (_, params) => params.slug,
+        setGlobal: assign({
+            global: (_, params) => params.global,
         }),
         setOnlyConnection: assign({
-            chosenConnectionSlug: (_, params) => Object.keys(params.connections)[0],
+            global: (_, params) => params.connections[0].global,
         }),
     },
     guards: {
-        "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),
+        "have more than one connection": (_, params) => Boolean(params.connections && params.connections.length > 1),
+        "have only one connection": (_, params) => Boolean(params.connections && params.connections.length === 1),
     },
 }).createMachine({
     context: ({ input }) => ({
@@ -125,7 +120,7 @@ export const removeConnectionMachine = setup({
                 input: ({ context }) => ({
                     developer: context.developer,
                     config: context.config,
-                    chosenConnectionSlug: context.chosenConnectionSlug,
+                    global: context.global,
                 }),
             },
             on: {
@@ -187,7 +182,12 @@ export const removeConnectionMachine = setup({
             on: {
                 "Connection Chosen": {
                     target: "Confirm Removal",
-                    actions: { type: "setConnection", params: ({ event }) => event },
+                    actions: {
+                        type: "setGlobal",
+                        params: ({ event }) => ({
+                            global: event.global,
+                        }),
+                    },
                     reenter: true,
                 },
             },

package/package.json

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