attio 0.0.1-experimental.20241219 → 0.0.1-experimental.20250101

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

@@ -1,9 +1,12 @@
-import readline from "readline";
 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 { loadAppConfig, loadDeveloperConfig } from "./actors.js";
+import { optionsSchema } from "../commands/connection/add.js";
+import { ask, askPassword, askWithChoices, loadAppConfig, loadDeveloperConfig } from "./actors.js";
+import { printInstallInstructions } from "../util/print-install-instructions.js";
+import { printLogo, showError } from "./actions.js";
+import Spinner from "tiny-spinner";
+import chalk from "chalk";
 export const connectionTypes = [
     { value: "secret", label: "Secret" },
     { value: "oauth2-code", label: "OAuth2" },
@@ -15,8 +18,13 @@ export const addConnectionMachine = setup({
         input: {},
     },
     actors: {
-        "createConnectionDefinition": fromCallback(({ sendBack, input: { developer: { token, slug: devSlug }, config, connectionType: connection_type, label, description, global, authorizeUrl, accessTokenUrl, clientId, clientSecret, scopes, }, }) => {
+        ask,
+        askWithChoices,
+        askPassword,
+        createConnectionDefinition: fromCallback(({ sendBack, input: { developer: { token, slug: devSlug }, config, connectionType: connection_type, label, description, global, authorizeUrl, accessTokenUrl, clientId, clientSecret, scopes, }, }) => {
+            const spinner = new Spinner();
             const add = async () => {
+                spinner.start("Creating connection definition...");
                 try {
                     await addConnectionDefinition({
                         token,
@@ -33,9 +41,11 @@ export const addConnectionMachine = setup({
                         clientSecret,
                         scopes,
                     });
+                    spinner.success("Connection definition created");
                     sendBack({ type: "Success" });
                 }
                 catch (error) {
+                    spinner.error(`Failed to create connection definition: ${chalk.red(error.message)}`);
                     sendBack({ type: "Error", error: error.message });
                 }
             };
@@ -43,95 +53,78 @@ export const addConnectionMachine = setup({
         }),
         loadDeveloperConfig,
         loadAppConfig,
-        "keyboard-navigation": fromCallback(({ sendBack }) => {
-            readline.emitKeypressEvents(process.stdin);
-            if (process.stdin.isTTY) {
-                process.stdin.setRawMode(true);
-            }
-            const handleKeyPress = (_, key) => {
-                if (key.meta) {
-                    switch (key.name) {
-                        case "down":
-                            sendBack({ type: "Next" });
-                            break;
-                        case "up":
-                            sendBack({ type: "Previous" });
-                            break;
-                        default:
-                            break;
-                    }
-                }
-            };
-            process.stdin.on("keypress", handleKeyPress);
-            return () => {
-                process.stdin.removeListener("keypress", handleKeyPress);
-                if (process.stdin.isTTY) {
-                    process.stdin.setRawMode(false);
-                }
-            };
-        }),
-        "validateGlobal": fromCallback(({ sendBack, input: { developer, config, global } }) => {
+        validateGlobal: fromCallback(({ sendBack, input: { developer, config, global } }) => {
+            const spinner = new Spinner();
+            spinner.start("Checking if global connection already exists..." + global);
             fetchConnections({
                 token: developer.token,
                 devSlug: developer.slug,
                 appId: config.id,
                 major: config.major,
-            }).then((connections) => {
-                if (connections.some((connection) => connection.global === global)) {
+            })
+                .then((connections) => {
+                const weHaveGlobal = connections.some((connection) => connection.global);
+                const weHaveUser = connections.some((connection) => !connection.global);
+                if (weHaveGlobal && weHaveUser) {
+                    spinner.stop();
+                    sendBack({
+                        type: "Error",
+                        error: "Both global and user connections already exist",
+                    });
+                }
+                else if (weHaveGlobal && global) {
+                    spinner.error("Global connection already exists");
+                    sendBack({ type: "Global Taken" });
+                }
+                else if (weHaveUser && !global) {
+                    spinner.error("A user connection already exists");
                     sendBack({ type: "Global Taken" });
                 }
                 else {
+                    spinner.success("All good.");
                     sendBack({ type: "Valid Global" });
                 }
+            })
+                .catch((error) => {
+                spinner.stop();
+                sendBack({ type: "Error", error: error.message });
             });
         }),
     },
     actions: {
+        printLogo,
+        showError,
+        showConfigInstructions: ({ context }) => printInstallInstructions(context.configError),
         clearError: assign({
             error: () => undefined,
         }),
-        initializeLabel: assign({
-            label: (_, params) => {
-                if (params.label?.trim())
-                    return params.label;
-                switch (params.connectionType) {
-                    case "oauth2-code":
-                        return "Connection";
-                    case "secret":
-                    case undefined:
-                        return "Access Token";
-                    default:
-                        return params.connectionType;
-                }
-            },
-        }),
         setError: assign({
             error: (_, params) => params.error,
         }),
         setConnectionType: assign({
-            connectionType: (_, params) => params.connectionType,
+            connectionType: (_, params) => params.output,
         }),
         setAuthorizeUrl: assign({
-            authorizeUrl: (_, params) => params.authorizeUrl,
+            authorizeUrl: (_, params) => params.output,
         }),
         setAccessTokenUrl: assign({
-            accessTokenUrl: (_, params) => params.accessTokenUrl,
+            accessTokenUrl: (_, params) => params.output,
         }),
         setScopes: assign({
-            scopes: (_, params) => params.scopes,
+            scopes: (_, params) => params.output,
         }),
         setClientId: assign({
-            clientId: (_, params) => params.clientId,
+            clientId: (_, params) => params.output,
         }),
         setClientSecret: assign({
-            clientSecret: (_, params) => params.clientSecret,
+            clientSecret: (_, params) => params.output,
         }),
         setDeveloperConfig: assign({
             developer: (_, params) => params,
         }),
         setInvalidAuthorizeUrl: assign({
             error: (_, params) => {
-                const result = options.shape.authorizeUrl
+                const result = optionsSchema.shape.authorizeUrl
                     .unwrap()
                     .safeParse(params.authorizeUrl?.trim());
                 return result.success ? undefined : result.error.errors[0].message;
@@ -139,7 +132,7 @@ export const addConnectionMachine = setup({
         }),
         setInvalidAccessTokenUrl: assign({
             error: (_, params) => {
-                const result = options.shape.accessTokenUrl
+                const result = optionsSchema.shape.accessTokenUrl
                     .unwrap()
                     .safeParse(params.accessTokenUrl?.trim());
                 return result.success ? undefined : result.error.errors[0].message;
@@ -147,19 +140,21 @@ export const addConnectionMachine = setup({
         }),
         setInvalidScopes: assign({
             error: (_, params) => {
-                const result = options.shape.scopes.unwrap().safeParse(params.scopes?.trim());
+                const result = optionsSchema.shape.scopes.unwrap().safeParse(params.scopes?.trim());
                 return result.success ? undefined : result.error.errors[0].message;
             },
         }),
         setInvalidClientId: assign({
             error: (_, params) => {
-                const result = options.shape.clientId.unwrap().safeParse(params.clientId?.trim());
+                const result = optionsSchema.shape.clientId
+                    .unwrap()
+                    .safeParse(params.clientId?.trim());
                 return result.success ? undefined : result.error.errors[0].message;
             },
         }),
         setInvalidClientSecret: assign({
             error: (_, params) => {
-                const result = options.shape.clientSecret
+                const result = optionsSchema.shape.clientSecret
                     .unwrap()
                     .safeParse(params.clientSecret?.trim());
                 return result.success ? undefined : result.error.errors[0].message;
@@ -169,13 +164,13 @@ export const addConnectionMachine = setup({
             configError: (_, params) => params.configError,
         }),
         setLabel: assign({
-            label: (_, params) => params.label,
+            label: (_, params) => params.output,
         }),
         setDescription: assign({
-            description: (_, params) => params.description,
+            description: (_, params) => params.output,
         }),
         setGlobal: assign({
-            global: (_, params) => params.global,
+            global: (_, params) => params.output === "true",
         }),
         setAppConfig: assign({
             config: (_, params) => params.config,
@@ -189,16 +184,19 @@ export const addConnectionMachine = setup({
         "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,
+            optionsSchema.shape.authorizeUrl.unwrap().safeParse(params.authorizeUrl?.trim())
+                .success,
         "have access token url": (_, params) => params.connectionType === "secret" ||
-            options.shape.accessTokenUrl.unwrap().safeParse(params.accessTokenUrl?.trim()).success,
+            optionsSchema.shape.accessTokenUrl.unwrap().safeParse(params.accessTokenUrl?.trim())
+                .success,
         "have scopes": (_, params) => params.connectionType === "secret" ||
-            options.shape.scopes.unwrap().safeParse(params.scopes?.trim()).success,
+            optionsSchema.shape.scopes.unwrap().safeParse(params.scopes?.trim()).success,
         "have client id": (_, params) => params.connectionType === "secret" ||
-            options.shape.clientId.unwrap().safeParse(params.clientId?.trim()).success,
+            optionsSchema.shape.clientId.unwrap().safeParse(params.clientId?.trim()).success,
         "have global": (_, params) => params.global !== undefined,
         "have client secret": (_, params) => params.connectionType === "secret" ||
-            options.shape.clientSecret.unwrap().safeParse(params.clientSecret?.trim()).success,
+            optionsSchema.shape.clientSecret.unwrap().safeParse(params.clientSecret?.trim())
+                .success,
         "is oauth": (_, params) => params.connectionType === "oauth2-code",
     },
 }).createMachine({
@@ -225,6 +223,7 @@ export const addConnectionMachine = setup({
         },
         "Show config instructions": {
             type: "final",
+            entry: "showConfigInstructions",
         },
         "Loading App Config": {
             invoke: {
@@ -244,6 +243,7 @@ export const addConnectionMachine = setup({
         },
         "Error": {
             type: "final",
+            entry: { type: "showError", params: ({ context }) => ({ error: context.error }) },
         },
         "Creating connection definition": {
             invoke: {
@@ -274,114 +274,84 @@ export const addConnectionMachine = setup({
             type: "final",
         },
         "Ask for Authorize URL": {
-            on: {
-                "Update Authorize URL": {
-                    actions: { type: "setAuthorizeUrl", params: ({ event }) => event },
-                },
-                "Submit": [
-                    {
-                        target: "Do we have an access token url?",
-                        guard: { type: "have authorize url", params: ({ context }) => context },
-                        actions: "clearError",
-                    },
-                    {
-                        target: "Ask for Authorize URL",
-                        actions: { type: "setInvalidAuthorizeUrl", params: ({ context }) => context },
+            invoke: {
+                src: "ask",
+                input: {
+                    message: "e.g. https://authorization-server.com/oauth/authorize\nOAuth Authorize URL:",
+                    required: true,
+                    validate: (value) => {
+                        const result = optionsSchema.shape.authorizeUrl
+                            .unwrap()
+                            .safeParse(value.trim());
+                        return result.success ? true : result.error.errors[0].message;
                     },
-                ],
-                "Previous": "Ask for global",
-                "Next": {
-                    target: "Ask for Access Token URL",
-                    guard: { type: "have authorize url", params: ({ context }) => context },
+                },
+                onDone: {
+                    target: "Do we have an access token url?",
+                    actions: { type: "setAuthorizeUrl", params: ({ event }) => event },
                 },
             },
         },
         "Ask for Access Token URL": {
-            on: {
-                "Submit": [
-                    {
-                        target: "Do we have scopes?",
-                        guard: { type: "have access token url", params: ({ context }) => context },
-                        actions: "clearError",
-                    },
-                    {
-                        target: "Ask for Access Token URL",
-                        actions: { type: "setInvalidAccessTokenUrl", params: ({ context }) => context },
+            invoke: {
+                src: "ask",
+                input: {
+                    message: "e.g. https://authorization-server.com/oauth/token\nOAuth Access Token URL:",
+                    required: true,
+                    validate: (value) => {
+                        const result = optionsSchema.shape.accessTokenUrl
+                            .unwrap()
+                            .safeParse(value.trim());
+                        return result.success ? true : result.error.errors[0].message;
                     },
-                ],
-                "Update Access Token URL": {
-                    actions: { type: "setAccessTokenUrl", params: ({ event }) => event },
                 },
-                "Previous": "Ask for Authorize URL",
-                "Next": {
-                    target: "Ask for Scopes",
-                    guard: { type: "have access token url", params: ({ context }) => context },
+                onDone: {
+                    target: "Do we have scopes?",
+                    actions: { type: "setAccessTokenUrl", params: ({ event }) => event },
                 },
             },
         },
         "Ask for Scopes": {
-            on: {
-                "Update Scopes": {
-                    actions: { type: "setScopes", params: ({ event }) => event },
-                },
-                "Submit": [
-                    {
-                        target: "Do we have a client id?",
-                        guard: { type: "have scopes", params: ({ context }) => context },
-                        actions: "clearError",
-                    },
-                    {
-                        target: "Ask for Scopes",
-                        actions: { type: "setInvalidScopes", params: ({ context }) => context },
+            invoke: {
+                src: "ask",
+                input: {
+                    message: "e.g. read:user,read:org\nOAuth Scopes:",
+                    required: true,
+                    validate: (value) => {
+                        const result = optionsSchema.shape.scopes.unwrap().safeParse(value.trim());
+                        return result.success ? true : result.error.errors[0].message;
                     },
-                ],
-                "Previous": "Ask for Access Token URL",
-                "Next": {
-                    target: "Ask for Client ID",
-                    guard: { type: "have scopes", params: ({ context }) => context },
+                },
+                onDone: {
+                    target: "Do we have a client id?",
+                    actions: { type: "setScopes", params: ({ event }) => event },
                 },
             },
         },
         "Ask for Client ID": {
-            on: {
-                "Update Client ID": {
-                    actions: { type: "setClientId", params: ({ event }) => event },
+            invoke: {
+                src: "ask",
+                input: {
+                    message: "OAuth Client ID:",
+                    required: true,
                 },
-                "Submit": [
-                    {
-                        target: "Do we have a client secret?",
-                        guard: { type: "have client id", params: ({ context }) => context },
-                        actions: "clearError",
-                    },
-                    {
-                        target: "Ask for Client ID",
-                        actions: { type: "setInvalidClientId", params: ({ context }) => context },
-                    },
-                ],
-                "Previous": "Ask for Scopes",
-                "Next": {
-                    target: "Ask for Client Secret",
-                    guard: { type: "have client id", params: ({ context }) => context },
+                onDone: {
+                    target: "Do we have a client secret?",
+                    actions: { type: "setClientId", params: ({ event }) => event },
                 },
             },
         },
         "Ask for Client Secret": {
-            on: {
-                "Update Client Secret": {
+            invoke: {
+                src: "askPassword",
+                input: {
+                    message: "OAuth Client Secret:",
+                    required: true,
+                },
+                onDone: {
+                    target: "Creating connection definition",
                     actions: { type: "setClientSecret", params: ({ event }) => event },
                 },
-                "Submit": [
-                    {
-                        target: "Creating connection definition",
-                        guard: { type: "have client secret", params: ({ context }) => context },
-                        actions: "clearError",
-                    },
-                    {
-                        target: "Ask for Client Secret",
-                        actions: { type: "setInvalidClientSecret", params: ({ context }) => context },
-                    },
-                ],
-                "Previous": "Ask for Client ID",
             },
         },
         "Do we have an authorize url?": {
@@ -450,15 +420,18 @@ export const addConnectionMachine = setup({
             ],
         },
         "Ask for connection type": {
-            on: {
-                "Choose Connection Type": {
+            invoke: {
+                src: "askWithChoices",
+                input: {
+                    message: "What type of connection would you like to add?",
+                    choices: [
+                        { name: "OAuth2 Code", value: "oauth2-code" },
+                        { name: "Secret", value: "secret" },
+                    ],
+                },
+                onDone: {
                     target: "Do we have a label?",
-                    actions: [{ type: "setConnectionType", params: ({ event }) => event }],
-                    reenter: true,
-                },
-                "Next": {
-                    target: "Ask for label",
-                    guard: { type: "have connection type", params: ({ context }) => context },
+                    actions: { type: "setConnectionType", params: ({ event }) => event },
                 },
             },
         },
@@ -509,57 +482,49 @@ export const addConnectionMachine = setup({
             ],
         },
         "Ask for label": {
-            on: {
-                "Submit": {
+            invoke: {
+                src: "ask",
+                input: ({ context }) => ({
+                    message: "What would you like to call this connection?",
+                    required: true,
+                    default: context.connectionType === "oauth2-code"
+                        ? "Connection"
+                        : context.connectionType === "secret"
+                            ? "Access Token"
+                            : "",
+                }),
+                onDone: {
                     target: "Do we have a description?",
-                    guard: { type: "have label", params: ({ context }) => context },
-                    reenter: true,
-                },
-                "Update Label": {
                     actions: { type: "setLabel", params: ({ event }) => event },
                 },
-                "Previous": "Ask for connection type",
-                "Next": {
-                    target: "Ask for description",
-                    guard: { type: "have label", params: ({ context }) => context },
-                },
             },
-            entry: [
-                {
-                    type: "initializeLabel",
-                    params: ({ context }) => context,
-                },
-            ],
         },
         "Ask for description": {
-            on: {
-                "Update Description": {
-                    actions: { type: "setDescription", params: ({ event }) => event },
+            invoke: {
+                src: "ask",
+                input: {
+                    message: "Description: (will be displayed in the UI)",
+                    required: true,
                 },
-                "Submit": {
+                onDone: {
                     target: "Do we have global?",
-                    guard: { type: "have description", params: ({ context }) => context },
-                    actions: "clearError",
-                },
-                "Previous": "Ask for label",
-                "Next": {
-                    target: "Ask for global",
-                    guard: { type: "have description", params: ({ context }) => context },
+                    actions: { type: "setDescription", params: ({ event }) => event },
                 },
             },
         },
         "Ask for global": {
-            on: {
-                "Choose Global": {
+            invoke: {
+                src: "askWithChoices",
+                input: ({ context }) => ({
+                    message: `A ${context.connectionType === "secret" ? "secret" : "token"} will be created for:`,
+                    choices: [
+                        { name: "The entire workspace", value: "true" },
+                        { name: "An individual user", value: "false" },
+                    ],
+                }),
+                onDone: {
                     target: "Validating Global",
                     actions: { type: "setGlobal", params: ({ event }) => event },
-                    reenter: true,
-                },
-                "Previous": "Ask for description",
-                "Next": {
-                    target: "Validating Global",
-                    guard: { type: "have global", params: ({ context }) => context },
-                    reenter: true,
                 },
             },
         },
@@ -573,6 +538,11 @@ export const addConnectionMachine = setup({
                     target: "Split on connection type",
                     reenter: true,
                 },
+                "Error": {
+                    target: "Error",
+                    reenter: true,
+                    actions: { type: "setError", params: ({ event }) => event },
+                },
             },
             invoke: {
                 src: "validateGlobal",
@@ -585,7 +555,5 @@ export const addConnectionMachine = setup({
         },
     },
     initial: "Loading Developer Config",
-    invoke: {
-        src: "keyboard-navigation",
-    },
+    entry: "printLogo",
 });

package/lib/machines/build-machine.js

@@ -1,8 +1,12 @@
 import { assign, setup } from "xstate";
+import Spinner from "tiny-spinner";
 import { codeGenMachine } from "./code-gen-machine.js";
 import { jsMachine } from "./js-machine.js";
 import { tsMachine } from "./ts-machine.js";
+import { printError } from "../util/typescript.js";
+import { printLogo } from "./actions.js";
 const processes = ["javascript", "typescript"];
+const spinner = new Spinner();
 export const buildMachine = setup({
     types: {
         context: {},
@@ -19,9 +23,26 @@ export const buildMachine = setup({
         "all success": ({ context }) => context.successful.length === processes.length,
     },
     actions: {
+        buildingStart: () => {
+            spinner.start("🔨 Building...");
+        },
+        buildFail: ({ self }) => {
+            spinner.error("Build failed");
+            const snapshot = self.getSnapshot();
+            const { tsErrors = [] } = snapshot.context;
+            process.stderr.write("\n");
+            tsErrors.forEach(printError);
+        },
+        buildSuccess: () => {
+            spinner.success("Build succeeded");
+        },
+        printLogo,
         setError: assign({
             failed: ({ context }, params) => [...context.failed, params.process],
         }),
+        setTypeScriptErrors: assign({
+            tsErrors: ({ context }, params) => params.errors,
+        }),
         setSuccess: assign({
             successful: ({ context }, params) => [
                 ...context.successful,
@@ -35,9 +56,11 @@ export const buildMachine = setup({
     states: {
         "Errored": {
             type: "final",
+            entry: "buildFail",
         },
         "Success": {
             type: "final",
+            entry: "buildSuccess",
         },
         "Building": {
             type: "parallel",
@@ -89,10 +112,16 @@ export const buildMachine = setup({
                                 },
                                 "TypeScript Error": {
                                     target: "Waiting",
-                                    actions: {
-                                        type: "setError",
-                                        params: { process: "typescript" },
-                                    },
+                                    actions: [
+                                        {
+                                            type: "setError",
+                                            params: { process: "typescript" },
+                                        },
+                                        {
+                                            type: "setTypeScriptErrors",
+                                            params: ({ event }) => event,
+                                        },
+                                    ],
                                 },
                             },
                             invoke: {
@@ -129,6 +158,7 @@ export const buildMachine = setup({
                     initial: "Code Generating",
                 },
             },
+            entry: "buildingStart",
         },
         "All Done": {
             always: [
@@ -144,4 +174,5 @@ export const buildMachine = setup({
         },
     },
     initial: "Building",
+    entry: "printLogo",
 });