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

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({ appId, appSlug, workspace, }) {
-    const haveInstallation = async () => (await fetchInstallation({ appId, workspaceId: workspace.workspace_id })) !== null;
     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,27 +1,55 @@
 import notifier from "node-notifier";
-import { startUpload } from "../../api/start-upload.js";
-import { completeBundleUpload } from "../../api/complete-bundle-upload.js";
 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, }) {
-    await spinnerify("Uploading...", () => `Upload complete at ${new Date().toLocaleTimeString()}`, async () => {
-        const { client_bundle_upload_url, server_bundle_upload_url, app_dev_version_bundle_id: bundleId, } = await startUpload({
+    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([
+        const uploadResults = await combineAsync([
             uploadBundle(clientBundle, client_bundle_upload_url),
             uploadBundle(serverBundle, server_bundle_upload_url),
         ]);
-        await completeBundleUpload({
+        if (isErrored(uploadResults)) {
+            return uploadResults;
+        }
+        const completeBundleUploadResult = await API.completeBundleUpload({
             appId,
             devVersionId,
             bundleId,
         });
+        if (isErrored(completeBundleUploadResult)) {
+            return completeBundleUploadResult;
+        }
         notifier.notify({
             title: "Upload Complete",
             message: "New bundle uploaded to Attio",
         });
+        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,15 +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 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: [
@@ -36,8 +28,7 @@ export function validateTypeScript(onSuccess) {
             }
             const errors = await getDiagnostics(program);
             if (errors.length) {
-                errors.forEach(printTsError);
-                notify(errors);
+                onError?.(errors);
             }
             else {
                 onSuccess?.();
@@ -52,8 +43,7 @@ export function validateTypeScript(onSuccess) {
             }
             if (error instanceof Error) {
                 const tsError = typeScriptErrorSchema.parse({ text: error.message });
-                printTsError(tsError);
-                notify([tsError]);
+                onError?.([tsError]);
             }
         }
     }

package/lib/commands/dev.js

@@ -8,7 +8,24 @@ import { bundleJavaScript } from "./dev/bundle-javascript.js";
 import { boot } from "./dev/boot.js";
 import { onboarding } from "./dev/onboarding.js";
 import { graphqlServer } from "./dev/graphql-server.js";
-import { upload } from "./dev/upload.js";
+import { printUploadError, upload } from "./dev/upload.js";
+import { isErrored } from "@attio/fetchable";
+import { printJsError, printTsError } from "../util/typescript.js";
+import { printBuildContextError, } from "./dev/prepare-build-contexts.js";
+import notifier from "node-notifier";
+const notifyTsErrors = (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`,
+    });
+};
+const notifyJsErrors = (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 const optionsSchema = z.object({
     workspace: z.string().optional(),
 });
@@ -46,12 +63,41 @@ export const dev = new Command("dev")
         cleanupFunctions.push(cleanupGraphqlServer);
         const cleanupOnboardingDaemon = onboarding({ appId, appSlug, workspace });
         cleanupFunctions.push(cleanupOnboardingDaemon);
-        const [cleanupTs, triggerTs] = validateTypeScript();
+        let haveTsErrors = false;
+        const [cleanupTs, triggerTs] = validateTypeScript(() => {
+            if (haveTsErrors) {
+                process.stdout.write(`${chalk.green("✓")} TypeScript errors fixed\n`);
+                haveTsErrors = false;
+            }
+        }, (errors) => {
+            haveTsErrors = true;
+            errors.forEach(printTsError);
+            notifyTsErrors(errors);
+        });
         cleanupFunctions.push(cleanupTs);
         const cleanupGraphqlCodeGen = graphqlCodeGen(triggerTs);
         cleanupFunctions.push(cleanupGraphqlCodeGen);
+        let haveJsErrors = false;
         const cleanupJs = bundleJavaScript(async (contents) => {
-            await upload({ contents, devVersionId, appId });
+            if (haveJsErrors) {
+                process.stdout.write(`${chalk.green("✓")} JavaScript errors fixed\n`);
+                haveJsErrors = false;
+            }
+            const uploadResult = await upload({ contents, devVersionId, appId });
+            if (isErrored(uploadResult)) {
+                printUploadError(uploadResult.error);
+            }
+        }, async (error) => {
+            haveJsErrors = true;
+            if (error.code === "BUILD_JAVASCRIPT_ERROR") {
+                notifyJsErrors(error);
+                const { errors, warnings } = error;
+                errors.forEach((error) => printJsError(error, "error"));
+                warnings.forEach((warning) => printJsError(warning, "warning"));
+            }
+            else {
+                printBuildContextError(error);
+            }
         });
         cleanupFunctions.push(cleanupJs);
         printMessage("\n👀 Watching for changes...");

package/lib/commands/init/create-project.js

@@ -1,41 +1,68 @@
 import { fileURLToPath } from "url";
 import path from "path";
 import chalk from "chalk";
-import boxen from "boxen";
 import { existsSync } from "fs";
 import { createDirectory } from "../../util/create-directory.js";
 import { canWrite } from "../../util/can-write.js";
 import { copyWithTransform } from "../../util/copy-with-replace.js";
-import { printMessage } from "../../util/print-message.js";
 import { spinnerify } from "../../util/spinner.js";
-import { hardExit } from "../../api/hard-exit.js";
+import { combineAsync, complete, errored, isErrored } from "@attio/fetchable";
 export async function createProject({ appSlug, language, appInfo, }) {
-    await spinnerify("Creating project...", "Project created", async () => {
-        if (existsSync(path.join(process.cwd(), appSlug))) {
-            hardExit(`Directory "${appSlug}" already exists`);
+    return await spinnerify("Creating project...", "Project created", async () => {
+        const cwd = process.cwd();
+        const projectPath = path.join(cwd, appSlug);
+        if (existsSync(projectPath)) {
+            return errored({ code: "DIRECTORY_ALREADY_EXISTS", path: projectPath });
         }
-        if (!canWrite(process.cwd())) {
-            hardExit("Write access denied to current directory");
+        if (!canWrite(cwd)) {
+            return errored({ code: "WRITE_ACCESS_DENIED", directory: cwd });
         }
         const __dirname = path.dirname(fileURLToPath(import.meta.url));
-        const projectDir = createDirectory(appSlug);
+        const projectDirResult = await createDirectory(appSlug);
+        if (isErrored(projectDirResult)) {
+            return projectDirResult;
+        }
+        const projectDir = projectDirResult.value;
         const templatesDir = path.resolve(__dirname, "../../templates", language);
         const commonDir = path.resolve(__dirname, "../../templates", "common");
         const transform = (contents) => contents
             .replaceAll("title-to-be-replaced", appInfo.title)
             .replaceAll("id-to-be-replaced", appInfo.app_id)
             .replaceAll("slug-to-be-replaced", appSlug);
-        await Promise.all([
+        const results = await combineAsync([
             copyWithTransform(templatesDir, projectDir, transform),
             copyWithTransform(commonDir, projectDir, transform),
         ]);
-        printMessage("\n" + chalk.green(`SUCCESS!! 🎉 Your app directory has been created.`));
-        printMessage("\nTo get started, run:\n");
-        printMessage(boxen(`cd ${appSlug}\nnpm install\nnpm run dev`, {
-            padding: 1,
-            margin: 1,
-            borderStyle: "round",
-        }) + "\n");
-        printMessage(`(${chalk.yellow("yarn")}, ${chalk.yellow("pnpm")}, and ${chalk.yellow("bun")} also work!)\n`);
+        if (isErrored(results)) {
+            return results;
+        }
+        return complete(undefined);
     });
 }
+export function printCreateProjectError(error) {
+    switch (error.code) {
+        case "DIRECTORY_ALREADY_EXISTS":
+            process.stderr.write(chalk.red(`Directory ${error.path} already exists`));
+            break;
+        case "WRITE_ACCESS_DENIED":
+            process.stderr.write(chalk.red(`Write access denied to ${error.directory}`));
+            break;
+        case "FAILED_TO_CREATE_DIRECTORY":
+            process.stderr.write(chalk.red(`Failed to create directory ${error.directory}`));
+            break;
+        case "FAILED_TO_COPY_FILE":
+            process.stderr.write(chalk.red(`Failed to copy file ${error.src} to ${error.dest}`));
+            break;
+        case "FAILED_TO_LIST_FILES":
+            process.stderr.write(chalk.red(`Failed to list files in ${error.directory}`));
+            break;
+        case "FAILED_TO_READ_FILE":
+            process.stderr.write(chalk.red(`Failed to read file ${error.path}`));
+            break;
+        case "FAILED_TO_WRITE_FILE":
+            process.stderr.write(chalk.red(`Failed to write file ${error.path}`));
+            break;
+        default:
+            return error;
+    }
+}

package/lib/commands/init.js

@@ -1,10 +1,13 @@
 import { Argument, Command, Option } from "commander";
 import { z } from "zod";
 import chalk from "chalk";
-import { createProject } from "./init/create-project.js";
+import { createProject, printCreateProjectError } from "./init/create-project.js";
 import { askLanguage } from "./init/ask-language.js";
 import { printLogo } from "../util/print-logo.js";
-import { getAppInfo } from "../api/get-app-info.spinner.js";
+import { getAppInfo } from "../spinners/get-app-info.spinner.js";
+import { printFetcherError } from "../api/fetcher.js";
+import { isErrored } from "@attio/fetchable";
+import boxen from "boxen";
 export const argsSchema = z.string();
 export const optionsSchema = z.object({
     language: z.enum(["javascript", "typescript"]).optional(),
@@ -18,13 +21,34 @@ export const init = new Command("init")
         printLogo();
         const appSlug = argsSchema.parse(unparsedArgs);
         const { language: cliLanguage } = optionsSchema.parse(unparsedOptions);
-        const appInfo = await getAppInfo(appSlug);
+        const appInfoResult = await getAppInfo(appSlug);
+        if (isErrored(appInfoResult)) {
+            printFetcherError("Failed to fetch app info", appInfoResult.error.fetcherError);
+            process.exit(1);
+        }
+        const appInfo = appInfoResult.value;
         const language = cliLanguage ?? (await askLanguage());
-        await createProject({
+        const result = await createProject({
             appSlug,
             language,
             appInfo,
         });
+        if (isErrored(result)) {
+            printCreateProjectError(result.error);
+            process.exit(1);
+        }
+        process.stdout.write(`${chalk.green(`SUCCESS!! 🎉 Your app directory has been created.`)}
+
+To get started, run:
+
+${boxen(`cd ${appSlug}\nnpm install\nnpm run dev`, {
+            padding: 1,
+            margin: 1,
+            borderStyle: "round",
+        })}
+
+(${chalk.yellow("yarn")}, ${chalk.yellow("pnpm")}, and ${chalk.yellow("bun")} also work!)
+`);
         process.exit(0);
     }
     catch (error) {

package/lib/commands/login.js

@@ -1,5 +1,5 @@
 import { Command } from "commander";
-import { auth } from "../api/auth.js";
+import { auth } from "../auth/auth.js";
 export const login = new Command("login")
     .description("Authenticate with Attio")
     .action(async () => {

package/lib/commands/logout.js

@@ -1,5 +1,5 @@
 import { Command } from "commander";
-import { deleteAuthToken } from "../api/keychain.js";
+import { deleteAuthToken } from "../auth/keychain.js";
 export const logout = new Command("logout").description("Log out from Attio").action(async () => {
     await deleteAuthToken();
     process.stdout.write("🔒 Successfully logged out.\n");

package/lib/commands/version/create/bundle-javascript.js

@@ -0,0 +1,28 @@
+import { complete, isErrored, errored, combineAsync } from "@attio/fetchable";
+import { prepareBuildContexts, } from "../../dev/prepare-build-contexts.js";
+export async function bundleJavaScript() {
+    const buildContextsResult = await prepareBuildContexts("in-memory");
+    if (isErrored(buildContextsResult)) {
+        return errored({
+            code: "ERROR_PREPARING_BUILD_CONTEXT",
+            buildContextError: buildContextsResult.error,
+        });
+    }
+    const buildContexts = buildContextsResult.value;
+    const results = await combineAsync(buildContexts.map(async (context) => await context.rebuild()));
+    if (isErrored(results)) {
+        return errored({
+            code: "ERROR_BUILDING_BUNDLE",
+            error: results.error,
+        });
+    }
+    const bundles = results.value.map((result) => result.outputFiles[0].text);
+    const disposeResults = await combineAsync(buildContexts.map(async (context) => await context.dispose()));
+    if (isErrored(disposeResults)) {
+        return errored({
+            code: "ERROR_DISPOSING_BUILD_CONTEXT",
+            buildContextError: disposeResults.error,
+        });
+    }
+    return complete(bundles);
+}