attio 0.0.1-experimental.20250311 → 0.0.1-experimental.20250324

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

@@ -1,174 +0,0 @@
-import { assign, setup, fromCallback } from "xstate";
-import { fetchConnections } from "../api/fetch-connections.js";
-import { emptyConfig } from "../schema.js";
-import { loadAppConfig, loadDeveloperConfig } from "./actors.js";
-import Table from "cli-table3";
-import { showError, printLogo } from "./actions.js";
-import { printInstallInstructions } from "../util/print-install-instructions.js";
-import boxen from "boxen";
-import chalk from "chalk";
-import Spinner from "tiny-spinner";
-export const listConnectionsMachine = setup({
-    types: {
-        context: {},
-        events: {},
-    },
-    actors: {
-        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) => {
-                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),
-        showNoConnections: () => {
-            process.stdout.write(chalk.red("This app has no connections.\n\n"));
-            process.stdout.write("To add one, use:\n");
-            process.stdout.write(boxen("attio connection add", {
-                padding: 1,
-                margin: 1,
-                borderStyle: "round",
-            }) + "\n");
-        },
-        showConnections: ({ context: { connections } }) => {
-            const maxWidth = process.stdout.columns - 10;
-            const table = new Table({
-                head: ["Name", "Level", "Type"].map((h) => chalk.bold(h)),
-                style: {
-                    head: [],
-                    border: [],
-                },
-                colWidths: [
-                    Math.floor(maxWidth * 0.5),
-                    Math.floor(maxWidth * 0.2),
-                    Math.floor(maxWidth * 0.3),
-                ],
-                colAligns: ["left", "center", "center"],
-                wordWrap: true,
-                wrapOnWordBoundary: true,
-            });
-            table.push(...connections.map((connection) => [
-                connection.label,
-                connection.global ? "Workspace" : "User",
-                connection.connection_type === "secret" ? "Secret" : "OAuth2 Code",
-            ]));
-            process.stdout.write(table.toString());
-        },
-        setError: assign({
-            error: (_, params) => params.error,
-        }),
-        setDeveloperConfig: assign({
-            developer: (_, params) => params,
-        }),
-        setConfigError: assign({
-            configError: (_, params) => params.configError,
-        }),
-        setConfig: assign({
-            config: (_, params) => params.config,
-        }),
-        setConnections: assign({
-            connections: (_, params) => params.connections,
-        }),
-    },
-    guards: {
-        "have connections": (_, params) => Boolean(params.connections && params.connections.length > 0),
-    },
-}).createMachine({
-    context: ({ input }) => ({
-        developer: { slug: "", token: "" },
-        config: emptyConfig,
-        ...input,
-    }),
-    id: "List Connections Machine",
-    states: {
-        "Loading Developer Config": {
-            invoke: {
-                src: "loadDeveloperConfig",
-            },
-            on: {
-                "Developer Config Loaded": {
-                    target: "Loading App Config",
-                    actions: { type: "setDeveloperConfig", params: ({ event }) => event },
-                },
-                "No Developer Config": {
-                    target: "Show config instructions",
-                    actions: { type: "setConfigError", params: ({ event }) => event },
-                },
-            },
-        },
-        "Show config instructions": {
-            type: "final",
-            entry: "showConfigInstructions",
-        },
-        "Loading App Config": {
-            invoke: {
-                src: "loadAppConfig",
-            },
-            on: {
-                "Error": {
-                    target: "Error",
-                    actions: { type: "setError", params: ({ event }) => event },
-                },
-                "App Config Loaded": {
-                    target: "Loading Connections",
-                    actions: { type: "setConfig", params: ({ event }) => event },
-                },
-            },
-        },
-        "Error": {
-            type: "final",
-            entry: { type: "showError", params: ({ context }) => ({ error: context.error }) },
-        },
-        "Loading Connections": {
-            invoke: {
-                src: "loadConnections",
-                input: ({ context }) => context,
-            },
-            on: {
-                "Connections Loaded": [
-                    {
-                        target: "Display Connections",
-                        actions: { type: "setConnections", params: ({ event }) => event },
-                        guard: {
-                            type: "have connections",
-                            params: ({ event }) => event,
-                        },
-                    },
-                    "No Connections",
-                ],
-                "Error": {
-                    target: "Error",
-                    actions: { type: "setError", params: ({ event }) => event },
-                },
-            },
-        },
-        "No Connections": {
-            type: "final",
-            entry: "showNoConnections",
-        },
-        "Display Connections": {
-            type: "final",
-            entry: "showConnections",
-        },
-    },
-    initial: "Loading Developer Config",
-    entry: "printLogo",
-});

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

@@ -1,151 +0,0 @@
-import { assign, setup } from "xstate";
-import { emptyConfig } from "../schema.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" },
-];
-export const audiences = [
-    { value: "workspace", label: "Workspace" },
-    { value: "workspace-member", label: "Workspace Member" },
-];
-export const listVersionsMachine = setup({
-    types: {
-        context: {},
-        events: {},
-    },
-    actors: {
-        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,
-        }),
-        setError: assign({
-            error: (_, params) => params.error,
-        }),
-        setDeveloperConfig: assign({
-            developer: (_, params) => params,
-        }),
-        setConfigError: assign({
-            configError: (_, params) => params.configError,
-        }),
-        setConfig: assign({
-            config: (_, params) => params.config,
-        }),
-        setVersions: assign({
-            versions: (_, params) => params.versions,
-        }),
-    },
-}).createMachine({
-    context: {
-        developer: { slug: "", token: "" },
-        config: emptyConfig,
-        versions: [],
-    },
-    id: "List Versions Machine",
-    states: {
-        "Loading Developer Config": {
-            invoke: {
-                src: "loadDeveloperConfig",
-            },
-            on: {
-                "Developer Config Loaded": {
-                    target: "Loading App Config",
-                    actions: { type: "setDeveloperConfig", params: ({ event }) => event },
-                },
-                "No Developer Config": {
-                    target: "Show config instructions",
-                    actions: { type: "setConfigError", params: ({ event }) => event },
-                },
-            },
-        },
-        "Show config instructions": {
-            type: "final",
-            entry: "showConfigInstructions",
-        },
-        "Loading App Config": {
-            invoke: {
-                src: "loadAppConfig",
-            },
-            on: {
-                "Error": {
-                    target: "Error",
-                    actions: { type: "setError", params: ({ event }) => event },
-                },
-                "App Config Loaded": {
-                    target: "Fetching Versions",
-                    actions: { type: "setConfig", params: ({ event }) => event },
-                    reenter: true,
-                },
-            },
-        },
-        "Error": {
-            type: "final",
-            entry: { type: "showError", params: ({ context }) => ({ error: context.error }) },
-        },
-        "Fetching Versions": {
-            on: {
-                "Versions Fetched": {
-                    target: "Display Versions",
-                    actions: { type: "setVersions", params: ({ event }) => event },
-                },
-                "Error": {
-                    target: "Error",
-                    actions: { type: "setError", params: ({ event }) => event },
-                },
-            },
-            invoke: {
-                src: "fetchVersions",
-                input: ({ context }) => ({
-                    developer: context.developer,
-                    config: context.config,
-                }),
-            },
-        },
-        "Display Versions": {
-            type: "final",
-            entry: "showVersions",
-        },
-    },
-    initial: "Loading Developer Config",
-    entry: "printLogo",
-});

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

@@ -1,230 +0,0 @@
-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 { 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" },
-];
-export const audiences = [
-    { value: "workspace", label: "Workspace" },
-    { value: "workspace-member", label: "Workspace Member" },
-];
-export const publishVersionMachine = setup({
-    types: {
-        context: {},
-        events: {},
-        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, 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,
-                        minor,
-                    });
-                    spinner.success(`Version ${major}.${minor} published successfully!`);
-                    sendBack({ type: "Success" });
-                }
-                catch (error) {
-                    spinner.error("Error publishing version");
-                    sendBack({ type: "Error", error: error.message });
-                }
-            };
-            add();
-        }),
-        loadDeveloperConfig,
-        loadAppConfig,
-    },
-    actions: {
-        printLogo,
-        showError,
-        showConfigInstructions: ({ context }) => printInstallInstructions(context.configError),
-        showNoUnpublishedVersions: () => {
-            process.stdout.write("No unpublished versions found.\n");
-        },
-        clearError: assign({
-            error: () => undefined,
-        }),
-        setError: assign({
-            error: (_, params) => params.error,
-        }),
-        setDeveloperConfig: assign({
-            developer: (_, params) => params,
-        }),
-        setConfigError: assign({
-            configError: (_, params) => params.configError,
-        }),
-        setConfig: assign({
-            config: (_, params) => params.config,
-        }),
-        setVersion: assign({
-            major: (_, params) => params.output.major,
-            minor: (_, params) => params.output.minor,
-        }),
-        setVersions: assign({
-            versions: (_, params) => params.versions,
-        }),
-    },
-    guards: {
-        "have version": (_, params) => params.major !== undefined && params.minor !== undefined,
-        "no unpublished versions": (_, params) => params.versions.length === 0,
-    },
-}).createMachine({
-    context: ({ input }) => ({
-        developer: { slug: "", token: "" },
-        config: emptyConfig,
-        versions: [],
-        major: input.major,
-        minor: input.minor,
-    }),
-    id: "Publish Version Machine",
-    states: {
-        "Loading Developer Config": {
-            invoke: {
-                src: "loadDeveloperConfig",
-            },
-            on: {
-                "Developer Config Loaded": {
-                    target: "Loading App Config",
-                    actions: { type: "setDeveloperConfig", params: ({ event }) => event },
-                },
-                "No Developer Config": {
-                    target: "Show config instructions",
-                    actions: { type: "setConfigError", params: ({ event }) => event },
-                },
-            },
-        },
-        "Show config instructions": {
-            type: "final",
-            entry: "showConfigInstructions",
-        },
-        "Loading App Config": {
-            invoke: {
-                src: "loadAppConfig",
-            },
-            on: {
-                "Error": {
-                    target: "Error",
-                    actions: { type: "setError", params: ({ event }) => event },
-                },
-                "App Config Loaded": {
-                    target: "Do we have a version selected?",
-                    actions: { type: "setConfig", params: ({ event }) => event },
-                    reenter: true,
-                },
-            },
-        },
-        "Error": {
-            type: "final",
-            entry: { type: "showError", params: ({ context }) => ({ error: context.error }) },
-        },
-        "Success": {
-            type: "final",
-        },
-        "Fetching Versions": {
-            on: {
-                "Versions Fetched": {
-                    target: "Ask for version",
-                    actions: { type: "setVersions", params: ({ event }) => event },
-                },
-            },
-            invoke: {
-                src: "fetchVersions",
-                input: ({ context }) => ({
-                    developer: context.developer,
-                    config: context.config,
-                }),
-            },
-        },
-        "Do we have a version selected?": {
-            always: [
-                {
-                    target: "Publishing",
-                    guard: {
-                        type: "have version",
-                        params: ({ context }) => context,
-                    },
-                },
-                {
-                    target: "Fetching Versions",
-                    reenter: true,
-                },
-            ],
-        },
-        "Publishing": {
-            invoke: {
-                src: "publishVersion",
-                input: ({ context }) => context,
-            },
-            on: {
-                Success: {
-                    target: "Success",
-                    reenter: true,
-                },
-                Error: {
-                    target: "Error",
-                    actions: { type: "setError", params: ({ event }) => event },
-                    reenter: true,
-                },
-            },
-        },
-        "Ask for version": {
-            always: {
-                target: "No unpublished versions",
-                guard: {
-                    type: "no unpublished versions",
-                    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",
-});