attio 0.0.1-experimental.20250328.1 → 0.0.1-experimental.20250401.1

package/lib/util/print-message.js

@@ -1,9 +1,10 @@
 import Blocker from "stdin-blocker";
 import Cursor from "tiny-cursor";
+import readline from "readline";
 export function printMessage(message) {
     Blocker.block();
     Cursor.hide();
-    process.stdout.cursorTo(0);
+    readline.cursorTo(process.stdout, 0);
     process.stdout.write(message);
-    process.stdout.clearLine(1);
+    readline.clearLine(process.stdout, 1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attio",
-  "version": "0.0.1-experimental.20250328.1",
+  "version": "0.0.1-experimental.20250401.1",
   "bin": "lib/attio.js",
   "type": "module",
   "files": [
@@ -39,13 +39,10 @@
     "@hono/node-server": "1.13.7",
     "@inquirer/prompts": "7.2.0",
     "@swc/core": "^1.3.58",
-    "@xstate/react": "4.1.1",
-    "@xstate/store": "1.0.0",
     "boxen": "^8.0.1",
     "chalk": "^5.4.1",
     "chokidar": "^3.6.0",
     "cli-table3": "^0.6.5",
-    "clipboardy": "^4.0.0",
     "commander": "^13.0.0",
     "date-fns": "^2.21.1",
     "dotenv": "^16.4.5",
@@ -54,24 +51,15 @@
     "glob": "^11.0.1",
     "graphql": "16.9.0",
     "hono": "4.6.18",
-    "immer": "^5.0.0",
-    "ini": "^4.1.3",
-    "inquirer": "^12.3.0",
     "keytar": "^7.9.0",
     "node-notifier": "^10.0.1",
     "open": "^7.0.0",
-    "prettier": "^3.4.1",
-    "react": "18.3.1",
     "stdin-blocker": "^2.0.0",
     "tiny-cursor": "^2.0.0",
     "tmp-promise": "^3.0.3",
     "ts-morph": "^24.0.0",
     "typescript": "5.6.3",
-    "uuid": "^9.0.1",
-    "xstate": "5.19.1",
-    "zod": "^3.22.3",
-    "zod-to-json-schema": "3.23.1",
-    "zod-validation-error": "3.3.0"
+    "zod": "^3.22.3"
   },
   "peerDependencies": {
     "react": "^18"

package/lib/api/create-developer-account.js

@@ -1,36 +0,0 @@
-import { v4 as uuid } from "uuid";
-import { z } from "zod";
-import { API } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.js";
-const isTest = process.env.NODE_ENV === "test";
-const createDeveloperAccountSchema = z.object({
-    developer_account: z.object({
-        developer_account_id: z.string(),
-    }),
-    developer_account_member: z.object({
-        developer_account_member_id: z.string(),
-    }),
-});
-export async function createDeveloperAccount({ token, developerSlug, }) {
-    const accountId = uuid();
-    if (isTest) {
-        return createDeveloperAccountSchema.parse({
-            developer_account: { developer_account_id: accountId },
-            developer_account_member: { developer_account_member_id: accountId },
-        });
-    }
-    const response = await fetch(`${API}/developer-accounts/${accountId}`, {
-        method: "PUT",
-        headers: makeHeaders(token),
-        body: JSON.stringify({ slug: developerSlug, title: developerSlug }),
-    });
-    await handleError(response);
-    const json = await response.json();
-    try {
-        return createDeveloperAccountSchema.parse(json);
-    }
-    catch {
-        throw new Error(JSON.stringify(json));
-    }
-}

package/lib/machines/actions.js

@@ -1,8 +0,0 @@
-import chalk from "chalk";
-import { textGradient } from "../util/text-gradient.js";
-import { attioLogoAndName } from "../attio-logo.js";
-export const showError = (_, params) => process.stderr.write(`${chalk.red("✖ " + params.error)}\n`);
-export const showActorError = (_, params) => process.stderr.write(`${chalk.red("✖ " + params.error)}\n`);
-export const printLogo = () => {
-    process.stdout.write(`\n${textGradient(attioLogoAndName, "#ff5f6d", "#ffc371")}\n\n`);
-};

package/lib/machines/actors.js

@@ -1,123 +0,0 @@
-import { fetchVersions as fetchVersionsApi } from "../api/fetch-versions.js";
-import { input as inputPrompt, password as passwordPrompt, select as selectPrompt, confirm as confirmPrompt, } from "@inquirer/prompts";
-import { fromCallback, fromPromise } from "xstate";
-import { readFileSync } from "fs";
-import { join } from "path";
-import { z } from "zod";
-import { getAppInfo } from "../api/get-app-info.js";
-import { ensureAuthed } from "../api/ensure-authed.js";
-import { fetchWorkspaces } from "../api/fetch-workspaces.js";
-import { APP } from "../env.js";
-import { Spinner } from "../util/spinner.js";
-export const authenticate = fromPromise(ensureAuthed);
-const packageJsonSchema = z.object({
-    name: z.string({
-        required_error: "No name field found in package.json",
-        invalid_type_error: "name must be a string in package.json",
-    }),
-});
-export const getAppSlugFromPackageJson = async () => {
-    try {
-        const packageJsonPath = join(process.cwd(), "package.json");
-        const packageJsonRaw = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-        const result = packageJsonSchema.safeParse(packageJsonRaw);
-        if (!result.success) {
-            throw new Error(result.error.issues[0]?.message || "Malformed package.json");
-        }
-        return result.data.name;
-    }
-    catch (error) {
-        if (error instanceof SyntaxError) {
-            throw new Error("Invalid JSON in package.json");
-        }
-        throw new Error("Failed to read package.json");
-    }
-};
-export const loadAppSlug = fromPromise(getAppSlugFromPackageJson);
-export const fetchVersions = fromPromise(async ({ input: { token, appInfo } }) => {
-    const spinner = new Spinner();
-    try {
-        spinner.start("Loading versions...");
-        const versions = await fetchVersionsApi({
-            token,
-            appId: appInfo.app_id,
-        });
-        spinner.success("Versions loaded");
-        return versions;
-    }
-    catch (error) {
-        spinner.error("Error loading versions");
-        throw error;
-    }
-    finally {
-        spinner.stop();
-    }
-});
-export async function fetchAppInfo({ token, appSlug, }) {
-    const spinner = new Spinner();
-    spinner.start("Loading app information...");
-    try {
-        const appInfo = await getAppInfo({ token, appSlug });
-        if (appInfo === null) {
-            spinner.error("App not found");
-            throw new Error("App not found");
-        }
-        spinner.success(`App found: ${appInfo.title}`);
-        return appInfo;
-    }
-    finally {
-        spinner.stop();
-    }
-}
-export const loadAppInfo = fromPromise(async ({ input: { token, appSlug } }) => await fetchAppInfo({ token, appSlug }));
-export const ask = fromPromise(async ({ input }) => await inputPrompt(input));
-export const askPassword = fromPromise(async ({ input }) => await passwordPrompt(input));
-export const askWithChoices = fromPromise(async ({ input, }) => await selectPrompt(input));
-export const askWithTypedChoices = () => fromPromise(async ({ input, }) => await selectPrompt(input));
-export const confirm = fromPromise(async ({ input }) => await confirmPrompt(input));
-export const fromCallbackWithErrorHandling = (callback) => fromCallback((...args) => {
-    try {
-        return callback(...args);
-    }
-    catch (error) {
-        args[0].sendBack({
-            type: "Error",
-            error: typeof error === "string" ? new Error(error) : error,
-        });
-    }
-});
-export async function determineWorkspace({ token, workspaceSlug, }) {
-    const spinner = new Spinner();
-    spinner.start("Loading workspaces...");
-    try {
-        const workspaces = await fetchWorkspaces({ token });
-        spinner.success("Workspaces loaded");
-        const workspace = workspaces.find((workspace) => workspace.slug === workspaceSlug);
-        if (workspace) {
-            spinner.success(`Using workspace: ${workspace.name}`);
-            return workspace;
-        }
-        if (workspaces.length === 0) {
-            throw new Error(`You are not the admin of any workspaces. Either request permission from an existing workspace or create your own.
-
-${APP}/welcome/workspace-details
-                    `);
-        }
-        if (workspaces.length === 1) {
-            spinner.success(`Using workspace: ${workspaces[0].name}`);
-            return workspaces[0];
-        }
-        const choice = await selectPrompt({
-            message: "Choose a workspace",
-            choices: workspaces.map((workspace) => ({
-                name: workspace.name,
-                value: workspace,
-            })),
-        });
-        spinner.success(`Using workspace: ${choice.name}`);
-        return choice;
-    }
-    finally {
-        spinner.stop();
-    }
-}

package/lib/machines/build-machine.js

@@ -1,192 +0,0 @@
-import { assign, setup } from "xstate";
-import { codeGenMachine } from "./code-gen-machine.js";
-import { jsMachine } from "./js-machine.js";
-import { tsMachine } from "./ts-machine.js";
-import { printJsError, printTsError } from "../util/typescript.js";
-import { printLogo } from "./actions.js";
-import { Spinner } from "../util/spinner.js";
-const processes = ["javascript", "typescript"];
-const spinner = new Spinner();
-export const buildMachine = setup({
-    types: {
-        context: {},
-        events: {},
-        children: {},
-    },
-    actors: {
-        "typescript": tsMachine,
-        "javascript": jsMachine,
-        "code-gen": codeGenMachine,
-    },
-    guards: {
-        "all done": ({ context }) => context.failed.length + context.successful.length === processes.length,
-        "all success": ({ context }) => context.successful.length === processes.length,
-    },
-    actions: {
-        buildingStart: () => {
-            spinner.start("🔨 Building...");
-        },
-        buildFail: ({ context }) => {
-            spinner.error("Build failed");
-            const { tsErrors = [], jsErrors } = context;
-            process.stderr.write("\n");
-            tsErrors.forEach(printTsError);
-            jsErrors?.errors?.forEach((error) => {
-                printJsError(error, "error");
-            });
-            jsErrors?.warnings?.forEach((warning) => {
-                printJsError(warning, "warning");
-            });
-        },
-        buildSuccess: () => {
-            spinner.success("Build succeeded");
-        },
-        printLogo,
-        setFailed: assign({
-            failed: ({ context }, params) => [...context.failed, params.process],
-        }),
-        setTypeScriptErrors: assign({
-            tsErrors: (_, params) => params.errors,
-        }),
-        setJavaScriptErrors: assign({
-            jsErrors: (_, params) => params.errors,
-        }),
-        setSuccess: assign({
-            successful: ({ context }, params) => [
-                ...context.successful,
-                params.process,
-            ],
-        }),
-    },
-}).createMachine({
-    context: { successful: [], failed: [] },
-    id: "Build Machine",
-    states: {
-        "Errored": {
-            type: "final",
-            entry: "buildFail",
-        },
-        "Success": {
-            type: "final",
-            entry: "buildSuccess",
-        },
-        "Building": {
-            type: "parallel",
-            states: {
-                JavaScript: {
-                    states: {
-                        Building: {
-                            on: {
-                                "JavaScript Success": {
-                                    target: "Waiting",
-                                    actions: {
-                                        type: "setSuccess",
-                                        params: { process: "javascript" },
-                                    },
-                                },
-                                "JavaScript Error": {
-                                    target: "Waiting",
-                                    actions: [
-                                        {
-                                            type: "setFailed",
-                                            params: { process: "javascript" },
-                                        },
-                                        {
-                                            type: "setJavaScriptErrors",
-                                            params: ({ event }) => event,
-                                        },
-                                    ],
-                                },
-                            },
-                        },
-                        Waiting: {
-                            always: {
-                                target: "#Build Machine.All Done",
-                                guard: "all done",
-                            },
-                        },
-                    },
-                    initial: "Building",
-                    invoke: {
-                        src: "javascript",
-                        id: "javascript",
-                        input: ({ self }) => ({ parentRef: self, write: true }),
-                    },
-                },
-                TypeScript: {
-                    states: {
-                        "Validating": {
-                            on: {
-                                "TypeScript Success": {
-                                    target: "Waiting",
-                                    actions: {
-                                        type: "setSuccess",
-                                        params: { process: "typescript" },
-                                    },
-                                },
-                                "TypeScript Error": {
-                                    target: "Waiting",
-                                    actions: [
-                                        {
-                                            type: "setFailed",
-                                            params: { process: "typescript" },
-                                        },
-                                        {
-                                            type: "setTypeScriptErrors",
-                                            params: ({ event }) => event,
-                                        },
-                                    ],
-                                },
-                            },
-                            invoke: {
-                                src: "typescript",
-                                id: "typescript",
-                                input: ({ self }) => ({ parentRef: self }),
-                            },
-                        },
-                        "Waiting": {
-                            always: {
-                                target: "#Build Machine.All Done",
-                                guard: "all done",
-                            },
-                        },
-                        "Code Generating": {
-                            on: {
-                                "Code Generation Done": "Validating",
-                                "Error": {
-                                    target: "Waiting",
-                                    actions: {
-                                        type: "setFailed",
-                                        params: { process: "typescript" },
-                                    },
-                                    reenter: true,
-                                },
-                            },
-                            invoke: {
-                                src: "code-gen",
-                                id: "code-gen",
-                                input: ({ self }) => ({ parentRef: self }),
-                            },
-                        },
-                    },
-                    initial: "Code Generating",
-                },
-            },
-            entry: "buildingStart",
-        },
-        "All Done": {
-            always: [
-                {
-                    target: "Success",
-                    guard: "all success",
-                },
-                {
-                    target: "Errored",
-                    reenter: true,
-                },
-            ],
-        },
-    },
-    initial: "Building",
-    entry: "printLogo",
-});

package/lib/machines/build-orchestrator.js

@@ -1 +0,0 @@
-export {};

package/lib/machines/code-gen-machine.js

@@ -1,97 +0,0 @@
-import { readFileSync } from "fs";
-import { parse } from "graphql";
-import { sendTo, assign, setup, fromCallback } from "xstate";
-import { generateOperations } from "../graphql/generate-operations.js";
-import { findNodeModulesPath } from "../util/find-node-modules-path.js";
-export const codeGenMachine = setup({
-    types: {
-        context: {},
-        events: {},
-        input: {},
-    },
-    actors: {
-        loadSchema: fromCallback(({ sendBack }) => {
-            const loadSchema = async () => {
-                try {
-                    const path = await findNodeModulesPath(["schema.graphql"]);
-                    if (!path) {
-                        sendBack({ type: "Error", error: new Error("No schema found") });
-                        return;
-                    }
-                    const schema = parse(readFileSync(path, "utf8"));
-                    sendBack({ type: "Schema Loaded", schema });
-                }
-                catch (error) {
-                    sendBack({ type: "Error", error });
-                }
-            };
-            loadSchema();
-        }),
-        generateOperations: fromCallback(({ sendBack, input }) => {
-            generateOperations(".", input.schema)
-                .then(() => sendBack({ type: "Done" }))
-                .catch((error) => sendBack({ type: "Error", error }));
-        }),
-    },
-    actions: {
-        clearError: assign({
-            error: () => undefined,
-        }),
-        setError: assign({
-            error: (_, params) => params.error,
-        }),
-        setSchema: assign({
-            schema: (_, params) => params.schema,
-        }),
-        raiseDone: sendTo(({ context }) => context.parentRef, { type: "Code Generation Done" }),
-    },
-}).createMachine({
-    id: "GraphQL Code Generation Machine",
-    context: ({ input }) => ({
-        schema: null,
-        parentRef: input.parentRef,
-    }),
-    states: {
-        "Load Schema": {
-            on: {
-                "Error": {
-                    target: "Errored",
-                    actions: { type: "setError", params: ({ event }) => event },
-                },
-                "Schema Loaded": {
-                    target: "Generating Operations",
-                    actions: { type: "setSchema", params: ({ event }) => event },
-                    reenter: true,
-                },
-            },
-            invoke: {
-                src: "loadSchema",
-            },
-        },
-        "Done": {
-            entry: "raiseDone",
-        },
-        "Errored": {},
-        "Generating Operations": {
-            on: {
-                Done: {
-                    target: "Done",
-                    actions: "clearError",
-                },
-                Error: {
-                    target: "Errored",
-                    actions: { type: "setError", params: ({ event }) => event },
-                },
-            },
-            invoke: {
-                src: "generateOperations",
-                input: ({ context }) => ({ schema: context.schema }),
-            },
-        },
-    },
-    initial: "Load Schema",
-    on: {
-        Change: ".Load Schema",
-    },
-    description: `Generates operations typescript types`,
-});