attio 0.0.1-experimental.20240925 → 0.0.1-experimental.20240926.1

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

@@ -1,16 +1,14 @@
 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" },
     { value: "oauth2-code", label: "OAuth2" },
 ];
-export const audiences = [
-    { value: "workspace", label: "Workspace" },
-    { value: "workspace-member", label: "Workspace Member" },
-];
 export const addConnectionMachine = setup({
     types: {
         context: {},
@@ -18,14 +16,20 @@ export const addConnectionMachine = setup({
         input: {},
     },
     actors: {
-        createConnectionDefinition: fromCallback(({ sendBack, input: { developer: { token, slug: devSlug }, appId, connectionType: connection_type, audience, authorizeUrl, accessTokenUrl, clientId, clientSecret, scopes, }, }) => {
+        createConnectionDefinition: fromCallback(({ sendBack, input: { developer: { token, slug: devSlug }, config, connectionType: connection_type, slug, label, description, allowMultiple, global, authorizeUrl, accessTokenUrl, clientId, clientSecret, scopes, }, }) => {
             const add = async () => {
                 try {
                     await addConnectionDefinition({
                         token,
                         devSlug,
-                        appId,
-                        connection: { connection_type, audience },
+                        appId: config.id,
+                        major: config.major,
+                        connectionType: connection_type,
+                        slug,
+                        label,
+                        description,
+                        allowMultiple,
+                        global,
                         accessTokenUrl,
                         authorizeUrl,
                         clientId,
@@ -34,7 +38,7 @@ export const addConnectionMachine = setup({
                     });
                     updateAppConfig((config) => ({
                         ...config,
-                        connection: { connection_type, audience },
+                        connectionType: connection_type,
                     }));
                     sendBack({ type: "Success" });
                 }
@@ -46,6 +50,21 @@ export const addConnectionMachine = setup({
         }),
         loadDeveloperConfig,
         loadAppConfig,
+        validateSlug: fromCallback(({ sendBack, input: { slug, developer, config } }) => {
+            fetchConnections({
+                token: developer.token,
+                devSlug: developer.slug,
+                appId: config.id,
+                major: config.major,
+            }).then((connections) => {
+                if (connections[slug]) {
+                    sendBack({ type: "Slug Taken" });
+                }
+                else {
+                    sendBack({ type: "Valid Slug" });
+                }
+            });
+        }),
     },
     actions: {
         clearError: assign({
@@ -54,9 +73,6 @@ export const addConnectionMachine = setup({
         setError: assign({
             error: (_, params) => params.error,
         }),
-        setAudience: assign({
-            audience: (_, params) => params.audience,
-        }),
         setConnectionType: assign({
             connectionType: (_, params) => params.connectionType,
         }),
@@ -78,6 +94,9 @@ export const addConnectionMachine = setup({
         setDeveloperConfig: assign({
             developer: (_, params) => params,
         }),
+        setSlug: assign({
+            slug: (_, params) => slugifyExtension(params.slug, false),
+        }),
         setInvalidAuthorizeUrl: assign({
             error: (_, params) => {
                 const result = options.shape.authorizeUrl
@@ -117,15 +136,30 @@ export const addConnectionMachine = setup({
         setConfigError: assign({
             configError: (_, params) => params.configError,
         }),
+        setLabel: assign({
+            label: (_, params) => params.label,
+        }),
+        setDescription: assign({
+            description: (_, params) => params.description,
+        }),
+        setGlobal: assign({
+            global: (_, params) => params.global,
+        }),
+        setAllowMultiple: assign({
+            allowMultiple: (_, params) => params.allowMultiple,
+        }),
         setAppConfig: assign({
-            appId: (_, params) => params.config.id,
-            haveConnection: (_, params) => Boolean(params.config.connection),
+            config: (_, params) => params.config,
+        }),
+        setSlugTaken: assign({
+            error: () => "Slug taken",
         }),
     },
     guards: {
-        "already have a connection": (_, params) => params.haveConnection,
-        "have audience": (_, params) => Boolean(params.audience),
         "have connection type": (_, params) => Boolean(params.connectionType),
+        "have slug": (_, params) => Boolean(params.slug),
+        "have label": (_, params) => Boolean(params.label),
+        "have description": (_, params) => Boolean(params.description),
         "have authorize url": (_, params) => params.connectionType === "secret" ||
             options.shape.authorizeUrl.unwrap().safeParse(params.authorizeUrl?.trim()).success,
         "have access token url": (_, params) => params.connectionType === "secret" ||
@@ -134,14 +168,15 @@ export const addConnectionMachine = setup({
             options.shape.scopes.unwrap().safeParse(params.scopes?.trim()).success,
         "have client id": (_, params) => params.connectionType === "secret" ||
             options.shape.clientId.unwrap().safeParse(params.clientId?.trim()).success,
+        "have global": (_, params) => params.global !== undefined,
+        "have allow multiple": (_, params) => params.allowMultiple !== undefined,
         "have client secret": (_, params) => params.connectionType === "secret" ||
             options.shape.clientSecret.unwrap().safeParse(params.clientSecret?.trim()).success,
+        "is oauth": (_, params) => params.connectionType === "oauth2-code",
     },
 }).createMachine({
     context: ({ input }) => ({
         developer: { slug: "", token: "" },
-        appId: "",
-        haveConnection: false,
         ...input,
     }),
     id: "Add Connection Machine",
@@ -173,71 +208,47 @@ export const addConnectionMachine = setup({
                     target: "Error",
                     actions: { type: "setError", params: ({ event }) => event },
                 },
-                "App Config Loaded": {
-                    target: "Do we already have a connection?",
-                    actions: { type: "setAppConfig", params: ({ event }) => event },
-                },
+                "App Config Loaded": [
+                    {
+                        target: "Do we have a slug?",
+                        actions: { type: "setAppConfig", params: ({ event }) => event },
+                    },
+                ],
             },
         },
         "Error": {
             type: "final",
         },
-        "Ask for connection type": {
-            on: {
-                "Choose Connection Type": {
-                    target: "Do we have an audience?",
-                    actions: { type: "setConnectionType", params: ({ event }) => event },
-                },
-            },
-        },
-        "Ask for audience": {
-            on: {
-                "Choose Audience": {
-                    target: "Do we have an authorize url?",
-                    actions: { type: "setAudience", params: ({ event }) => event },
-                },
-            },
-        },
         "Creating connection definition": {
             invoke: {
                 src: "createConnectionDefinition",
                 input: ({ context }) => ({
                     developer: context.developer,
-                    appId: context.appId,
+                    config: context.config,
                     connectionType: context.connectionType,
-                    audience: context.audience,
                     authorizeUrl: context.authorizeUrl,
                     accessTokenUrl: context.accessTokenUrl,
                     scopes: context.scopes,
                     clientId: context.clientId,
                     clientSecret: context.clientSecret,
+                    global: context.global,
+                    allowMultiple: context.allowMultiple,
+                    label: context.label,
+                    description: context.description,
+                    slug: context.slug,
                 }),
             },
             on: {
-                Success: "Success",
                 Error: {
                     target: "Error",
                     actions: { type: "setError", params: ({ event }) => event },
                 },
+                Success: "Success",
             },
         },
         "Success": {
             type: "final",
         },
-        "Do we already have a connection?": {
-            always: [
-                {
-                    target: "Already have a connection",
-                    guard: { type: "already have a connection", params: ({ context }) => context },
-                },
-                {
-                    target: "Do we have a connection type?",
-                },
-            ],
-        },
-        "Already have a connection": {
-            type: "final",
-        },
         "Ask for Authorize URL": {
             on: {
                 "Update Authorize URL": {
@@ -316,35 +327,9 @@ export const addConnectionMachine = setup({
                         target: "Creating connection definition",
                         guard: { type: "have client secret", params: ({ context }) => context },
                     },
-                    {
-                        target: "Ask for Client Secret",
-                        actions: { type: "setInvalidClientSecret", params: ({ context }) => context },
-                    },
                 ],
             },
         },
-        "Do we have a connection type?": {
-            always: [
-                {
-                    target: "Do we have an audience?",
-                    guard: { type: "have connection type", params: ({ context }) => context },
-                },
-                {
-                    target: "Ask for connection type",
-                },
-            ],
-        },
-        "Do we have an audience?": {
-            always: [
-                {
-                    target: "Do we have an authorize url?",
-                    guard: { type: "have audience", params: ({ context }) => context },
-                },
-                {
-                    target: "Ask for audience",
-                },
-            ],
-        },
         "Do we have an authorize url?": {
             always: [
                 {
@@ -400,6 +385,154 @@ export const addConnectionMachine = setup({
                 },
             ],
         },
+        "Do we have a slug?": {
+            always: [
+                {
+                    target: "Validating Slug",
+                    guard: { type: "have slug", params: ({ context }) => context },
+                },
+                {
+                    target: "Ask for slug",
+                },
+            ],
+        },
+        "Validating Slug": {
+            on: {
+                "Slug Taken": {
+                    target: "Ask for slug",
+                    actions: "setSlugTaken",
+                },
+                "Valid Slug": {
+                    target: "Do we have a label?",
+                },
+            },
+            invoke: {
+                src: "validateSlug",
+                input: ({ context }) => ({
+                    slug: context.slug,
+                    developer: context.developer,
+                    config: context.config,
+                }),
+            },
+        },
+        "Ask for slug": {
+            on: {
+                "Update Slug": {
+                    actions: { type: "setSlug", params: ({ event }) => event },
+                },
+                "Submit": "Validating Slug",
+            },
+        },
+        "Do we have a connection type?": {
+            always: [
+                {
+                    target: "Split on connection type",
+                    guard: { type: "have connection type", params: ({ context }) => context },
+                },
+                "Ask for connection type",
+            ],
+        },
+        "Ask for connection type": {
+            on: {
+                "Choose Connection Type": {
+                    target: "Split on connection type",
+                    actions: { type: "setConnectionType", params: ({ event }) => event },
+                },
+            },
+        },
+        "Split on connection type": {
+            always: [
+                {
+                    target: "Do we have an authorize url?",
+                    guard: { type: "is oauth", params: ({ context }) => context },
+                },
+                {
+                    target: "Creating connection definition",
+                },
+            ],
+        },
+        "Do we have a label?": {
+            always: [
+                {
+                    target: "Do we have a description?",
+                    guard: { type: "have label", params: ({ context }) => context },
+                },
+                {
+                    target: "Ask for label",
+                },
+            ],
+        },
+        "Do we have a description?": {
+            always: [
+                {
+                    target: "Do we have global?",
+                    guard: { type: "have description", params: ({ context }) => context },
+                },
+                {
+                    target: "Ask for description",
+                },
+            ],
+        },
+        "Do we have global?": {
+            always: [
+                {
+                    target: "Do we have allow multiple?",
+                    guard: { type: "have global", params: ({ context }) => context },
+                },
+                {
+                    target: "Ask for global",
+                },
+            ],
+        },
+        "Do we have allow multiple?": {
+            always: [
+                {
+                    target: "Do we have a connection type?",
+                    guard: { type: "have allow multiple", params: ({ context }) => context },
+                },
+                {
+                    target: "Ask for allow multiple",
+                },
+            ],
+        },
+        "Ask for label": {
+            on: {
+                "Submit": {
+                    target: "Do we have a description?",
+                    guard: { type: "have label", params: ({ context }) => context },
+                },
+                "Update Label": {
+                    actions: { type: "setLabel", params: ({ event }) => event },
+                },
+            },
+        },
+        "Ask for description": {
+            on: {
+                "Update Description": {
+                    actions: { type: "setDescription", params: ({ event }) => event },
+                },
+                "Submit": {
+                    target: "Do we have global?",
+                    guard: { type: "have description", params: ({ context }) => context },
+                },
+            },
+        },
+        "Ask for global": {
+            on: {
+                "Choose Global": {
+                    target: "Do we have allow multiple?",
+                    actions: { type: "setGlobal", params: ({ event }) => event },
+                },
+            },
+        },
+        "Ask for allow multiple": {
+            on: {
+                "Choose Allow Multiple": {
+                    target: "Do we have a connection type?",
+                    actions: { type: "setAllowMultiple", params: ({ event }) => event },
+                },
+            },
+        },
     },
     initial: "Loading Developer Config",
 });

package/lib/machines/dev-machine.js

@@ -1,7 +1,10 @@
 import chokidar from "chokidar";
+import open from "open";
+import readline from "readline";
 import { assign, fromCallback, setup, enqueueActions } from "xstate";
 import { completeBundleUpload } from "../api/complete-bundle-upload.js";
 import { createDevVersion } from "../api/create-dev-version.js";
+import { startGraphqlServer } from "../api/start-graphql-server.js";
 import { startUpload } from "../api/start-upload.js";
 import { loadAppConfigFile } from "../util/app-config.js";
 import { loadDeveloperConfig, loadInitialDeveloperConfig, } from "../util/load-developer-config.js";
@@ -30,6 +33,24 @@ export const devMachine = setup({
             }
             sendBack({ type: "Initialized", config });
         }),
+        listenForGraphqlOpen: fromCallback(({ input }) => {
+            readline.emitKeypressEvents(process.stdin);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(true);
+            }
+            const handleKeyPress = (str, key) => {
+                if (key.name?.toLowerCase() === "o") {
+                    open(`http://localhost:${input.graphqlPort}/graphql`);
+                }
+            };
+            process.stdin.on("keypress", handleKeyPress);
+            return () => {
+                process.stdin.removeListener("keypress", handleKeyPress);
+                if (process.stdin.isTTY) {
+                    process.stdin.setRawMode(false);
+                }
+            };
+        }),
         prepareUpload: fromCallback(({ sendBack }) => {
             const prepareUpload = async () => {
                 const config = await loadDeveloperConfig();
@@ -108,6 +129,7 @@ export const devMachine = setup({
                 watcher.close();
             };
         }),
+        graphql: fromCallback(({ sendBack }) => startGraphqlServer(sendBack)),
     },
     actions: {
         clearUploadError: assign({ uploadError: undefined }),
@@ -125,6 +147,9 @@ export const devMachine = setup({
         setDevVersion: assign({
             devVersion: (_, params) => params.devVersion,
         }),
+        setGraphqlPort: assign({
+            graphqlPort: (_, params) => params.port,
+        }),
         setSuccess: assign({
             jsContents: (_, params) => params.contents,
             lastSuccessfulJavaScriptBuild: (_, params) => params.time,
@@ -252,6 +277,31 @@ export const devMachine = setup({
                     },
                     initial: "Validating",
                 },
+                Graphql: {
+                    invoke: {
+                        src: "graphql",
+                    },
+                    states: {
+                        "Not Started": {
+                            on: {
+                                "GraphQL Server Started": {
+                                    target: "Started",
+                                    actions: {
+                                        type: "setGraphqlPort",
+                                        params: ({ event }) => event,
+                                    },
+                                },
+                            },
+                        },
+                        "Started": {
+                            invoke: {
+                                src: "listenForGraphqlOpen",
+                                input: ({ context }) => ({ graphqlPort: context.graphqlPort }),
+                            },
+                        },
+                    },
+                    initial: "Not Started",
+                },
             },
             type: "parallel",
         },