attio 0.0.1-experimental.20250403 → 0.0.1-experimental.20250408

package/lib/api/api.js

@@ -0,0 +1,98 @@
+import { Fetcher } from "./fetcher.js";
+import { APP } from "../env.js";
+import { isErrored, complete, errored } from "@attio/fetchable";
+import { whoamiSchema, listDevWorkspacesResponseSchema, createVersionSchema, appInfoSchema, completeBundleUploadSchema, startUploadSchema, createDevVersionSchema, installationSchema, versionsSchema, TEST_WORKSPACES, TEST_APP_INFO, } from "./schemas.js";
+class CliApi {
+    _fetcher;
+    constructor() {
+        this._fetcher = new Fetcher();
+    }
+    async whoami() {
+        const result = await this._fetcher.get(`${APP}/api/auth/whoami`, whoamiSchema);
+        if (isErrored(result)) {
+            return errored({ code: "WHOAMI_ERROR", fetcherError: result.error });
+        }
+        return complete(result.value.user);
+    }
+    async fetchWorkspaces() {
+        if (process.env.NODE_ENV === "test") {
+            return complete(TEST_WORKSPACES);
+        }
+        const result = await this._fetcher.get("/dev-workspaces", listDevWorkspacesResponseSchema);
+        if (isErrored(result)) {
+            return errored({ code: "FETCH_WORKSPACES_ERROR", fetcherError: result.error });
+        }
+        return complete(result.value.workspaces);
+    }
+    async createVersion({ appId, major, cliVersion, }) {
+        const result = await this._fetcher.post(`/apps/${appId}/prod-versions`, {
+            major,
+            cli_version: cliVersion,
+        }, createVersionSchema);
+        if (isErrored(result)) {
+            return errored({ code: "CREATE_VERSION_ERROR", fetcherError: result.error });
+        }
+        return result;
+    }
+    async fetchAppInfo(appSlug) {
+        if (process.env.NODE_ENV === "test") {
+            return complete(TEST_APP_INFO.app);
+        }
+        const result = await this._fetcher.get(`/apps/by-slug/${appSlug}`, appInfoSchema);
+        if (isErrored(result)) {
+            return errored({ code: "FETCH_APP_INFO_ERROR", fetcherError: result.error });
+        }
+        return complete(result.value.app);
+    }
+    async completeBundleUpload({ appId, devVersionId, bundleId, }) {
+        const result = await this._fetcher.post(`/apps/${appId}/dev-versions/${devVersionId}/bundles/${bundleId}/complete`, {}, completeBundleUploadSchema);
+        if (isErrored(result)) {
+            return errored({ code: "COMPLETE_BUNDLE_UPLOAD_ERROR", fetcherError: result.error });
+        }
+        return complete(undefined);
+    }
+    async completeProdBundleUpload({ appId, bundleId, major, minor, }) {
+        const result = await this._fetcher.post(`/apps/${appId}/prod-versions/${major}/${minor}/bundles/${bundleId}/complete`, {}, completeBundleUploadSchema);
+        if (isErrored(result)) {
+            return errored({ code: "COMPLETE_PROD_BUNDLE_UPLOAD_ERROR", fetcherError: result.error });
+        }
+        return complete(undefined);
+    }
+    async startUpload({ appId, devVersionId, }) {
+        const result = await this._fetcher.post(`/apps/${appId}/dev-versions/${devVersionId}/bundles`, {}, startUploadSchema);
+        if (isErrored(result)) {
+            return errored({ code: "START_UPLOAD_ERROR", fetcherError: result.error });
+        }
+        return result;
+    }
+    async createDevVersion({ appId, cliVersion, targetWorkspaceId, environmentVariables, }) {
+        const result = await this._fetcher.post(`/apps/${appId}/dev-versions`, {
+            major: 1,
+            target_workspace_id: targetWorkspaceId,
+            environment_variables: environmentVariables,
+            cli_version: cliVersion,
+        }, createDevVersionSchema);
+        if (isErrored(result)) {
+            return errored({ code: "CREATE_DEV_VERSION_ERROR", fetcherError: result.error });
+        }
+        return result;
+    }
+    async fetchInstallation({ appId, workspaceId, }) {
+        const result = await this._fetcher.get(`/apps/${appId}/workspace/${workspaceId}/dev-installation`, installationSchema);
+        if (isErrored(result)) {
+            if (result.error.code === "HTTP_ERROR" && result.error.status === 404) {
+                return complete(null);
+            }
+            return errored({ code: "FETCH_INSTALLATION_ERROR", fetcherError: result.error });
+        }
+        return result;
+    }
+    async fetchVersions(appId) {
+        const result = await this._fetcher.get(`/apps/${appId}/prod-versions`, versionsSchema);
+        if (isErrored(result)) {
+            return errored({ code: "FETCH_VERSIONS_ERROR", fetcherError: result.error });
+        }
+        return complete(result.value.app_prod_versions);
+    }
+}
+export const API = new CliApi();

package/lib/api/fetcher.js

@@ -0,0 +1,65 @@
+import { complete, errored } from "@attio/fetchable";
+import { API } from "../env.js";
+import { ensureAuthed } from "../auth/ensure-authed.js";
+import chalk from "chalk";
+export class Fetcher {
+    async _fetch(path, fetchOptions, schema) {
+        const token = await ensureAuthed();
+        try {
+            const response = await fetch(path.startsWith("https") ? path : `${API}${path}`, {
+                ...fetchOptions,
+                headers: {
+                    "x-attio-platform": "developer-cli",
+                    "Authorization": `Bearer ${token}`,
+                    "Content-Type": "application/json",
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                return errored({
+                    code: "HTTP_ERROR",
+                    status: response.status,
+                    message: errorText,
+                });
+            }
+            const data = await response.json();
+            const result = schema.safeParse(data);
+            if (!result.success) {
+                return errored({
+                    code: "INVALID_RESPONSE",
+                    message: result.error.message,
+                });
+            }
+            return complete(result.data);
+        }
+        catch (error) {
+            return errored({
+                code: "NETWORK_ERROR",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async get(path, schema) {
+        return this._fetch(path, { method: "GET" }, schema);
+    }
+    async post(path, body, schema) {
+        return this._fetch(path, {
+            method: "POST",
+            body: JSON.stringify(body),
+        }, schema);
+    }
+}
+export function printFetcherError(message, error) {
+    process.stderr.write(`${chalk.red("✖ ")}${message}\n`);
+    switch (error.code) {
+        case "HTTP_ERROR":
+            process.stderr.write(`HTTP Error (${error.status}): ${error.message}\n`);
+            break;
+        case "INVALID_RESPONSE":
+            process.stderr.write(`Invalid response: ${error.message}\n`);
+            break;
+        case "NETWORK_ERROR":
+            process.stderr.write(`Network error: ${error.message}\n`);
+            break;
+    }
+}

package/lib/api/schemas.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+export const whoamiSchema = z.object({
+    user: z.object({
+        id: z.string(),
+        email_address: z.string(),
+        name: z.object({
+            full: z.string(),
+        }),
+    }),
+});
+export const workspaceResponseSchema = z.object({
+    workspace_id: z.string().uuid(),
+    slug: z.string(),
+    name: z.string(),
+    logo_url: z.string().nullable(),
+});
+export const TEST_WORKSPACES = [
+    workspaceResponseSchema.parse({
+        workspace_id: "a85e3bcf-a9a2-4df9-9e92-e708bf98d238",
+        slug: "test-slug",
+        name: "Test Workspace",
+        logo_url: null,
+    }),
+];
+export const listDevWorkspacesResponseSchema = z.object({
+    workspaces: z.array(workspaceResponseSchema),
+});
+export const createVersionSchema = z.object({
+    app_id: z.string().uuid(),
+    major: z.number(),
+    minor: z.number(),
+    app_prod_version_bundle_id: z.string(),
+    client_bundle_upload_url: z.string(),
+    server_bundle_upload_url: z.string(),
+});
+export const appInfoSchema = z.object({
+    app: z.object({
+        app_id: z.string().uuid(),
+        title: z.string(),
+    }),
+});
+export const TEST_APP_INFO = appInfoSchema.parse({
+    app: {
+        app_id: "0cbafb09-2ef7-473c-a048-08a5d190a395",
+        title: "Test App",
+    },
+});
+export const completeBundleUploadSchema = z.object({
+    success: z.literal(true),
+});
+export const startUploadSchema = z.object({
+    app_dev_version_id: z.string().uuid(),
+    app_dev_version_bundle_id: z.string().uuid(),
+    client_bundle_upload_url: z.string().url(),
+    server_bundle_upload_url: z.string().url(),
+});
+export const createDevVersionSchema = z.object({
+    app_id: z.string().uuid(),
+    app_dev_version_id: z.string(),
+});
+export const installationSchema = z.object({
+    app_id: z.string().uuid(),
+    workspace_id: z.string(),
+});
+export const versionSchema = z.object({
+    major: z.number(),
+    minor: z.number(),
+    created_at: z.string(),
+    released_at: z.string().nullable().optional(),
+    is_published: z.boolean(),
+    num_installations: z.number(),
+    publication_status: z.enum(["private", "in_review", "published", "rejected"]),
+});
+export const versionsSchema = z.object({
+    app_prod_versions: z.array(versionSchema),
+});

package/lib/{api → auth}/auth.js

@@ -6,8 +6,9 @@ import { APP } from "../env.js";
 import { findAvailablePort } from "../util/find-available-port.js";
 import { loadAuthToken, saveAuthToken, deleteAuthToken } from "./keychain.js";
 import { z } from "zod";
-import { whoami } from "./whoami.js";
-import { hardExit } from "./hard-exit.js";
+import { hardExit } from "../util/hard-exit.js";
+import { API } from "../api/api.js";
+import { isComplete } from "@attio/fetchable";
 const CLIENT_ID = "f881c6f1-82d7-48a5-a581-649596167845";
 const tokenResponseSchema = z.object({
     access_token: z.string(),
@@ -48,7 +49,8 @@ async function exchangeCodeForToken(code, codeVerifier, redirectUri) {
 export async function auth() {
     const existingTokenResult = await loadAuthToken();
     if (existingTokenResult !== null) {
-        const user = await whoami();
+        const userResult = await API.whoami();
+        const user = isComplete(userResult) ? userResult.value : null;
         if (user !== null) {
             return existingTokenResult;
         }

package/lib/{api → auth}/keychain.js

@@ -1,4 +1,4 @@
-import { hardExit } from "./hard-exit.js";
+import { hardExit } from "../util/hard-exit.js";
 const TEST_TOKEN = "TEST";
 let keytar = null;
 if (process.env.NODE_ENV !== "test") {

package/lib/build/client/generate-client-entry.js

@@ -1,9 +1,19 @@
 import fs from "fs/promises";
 import path from "path";
-import { findSurfaceExports } from "../../util/find-surface-exports/find-surface-exports.js";
+import { findSurfaceExports, } from "../../util/find-surface-exports/find-surface-exports.js";
+import { errored, complete } from "@attio/fetchable";
 const ASSET_FILE_EXTENSIONS = ["png"];
 export async function generateClientEntry({ srcDirAbsolute, assetsDirAbsolute, }) {
-    const surfaceExports = await findSurfaceExports(srcDirAbsolute);
+    let surfaceExports;
+    try {
+        surfaceExports = await findSurfaceExports(srcDirAbsolute);
+    }
+    catch (error) {
+        return errored({
+            code: "ERROR_FINDING_SURFACE_EXPORTS",
+            error,
+        });
+    }
     let assetFiles;
     try {
         assetFiles = await fs.readdir(assetsDirAbsolute, { recursive: true });
@@ -47,7 +57,7 @@ const assets = [];
 
 registerAssets(assets);
 `;
-    return `
+    return complete(`
 ${importSurfacesJS}
 
 ${importAssetsJS}
@@ -55,5 +65,5 @@ ${importAssetsJS}
 ${registerSurfacesJS}
 
 ${registerAssetsJS}
-`;
+`);
 }

package/lib/build/server/generate-server-entry.js

@@ -1,20 +1,29 @@
 import { glob } from "glob";
 import path from "path";
+import { errored, complete, isErrored, combineAsync } from "@attio/fetchable";
+async function findPaths(dir, pattern) {
+    try {
+        return complete(await glob(`**/*.${pattern}.(js|ts)`, { nodir: true, cwd: dir }));
+    }
+    catch (error) {
+        return errored({
+            code: "ERROR_FINDING_SERVER_FUNCTION_MODULES",
+            dir,
+            pattern,
+            error,
+        });
+    }
+}
 export async function generateServerEntry({ srcDirAbsolute, webhooksDirAbsolute, eventDirAbsolute, log, }) {
-    const [serverFunctionConcretePaths, webhookConcretePaths, eventConcretePaths] = await Promise.all([
-        Promise.all([
-            glob("**/*.server.ts", { nodir: true, cwd: srcDirAbsolute }),
-            glob("**/*.server.js", { nodir: true, cwd: srcDirAbsolute }),
-        ]).then((paths) => paths.flat()),
-        Promise.all([
-            glob("**/*.webhook.ts", { nodir: true, cwd: webhooksDirAbsolute }),
-            glob("**/*.webhook.js", { nodir: true, cwd: webhooksDirAbsolute }),
-        ]).then((paths) => paths.flat()),
-        Promise.all([
-            glob("*.event.ts", { nodir: true, cwd: eventDirAbsolute }),
-            glob("*.event.js", { nodir: true, cwd: eventDirAbsolute }),
-        ]).then((paths) => paths.flat()),
+    const pathsResult = await combineAsync([
+        findPaths(srcDirAbsolute, "server"),
+        findPaths(webhooksDirAbsolute, "webhook"),
+        findPaths(eventDirAbsolute, "event"),
     ]);
+    if (isErrored(pathsResult)) {
+        return pathsResult;
+    }
+    const [serverFunctionConcretePaths, webhookConcretePaths, eventConcretePaths] = pathsResult.value;
     const serverFunctionModules = serverFunctionConcretePaths.map((path) => ({
         path,
         hash: path.replace(/\.(js|ts)$/, ""),
@@ -30,7 +39,7 @@ export async function generateServerEntry({ srcDirAbsolute, webhooksDirAbsolute,
     for (const module of serverFunctionModules) {
         log?.(`🔎 Found server module "${module.path}"`);
     }
-    return `
+    return complete(`
     
         const modules = new Map()
         const webhookModules = new Map()
@@ -118,5 +127,5 @@ export async function generateServerEntry({ srcDirAbsolute, webhooksDirAbsolute,
 
         main()
 
-`;
+`);
 }

package/lib/commands/build/build-javascript.js

@@ -1,22 +1,18 @@
-import { prepareBuildContexts } from "../dev/prepare-build-contexts.js";
-import { printJsError } from "../../util/typescript.js";
-import { errorsAndWarningsSchema } from "../../build.js";
+import { prepareBuildContexts, } from "../dev/prepare-build-contexts.js";
+import { combineAsync, complete, isErrored } from "@attio/fetchable";
 export async function buildJavaScript() {
-    let buildContexts;
-    try {
-        buildContexts = await prepareBuildContexts("write-to-disk");
-        await Promise.all(buildContexts.map(async (context) => context.rebuild()));
-        return true;
+    const buildContextsResult = await prepareBuildContexts("write-to-disk");
+    if (isErrored(buildContextsResult)) {
+        return buildContextsResult;
     }
-    catch (error) {
-        const errors = errorsAndWarningsSchema.parse(error);
-        errors.errors?.forEach((error) => printJsError(error, "error"));
-        errors.warnings?.forEach((warning) => printJsError(warning, "warning"));
-        return false;
+    const buildContexts = buildContextsResult.value;
+    const buildResult = await combineAsync(buildContexts.map(async (context) => context.rebuild()));
+    const disposeResult = await combineAsync(buildContexts.map(async (context) => context.dispose()));
+    if (isErrored(disposeResult)) {
+        return disposeResult;
     }
-    finally {
-        if (buildContexts) {
-            await Promise.all(buildContexts.map(async (context) => context.dispose()));
-        }
+    if (isErrored(buildResult)) {
+        return buildResult;
     }
+    return complete(true);
 }

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

@@ -1,30 +1,23 @@
 import path from "path";
-import { getDiagnostics, readConfig, typeScriptErrorSchema, printTsError, } from "../../util/typescript.js";
+import { getDiagnostics, readConfig, typeScriptErrorSchema, } from "../../util/typescript.js";
+import { complete, errored } from "@attio/fetchable";
 export async function validateTypeScript() {
     try {
         const program = await readConfig(path.resolve("tsconfig.json"));
         if (program === "Not a TypeScript project") {
-            return true;
+            return complete(true);
         }
         const errors = await getDiagnostics(program);
         if (errors.length) {
-            errors.forEach(printTsError);
-            return false;
+            return errored({ code: "VALIDATE_TYPE_SCRIPT_ERROR", errors });
         }
-        return true;
+        return complete(true);
     }
     catch (error) {
         if (error instanceof Error) {
             const tsError = typeScriptErrorSchema.parse({ text: error.message });
-            printTsError(tsError);
-            return false;
+            return errored({ code: "VALIDATE_TYPE_SCRIPT_ERROR", errors: [tsError] });
         }
-        if (typeof error === "object" &&
-            error !== null &&
-            "code" in error &&
-            (error.code === "ENOENT" || error.code === "EACCES" || error.code === "EPERM")) {
-            throw error;
-        }
-        return false;
+        return errored({ code: "FILE_SYSTEM_ERROR", error });
     }
 }

package/lib/commands/build.js

@@ -2,20 +2,37 @@ import { Command } from "commander";
 import { validateTypeScript } from "./build/validate-typescript.js";
 import { buildJavaScript } from "./build/build-javascript.js";
 import { spinnerify } from "../util/spinner.js";
-import { hardExit } from "../api/hard-exit.js";
+import { isErrored } from "@attio/fetchable";
+import { printJsError, printTsError } from "../util/typescript.js";
+import { printBuildContextError } from "./dev/prepare-build-contexts.js";
 export const build = new Command("build")
     .description("Build your Attio extension locally")
-    .action(async (unparsedOptions) => {
-    await spinnerify("Validating TypeScript...", "TypeScript validation passed", async () => {
-        const tsValid = await validateTypeScript();
-        if (!tsValid) {
-            hardExit("TypeScript validation failed");
+    .action(async () => {
+    const tsResult = await spinnerify("Validating TypeScript...", "TypeScript validation passed", validateTypeScript);
+    if (isErrored(tsResult)) {
+        switch (tsResult.error.code) {
+            case "VALIDATE_TYPE_SCRIPT_ERROR":
+                tsResult.error.errors.forEach(printTsError);
+                process.stderr.write("TypeScript validation failed");
+                process.exit(1);
+            case "FILE_SYSTEM_ERROR":
+                process.stderr.write(`TypeScript validation failed due to a file system error: ${tsResult.error.error}`);
+                process.exit(1);
         }
-    });
-    await spinnerify("Building JavaScript...", "Build completed successfully", async () => {
-        const jsBuilt = await buildJavaScript();
-        if (!jsBuilt) {
-            hardExit("JavaScript build failed");
+    }
+    const jsResult = await spinnerify("Building JavaScript...", "JavaScript build completed successfully", buildJavaScript);
+    if (isErrored(jsResult)) {
+        if (jsResult.error.code === "BUILD_JAVASCRIPT_ERROR") {
+            const { errors, warnings } = jsResult.error;
+            errors.forEach((error) => printJsError(error, "error"));
+            warnings.forEach((warning) => printJsError(warning, "warning"));
+            process.stderr.write("JavaScript build failed");
+            process.exit(1);
         }
-    });
+        else {
+            printBuildContextError(jsResult.error);
+            process.stderr.write("Build context error");
+            process.exit(1);
+        }
+    }
 });

package/lib/commands/dev/boot.js

@@ -1,21 +1,48 @@
-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 { 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 { 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 appSlug = await getAppSlugFromPackageJson();
-    const appInfo = await getAppInfo(appSlug);
-    const workspace = await determineWorkspace(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({
+    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: packageJson.version,
+        cliVersion,
         targetWorkspaceId: workspace.workspace_id,
         environmentVariables,
     });
+    if (isErrored(devVersionResult)) {
+        printFetcherError("Error creating dev version", devVersionResult.error.fetcherError);
+        process.exit(1);
+    }
+    const devVersion = devVersionResult.value;
     return {
         appId: appInfo.app_id,
         appSlug,

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

@@ -1,16 +1,7 @@
 import chokidar from "chokidar";
-import notifier from "node-notifier";
-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(),
@@ -22,36 +13,46 @@ export function bundleJavaScript(onSuccess) {
     async function handleBuild() {
         if (isBuilding || isDisposing) {
             buildQueued = true;
-            return;
+            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 bundleResults = await combineAsync(buildContexts.map(async (context) => context.rebuild()));
+            if (isErrored(bundleResults)) {
+                return bundleResults;
             }
-            const results = await Promise.all(buildContexts.map(async (context) => context.rebuild()));
+            const results = bundleResults.value;
             const bundles = results.map((result) => result.outputFiles[0].text);
             await onSuccess?.(bundles);
-        }
-        catch (error) {
-            const errors = errorsAndWarningsSchema.parse(error);
-            errors.errors?.forEach((error) => printJsError(error, "error"));
-            errors.warnings?.forEach((warning) => printJsError(warning, "warning"));
-            notify(errors);
-        }
-        finally {
             isBuilding = false;
             if (buildQueued && !isDisposing) {
                 buildQueued = false;
-                handleBuild();
+                return await handleBuild();
             }
+            return complete(undefined);
+        }
+        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);
+                }
             }
         });
     });

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

@@ -4,7 +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 "../../api/hard-exit.js";
+import { hardExit } from "../../util/hard-exit.js";
 export function graphqlCodeGen(onSuccess) {
     const watcher = chokidar.watch(["**/*.graphql", "**/*.gql"], {
         ignored: ["**/node_modules/**", "**/dist/**"],