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

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

@@ -1,253 +0,0 @@
-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 { 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,
-                        appId: input.config.id,
-                        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 });
-                }
-            };
-            add();
-        }),
-        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),
-        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,
-        }),
-        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,
-        }),
-        setGlobal: assign({
-            global: (_, params) => params.output === "true",
-        }),
-        setOnlyConnection: assign({
-            global: (_, params) => params.connections[0].global,
-        }),
-    },
-    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 }) => ({
-        developer: { slug: "", token: "" },
-        config: emptyConfig,
-        ...input,
-    }),
-    id: "Remove Connection 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 }) },
-        },
-        "Removing connection definition": {
-            invoke: {
-                src: "removeConnectionDefinition",
-                input: ({ context }) => ({
-                    developer: context.developer,
-                    config: context.config,
-                    global: context.global,
-                }),
-            },
-            on: {
-                Success: "Success",
-                Error: {
-                    target: "Error",
-                    actions: { type: "setError", params: ({ event }) => event },
-                },
-            },
-        },
-        "Success": {
-            type: "final",
-        },
-        "Loading Connections": {
-            invoke: {
-                src: "loadConnections",
-                input: ({ context }) => context,
-            },
-            on: {
-                "Connections Loaded": [
-                    {
-                        target: "Choosing a Connection",
-                        actions: { type: "setConnections", params: ({ event }) => event },
-                        guard: {
-                            type: "have more than one connection",
-                            params: ({ event }) => event,
-                        },
-                    },
-                    {
-                        target: "Confirm Removal",
-                        guard: {
-                            type: "have only one connection",
-                            params: ({ event }) => event,
-                        },
-                        reenter: true,
-                        actions: [
-                            {
-                                type: "setConnections",
-                                params: ({ event }) => event,
-                            },
-                            {
-                                type: "setOnlyConnection",
-                                params: ({ event }) => event,
-                            },
-                        ],
-                    },
-                    "No Connections",
-                ],
-                "Error": {
-                    target: "Error",
-                    actions: { type: "setError", params: ({ event }) => event },
-                },
-            },
-        },
-        "No Connections": {
-            type: "final",
-            entry: "showNoConnections",
-        },
-        "Choosing a Connection": {
-            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 }) => event },
-                },
-            },
-        },
-        "Confirm Removal": {
-            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,
-                    },
-                ],
-            },
-        },
-        "Canceled": {
-            type: "final",
-            entry: "showCanceled",
-        },
-    },
-    initial: "Loading Developer Config",
-    entry: "printLogo",
-});

package/lib/templates/javascript/src/advice.jsx

@@ -1,16 +0,0 @@
-import React from "react"
-import {TextBlock, useAsyncCache} from "attio/client"
-import getAdvice from "./get-advice.server"
-
-export const Advice = ({recordId}) => {
-    // By passing in the recordId, the result will be cached for each recordId
-    const {
-        values: {advice},
-        //       ^^^^^^– this key matches
-        //             vvvvvv– this key
-    } = useAsyncCache({advice: [getAdvice, recordId]})
-    //                          ^^^^^^^^^  ^^^^^^^^
-    //                          async fn   parameter(s)
-
-    return <TextBlock align="center">{`"${advice}"`}</TextBlock>
-}

package/lib/templates/javascript/src/get-advice.server.js

@@ -1,6 +0,0 @@
-export default async function getAdvice(recordId) {
-    // We don't really need the recordId for this API, but this is how we could use a parameter
-    const response = await fetch(`https://api.adviceslip.com/advice?${recordId}`)
-    const data = await response.json()
-    return data.slip.advice
-}

package/lib/templates/typescript/src/advice.tsx

@@ -1,16 +0,0 @@
-import React from "react"
-import {TextBlock, useAsyncCache} from "attio/client"
-import getAdvice from "./get-advice.server"
-
-export function Advice({recordId}: {recordId: string}) {
-    // By passing in the recordId, the result will be cached for each recordId
-    const {
-        values: {advice},
-        //       ^^^^^^– this key matches
-        //             vvvvvv– this key
-    } = useAsyncCache({advice: [getAdvice, recordId]})
-    //                          ^^^^^^^^^  ^^^^^^^^
-    //                          async fn   parameter(s)
-
-    return <TextBlock align="center">{`"${advice}"`}</TextBlock>
-}

package/lib/templates/typescript/src/get-advice.server.ts

@@ -1,6 +0,0 @@
-export default async function getAdvice(recordId: string): Promise<string> {
-    // We don't really need the recordId for this API, but this is how we could use a parameter
-    const response = await fetch(`https://api.adviceslip.com/advice?${recordId}`)
-    const data = await response.json()
-    return data.slip.advice
-}