attio 0.0.1-experimental.20250408 → 0.0.1-experimental.20250414

package/lib/auth/keychain.js

@@ -1,52 +1,95 @@
-import { hardExit } from "../util/hard-exit.js";
-const TEST_TOKEN = "TEST";
-let keytar = null;
-if (process.env.NODE_ENV !== "test") {
-    try {
-        keytar = (await import("keytar")).default;
+import { complete, errored, isErrored } from "@attio/fetchable";
+import { z } from "zod";
+const authTokenSchema = z.object({
+    access_token: z.string(),
+    refresh_token: z.string(),
+    token_type: z.literal("Bearer"),
+    expires_at: z.number(),
+});
+class KeytarKeychain {
+    SERVICE_NAME = "attio-cli";
+    ACCOUNT_NAME = "developer";
+    keytarPromise;
+    constructor() {
+        this.keytarPromise = import("keytar").then((module) => module.default);
     }
-    catch (e) {
-        console.warn("Keychain functionality not available");
-    }
-}
-const SERVICE_NAME = "attio-cli";
-const ACCOUNT_NAME = "developer";
-export async function saveAuthToken(token) {
-    if (!keytar) {
-        return hardExit("Keychain functionality not available");
-    }
-    try {
-        await keytar.setPassword(SERVICE_NAME, ACCOUNT_NAME, token);
-    }
-    catch (error) {
-        return hardExit(error instanceof Error ? error.message : "Failed to save token to keychain");
-    }
-}
-export async function loadAuthToken() {
-    if (process.env.NODE_ENV === "test") {
-        return TEST_TOKEN;
-    }
-    if (!keytar) {
-        return hardExit("Keychain functionality not available");
+    async save(token) {
+        const keytar = await this.keytarPromise;
+        try {
+            await keytar.setPassword(this.SERVICE_NAME, this.ACCOUNT_NAME, JSON.stringify(token));
+            return complete(undefined);
+        }
+        catch (error) {
+            return errored({
+                code: "SAVE_KEYCHAIN_ERROR",
+                error,
+            });
+        }
     }
-    try {
-        return await keytar.getPassword(SERVICE_NAME, ACCOUNT_NAME);
+    async load() {
+        const keytar = await this.keytarPromise;
+        let unparsedToken = null;
+        try {
+            unparsedToken = await keytar.getPassword(this.SERVICE_NAME, this.ACCOUNT_NAME);
+        }
+        catch (error) {
+            return errored({ code: "LOAD_KEYCHAIN_ERROR", error });
+        }
+        if (unparsedToken === null) {
+            return complete(null);
+        }
+        let jsonToken;
+        try {
+            jsonToken = JSON.parse(unparsedToken);
+        }
+        catch (error) {
+            const deleteResult = await this.delete();
+            if (isErrored(deleteResult)) {
+                return errored({ code: "LOAD_KEYCHAIN_ERROR", error: deleteResult.error });
+            }
+            console.debug("Wiped keychain entry due to invalid JSON");
+            return complete(null);
+        }
+        const parsedToken = authTokenSchema.safeParse(jsonToken);
+        if (!parsedToken.success) {
+            const deleteResult = await this.delete();
+            if (isErrored(deleteResult)) {
+                return errored({ code: "LOAD_KEYCHAIN_ERROR", error: deleteResult.error });
+            }
+            console.debug("Wiped keychain entry due to schema mismatch");
+            return complete(null);
+        }
+        return complete(parsedToken.data);
     }
-    catch (error) {
-        return hardExit(error instanceof Error ? error.message : "Failed to load token from keychain");
+    async delete() {
+        const keytar = await this.keytarPromise;
+        try {
+            await keytar.deletePassword(this.SERVICE_NAME, this.ACCOUNT_NAME);
+            return complete(undefined);
+        }
+        catch (error) {
+            return errored({
+                code: "DELETE_KEYCHAIN_ERROR",
+                error,
+            });
+        }
     }
 }
-export async function deleteAuthToken() {
-    if (!keytar) {
-        if (process.env.NODE_ENV === "test") {
-            return;
-        }
-        return hardExit("Keychain functionality not available");
+class TestKeychain {
+    TEST_TOKEN = {
+        access_token: "TEST",
+        refresh_token: "TEST",
+        token_type: "Bearer",
+        expires_at: Number.MAX_SAFE_INTEGER,
+    };
+    async save(_token) {
+        return complete(undefined);
     }
-    try {
-        await keytar.deletePassword(SERVICE_NAME, ACCOUNT_NAME);
+    async load() {
+        return complete(this.TEST_TOKEN);
     }
-    catch (error) {
-        return hardExit(error instanceof Error ? error.message : "Failed to delete token from keychain");
+    async delete() {
+        return complete(undefined);
     }
 }
+export const keychain = process.env.NODE_ENV === "test" ? new TestKeychain() : new KeytarKeychain();

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

@@ -1,14 +1,14 @@
 import { glob } from "glob";
 import path from "path";
 import { errored, complete, isErrored, combineAsync } from "@attio/fetchable";
-async function findPaths(dir, pattern) {
+async function findServerFunctionModules(cwd, pattern) {
     try {
-        return complete(await glob(`**/*.${pattern}.(js|ts)`, { nodir: true, cwd: dir }));
+        return complete(await glob(`**/*.${pattern}.{js,ts}`, { nodir: true, cwd }));
     }
     catch (error) {
         return errored({
             code: "ERROR_FINDING_SERVER_FUNCTION_MODULES",
-            dir,
+            path: cwd,
             pattern,
             error,
         });
@@ -16,9 +16,9 @@ async function findPaths(dir, pattern) {
 }
 export async function generateServerEntry({ srcDirAbsolute, webhooksDirAbsolute, eventDirAbsolute, log, }) {
     const pathsResult = await combineAsync([
-        findPaths(srcDirAbsolute, "server"),
-        findPaths(webhooksDirAbsolute, "webhook"),
-        findPaths(eventDirAbsolute, "event"),
+        findServerFunctionModules(srcDirAbsolute, "server"),
+        findServerFunctionModules(webhooksDirAbsolute, "webhook"),
+        findServerFunctionModules(eventDirAbsolute, "event"),
     ]);
     if (isErrored(pathsResult)) {
         return pathsResult;

package/lib/build.js

@@ -13,6 +13,6 @@ const jsErrorSchema = z.object({
     }),
 });
 export const errorsAndWarningsSchema = z.object({
-    errors: z.array(jsErrorSchema).optional(),
-    warnings: z.array(jsErrorSchema).optional(),
+    errors: z.array(jsErrorSchema).optional().readonly(),
+    warnings: z.array(jsErrorSchema).optional().readonly(),
 });

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

@@ -1,5 +1,5 @@
-import { prepareBuildContexts, } from "../dev/prepare-build-contexts.js";
 import { combineAsync, complete, isErrored } from "@attio/fetchable";
+import { prepareBuildContexts } from "../dev/prepare-build-contexts.js";
 export async function buildJavaScript() {
     const buildContextsResult = await prepareBuildContexts("write-to-disk");
     if (isErrored(buildContextsResult)) {

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

@@ -1,5 +1,5 @@
 import path from "path";
-import { getDiagnostics, readConfig, typeScriptErrorSchema, } from "../../util/typescript.js";
+import { getDiagnostics, readConfig, typeScriptErrorSchema } from "../../util/typescript.js";
 import { complete, errored } from "@attio/fetchable";
 export async function validateTypeScript() {
     try {

package/lib/commands/build.js

@@ -24,8 +24,8 @@ export const build = new Command("build")
     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"));
+            errors?.forEach((error) => printJsError(error, "error"));
+            warnings?.forEach((warning) => printJsError(warning, "warning"));
             process.stderr.write("JavaScript build failed");
             process.exit(1);
         }

package/lib/commands/dev/boot.js

@@ -1,11 +1,11 @@
-import { getAppSlugFromPackageJson, printPackageJsonError, } from "../../spinners/get-app-slug-from-package-json.js";
-import { determineWorkspace, printDetermineWorkspaceError, } from "../../spinners/determine-workspace.spinner.js";
+import { isErrored } from "@attio/fetchable";
+import { printFetcherError, printCliVersionError, printPackageJsonError, printDetermineWorkspaceError, } from "../../print-errors.js";
+import { getAppSlugFromPackageJson } from "../../spinners/get-app-slug-from-package-json.js";
+import { determineWorkspace } from "../../spinners/determine-workspace.spinner.js";
+import { loadAttioCliVersion } from "../../util/load-attio-cli-version.js";
+import { api } from "../../api/api.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 appSlugResult = await getAppSlugFromPackageJson();
     if (isErrored(appSlugResult)) {
@@ -15,7 +15,7 @@ export async function boot({ workspaceSlug }) {
     const appSlug = appSlugResult.value;
     const appInfoResult = await getAppInfo(appSlug);
     if (isErrored(appInfoResult)) {
-        printFetcherError("Error loading app info", appInfoResult.error.fetcherError);
+        printFetcherError("Error loading app info", appInfoResult.error);
         process.exit(1);
     }
     const appInfo = appInfoResult.value;
@@ -32,14 +32,14 @@ export async function boot({ workspaceSlug }) {
         process.exit(1);
     }
     const cliVersion = cliVersionResult.value;
-    const devVersionResult = await API.createDevVersion({
+    const devVersionResult = await api.createDevVersion({
         appId: appInfo.app_id,
         cliVersion,
         targetWorkspaceId: workspace.workspace_id,
         environmentVariables,
     });
     if (isErrored(devVersionResult)) {
-        printFetcherError("Error creating dev version", devVersionResult.error.fetcherError);
+        printFetcherError("Error creating dev version", devVersionResult.error);
         process.exit(1);
     }
     const devVersion = devVersionResult.value;

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

@@ -1,6 +1,6 @@
 import chokidar from "chokidar";
-import { prepareBuildContexts, } from "./prepare-build-contexts.js";
 import { combineAsync, complete, isErrored } from "@attio/fetchable";
+import { prepareBuildContexts } from "./prepare-build-contexts.js";
 export function bundleJavaScript(onSuccess, onError) {
     const watcher = chokidar.watch(["./src/**/*.{js,jsx,ts,tsx}"], {
         ignored: ["**/node_modules/**", "**/dist/**", "**/*.graphql.d.ts", "**/*.gql.d.ts"],

package/lib/commands/dev/onboarding.js

@@ -1,7 +1,7 @@
 import { listenForKey } from "../../util/listen-for-key.js";
 import open from "open";
 import { APP } from "../../env.js";
-import { API } from "../../api/api.js";
+import { api } from "../../api/api.js";
 import { isErrored } from "@attio/fetchable";
 function prompt() {
     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`);
@@ -11,7 +11,7 @@ export function onboarding({ appId, appSlug, workspace, }) {
         open(`${APP}/${workspace.slug}/settings/apps/${appSlug}`);
     });
     const poll = async () => {
-        const installationResult = await API.fetchInstallation({
+        const installationResult = await api.fetchInstallation({
             appId,
             workspaceId: workspace.workspace_id,
         });
@@ -23,7 +23,7 @@ export function onboarding({ appId, appSlug, workspace, }) {
             prompt();
             while (!installation) {
                 await new Promise((resolve) => setTimeout(resolve, 60_000));
-                const installationResult = await API.fetchInstallation({
+                const installationResult = await api.fetchInstallation({
                     appId,
                     workspaceId: workspace.workspace_id,
                 });

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

@@ -3,7 +3,7 @@ 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";

package/lib/commands/dev/upload.js

@@ -1,13 +1,11 @@
 import notifier from "node-notifier";
 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";
+import { api } from "../../api/api.js";
+import { isErrored, complete, combineAsync } from "@attio/fetchable";
 export async function upload({ contents, devVersionId, appId, }) {
     return await spinnerify("Uploading...", () => `Upload complete at ${new Date().toLocaleTimeString()}`, async () => {
-        const startUploadResult = await API.startUpload({
+        const startUploadResult = await api.startUpload({
             appId,
             devVersionId,
         });
@@ -23,7 +21,7 @@ export async function upload({ contents, devVersionId, appId, }) {
         if (isErrored(uploadResults)) {
             return uploadResults;
         }
-        const completeBundleUploadResult = await API.completeBundleUpload({
+        const completeBundleUploadResult = await api.completeBundleUpload({
             appId,
             devVersionId,
             bundleId,
@@ -38,18 +36,3 @@ export async function upload({ contents, devVersionId, appId, }) {
         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.js

@@ -8,10 +8,11 @@ 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 { printUploadError, upload } from "./dev/upload.js";
+import { printUploadError } from "../print-errors.js";
+import { 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 { printBuildContextError } from "./dev/prepare-build-contexts.js";
 import notifier from "node-notifier";
 const notifyTsErrors = (errors) => {
     notifier.notify({
@@ -92,8 +93,8 @@ export const dev = new Command("dev")
             if (error.code === "BUILD_JAVASCRIPT_ERROR") {
                 notifyJsErrors(error);
                 const { errors, warnings } = error;
-                errors.forEach((error) => printJsError(error, "error"));
-                warnings.forEach((warning) => printJsError(warning, "warning"));
+                errors?.forEach((error) => printJsError(error, "error"));
+                warnings?.forEach((warning) => printJsError(warning, "warning"));
             }
             else {
                 printBuildContextError(error);

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

@@ -1,13 +1,12 @@
 import { fileURLToPath } from "url";
 import path from "path";
-import chalk from "chalk";
 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 { spinnerify } from "../../util/spinner.js";
-import { combineAsync, complete, errored, isErrored } from "@attio/fetchable";
-export async function createProject({ appSlug, language, appInfo, }) {
+import { complete, errored, isErrored } from "@attio/fetchable";
+export async function createProject({ appSlug, appInfo, }) {
     return await spinnerify("Creating project...", "Project created", async () => {
         const cwd = process.cwd();
         const projectPath = path.join(cwd, appSlug);
@@ -15,7 +14,7 @@ export async function createProject({ appSlug, language, appInfo, }) {
             return errored({ code: "DIRECTORY_ALREADY_EXISTS", path: projectPath });
         }
         if (!canWrite(cwd)) {
-            return errored({ code: "WRITE_ACCESS_DENIED", directory: cwd });
+            return errored({ code: "WRITE_ACCESS_DENIED", path: cwd });
         }
         const __dirname = path.dirname(fileURLToPath(import.meta.url));
         const projectDirResult = await createDirectory(appSlug);
@@ -23,46 +22,15 @@ export async function createProject({ appSlug, language, appInfo, }) {
             return projectDirResult;
         }
         const projectDir = projectDirResult.value;
-        const templatesDir = path.resolve(__dirname, "../../templates", language);
-        const commonDir = path.resolve(__dirname, "../../templates", "common");
+        const templateDir = path.resolve(__dirname, "../../template");
         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);
-        const results = await combineAsync([
-            copyWithTransform(templatesDir, projectDir, transform),
-            copyWithTransform(commonDir, projectDir, transform),
-        ]);
-        if (isErrored(results)) {
-            return results;
+        const result = await copyWithTransform(templateDir, projectDir, transform);
+        if (isErrored(result)) {
+            return result;
         }
         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,36 +1,28 @@
-import { Argument, Command, Option } from "commander";
+import { Argument, Command } from "commander";
 import { z } from "zod";
 import chalk from "chalk";
-import { createProject, printCreateProjectError } from "./init/create-project.js";
-import { askLanguage } from "./init/ask-language.js";
+import { createProject } from "./init/create-project.js";
+import { printCreateProjectError, printFetcherError } from "../print-errors.js";
 import { printLogo } from "../util/print-logo.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(),
-});
 export const init = new Command("init")
     .description("Initialize a new Attio app")
     .addArgument(new Argument("<app-slug>", "The app slug, chosen in the developer dashboard"))
-    .addOption(new Option("--language <language>", "Language").choices(["javascript", "typescript"]))
-    .action(async (unparsedArgs, unparsedOptions) => {
+    .action(async (unparsedArgs) => {
     try {
         printLogo();
         const appSlug = argsSchema.parse(unparsedArgs);
-        const { language: cliLanguage } = optionsSchema.parse(unparsedOptions);
         const appInfoResult = await getAppInfo(appSlug);
         if (isErrored(appInfoResult)) {
-            printFetcherError("Failed to fetch app info", appInfoResult.error.fetcherError);
+            printFetcherError("Failed to fetch app info", appInfoResult.error);
             process.exit(1);
         }
         const appInfo = appInfoResult.value;
-        const language = cliLanguage ?? (await askLanguage());
         const result = await createProject({
             appSlug,
-            language,
             appInfo,
         });
         if (isErrored(result)) {
@@ -52,7 +44,7 @@ ${boxen(`cd ${appSlug}\nnpm install\nnpm run dev`, {
         process.exit(0);
     }
     catch (error) {
-        process.stderr.write(chalk.red("✖ " + String(error)) + "\n");
+        process.stderr.write(`${chalk.red(`✖ ${error}`)}\n`);
         process.exit(1);
     }
 });

package/lib/commands/login.js

@@ -1,9 +1,15 @@
 import { Command } from "commander";
-import { auth } from "../auth/auth.js";
+import { authenticator } from "../auth/auth.js";
+import { isErrored } from "@attio/fetchable";
+import { printAuthenticationError } from "../print-errors.js";
 export const login = new Command("login")
     .description("Authenticate with Attio")
     .action(async () => {
-    await auth();
+    const result = await authenticator.authenticate();
+    if (isErrored(result)) {
+        printAuthenticationError(result.error);
+        process.exit(1);
+    }
     process.stdout.write("🔓 Successfully authenticated.\n");
     process.exit(0);
 });

package/lib/commands/logout.js

@@ -1,7 +1,13 @@
 import { Command } from "commander";
-import { deleteAuthToken } from "../auth/keychain.js";
+import { keychain } from "../auth/keychain.js";
+import { printKeychainError } from "../print-errors.js";
+import { isErrored } from "@attio/fetchable";
 export const logout = new Command("logout").description("Log out from Attio").action(async () => {
-    await deleteAuthToken();
+    const result = await keychain.delete();
+    if (isErrored(result)) {
+        printKeychainError(result.error);
+        process.exit(1);
+    }
     process.stdout.write("🔒 Successfully logged out.\n");
     process.exit(0);
 });

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

@@ -1,11 +1,11 @@
 import { complete, isErrored, errored, combineAsync } from "@attio/fetchable";
-import { prepareBuildContexts, } from "../../dev/prepare-build-contexts.js";
+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,
+            error: buildContextsResult.error,
         });
     }
     const buildContexts = buildContextsResult.value;
@@ -21,7 +21,7 @@ export async function bundleJavaScript() {
     if (isErrored(disposeResults)) {
         return errored({
             code: "ERROR_DISPOSING_BUILD_CONTEXT",
-            buildContextError: disposeResults.error,
+            error: disposeResults.error,
         });
     }
     return complete(bundles);