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

package/lib/api/determine-workspace.spinner.js

@@ -1,39 +0,0 @@
-import { select } from "@inquirer/prompts";
-import { fetchWorkspaces } from "./fetch-workspaces.js";
-import { APP } from "../env.js";
-import { Spinner } from "../util/spinner.js";
-export async function determineWorkspace({ token, workspaceSlug, }) {
-    const spinner = new Spinner();
-    spinner.start("Loading workspaces...");
-    try {
-        const workspaces = await fetchWorkspaces({ token });
-        spinner.success("Workspaces loaded");
-        const workspace = workspaces.find((workspace) => workspace.slug === workspaceSlug);
-        if (workspace) {
-            spinner.success(`Using workspace: ${workspace.name}`);
-            return workspace;
-        }
-        if (workspaces.length === 0) {
-            throw new Error(`You are not the admin of any workspaces. Either request permission from an existing workspace or create your own.
-
-${APP}/welcome/workspace-details
-                    `);
-        }
-        if (workspaces.length === 1) {
-            spinner.success(`Using workspace: ${workspaces[0].name}`);
-            return workspaces[0];
-        }
-        const choice = await select({
-            message: "Choose a workspace",
-            choices: workspaces.map((workspace) => ({
-                name: workspace.name,
-                value: workspace,
-            })),
-        });
-        spinner.success(`Using workspace: ${choice.name}`);
-        return choice;
-    }
-    finally {
-        spinner.stop();
-    }
-}

package/lib/api/ensure-authed.js

@@ -1,31 +0,0 @@
-import { auth as authApi } from "./auth.js";
-import { deleteAuthToken, loadAuthToken } from "./keychain.js";
-import { whoami } from "./whoami.js";
-async function auth() {
-    await deleteAuthToken();
-    if (process.env.NODE_ENV !== "test") {
-        process.stdout.write("You need to log in with Attio. Press Enter to continue...\n\n");
-        await new Promise((resolve) => {
-            process.stdin.once("data", () => {
-                resolve();
-            });
-        });
-    }
-    return await authApi();
-}
-export async function ensureAuthed() {
-    let token = await loadAuthToken();
-    if (!token) {
-        token = await auth();
-    }
-    try {
-        const user = await whoami({ token });
-        if (!user) {
-            token = await auth();
-        }
-    }
-    catch (error) {
-        return await auth();
-    }
-    return token;
-}

package/lib/api/fetch-app-info.js

@@ -1,26 +0,0 @@
-import { z } from "zod";
-import { API } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.js";
-const isTest = process.env.NODE_ENV === "test";
-const appSchema = z.object({
-    app: z
-        .object({
-        app_id: z.string().uuid(),
-        title: z.string(),
-    })
-        .nullable(),
-});
-export async function fetchAppInfo({ token, appSlug, }) {
-    if (isTest) {
-        return {
-            app_id: "test-id",
-            title: "Test App",
-        };
-    }
-    const response = await fetch(`${API}/apps/by-slug/${appSlug}`, {
-        headers: makeHeaders(token),
-    });
-    await handleError(response);
-    return appSchema.parse(await response.json()).app;
-}

package/lib/api/fetch-connections.js

@@ -1,20 +0,0 @@
-import { z } from "zod";
-import { API } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.js";
-const connectionDefinitionsResponseSchema = z.object({
-    values: z.array(z.object({
-        label: z.string(),
-        connection_type: z.enum(["oauth2-code", "secret"]),
-        description: z.string().nullable(),
-        global: z.boolean(),
-    })),
-});
-export async function fetchConnections({ token, appId, major, }) {
-    const response = await fetch(`${API}/apps/${appId}/versions/${major}/connection-definitions`, {
-        method: "GET",
-        headers: makeHeaders(token),
-    });
-    await handleError(response);
-    return connectionDefinitionsResponseSchema.parse(await response.json()).values;
-}

package/lib/api/fetch-installation.js

@@ -1,20 +0,0 @@
-import { z } from "zod";
-import { API } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.js";
-const installationSchema = z.object({
-    workspace_slug: z.string(),
-    workspace_id: z.string().uuid(),
-    app_id: z.string().uuid(),
-    installation_id: z.string().uuid(),
-});
-export async function fetchInstallation({ token, appId, workspaceId, }) {
-    const response = await fetch(`${API}/apps/${appId}/workspace/${workspaceId}/dev-installation`, {
-        method: "GET",
-        headers: makeHeaders(token),
-    });
-    if (response.status === 404)
-        return null;
-    await handleError(response);
-    return installationSchema.parse(await response.json());
-}

package/lib/api/fetch-versions.js

@@ -1,25 +0,0 @@
-import { z } from "zod";
-import { API } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.js";
-const prodVersionSchema = z.object({
-    app_id: z.string(),
-    major: z.number(),
-    minor: z.number(),
-    is_published: z.boolean(),
-    num_installations: z.number(),
-    created_at: z.string(),
-    updated_at: z.string(),
-    accurate_at: z.string(),
-});
-const fetchVersionsSchema = z.object({
-    app_prod_versions: z.array(prodVersionSchema),
-});
-export async function fetchVersions({ token, appId, }) {
-    const response = await fetch(`${API}/apps/${appId}/prod-versions`, {
-        method: "GET",
-        headers: makeHeaders(token),
-    });
-    await handleError(response);
-    return fetchVersionsSchema.parse(await response.json()).app_prod_versions;
-}

package/lib/api/fetch-workspaces.js

@@ -1,33 +0,0 @@
-import { z } from "zod";
-import { API } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.js";
-const isTest = process.env.NODE_ENV === "test";
-const workspaceResponseSchema = z.object({
-    workspace_id: z.string().uuid(),
-    slug: z.string(),
-    name: z.string(),
-    logo_url: z.string().nullable(),
-});
-const listDevWorkspacesResponseSchema = z.object({
-    workspaces: z.array(workspaceResponseSchema),
-    accurate_at: z.string().datetime(),
-});
-export async function fetchWorkspaces({ token }) {
-    if (isTest) {
-        return [
-            {
-                workspace_id: "test-id",
-                slug: "test-slug",
-                name: "Test Workspace",
-                logo_url: null,
-            },
-        ];
-    }
-    const response = await fetch(`${API}/dev-workspaces`, {
-        method: "GET",
-        headers: makeHeaders(token),
-    });
-    await handleError(response);
-    return listDevWorkspacesResponseSchema.parse(await response.json()).workspaces;
-}

package/lib/api/get-app-info.spinner.js

@@ -1,18 +0,0 @@
-import { fetchAppInfo } from "./fetch-app-info.js";
-import { Spinner } from "../util/spinner.js";
-export async function getAppInfo({ token, appSlug, }) {
-    const spinner = new Spinner();
-    spinner.start("Loading app information...");
-    try {
-        const appInfo = await fetchAppInfo({ token, appSlug });
-        if (appInfo === null) {
-            spinner.error("App not found");
-            throw new Error("App not found");
-        }
-        spinner.success(`App found: ${appInfo.title}`);
-        return appInfo;
-    }
-    finally {
-        spinner.stop();
-    }
-}

package/lib/api/get-app-slug-from-package-json.js

@@ -1,26 +0,0 @@
-import { readFileSync } from "fs";
-import { join } from "path";
-import { z } from "zod";
-const packageJsonSchema = z.object({
-    name: z.string({
-        required_error: "No name field found in package.json",
-        invalid_type_error: "name must be a string in package.json",
-    }),
-});
-export async function getAppSlugFromPackageJson() {
-    try {
-        const packageJsonPath = join(process.cwd(), "package.json");
-        const packageJsonRaw = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-        const result = packageJsonSchema.safeParse(packageJsonRaw);
-        if (!result.success) {
-            throw new Error(result.error.issues[0]?.message || "Malformed package.json");
-        }
-        return result.data.name;
-    }
-    catch (error) {
-        if (error instanceof SyntaxError) {
-            throw new Error("Invalid JSON in package.json");
-        }
-        throw new Error("Failed to read package.json");
-    }
-}

package/lib/api/get-versions.spinner.js

@@ -1,21 +0,0 @@
-import { fetchVersions } from "./fetch-versions.js";
-import { Spinner } from "../util/spinner.js";
-export async function getVersions({ token, appInfo, }) {
-    const spinner = new Spinner();
-    try {
-        spinner.start("Loading versions...");
-        const versions = await fetchVersions({
-            token,
-            appId: appInfo.app_id,
-        });
-        spinner.success("Versions loaded");
-        return versions;
-    }
-    catch (error) {
-        spinner.error("Error loading versions");
-        throw error;
-    }
-    finally {
-        spinner.stop();
-    }
-}

package/lib/api/handle-error.js

@@ -1,18 +0,0 @@
-import { z } from "zod";
-const serverErrorSchema = z.object({
-    message: z.string(),
-});
-export async function handleError(response) {
-    if (response.ok)
-        return;
-    const text = await response.text();
-    let json;
-    try {
-        json = JSON.parse(text);
-    }
-    catch {
-        throw new Error(`Error parsing JSON: ${JSON.stringify(text)}`);
-    }
-    const error = serverErrorSchema.parse(json);
-    throw new Error(error.message);
-}

package/lib/api/keychain.js

@@ -1,30 +0,0 @@
-let keytar = null;
-if (process.env.NODE_ENV !== "test") {
-    try {
-        keytar = (await import("keytar")).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;
-    }
-    await keytar.setPassword(SERVICE_NAME, ACCOUNT_NAME, token);
-}
-export async function loadAuthToken() {
-    if (!keytar) {
-        return "TEST";
-    }
-    const token = await keytar.getPassword(SERVICE_NAME, ACCOUNT_NAME);
-    return token || null;
-}
-export async function deleteAuthToken() {
-    if (!keytar) {
-        return true;
-    }
-    return await keytar.deletePassword(SERVICE_NAME, ACCOUNT_NAME);
-}

package/lib/api/make-headers.js

@@ -1,7 +0,0 @@
-export function makeHeaders(token) {
-    return {
-        "x-attio-platform": "developer-cli",
-        "Authorization": `Bearer ${token}`,
-        "Content-Type": "application/json",
-    };
-}

package/lib/api/remove-connection-definition.js

@@ -1,10 +0,0 @@
-import { API } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.js";
-export async function removeConnectionDefinition({ token, appId, global, major, }) {
-    const response = await fetch(`${API}/apps/${appId}/versions/${major}/connection-definitions/${global ? "workspace" : "user"}/remove`, {
-        method: "DELETE",
-        headers: makeHeaders(token),
-    });
-    await handleError(response);
-}

package/lib/api/start-upload.js

@@ -1,18 +0,0 @@
-import { z } from "zod";
-import { API } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.js";
-const startUploadSchema = z.object({
-    app_dev_version_id: z.string(),
-    app_dev_version_bundle_id: z.string(),
-    client_bundle_upload_url: z.string(),
-    server_bundle_upload_url: z.string(),
-});
-export async function startUpload({ token, appId, devVersionId, }) {
-    const response = await fetch(`${API}/apps/${appId}/dev-versions/${devVersionId}/bundles`, {
-        method: "POST",
-        headers: makeHeaders(token),
-    });
-    await handleError(response);
-    return startUploadSchema.parse(await response.json());
-}

package/lib/api/whoami.js

@@ -1,21 +0,0 @@
-import { z } from "zod";
-import { APP } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.js";
-const whoamiSchema = z.object({
-    user: z.object({
-        id: z.string(),
-        email_address: z.string(),
-        name: z.object({
-            full: z.string(),
-        }),
-    }),
-});
-export async function whoami({ token }) {
-    const response = await fetch(`${APP}/api/auth/whoami`, {
-        method: "GET",
-        headers: makeHeaders(token),
-    });
-    await handleError(response);
-    return whoamiSchema.parse(await response.json()).user;
-}

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

@@ -1,49 +0,0 @@
-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 buildJavaScript(onSuccess) {
-    const watcher = chokidar.watch(["src/**/*.{js,jsx,ts,tsx}"], {
-        ignored: ["**/node_modules/**", "**/dist/**", "**/*.graphql.d.ts", "**/*.gql.d.ts"],
-        cwd: ".",
-    });
-    let buildContexts;
-    async function handleBuild() {
-        try {
-            if (!buildContexts) {
-                buildContexts = await prepareBuildContexts("in-memory");
-            }
-            const results = await Promise.all(buildContexts.map(async (context) => context.rebuild()));
-            const bundles = results.map((result) => result.outputFiles[0].text);
-            onSuccess?.(bundles);
-        }
-        catch (error) {
-            const errors = errorsAndWarningsSchema.parse(error);
-            clearTerminal();
-            errors.errors?.forEach((error) => printJsError(error, "error"));
-            errors.warnings?.forEach((warning) => printJsError(warning, "warning"));
-            notify(errors);
-        }
-    }
-    watcher.on("ready", () => {
-        handleBuild();
-        watcher.on("all", (event) => {
-            if (event === "add" || event === "change" || event === "unlink") {
-                handleBuild();
-            }
-        });
-    });
-    return async () => {
-        await Promise.all(buildContexts?.map(async (context) => context.dispose()) ?? []);
-        await watcher.close();
-    };
-}

package/lib/commands/init/boot.js

@@ -1,14 +0,0 @@
-import { ensureAuthed } from "../../api/ensure-authed.js";
-import { getAppInfo } from "../../api/get-app-info.spinner.js";
-import { determineWorkspace } from "../../api/determine-workspace.spinner.js";
-export async function boot({ workspaceSlug, appSlug, }) {
-    const token = await ensureAuthed();
-    const appInfo = await getAppInfo({ token, appSlug });
-    const workspace = await determineWorkspace({ token, workspaceSlug });
-    return {
-        token,
-        appId: appInfo.app_id,
-        appInfo,
-        workspace,
-    };
-}

package/lib/commands/version/create/boot.js

@@ -1,9 +0,0 @@
-import { ensureAuthed } from "../../../api/ensure-authed.js";
-import { getAppSlugFromPackageJson } from "../../../api/get-app-slug-from-package-json.js";
-import { getAppInfo } from "../../../api/get-app-info.spinner.js";
-export async function boot() {
-    const token = await ensureAuthed();
-    const appSlug = await getAppSlugFromPackageJson();
-    const appInfo = await getAppInfo({ token, appSlug });
-    return { token, appInfo };
-}

package/lib/util/clear-terminal.js

@@ -1,4 +0,0 @@
-export function clearTerminal() {
-    process.stdout.write("\x1b[2J");
-    process.stdout.write("\x1b[H");
-}

package/lib/util/load-attio-cli-package-json.js

@@ -1,26 +0,0 @@
-import { readFileSync } from "fs";
-import { findUpSync } from "find-up-simple";
-import { z } from "zod";
-import { fileURLToPath } from "url";
-const FILE_NAME = "package.json";
-const packageJsonSchema = z.object({
-    version: z.string(),
-    name: z.literal("attio"),
-});
-let packageJson;
-export function loadAttioCliPackageJson() {
-    if (packageJson === undefined) {
-        const packageJsonPath = findUpSync(FILE_NAME, { cwd: fileURLToPath(import.meta.url) });
-        if (packageJsonPath === undefined) {
-            throw new Error("Failed to find package.json");
-        }
-        try {
-            const packageJsonContent = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-            packageJson = packageJsonSchema.parse(packageJsonContent);
-        }
-        catch (error) {
-            throw new Error("Failed to find version in package.json");
-        }
-    }
-    return packageJson;
-}