attio 0.0.1-experimental.20241226 → 0.0.1-experimental.20250108

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

@@ -1,7 +1,12 @@
-import { assign, setup, fromCallback } from "xstate";
-import { fetchVersions } from "../api/fetch-versions.js";
+import { assign, setup } from "xstate";
 import { emptyConfig } from "../schema.js";
-import { loadAppConfig, loadDeveloperConfig } from "./actors.js";
+import { loadAppConfig, loadDeveloperConfig, fetchVersions } from "./actors.js";
+import formatDate from "date-fns/format/index.js";
+import { showError, printLogo } from "./actions.js";
+import { printInstallInstructions } from "../util/print-install-instructions.js";
+import Table from "cli-table3";
+import chalk from "chalk";
+import boxen from "boxen";
 export const connectionTypes = [
     { value: "secret", label: "Secret" },
     { value: "oauth2-code", label: "OAuth2" },
@@ -16,21 +21,41 @@ export const listVersionsMachine = setup({
         events: {},
     },
     actors: {
-        fetchVersions: fromCallback(({ sendBack, input: { developer: { token, slug: devSlug }, config, }, }) => {
-            const getVersions = async () => {
-                const versions = await fetchVersions({
-                    token,
-                    devSlug,
-                    appId: config.id,
-                });
-                sendBack({ type: "Versions Fetched", versions });
-            };
-            getVersions();
-        }),
+        fetchVersions,
         loadDeveloperConfig,
         loadAppConfig,
     },
     actions: {
+        printLogo,
+        showError,
+        showConfigInstructions: ({ context }) => printInstallInstructions(context.configError),
+        showVersions: ({ context }) => {
+            if (context.versions.length === 0) {
+                process.stdout.write(chalk.red("\nNo versions found.\n\n"));
+                process.stdout.write("You can create a new version by running:\n");
+                process.stdout.write(boxen("attio version create", {
+                    padding: 1,
+                    margin: 1,
+                    borderStyle: "round",
+                }));
+                return;
+            }
+            const table = new Table({
+                head: ["Version", "Published", "Installations", "Created"].map((h) => chalk.bold(h)),
+                style: {
+                    head: [],
+                    border: [],
+                },
+                colAligns: ["center", "center", "right", "left"],
+            });
+            table.push(...context.versions.map((version) => [
+                `${version.major}.${version.minor}`,
+                version.is_published ? "Yes" : "No",
+                version.num_installations.toLocaleString(),
+                formatDate(new Date(version.created_at), "MMMM d, yyyy, HH:mm"),
+            ]));
+            process.stdout.write(table.toString());
+        },
         clearError: assign({
             error: () => undefined,
         }),
@@ -75,6 +100,7 @@ export const listVersionsMachine = setup({
         },
         "Show config instructions": {
             type: "final",
+            entry: "showConfigInstructions",
         },
         "Loading App Config": {
             invoke: {
@@ -94,6 +120,7 @@ export const listVersionsMachine = setup({
         },
         "Error": {
             type: "final",
+            entry: { type: "showError", params: ({ context }) => ({ error: context.error }) },
         },
         "Fetching Versions": {
             on: {
@@ -101,6 +128,10 @@ export const listVersionsMachine = setup({
                     target: "Display Versions",
                     actions: { type: "setVersions", params: ({ event }) => event },
                 },
+                "Error": {
+                    target: "Error",
+                    actions: { type: "setError", params: ({ event }) => event },
+                },
             },
             invoke: {
                 src: "fetchVersions",
@@ -112,7 +143,9 @@ export const listVersionsMachine = setup({
         },
         "Display Versions": {
             type: "final",
+            entry: "showVersions",
         },
     },
     initial: "Loading Developer Config",
+    entry: "printLogo",
 });

package/lib/machines/publish-version-machine.js

@@ -2,7 +2,10 @@ import { assign, setup, fromCallback } from "xstate";
 import { fetchPublishableVersions } from "../api/fetch-versions.js";
 import { publishVersion } from "../api/publish-version.js";
 import { emptyConfig } from "../schema.js";
-import { loadAppConfig, loadDeveloperConfig } from "./actors.js";
+import { askWithTypedChoices, loadAppConfig, loadDeveloperConfig } from "./actors.js";
+import { printInstallInstructions } from "../util/print-install-instructions.js";
+import { printLogo, showError } from "./actions.js";
+import Spinner from "tiny-spinner";
 export const connectionTypes = [
     { value: "secret", label: "Secret" },
     { value: "oauth2-code", label: "OAuth2" },
@@ -18,30 +21,41 @@ export const publishVersionMachine = setup({
         input: {},
     },
     actors: {
+        askForVersion: askWithTypedChoices(),
         fetchVersions: fromCallback(({ sendBack, input: { developer: { token, slug: devSlug }, config, }, }) => {
             const getVersions = async () => {
+                const spinner = new Spinner();
+                spinner.start("Loading versions...");
                 const versions = await fetchPublishableVersions({
                     token,
                     devSlug,
                     appId: config.id,
                 });
+                spinner.success("Versions loaded");
                 sendBack({ type: "Versions Fetched", versions });
             };
             getVersions();
         }),
-        publishVersion: fromCallback(({ sendBack, input: { developer: { token, slug: devSlug }, config, }, }) => {
+        publishVersion: fromCallback(({ sendBack, input: { developer: { token, slug: devSlug }, config, major, minor, }, }) => {
             const add = async () => {
+                const spinner = new Spinner();
                 try {
+                    spinner.start(`Publishing version ${major}.${minor}...`);
+                    if (major === undefined || minor === undefined) {
+                        throw new Error("Major and minor must be provided");
+                    }
                     await publishVersion({
                         token,
                         devSlug,
                         appId: config.id,
-                        major: config.major,
-                        minor: config.minor,
+                        major,
+                        minor,
                     });
+                    spinner.success(`Version ${major}.${minor} published successfully!`);
                     sendBack({ type: "Success" });
                 }
                 catch (error) {
+                    spinner.error("Error publishing version");
                     sendBack({ type: "Error", error: error.message });
                 }
             };
@@ -51,6 +65,12 @@ export const publishVersionMachine = setup({
         loadAppConfig,
     },
     actions: {
+        printLogo,
+        showError,
+        showConfigInstructions: ({ context }) => printInstallInstructions(context.configError),
+        showNoUnpublishedVersions: () => {
+            process.stdout.write("No unpublished versions found.\n");
+        },
         clearError: assign({
             error: () => undefined,
         }),
@@ -67,8 +87,8 @@ export const publishVersionMachine = setup({
             config: (_, params) => params.config,
         }),
         setVersion: assign({
-            major: (_, params) => params.version.major,
-            minor: (_, params) => params.version.minor,
+            major: (_, params) => params.output.major,
+            minor: (_, params) => params.output.minor,
         }),
         setVersions: assign({
             versions: (_, params) => params.versions,
@@ -105,6 +125,7 @@ export const publishVersionMachine = setup({
         },
         "Show config instructions": {
             type: "final",
+            entry: "showConfigInstructions",
         },
         "Loading App Config": {
             invoke: {
@@ -124,6 +145,7 @@ export const publishVersionMachine = setup({
         },
         "Error": {
             type: "final",
+            entry: { type: "showError", params: ({ context }) => ({ error: context.error }) },
         },
         "Success": {
             type: "final",
@@ -161,10 +183,7 @@ export const publishVersionMachine = setup({
         "Publishing": {
             invoke: {
                 src: "publishVersion",
-                input: ({ context }) => ({
-                    developer: context.developer,
-                    config: context.config,
-                }),
+                input: ({ context }) => context,
             },
             on: {
                 Success: {
@@ -179,12 +198,6 @@ export const publishVersionMachine = setup({
             },
         },
         "Ask for version": {
-            on: {
-                "Select Version": {
-                    target: "Publishing",
-                    actions: { type: "setVersion", params: ({ event }) => event },
-                },
-            },
             always: {
                 target: "No unpublished versions",
                 guard: {
@@ -192,10 +205,26 @@ export const publishVersionMachine = setup({
                     params: ({ context }) => context,
                 },
             },
+            invoke: {
+                src: "askForVersion",
+                input: ({ context }) => ({
+                    message: "Select a version to publish:",
+                    choices: context.versions.map((version) => ({
+                        name: `${version.major}.${version.minor}`,
+                        value: version,
+                    })),
+                }),
+                onDone: {
+                    target: "Publishing",
+                    actions: { type: "setVersion", params: ({ event }) => event },
+                },
+            },
         },
         "No unpublished versions": {
             type: "final",
+            entry: "showNoUnpublishedVersions",
         },
     },
     initial: "Loading Developer Config",
+    entry: "printLogo",
 });

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

@@ -2,16 +2,23 @@ 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 { loadAppConfig, loadDeveloperConfig } from "./actors.js";
+import { askWithChoices, loadAppConfig, loadDeveloperConfig, confirm } from "./actors.js";
+import { printInstallInstructions } from "../util/print-install-instructions.js";
+import { showError, printLogo } from "./actions.js";
+import Spinner from "tiny-spinner";
 export const removeConnectionMachine = setup({
     types: {
         context: {},
         events: {},
     },
     actors: {
+        askWithChoices,
+        confirm,
         removeConnectionDefinition: fromCallback(({ sendBack, input }) => {
             const add = async () => {
+                const spinner = new Spinner();
                 try {
+                    spinner.start("Removing connection...");
                     await removeConnectionDefinition({
                         token: input.developer.token,
                         devSlug: input.developer.slug,
@@ -19,9 +26,11 @@ export const removeConnectionMachine = setup({
                         global: input.global,
                         major: input.config.major,
                     });
+                    spinner.success("Connection removed");
                     sendBack({ type: "Success" });
                 }
                 catch (error) {
+                    spinner.error("Error removing connection");
                     sendBack({ type: "Error", error: error.message });
                 }
             };
@@ -30,17 +39,34 @@ export const removeConnectionMachine = setup({
         loadDeveloperConfig,
         loadAppConfig,
         loadConnections: fromCallback(({ sendBack, input }) => {
+            const spinner = new Spinner();
+            spinner.start("Loading connections...");
             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 }));
+                .then((connections) => {
+                spinner.success("Connections loaded");
+                sendBack({ type: "Connections Loaded", connections });
+            })
+                .catch((error) => {
+                spinner.error("Error loading connections");
+                sendBack({ type: "Error", error: error.message });
+            });
         }),
     },
     actions: {
+        printLogo,
+        showError,
+        showConfigInstructions: ({ context }) => printInstallInstructions(context.configError),
+        showCanceled: () => {
+            process.stdout.write("No connection removed.\n\n");
+        },
+        showNoConnections: () => {
+            process.stdout.write("This app has no connections to remove.\n\n");
+        },
         clearError: assign({
             error: () => undefined,
         }),
@@ -60,7 +86,7 @@ export const removeConnectionMachine = setup({
             connections: (_, params) => params.connections,
         }),
         setGlobal: assign({
-            global: (_, params) => params.global,
+            global: (_, params) => params.output === "true",
         }),
         setOnlyConnection: assign({
             global: (_, params) => params.connections[0].global,
@@ -69,6 +95,7 @@ export const removeConnectionMachine = setup({
     guards: {
         "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),
+        "confirmed": (_, params) => params.output,
     },
 }).createMachine({
     context: ({ input }) => ({
@@ -95,6 +122,7 @@ export const removeConnectionMachine = setup({
         },
         "Show config instructions": {
             type: "final",
+            entry: "showConfigInstructions",
         },
         "Loading App Config": {
             invoke: {
@@ -113,6 +141,7 @@ export const removeConnectionMachine = setup({
         },
         "Error": {
             type: "final",
+            entry: { type: "showError", params: ({ context }) => ({ error: context.error }) },
         },
         "Removing connection definition": {
             invoke: {
@@ -177,30 +206,48 @@ export const removeConnectionMachine = setup({
         },
         "No Connections": {
             type: "final",
+            entry: "showNoConnections",
         },
         "Choosing a Connection": {
-            on: {
-                "Connection Chosen": {
+            invoke: {
+                src: "askWithChoices",
+                input: ({ context }) => ({
+                    message: "Which connection would you like to remove?",
+                    choices: context.connections.map((connection) => ({
+                        name: `${connection.label} (${connection.global ? "workspace" : "user"})`,
+                        value: connection.global ? "true" : "false",
+                    })),
+                    required: true,
+                }),
+                onDone: {
                     target: "Confirm Removal",
-                    actions: {
-                        type: "setGlobal",
-                        params: ({ event }) => ({
-                            global: event.global,
-                        }),
-                    },
-                    reenter: true,
+                    actions: { type: "setGlobal", params: ({ event }) => event },
                 },
             },
         },
         "Confirm Removal": {
-            on: {
-                Confirm: "Removing connection definition",
-                Cancel: "Cancelled",
+            invoke: {
+                src: "confirm",
+                input: ({ context }) => ({
+                    message: `Are you sure you want to remove "${context.connections[0].label}"?`,
+                }),
+                onDone: [
+                    {
+                        target: "Removing connection definition",
+                        guard: { type: "confirmed", params: ({ event }) => event },
+                    },
+                    {
+                        target: "Canceled",
+                        reenter: true,
+                    },
+                ],
             },
         },
-        "Cancelled": {
+        "Canceled": {
             type: "final",
+            entry: "showCanceled",
         },
     },
     initial: "Loading Developer Config",
+    entry: "printLogo",
 });

package/lib/machines/ts-machine.js

@@ -47,7 +47,10 @@ export const tsMachine = setup({
         clearTime: assign({
             time: () => undefined,
         }),
-        raiseErrored: sendTo(({ context }) => context.parentRef, { type: "TypeScript Error" }),
+        raiseErrored: sendTo(({ context }) => context.parentRef, ({ context }) => ({
+            type: "TypeScript Error",
+            errors: context.errors,
+        })),
         raiseSuccess: sendTo(({ context }) => context.parentRef, { type: "TypeScript Success" }),
         setErrors: assign({
             errors: (_, params) => params.errors,

package/lib/server/attio-fetch.d.ts

@@ -21,10 +21,11 @@ interface FetchAttioOptions {
     /**
      * The body to use in the request.
      *
-     * In the Attio API, this is always an object with the single key "data".
+     * In the Attio API, this is always an object with key "data" or "filter".
      */
     body?: {
-        data: Record<string, unknown>;
+        data?: Record<string, unknown>;
+        filter?: Record<string, unknown>;
     };
 }
 /**