attio 0.0.1-experimental.20250218 → 0.0.1-experimental.20250227

package/lib/machines/create-machine.js

@@ -1,409 +0,0 @@
-import { existsSync } from "fs";
-import Spinner from "tiny-spinner";
-import path, { join } from "path";
-import { fileURLToPath } from "url";
-import { assign, setup, fromCallback } from "xstate";
-import { createApp } from "../api/create-app.js";
-import { isAppSlugValid } from "../api/is-app-slug-valid.js";
-import { copyWithTransform } from "../util/copy-with-replace.js";
-import { createDirectory } from "../util/create-directory.js";
-import { loadDeveloperConfig } from "../util/load-developer-config.js";
-import { slugifyExtension } from "../util/slugify-extension.js";
-import { canWrite, isValidSlug } from "../util/validate-slug.js";
-import { ask, askWithChoices } from "./actors.js";
-import { showError, printLogo } from "./actions.js";
-import chalk from "chalk";
-import boxen from "boxen";
-import { printInstallInstructions } from "../util/print-install-instructions.js";
-export const languages = [
-    { name: "TypeScript – recommended!", value: "typescript" },
-    { name: "JavaScript", value: "javascript" },
-];
-export const createMachine = setup({
-    types: {
-        context: {},
-        events: {},
-        input: {},
-    },
-    actors: {
-        ask,
-        askWithChoices,
-        createProject: fromCallback(({ sendBack, input }) => {
-            const create = async () => {
-                try {
-                    const __dirname = path.dirname(fileURLToPath(import.meta.url));
-                    const projectDir = createDirectory(input.appSlug);
-                    const templatesDir = path.resolve(__dirname, "../templates", input.language);
-                    const commonDir = path.resolve(__dirname, "../templates", "common");
-                    const transform = (contents) => contents
-                        .replaceAll("title-to-be-replaced", input.title)
-                        .replaceAll("id-to-be-replaced", input.appId)
-                        .replaceAll("slug-to-be-replaced", input.appSlug);
-                    await Promise.all([
-                        copyWithTransform(templatesDir, projectDir, transform),
-                        copyWithTransform(commonDir, projectDir, transform),
-                    ]);
-                    sendBack({ type: "Success" });
-                }
-                catch (error) {
-                    sendBack({ type: "Error", error: error.message });
-                }
-            };
-            create();
-        }),
-        createApp: fromCallback(({ sendBack, input: { appSlug, token, developerSlug, title } }) => {
-            const create = async () => {
-                const spinner = new Spinner();
-                spinner.start(`Creating app "${title}"...`);
-                try {
-                    const result = await createApp({
-                        token,
-                        developerSlug,
-                        appSlug: appSlug,
-                        title,
-                    });
-                    spinner.success(`"${title}" created!`);
-                    sendBack({ type: "App Created", appId: result.app_id });
-                }
-                catch (error) {
-                    spinner.error(error.message);
-                    sendBack({ type: "Error", error: error.message });
-                }
-            };
-            create();
-        }),
-        loadConfig: fromCallback(({ sendBack }) => {
-            const load = async () => {
-                const config = await loadDeveloperConfig();
-                if (typeof config === "string") {
-                    sendBack({ type: "No Config", configError: config });
-                    return;
-                }
-                sendBack({
-                    type: "Config Loaded",
-                    token: config.token,
-                    developerSlug: config.developer_slug,
-                });
-            };
-            load();
-        }),
-        validateSlug: fromCallback(({ sendBack, input: { appSlug, token, developerSlug } }) => {
-            const spinner = new Spinner();
-            spinner.start("Checking if slug is valid...");
-            if (!isValidSlug(appSlug)) {
-                spinner.error("Invalid slug");
-                sendBack({
-                    type: "Invalid Slug",
-                    error: "Slug contains invalid characters. Must be lowercase letters or hyphens only.",
-                });
-            }
-            if (existsSync(join(process.cwd(), appSlug))) {
-                spinner.error("Invalid slug");
-                sendBack({
-                    type: "Invalid Slug",
-                    error: `Directory "${appSlug}" already exists`,
-                });
-                return;
-            }
-            if (!canWrite(".")) {
-                spinner.error("Fatal Error");
-                sendBack({
-                    type: "Fatal Error",
-                    error: "Write access denied to current directory",
-                });
-                return;
-            }
-            isAppSlugValid({ token, developerSlug, appSlug: appSlug })
-                .then((valid) => {
-                spinner.success("Valid slug");
-                sendBack(valid
-                    ? { type: "Valid Slug" }
-                    : {
-                        type: "Invalid Slug",
-                        error: "An app already exists with this slug",
-                    });
-            })
-                .catch((error) => {
-                spinner.error("Fatal Error");
-                sendBack({ type: "Fatal Error", error: error.message });
-            });
-        }),
-    },
-    actions: {
-        printLogo,
-        clearError: assign({
-            error: () => undefined,
-        }),
-        showError,
-        showConfigInstructions: ({ context: { configError } }) => {
-            printInstallInstructions(configError);
-        },
-        showInstructions: ({ context: { appSlug, title } }) => {
-            const commands = `cd ${appSlug}\nnpm install\nnpm run dev`;
-            process.stdout.write("\n" +
-                chalk.green(`SUCCESS!! 🎉 Your extension "${title}" has been created.`) +
-                "\n");
-            process.stdout.write("\nTo get started, run:\n");
-            process.stdout.write(boxen(commands, {
-                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,
-        }),
-        setTitle: assign({
-            title: (_, params) => params.output,
-        }),
-        setConfig: assign({
-            token: (_, params) => params.token,
-            developerSlug: (_, params) => params.developerSlug,
-        }),
-        setConfigError: assign({
-            configError: (_, params) => params.configError,
-        }),
-        setAppId: assign({
-            appId: (_, params) => params.appId,
-        }),
-        setSlug: assign({
-            appSlug: (_, params) => slugifyExtension(params.output, false),
-        }),
-        slugifyTitle: assign({
-            appSlug: (_, params) => slugifyExtension(params.title),
-        }),
-    },
-    guards: {
-        "have title": (_, params) => Boolean(params.title.trim()),
-        "have slug": (_, params) => Boolean(params.slug.trim()),
-        "have language": (_, params) => Boolean(params.language),
-    },
-}).createMachine({
-    context: ({ input }) => ({
-        availablePackageManagers: ["npm"],
-        developerSlug: "",
-        appId: "",
-        appSlug: "",
-        token: "",
-        ...input,
-    }),
-    id: "Create Machine",
-    states: {
-        "Do we need title?": {
-            always: [
-                {
-                    target: "Validate Slug From CLI Title",
-                    guard: { type: "have title", params: ({ context }) => context },
-                    description: `Title may have been provided via CLI arg`,
-                    actions: { type: "slugifyTitle", params: ({ context }) => context },
-                    reenter: true,
-                },
-                {
-                    target: "Ask for title",
-                    reenter: true,
-                },
-            ],
-        },
-        "Ask for title": {
-            invoke: {
-                src: "ask",
-                input: {
-                    message: 'What would you like to call your new app? (in "Title Case")',
-                    required: true,
-                },
-                onDone: {
-                    target: "Validate Slug From Title",
-                    actions: [
-                        { type: "setTitle", params: ({ event }) => event },
-                        { type: "slugifyTitle", params: ({ context }) => context },
-                    ],
-                },
-            },
-        },
-        "Ask for language": {
-            invoke: {
-                src: "askWithChoices",
-                input: {
-                    message: "What language would you like to use?",
-                    choices: languages,
-                },
-                onDone: {
-                    target: "Create App",
-                    actions: {
-                        type: "setLanguage",
-                        params: ({ event }) => event,
-                    },
-                    reenter: true,
-                },
-            },
-        },
-        "Creating Project": {
-            on: {
-                Error: {
-                    target: "Error",
-                    actions: { type: "showError", params: ({ event }) => event },
-                },
-                Success: {
-                    target: "Success",
-                    reenter: true,
-                },
-            },
-            invoke: {
-                src: "createProject",
-                input: ({ context }) => ({
-                    title: context.title,
-                    language: context.language,
-                    appId: context.appId,
-                    appSlug: context.appSlug,
-                }),
-            },
-        },
-        "Error": {
-            type: "final",
-            description: `😭😭😭😭😭`,
-        },
-        "Success": {
-            type: "final",
-            description: `🎉🎉🎉🎉🎉🎉`,
-            entry: "showInstructions",
-        },
-        "Do we need language?": {
-            always: [
-                {
-                    target: "Create App",
-                    guard: { type: "have language", params: ({ context }) => context },
-                    reenter: true,
-                    description: `language may have been provided by CLI option`,
-                },
-                "Ask for language",
-            ],
-        },
-        "Validate Slug": {
-            invoke: [
-                {
-                    src: "validateSlug",
-                    input: ({ context }) => context,
-                },
-            ],
-            on: {
-                "Invalid Slug": {
-                    target: "Ask for slug",
-                    actions: {
-                        type: "showError",
-                        params: ({ event }) => event,
-                    },
-                    reenter: true,
-                },
-                "Valid Slug": {
-                    target: "Do we need language?",
-                    actions: "clearError",
-                },
-            },
-            description: `Checks if can create directory and if app with this slug already exists on backend`,
-        },
-        "Load Config": {
-            on: {
-                "No Config": {
-                    target: "Show config instructions",
-                    actions: { type: "setConfigError", params: ({ event }) => event },
-                },
-                "Config Loaded": {
-                    target: "Do we need title?",
-                    actions: { type: "setConfig", params: ({ event }) => event },
-                },
-            },
-            invoke: {
-                src: "loadConfig",
-            },
-        },
-        "Show config instructions": {
-            type: "final",
-            entry: "showConfigInstructions",
-        },
-        "Create App": {
-            invoke: {
-                src: "createApp",
-                input: ({ context }) => context,
-            },
-            on: {
-                "App Created": {
-                    target: "Creating Project",
-                    actions: { type: "setAppId", params: ({ event }) => event },
-                },
-                "Error": {
-                    target: "Error",
-                    actions: { type: "showError", params: ({ event }) => event },
-                },
-            },
-        },
-        "Ask for slug": {
-            invoke: {
-                src: "ask",
-                input: ({ context }) => ({
-                    message: "Please provide a slug for your extension:",
-                    default: context.appSlug,
-                    required: true,
-                }),
-                onDone: {
-                    target: "Validate Slug",
-                    actions: { type: "setSlug", params: ({ event }) => event },
-                },
-            },
-        },
-        "Validate Slug From Title": {
-            invoke: {
-                src: "validateSlug",
-                input: ({ context }) => context,
-            },
-            on: {
-                "Invalid Slug": {
-                    target: "Ask for slug",
-                    actions: {
-                        type: "showError",
-                        params: ({ event }) => event,
-                    },
-                },
-                "Valid Slug": {
-                    target: "Ask for slug",
-                    description: `Just double check with user that they like their slug`,
-                },
-                "Fatal Error": {
-                    target: "Error",
-                    actions: {
-                        type: "showError",
-                        params: ({ event }) => event,
-                    },
-                },
-            },
-        },
-        "Validate Slug From CLI Title": {
-            invoke: {
-                src: "validateSlug",
-                input: ({ context }) => context,
-            },
-            on: {
-                "Invalid Slug": {
-                    target: "Ask for slug",
-                    actions: {
-                        type: "showError",
-                        params: ({ event }) => event,
-                    },
-                },
-                "Valid Slug": {
-                    target: "Do we need language?",
-                    reenter: true,
-                },
-                "Fatal Error": {
-                    target: "Error",
-                    actions: {
-                        type: "showError",
-                        params: ({ event }) => event,
-                    },
-                },
-            },
-        },
-    },
-    initial: "Load Config",
-    entry: "printLogo",
-});

package/lib/util/slugify-extension.js

@@ -1,14 +0,0 @@
-export function slugifyExtension(string, trim = true) {
-    const slug = (trim ? string.trim() : string)
-        .toLowerCase()
-        .replace(/[\s._@]/g, "-")
-        .replace(/[^\w-]/g, "");
-    if (trim) {
-        return slug
-            .replace(/^-+|-+$/g, "")
-            .replace(/--+/g, "-");
-    }
-    return slug
-        .replace(/^-+/g, "")
-        .replace(/(?!-+$)--+/g, "-");
-}