attio 0.0.1-experimental.20241011.3 → 0.0.1-experimental.20241011.4

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/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,7 +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 = [
@@ -36,10 +35,6 @@ export const addConnectionMachine = setup({
                         clientSecret,
                         scopes,
                     });
-                    updateAppConfig((config) => ({
-                        ...config,
-                        connectionType: connection_type,
-                    }));
                     sendBack({ type: "Success" });
                 }
                 catch (error) {
@@ -77,18 +72,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" });
                 }
             });
         }),
@@ -190,8 +185,8 @@ export const addConnectionMachine = setup({
         setAppConfig: assign({
             config: (_, params) => params.config,
         }),
-        setKeyTaken: assign({
-            error: () => "Key taken",
+        setGlobalTaken: assign({
+            error: () => "Global taken",
         }),
         slugifyLabel: assign({
             key: (_, params) => slugifyExtension(params.label, true),
@@ -457,7 +452,9 @@ export const addConnectionMachine = setup({
         "Do we have a key?": {
             always: [
                 {
-                    target: "Validating Key",
+                    target: "Do we have a description?",
+                    reenter: true,
+                    actions: "clearError",
                     guard: { type: "have key", params: ({ context }) => context },
                 },
                 {
@@ -469,35 +466,14 @@ export const addConnectionMachine = setup({
                 },
             ],
         },
-        "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",
+                "Submit": "Do we have a description?",
                 "Previous": "Ask for label",
-                "Next": "Validating Key",
+                "Next": "Do we have a description?",
             },
         },
         "Do we have a connection type?": {
@@ -560,7 +536,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,
                 },
@@ -612,18 +588,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.4",
   "bin": "lib/attio.js",
   "type": "module",
   "files": [