attio 0.0.1-experimental.20250328 → 0.0.1-experimental.20250401

package/lib/machines/create-version-machine.js

@@ -1,308 +0,0 @@
-import { assign, setup, fromPromise } from "xstate";
-import chalk from "chalk";
-import { completeProdBundleUpload } from "../api/complete-prod-bundle-upload.js";
-import { createVersion } from "../api/create-version.js";
-import { authenticate, confirm, fetchVersions, loadAppInfo, loadAppSlug } from "./actors.js";
-import { jsMachine } from "./js-machine.js";
-import { printLogo, showActorError } from "./actions.js";
-import Spinner from "tiny-spinner";
-import { loadAttioCliPackageJson } from "../util/load-attio-cli-package-json.js";
-export const connectionTypes = [
-    { value: "secret", label: "Secret" },
-    { value: "oauth2-code", label: "OAuth2" },
-];
-export const audiences = [
-    { value: "workspace", label: "Workspace" },
-    { value: "workspace-member", label: "Workspace Member" },
-];
-const bundlingSpinner = new Spinner();
-export const createVersionMachine = setup({
-    types: {
-        context: {},
-        events: {},
-        children: {},
-    },
-    guards: {
-        "confirmed": (_, params) => params.output,
-        "is major": (_, params) => params.output === "major",
-        "no major version": (_, params) => params.versions.length === 0,
-    },
-    actors: {
-        confirm,
-        fetchVersions,
-        javascript: jsMachine,
-        createVersion: fromPromise(async ({ input: { token, appInfo, upgradeType, versions } }) => {
-            const spinner = new Spinner();
-            spinner.start("Creating version...");
-            try {
-                const packageJson = loadAttioCliPackageJson();
-                if (typeof packageJson === "string")
-                    throw packageJson;
-                const major = Math.max(...versions.map((version) => version.major), 1);
-                const version = await createVersion({
-                    token,
-                    appId: appInfo.app_id,
-                    major: upgradeType === "initial" ? 1 : major,
-                    cliVersion: packageJson.version,
-                });
-                spinner.success("Version created");
-                return version;
-            }
-            catch (error) {
-                spinner.error("Error creating version");
-                throw error;
-            }
-            finally {
-                spinner.stop();
-            }
-        }),
-        authenticate,
-        loadAppInfo,
-        loadAppSlug: loadAppSlug,
-        upload: fromPromise(async ({ input: { token, jsContents, version: { app_id: appId, client_bundle_upload_url, server_bundle_upload_url, major, minor, app_prod_version_bundle_id: bundleId, }, }, }) => {
-            const uploadSpinner = new Spinner();
-            try {
-                uploadSpinner.start("Uploading...");
-                const [clientBundle, serverBundle] = jsContents;
-                await Promise.all([
-                    fetch(client_bundle_upload_url, {
-                        method: "PUT",
-                        body: clientBundle,
-                        headers: {
-                            "Content-Type": "text/javascript",
-                            "Content-Length": String(Buffer.from(clientBundle).length),
-                        },
-                    }),
-                    fetch(server_bundle_upload_url, {
-                        method: "PUT",
-                        body: serverBundle,
-                        headers: {
-                            "Content-Type": "text/javascript",
-                            "Content-Length": String(Buffer.from(serverBundle).length),
-                        },
-                    }),
-                ]);
-                uploadSpinner.success("Upload complete");
-                const signSpinner = new Spinner();
-                signSpinner.start("Signing bundles...");
-                await completeProdBundleUpload({
-                    token,
-                    appId,
-                    major,
-                    minor,
-                    bundleId,
-                });
-                signSpinner.success("Bundles signed");
-                process.stdout.write(`\nVersion ${chalk.green(`${major}.${minor}`)} created!\n\n`);
-            }
-            catch (error) {
-                uploadSpinner.error("Upload failed");
-                throw error;
-            }
-            finally {
-                uploadSpinner.stop();
-            }
-        }),
-    },
-    actions: {
-        printLogo,
-        showActorError,
-        startBundlingSpinner: () => {
-            bundlingSpinner.start("Bundling JavaScript...");
-        },
-        successBundlingSpinner: () => {
-            bundlingSpinner.success("Bundling complete");
-        },
-        errorBundlingSpinner: () => {
-            bundlingSpinner.error("Bundling failed");
-        },
-        setUpgradeType: assign({
-            upgradeType: (_, params) => params.output,
-        }),
-        setVersions: assign({
-            versions: (_, params) => params.output,
-        }),
-        setJsContents: assign({
-            jsContents: (_, params) => params.contents,
-        }),
-        setVersion: assign({
-            version: (_, params) => params.output,
-        }),
-        setToken: assign({
-            token: (_, params) => params.output,
-        }),
-        setAppSlug: assign({
-            appSlug: (_, params) => params.output,
-        }),
-        setAppInfo: assign({
-            appInfo: (_, params) => params.output,
-        }),
-    },
-}).createMachine({
-    context: {
-        token: "",
-        appSlug: "",
-        upgradeType: "minor",
-        versions: [],
-    },
-    id: "Create Version Machine",
-    states: {
-        "Authenticate": {
-            invoke: {
-                src: "authenticate",
-                onDone: {
-                    target: "Loading App Slug",
-                    actions: { type: "setToken", params: ({ event }) => event },
-                },
-                onError: {
-                    target: "Error",
-                    actions: { type: "showActorError", params: ({ event }) => event },
-                },
-            },
-        },
-        "Error": {
-            type: "final",
-        },
-        "Creating version": {
-            invoke: {
-                src: "createVersion",
-                input: ({ context }) => ({
-                    token: context.token,
-                    appSlug: context.appSlug,
-                    upgradeType: context.upgradeType,
-                    appInfo: context.appInfo,
-                    versions: context.versions,
-                }),
-                onDone: {
-                    target: "Uploading",
-                    actions: { type: "setVersion", params: ({ event }) => event },
-                },
-                onError: {
-                    target: "Error",
-                    actions: { type: "showActorError", params: ({ event }) => event },
-                },
-            },
-        },
-        "Success": {
-            type: "final",
-        },
-        "JavaScript": {
-            invoke: {
-                src: "javascript",
-                id: "javascript",
-                input: ({ self }) => ({
-                    parentRef: self,
-                    write: false,
-                }),
-            },
-            on: {
-                "JavaScript Success": {
-                    target: "Fetching Versions",
-                    actions: [
-                        { type: "setJsContents", params: ({ event }) => event },
-                        "successBundlingSpinner",
-                    ],
-                    reenter: true,
-                },
-                "JavaScript Error": ".Build Error",
-            },
-            states: {
-                "Build Error": {
-                    type: "final",
-                    entry: "errorBundlingSpinner",
-                },
-                "Building": {},
-            },
-            initial: "Building",
-            entry: "startBundlingSpinner",
-        },
-        "Uploading": {
-            invoke: {
-                src: "upload",
-                input: ({ context }) => ({
-                    token: context.token,
-                    version: context.version,
-                    jsContents: context.jsContents,
-                }),
-                onDone: "Success",
-                onError: {
-                    target: "Error",
-                    actions: { type: "showActorError", params: ({ event }) => event },
-                },
-            },
-        },
-        "Determine if first version": {
-            always: [
-                {
-                    target: "Creating version",
-                    guard: { type: "no major version", params: ({ context }) => context },
-                    reenter: true,
-                    actions: {
-                        type: "setUpgradeType",
-                        params: { output: "initial" },
-                    },
-                    description: `We're publishing v1.0`,
-                },
-                {
-                    target: "Creating version",
-                    actions: {
-                        type: "setUpgradeType",
-                        params: { output: "minor" },
-                    },
-                    reenter: true,
-                    description: `It's a minor version`,
-                },
-            ],
-        },
-        "Fetching Versions": {
-            invoke: {
-                src: "fetchVersions",
-                input: ({ context }) => ({
-                    token: context.token,
-                    appInfo: context.appInfo,
-                }),
-                onDone: {
-                    target: "Determine if first version",
-                    actions: {
-                        type: "setVersions",
-                        params: ({ event }) => event,
-                    },
-                },
-                onError: {
-                    target: "Error",
-                    actions: { type: "showActorError", params: ({ event }) => event },
-                },
-            },
-        },
-        "Loading App Slug": {
-            invoke: {
-                src: "loadAppSlug",
-                onDone: {
-                    target: "Loading App Info",
-                    actions: { type: "setAppSlug", params: ({ event }) => event },
-                    reenter: true,
-                },
-                onError: {
-                    target: "Error",
-                    actions: { type: "showActorError", params: ({ event }) => event },
-                },
-            },
-        },
-        "Loading App Info": {
-            invoke: {
-                src: "loadAppInfo",
-                input: ({ context }) => context,
-                onDone: {
-                    target: "JavaScript",
-                    actions: { type: "setAppInfo", params: ({ event }) => event },
-                },
-                onError: {
-                    target: "Error",
-                    actions: { type: "showActorError", params: ({ event }) => event },
-                },
-            },
-        },
-    },
-    initial: "Authenticate",
-    entry: "printLogo",
-});

package/lib/machines/env-machine.js

@@ -1,82 +0,0 @@
-import { sendTo, assign, setup, fromCallback } from "xstate";
-import { loadEnv } from "../util/load-env.js";
-import { updateEnvTypes } from "../util/update-env-types.js";
-export const envMachine = setup({
-    types: {
-        context: {},
-        events: {},
-        input: {},
-    },
-    guards: {
-        "variables have changed": (_, params) => JSON.stringify(params.previousVariables) !== JSON.stringify(params.newVariables),
-    },
-    actors: {
-        loadEnvironmentVariables: fromCallback(({ sendBack }) => {
-            loadEnv()
-                .then((variables) => sendBack({ type: "Environment Variables Loaded", variables }))
-                .catch(() => sendBack({ type: "Error" }));
-        }),
-        updateTypes: fromCallback(({ sendBack, input: { variables } }) => {
-            updateEnvTypes(variables)
-                .then(() => sendBack({ type: "Types Updated" }))
-                .catch(() => sendBack({ type: "Error" }));
-        }),
-    },
-    actions: {
-        setVariables: assign({
-            variables: (_, params) => params.variables,
-        }),
-        raiseDone: sendTo(({ context }) => context.parentRef, { type: "Done" }),
-    },
-}).createMachine({
-    id: "Environment Variable Machine",
-    context: ({ input }) => ({
-        variables: null,
-        parentRef: input.parentRef,
-    }),
-    states: {
-        "Load Environment Variables": {
-            on: {
-                "Environment Variables Loaded": [
-                    {
-                        target: "Updating Types",
-                        guard: {
-                            type: "variables have changed",
-                            params: ({ context, event }) => ({
-                                previousVariables: context.variables,
-                                newVariables: event.variables,
-                            }),
-                        },
-                        actions: { type: "setVariables", params: ({ event }) => event },
-                    },
-                    {
-                        target: "Done",
-                        reenter: true,
-                    },
-                ],
-                "Error": "Errored",
-            },
-            invoke: {
-                src: "loadEnvironmentVariables",
-            },
-        },
-        "Updating Types": {
-            on: {
-                "Types Updated": "Done",
-            },
-            invoke: {
-                src: "updateTypes",
-                input: ({ context }) => ({ variables: context.variables ?? {} }),
-            },
-        },
-        "Done": {
-            entry: "raiseDone",
-        },
-        "Errored": {},
-    },
-    initial: "Load Environment Variables",
-    on: {
-        Change: ".Load Environment Variables",
-    },
-    description: `Looks for a .env file and updates types in "node_modules/attio/server" to match.`,
-});

package/lib/machines/init-machine.js

@@ -1,192 +0,0 @@
-import { existsSync } from "fs";
-import Spinner from "tiny-spinner";
-import path, { join } from "path";
-import { fileURLToPath } from "url";
-import { assign, setup, fromPromise } from "xstate";
-import { copyWithTransform } from "../util/copy-with-replace.js";
-import { createDirectory } from "../util/create-directory.js";
-import { canWrite } from "../util/validate-slug.js";
-import { ask, askWithChoices, authenticate, loadAppInfo } from "./actors.js";
-import { printLogo, showActorError } from "./actions.js";
-import chalk from "chalk";
-import boxen from "boxen";
-export const languages = [
-    { name: "TypeScript (recommended)", value: "typescript" },
-    { name: "JavaScript", value: "javascript" },
-];
-export const initMachine = setup({
-    types: {
-        context: {},
-        input: {},
-    },
-    actors: {
-        ask,
-        askWithChoices,
-        createProject: fromPromise(async ({ input }) => {
-            const { appSlug, appInfo, language } = input;
-            const spinner = new Spinner();
-            try {
-                if (existsSync(join(process.cwd(), appSlug))) {
-                    throw new Error(`Directory "${appSlug}" already exists`);
-                }
-                if (!canWrite(process.cwd())) {
-                    throw new Error("Write access denied to current directory");
-                }
-                const __dirname = path.dirname(fileURLToPath(import.meta.url));
-                const projectDir = createDirectory(appSlug);
-                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);
-                spinner.start("Creating project...");
-                await Promise.all([
-                    copyWithTransform(templatesDir, projectDir, transform),
-                    copyWithTransform(commonDir, projectDir, transform),
-                ]);
-                spinner.success("Project created");
-            }
-            catch (error) {
-                spinner.error("Error creating project");
-                throw error;
-            }
-            finally {
-                spinner.stop();
-            }
-        }),
-        authenticate,
-        loadAppInfo,
-    },
-    actions: {
-        printLogo,
-        showActorError,
-        showInstructions: (_, params) => {
-            process.stdout.write("\n" + chalk.green(`SUCCESS!! 🎉 Your app directory has been created.`) + "\n");
-            process.stdout.write("\nTo get started, run:\n");
-            process.stdout.write(boxen(`cd ${params.appSlug}\nnpm install\nnpm run dev`, {
-                padding: 1,
-                margin: 1,
-                borderStyle: "round",
-            }) + "\n");
-            process.stdout.write(`(${chalk.yellow("yarn")}, ${chalk.yellow("pnpm")}, and ${chalk.yellow("bun")} also work!)\n`);
-        },
-        setLanguage: assign({
-            language: (_, params) => params.output,
-        }),
-        setAppInfo: assign({
-            appInfo: (_, params) => params.output,
-        }),
-        setToken: assign({
-            token: (_, params) => params.output,
-        }),
-    },
-    guards: {
-        "app exists": (_, params) => Boolean(params.output),
-        "have language": (_, params) => Boolean(params.language),
-    },
-}).createMachine({
-    context: ({ input }) => ({
-        appId: "",
-        token: "",
-        ...input,
-    }),
-    id: "Init Machine",
-    states: {
-        "Ask for language": {
-            invoke: {
-                src: "askWithChoices",
-                input: {
-                    message: "What language would you like to use?",
-                    choices: languages,
-                },
-                onDone: {
-                    target: "Creating Project",
-                    actions: {
-                        type: "setLanguage",
-                        params: ({ event }) => event,
-                    },
-                    reenter: true,
-                },
-            },
-        },
-        "Creating Project": {
-            invoke: {
-                src: "createProject",
-                input: ({ context }) => ({
-                    language: context.language,
-                    appInfo: context.appInfo,
-                    appSlug: context.appSlug,
-                }),
-                onDone: "Success",
-                onError: {
-                    target: "Error",
-                    actions: { type: "showActorError", params: ({ event }) => event },
-                },
-            },
-        },
-        "Error": {
-            type: "final",
-        },
-        "Success": {
-            type: "final",
-            entry: {
-                type: "showInstructions",
-                params: ({ context }) => ({
-                    appSlug: context.appSlug,
-                    title: context.appInfo.title,
-                }),
-            },
-        },
-        "Do we need language?": {
-            always: [
-                {
-                    target: "Creating Project",
-                    guard: { type: "have language", params: ({ context }) => context },
-                    reenter: true,
-                    description: `language may have been provided by CLI option`,
-                },
-                "Ask for language",
-            ],
-        },
-        "Loading App Info": {
-            invoke: [
-                {
-                    src: "loadAppInfo",
-                    input: ({ context }) => context,
-                    onDone: {
-                        target: "Do we need language?",
-                        guard: { type: "app exists", params: ({ event }) => event },
-                        actions: {
-                            type: "setAppInfo",
-                            params: ({ event }) => event,
-                        },
-                    },
-                    onError: {
-                        target: "Error",
-                        actions: {
-                            type: "showActorError",
-                            params: ({ event }) => event,
-                        },
-                    },
-                },
-            ],
-        },
-        "Authenticate": {
-            invoke: {
-                src: "authenticate",
-                onError: {
-                    target: "Error",
-                    reenter: true,
-                    actions: { type: "showActorError", params: ({ event }) => event },
-                },
-                onDone: {
-                    target: "Loading App Info",
-                    actions: { type: "setToken", params: ({ event }) => event },
-                },
-            },
-        },
-    },
-    initial: "Authenticate",
-    entry: "printLogo",
-});