attio 0.0.1-experimental.20250402.1 → 0.0.1-experimental.20250407

package/lib/commands/dev/boot.js

@@ -1,26 +1,49 @@
-import { ensureAuthed } from "../../api/ensure-authed.js";
+import { getAppSlugFromPackageJson, printPackageJsonError, } from "../../spinners/get-app-slug-from-package-json.js";
+import { determineWorkspace, printDetermineWorkspaceError, } from "../../spinners/determine-workspace.spinner.js";
+import { getAppInfo } from "../../spinners/get-app-info.spinner.js";
 import { loadEnv } from "../../util/load-env.js";
-import { getAppSlugFromPackageJson } from "../../api/get-app-slug-from-package-json.js";
-import { loadAttioCliPackageJson } from "../../util/load-attio-cli-package-json.js";
-import { createDevVersion } from "../../api/create-dev-version.js";
-import { determineWorkspace } from "../../api/determine-workspace.spinner.js";
-import { getAppInfo } from "../../api/get-app-info.spinner.js";
+import { printFetcherError } from "../../api/fetcher.js";
+import { isErrored } from "@attio/fetchable";
+import { loadAttioCliVersion, printCliVersionError } from "../../util/load-attio-cli-version.js";
+import { API } from "../../api/api.js";
 export async function boot({ workspaceSlug }) {
-    const token = await ensureAuthed();
-    const appSlug = await getAppSlugFromPackageJson();
-    const appInfo = await getAppInfo({ token, appSlug });
-    const workspace = await determineWorkspace({ token, workspaceSlug });
+    const appSlugResult = await getAppSlugFromPackageJson();
+    if (isErrored(appSlugResult)) {
+        printPackageJsonError(appSlugResult.error);
+        process.exit(1);
+    }
+    const appSlug = appSlugResult.value;
+    const appInfoResult = await getAppInfo(appSlug);
+    if (isErrored(appInfoResult)) {
+        printFetcherError("Error loading app info", appInfoResult.error.fetcherError);
+        process.exit(1);
+    }
+    const appInfo = appInfoResult.value;
+    const workspaceResult = await determineWorkspace(workspaceSlug);
+    if (isErrored(workspaceResult)) {
+        printDetermineWorkspaceError(workspaceResult.error);
+        process.exit(1);
+    }
+    const workspace = workspaceResult.value;
     const environmentVariables = await loadEnv();
-    const packageJson = loadAttioCliPackageJson();
-    const devVersion = await createDevVersion({
-        token,
+    const cliVersionResult = loadAttioCliVersion();
+    if (isErrored(cliVersionResult)) {
+        printCliVersionError(cliVersionResult);
+        process.exit(1);
+    }
+    const cliVersion = cliVersionResult.value;
+    const devVersionResult = await API.createDevVersion({
         appId: appInfo.app_id,
+        cliVersion,
         targetWorkspaceId: workspace.workspace_id,
         environmentVariables,
-        cliVersion: packageJson.version,
     });
+    if (isErrored(devVersionResult)) {
+        printFetcherError("Error creating dev version", devVersionResult.error.fetcherError);
+        process.exit(1);
+    }
+    const devVersion = devVersionResult.value;
     return {
-        token,
         appId: appInfo.app_id,
         appSlug,
         devVersionId: devVersion.app_dev_version_id,

package/lib/commands/dev/bundle-javascript.js

@@ -1,49 +1,87 @@
 import chokidar from "chokidar";
-import notifier from "node-notifier";
-import { clearTerminal } from "../../util/clear-terminal.js";
-import { errorsAndWarningsSchema } from "../../build.js";
-import { prepareBuildContexts } from "./prepare-build-contexts.js";
-import { printJsError } from "../../util/typescript.js";
-const notify = (errors) => {
-    const totalErrors = (errors.errors?.length || 0) + (errors.warnings?.length || 0);
-    notifier.notify({
-        title: `JavaScript ${totalErrors === 1 ? "Error" : "Errors"}`,
-        message: `There ${totalErrors === 1 ? "was one error" : `were ${totalErrors} errors`} in your JavaScript code`,
-    });
-};
-export function bundleJavaScript(onSuccess) {
+import { prepareBuildContexts, } from "./prepare-build-contexts.js";
+import { combineAsync, complete, isErrored } from "@attio/fetchable";
+export function bundleJavaScript(onSuccess, onError) {
     const watcher = chokidar.watch(["./src/**/*.{js,jsx,ts,tsx}"], {
         ignored: ["**/node_modules/**", "**/dist/**", "**/*.graphql.d.ts", "**/*.gql.d.ts"],
         cwd: process.cwd(),
     });
     let buildContexts;
+    let isBuilding = false;
+    let buildQueued = false;
+    let isDisposing = false;
     async function handleBuild() {
+        if (isBuilding || isDisposing) {
+            buildQueued = true;
+            return complete(undefined);
+        }
+        isBuilding = true;
         try {
             if (!buildContexts) {
-                buildContexts = await prepareBuildContexts("in-memory");
+                const buildContextsResult = await prepareBuildContexts("in-memory");
+                if (isErrored(buildContextsResult)) {
+                    return buildContextsResult;
+                }
+                buildContexts = buildContextsResult.value;
             }
-            const results = await Promise.all(buildContexts.map(async (context) => context.rebuild()));
+            const bundleResults = await combineAsync(buildContexts.map(async (context) => context.rebuild()));
+            if (isErrored(bundleResults)) {
+                return bundleResults;
+            }
+            const results = bundleResults.value;
             const bundles = results.map((result) => result.outputFiles[0].text);
-            onSuccess?.(bundles);
+            await onSuccess?.(bundles);
+            isBuilding = false;
+            if (buildQueued && !isDisposing) {
+                buildQueued = false;
+                return await handleBuild();
+            }
+            return complete(undefined);
         }
-        catch (error) {
-            const errors = errorsAndWarningsSchema.parse(error);
-            clearTerminal();
-            errors.errors?.forEach((error) => printJsError(error, "error"));
-            errors.warnings?.forEach((warning) => printJsError(warning, "warning"));
-            notify(errors);
+        finally {
+            isBuilding = false;
         }
     }
-    watcher.on("ready", () => {
-        handleBuild();
-        watcher.on("all", (event) => {
+    watcher.on("ready", async () => {
+        const result = await handleBuild();
+        if (isErrored(result)) {
+            onError?.(result.error);
+        }
+        watcher.on("all", async (event) => {
             if (event === "add" || event === "change" || event === "unlink") {
-                handleBuild();
+                const result = await handleBuild();
+                if (isErrored(result)) {
+                    onError?.(result.error);
+                }
             }
         });
     });
     return async () => {
-        await Promise.all(buildContexts?.map(async (context) => context.dispose()) ?? []);
+        isDisposing = true;
+        if (isBuilding) {
+            await new Promise((resolve) => {
+                const checkBuild = setInterval(() => {
+                    if (!isBuilding) {
+                        clearInterval(checkBuild);
+                        resolve(undefined);
+                    }
+                }, 10);
+            });
+        }
         await watcher.close();
+        if (buildContexts) {
+            for (const context of buildContexts) {
+                try {
+                    await Promise.race([
+                        context.dispose(),
+                        new Promise((_, reject) => setTimeout(() => reject(new Error("Context disposal timeout")), 1_000)),
+                    ]);
+                }
+                catch (e) {
+                    process.stderr.write(`Error disposing build context: ${e}\n`);
+                }
+            }
+            buildContexts = undefined;
+        }
     };
 }

package/lib/commands/dev/graphql-code-gen.js

@@ -4,6 +4,7 @@ import { parse } from "graphql";
 import { findNodeModulesPath } from "../../util/find-node-modules-path.js";
 import { generateOperations } from "../../graphql/generate-operations.js";
 import { GraphQLError } from "../../graphql/graphql-error.js";
+import { hardExit } from "../../util/hard-exit.js";
 export function graphqlCodeGen(onSuccess) {
     const watcher = chokidar.watch(["**/*.graphql", "**/*.gql"], {
         ignored: ["**/node_modules/**", "**/dist/**"],
@@ -13,7 +14,7 @@ export function graphqlCodeGen(onSuccess) {
         try {
             const schemaPath = await findNodeModulesPath(["schema.graphql"]);
             if (!schemaPath) {
-                throw new Error("No schema.graphql found in node_modules");
+                hardExit("No schema.graphql found in node_modules");
             }
             const schema = parse(readFileSync(schemaPath, "utf8"));
             await generateOperations(".", schema);
@@ -24,7 +25,7 @@ export function graphqlCodeGen(onSuccess) {
                 process.stderr.write(error.toString());
             }
             else {
-                throw error;
+                hardExit(error instanceof Error ? error.message : "GraphQL code generation failed");
             }
         }
     }

package/lib/commands/dev/onboarding.js

@@ -1,22 +1,36 @@
 import { listenForKey } from "../../util/listen-for-key.js";
 import open from "open";
-import { fetchInstallation } from "../../api/fetch-installation.js";
 import { APP } from "../../env.js";
+import { API } from "../../api/api.js";
+import { isErrored } from "@attio/fetchable";
 function prompt() {
-    process.stdout.write(`\n\n🚨 IMPORTANT: You will need to install your app in your workspace. Press "i" to open the app settings page, and then click "Install".\n\n`);
+    process.stdout.write(`🚨 IMPORTANT: You will need to install your app in your workspace. Press "i" to open the app settings page, and then click "Install".\n\n`);
 }
-export function onboarding({ token, appId, appSlug, workspace, }) {
-    const haveInstallation = async () => (await fetchInstallation({ token, appId, workspaceId: workspace.workspace_id })) !== null;
+export function onboarding({ appId, appSlug, workspace, }) {
     const cleanup = listenForKey("i", () => {
         open(`${APP}/${workspace.slug}/settings/apps/${appSlug}`);
     });
     const poll = async () => {
-        let installation = await haveInstallation();
+        const installationResult = await API.fetchInstallation({
+            appId,
+            workspaceId: workspace.workspace_id,
+        });
+        if (isErrored(installationResult)) {
+            return;
+        }
+        let installation = installationResult.value;
         if (!installation) {
             prompt();
             while (!installation) {
                 await new Promise((resolve) => setTimeout(resolve, 60_000));
-                installation = await haveInstallation();
+                const installationResult = await API.fetchInstallation({
+                    appId,
+                    workspaceId: workspace.workspace_id,
+                });
+                if (isErrored(installationResult)) {
+                    return;
+                }
+                installation = installationResult.value;
                 if (!installation) {
                     prompt();
                 }

package/lib/commands/dev/prepare-build-contexts.js

@@ -3,73 +3,204 @@ import tmp from "tmp-promise";
 import fs from "fs/promises";
 import path from "path";
 import { createClientBuildConfig } from "../../build/client/create-client-build-config.js";
-import { generateClientEntry } from "../../build/client/generate-client-entry.js";
+import { generateClientEntry, } from "../../build/client/generate-client-entry.js";
 import { createServerBuildConfig } from "../../build/server/create-server-build-config.js";
 import { generateServerEntry } from "../../build/server/generate-server-entry.js";
+import { errored, isErrored, complete, combineAsync } from "@attio/fetchable";
+import chalk from "chalk";
+import { errorsAndWarningsSchema } from "../../build.js";
 export async function prepareBuildContexts(mode) {
     const srcDir = "src";
     const assetsDir = path.join(srcDir, "assets");
     const webhooksDir = path.join(srcDir, "webhooks");
     const eventsDir = path.join(srcDir, "events");
-    return Promise.all([
-        tmp.file({ postfix: ".js" }).then(async (tempFile) => {
+    return await combineAsync([
+        tmp
+            .file({ postfix: ".js" })
+            .then(async (tempFile) => {
             let lastJS;
             const updateTempFile = async () => {
-                const js = await generateClientEntry({
+                const jsResult = await generateClientEntry({
                     srcDirAbsolute: path.resolve(srcDir),
                     assetsDirAbsolute: path.resolve(assetsDir),
                 });
+                if (isErrored(jsResult)) {
+                    return jsResult;
+                }
+                const js = jsResult.value;
                 if (js === lastJS)
-                    return;
+                    return complete(undefined);
                 lastJS = js;
-                await fs.writeFile(tempFile.path, js);
+                try {
+                    await fs.writeFile(tempFile.path, js);
+                    return complete(undefined);
+                }
+                catch (error) {
+                    return errored({
+                        code: "FAILED_TO_CREATE_TEMP_FILE",
+                        path: tempFile.path,
+                        error,
+                    });
+                }
             };
-            const esbuildContext = await esbuild.context({
-                ...createClientBuildConfig({
-                    entryPoint: tempFile.path,
-                    srcDir,
-                }),
-                write: mode === "write-to-disk",
-                outfile: path.resolve("dist", "index.js"),
-                loader: { ".png": "dataurl", ".graphql": "text", ".gql": "text" },
-            });
-            return {
+            let esbuildContext;
+            const outfile = path.resolve("dist", "index.js");
+            try {
+                esbuildContext = await esbuild.context({
+                    ...createClientBuildConfig({
+                        entryPoint: tempFile.path,
+                        srcDir,
+                    }),
+                    write: mode === "write-to-disk",
+                    outfile,
+                    loader: { ".png": "dataurl", ".graphql": "text", ".gql": "text" },
+                });
+            }
+            catch (error) {
+                return errored({
+                    code: "FAILED_TO_CREATE_ESBUILD_CONTEXT",
+                    outfile,
+                    error,
+                });
+            }
+            return complete({
                 rebuild: async () => {
                     await updateTempFile();
-                    return esbuildContext.rebuild();
+                    try {
+                        return complete(await esbuildContext.rebuild());
+                    }
+                    catch (error) {
+                        const parseResult = errorsAndWarningsSchema.safeParse(error);
+                        if (!parseResult.success) {
+                            return errored({
+                                code: "UNPARSABLE_BUILD_ERROR",
+                                error,
+                            });
+                        }
+                        return errored({
+                            code: "BUILD_JAVASCRIPT_ERROR",
+                            errors: parseResult.data.errors ?? [],
+                            warnings: parseResult.data.warnings ?? [],
+                        });
+                    }
                 },
                 dispose: async () => {
-                    await Promise.all([esbuildContext.dispose(), tempFile.cleanup()]);
+                    try {
+                        await Promise.all([esbuildContext.dispose(), tempFile.cleanup()]);
+                    }
+                    catch (error) {
+                        return errored({
+                            code: "FAILED_TO_DISPOSE_OF_BUILD_CONTEXT",
+                            error,
+                        });
+                    }
+                    return complete(undefined);
                 },
-            };
+            });
         }),
-        tmp.file({ postfix: ".js" }).then(async (tempFile) => {
+        tmp
+            .file({ postfix: ".js" })
+            .then(async (tempFile) => {
             let lastJS;
             const updateTempFile = async () => {
-                const js = await generateServerEntry({
+                const jsResult = await generateServerEntry({
                     srcDirAbsolute: path.resolve(srcDir),
                     webhooksDirAbsolute: path.resolve(webhooksDir),
                     eventDirAbsolute: path.resolve(eventsDir),
                 });
+                if (isErrored(jsResult)) {
+                    return jsResult;
+                }
+                const js = jsResult.value;
                 if (js === lastJS)
-                    return;
+                    return complete(undefined);
                 lastJS = js;
-                await fs.writeFile(tempFile.path, js);
+                try {
+                    await fs.writeFile(tempFile.path, js);
+                    return complete(undefined);
+                }
+                catch (error) {
+                    return errored({
+                        code: "FAILED_TO_CREATE_TEMP_FILE",
+                        path: tempFile.path,
+                        error,
+                    });
+                }
             };
-            const esbuildContext = await esbuild.context({
-                ...createServerBuildConfig(tempFile.path),
-                write: mode === "write-to-disk",
-                outfile: path.resolve("dist", "server.js"),
-            });
-            return {
+            let esbuildContext;
+            const outfile = path.resolve("dist", "server.js");
+            try {
+                esbuildContext = await esbuild.context({
+                    ...createServerBuildConfig(tempFile.path),
+                    write: mode === "write-to-disk",
+                    outfile,
+                });
+            }
+            catch (error) {
+                return errored({
+                    code: "FAILED_TO_CREATE_ESBUILD_CONTEXT",
+                    outfile,
+                    error,
+                });
+            }
+            return complete({
                 rebuild: async () => {
                     await updateTempFile();
-                    return esbuildContext.rebuild();
+                    try {
+                        return complete(await esbuildContext.rebuild());
+                    }
+                    catch (error) {
+                        const parseResult = errorsAndWarningsSchema.safeParse(error);
+                        if (!parseResult.success) {
+                            return errored({
+                                code: "UNPARSABLE_BUILD_ERROR",
+                                error,
+                            });
+                        }
+                        return errored({
+                            code: "BUILD_JAVASCRIPT_ERROR",
+                            errors: parseResult.data.errors ?? [],
+                            warnings: parseResult.data.warnings ?? [],
+                        });
+                    }
                 },
                 dispose: async () => {
-                    await Promise.all([esbuildContext.dispose(), tempFile.cleanup()]);
+                    try {
+                        await Promise.all([esbuildContext.dispose(), tempFile.cleanup()]);
+                    }
+                    catch (error) {
+                        return errored({
+                            code: "FAILED_TO_DISPOSE_OF_BUILD_CONTEXT",
+                            error,
+                        });
+                    }
+                    return complete(undefined);
                 },
-            };
+            });
         }),
     ]);
 }
+export function printBuildContextError(error) {
+    switch (error.code) {
+        case "FAILED_TO_CREATE_TEMP_FILE":
+            process.stderr.write(`${chalk.red("✖ ")}Failed to create temp file: ${error.path}\n`);
+            break;
+        case "FAILED_TO_GENERATE_CLIENT_ENTRY":
+            process.stderr.write(`${chalk.red("✖ ")}Failed to generate client entry\n`);
+            break;
+        case "FAILED_TO_DISPOSE_OF_BUILD_CONTEXT":
+            process.stderr.write(`${chalk.red("✖ ")}Failed to dispose of build context: ${error.error}\n`);
+            break;
+        case "FAILED_TO_CREATE_ESBUILD_CONTEXT":
+            process.stderr.write(`${chalk.red("✖ ")}Failed to create esbuild context (${error.outfile}): ${error.error}\n`);
+            break;
+        case "ERROR_FINDING_SURFACE_EXPORTS":
+            process.stderr.write(`${chalk.red("✖ ")}Failed to find surface exports: ${error.error}\n`);
+            break;
+        case "UNPARSABLE_BUILD_ERROR":
+            process.stderr.write(`${chalk.red("✖ ")}Failed to parse build error: ${error.error}\n`);
+            break;
+        default:
+            return error;
+    }
+}

package/lib/{api → commands/dev}/start-graphql-server.js

@@ -5,7 +5,7 @@ import { buildSchema } from "graphql";
 import { Hono } from "hono";
 import path, { dirname } from "path";
 import { fileURLToPath } from "url";
-import { findAvailablePort } from "../util/find-available-port.js";
+import { findAvailablePort } from "../../util/find-available-port.js";
 export function startGraphqlServer(sendBack) {
     let server = null;
     const startServer = async () => {
@@ -21,7 +21,7 @@ export function startGraphqlServer(sendBack) {
         };
         app.use("/graphql", graphqlServer({ schema, rootResolver, graphiql: true }));
         server = serve({ fetch: app.fetch, port });
-        sendBack({ type: "GraphQL Server Started", port });
+        sendBack({ code: "GraphQL Server Started", port });
     };
     startServer();
     return () => {

package/lib/commands/dev/upload.js

@@ -1,59 +1,55 @@
 import notifier from "node-notifier";
-import { startUpload } from "../../api/start-upload.js";
-import { completeBundleUpload } from "../../api/complete-bundle-upload.js";
-import { Spinner } from "../../util/spinner.js";
-export async function upload({ token, contents, devVersionId, appId, }) {
-    const spinner = new Spinner().start("Uploading...");
-    try {
-        const { client_bundle_upload_url, server_bundle_upload_url, app_dev_version_bundle_id: bundleId, } = await startUpload({
-            token,
+import { spinnerify } from "../../util/spinner.js";
+import { uploadBundle } from "../../util/upload-bundle.js";
+import { API } from "../../api/api.js";
+import { isErrored, combineAsync, complete } from "@attio/fetchable";
+import { printFetcherError } from "../../api/fetcher.js";
+import chalk from "chalk";
+export async function upload({ contents, devVersionId, appId, }) {
+    return await spinnerify("Uploading...", () => `Upload complete at ${new Date().toLocaleTimeString()}`, async () => {
+        const startUploadResult = await API.startUpload({
             appId,
             devVersionId,
         });
+        if (isErrored(startUploadResult)) {
+            return startUploadResult;
+        }
+        const { client_bundle_upload_url, server_bundle_upload_url, app_dev_version_bundle_id: bundleId, } = startUploadResult.value;
         const [clientBundle, serverBundle] = contents;
-        await Promise.all([
-            fetch(client_bundle_upload_url, {
-                method: "PUT",
-                body: clientBundle,
-                headers: {
-                    "Content-Type": "text/javascript",
-                    "Content-Length": String(Buffer.from(clientBundle).length),
-                },
-            }),
-            fetch(server_bundle_upload_url, {
-                method: "PUT",
-                body: serverBundle,
-                headers: {
-                    "Content-Type": "text/javascript",
-                    "Content-Length": String(Buffer.from(serverBundle).length),
-                },
-            }),
-        ]).catch((error) => {
-            process.stderr.write(`Upload Error: ${error}`);
-        });
-        await completeBundleUpload({
-            token,
+        const uploadResults = await combineAsync([
+            uploadBundle(clientBundle, client_bundle_upload_url),
+            uploadBundle(serverBundle, server_bundle_upload_url),
+        ]);
+        if (isErrored(uploadResults)) {
+            return uploadResults;
+        }
+        const completeBundleUploadResult = await API.completeBundleUpload({
             appId,
             devVersionId,
             bundleId,
         });
-        spinner.success(`Upload completed at ${new Date().toLocaleString()}.`);
+        if (isErrored(completeBundleUploadResult)) {
+            return completeBundleUploadResult;
+        }
         notifier.notify({
             title: "Upload Complete",
             message: "New bundle uploaded to Attio",
         });
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            spinner.error(`Upload failed: ${error.message}`);
-            notifier.notify({
-                title: "Upload Failed",
-                message: "Bundle upload to Attio failed",
-            });
-        }
-        throw error;
-    }
-    finally {
-        spinner.stop();
+        return complete(undefined);
+    });
+}
+export function printUploadError(error) {
+    switch (error.code) {
+        case "BUNDLE_UPLOAD_ERROR":
+            process.stderr.write(chalk.red(`Error uploading bundle: ${error.error}\n`));
+            break;
+        case "START_UPLOAD_ERROR":
+            printFetcherError("Error starting upload", error.fetcherError);
+            break;
+        case "COMPLETE_BUNDLE_UPLOAD_ERROR":
+            printFetcherError("Error completing bundle upload", error.fetcherError);
+            break;
+        default:
+            return error;
     }
 }

package/lib/commands/dev/validate-typescript.js

@@ -1,16 +1,7 @@
 import chokidar from "chokidar";
-import notifier from "node-notifier";
 import { getDiagnostics, readConfig, typeScriptErrorSchema, } from "../../util/typescript.js";
-import { printTsError } from "../../util/typescript.js";
-import { clearTerminal } from "../../util/clear-terminal.js";
 import path from "path";
-const notify = (errors) => {
-    notifier.notify({
-        title: `TypeScript Error${errors.length === 1 ? "" : "s"}`,
-        message: `There ${errors.length === 1 ? "was one error" : `were ${errors.length} errors`} in your TypeScript code`,
-    });
-};
-export function validateTypeScript(onSuccess) {
+export function validateTypeScript(onSuccess, onError) {
     let isShuttingDown = false;
     const watcher = chokidar.watch(["src/**/*.ts", "src/**/*.tsx"], {
         ignored: [
@@ -37,9 +28,7 @@ export function validateTypeScript(onSuccess) {
             }
             const errors = await getDiagnostics(program);
             if (errors.length) {
-                clearTerminal();
-                errors.forEach(printTsError);
-                notify(errors);
+                onError?.(errors);
             }
             else {
                 onSuccess?.();
@@ -54,16 +43,13 @@ export function validateTypeScript(onSuccess) {
             }
             if (error instanceof Error) {
                 const tsError = typeScriptErrorSchema.parse({ text: error.message });
-                clearTerminal();
-                printTsError(tsError);
-                notify([tsError]);
+                onError?.([tsError]);
             }
         }
     }
     let watcherReady = false;
     watcher.on("ready", () => {
         watcherReady = true;
-        handleValidation();
         watcher.on("all", (event, path) => {
             if (event === "add" || event === "change" || event === "unlink") {
                 handleValidation();