attio 0.0.1-experimental.20250303 → 0.0.1-experimental.20250321

package/lib/commands/version/publish.js

@@ -1,48 +0,0 @@
-import { Argument, Command, Option } from "commander";
-import { createActor } from "xstate";
-import { z } from "zod";
-import { publishVersionMachine } from "../../machines/publish-version-machine.js";
-export const argsSchema = z
-    .string()
-    .regex(/^\d+\.\d+$/, 'Version must be in the format "major.minor" (e.g., "1.0")')
-    .optional()
-    .describe(`The version to invite someone to (e.g: "1.0"). If you don't specify a version, you will be prompted to choose.`);
-export const optionsSchema = z.object({
-    dev: z.boolean().default(false),
-});
-export const versionPublish = new Command("publish")
-    .description("Publish an unpublished production version of your Attio app")
-    .addArgument(new Argument("<version>", `The version to publish (e.g: "1.0"). If you don't specify a version, you will be prompted to choose.`).argOptional())
-    .addOption(new Option("--dev", "Run in development mode (additional debugging info)"))
-    .action((unparsedArgs, unparsedOptions) => {
-    const versionResult = argsSchema.safeParse(unparsedArgs);
-    const optionsResult = optionsSchema.safeParse(unparsedOptions);
-    if (!versionResult.success) {
-        process.stderr.write("\nInvalid version argument:\n");
-        versionResult.error.errors.forEach((err) => {
-            process.stderr.write(`- ${err.message}\n`);
-        });
-        process.exit(1);
-    }
-    if (!optionsResult.success) {
-        process.stderr.write("\nInvalid options:\n");
-        optionsResult.error.errors.forEach((err) => {
-            process.stderr.write(`- ${err.path.map((p) => String(p).replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`)).join(".")}: ${err.message}\n`);
-        });
-        process.exit(1);
-    }
-    const version = versionResult.data;
-    const options = optionsResult.data;
-    const actor = createActor(publishVersionMachine, {
-        input: {
-            major: version ? Number(version.split(".")[0]) : undefined,
-            minor: version ? Number(version.split(".")[1]) : undefined,
-        },
-    });
-    if (options.dev) {
-        actor.subscribe((state) => {
-            console.log("state:", state.value);
-        });
-    }
-    actor.start();
-});

package/lib/machines/add-connection-machine.js

@@ -1,559 +0,0 @@
-import { assign, setup, fromCallback } from "xstate";
-import { addConnectionDefinition } from "../api/add-connection-definition.js";
-import { fetchConnections } from "../api/fetch-connections.js";
-import { optionsSchema } from "../commands/connection/add.js";
-import { ask, askPassword, askWithChoices, loadAppConfig, loadDeveloperConfig } from "./actors.js";
-import { printInstallInstructions } from "../util/print-install-instructions.js";
-import { printLogo, showError } from "./actions.js";
-import Spinner from "tiny-spinner";
-import chalk from "chalk";
-export const connectionTypes = [
-    { value: "secret", label: "Secret" },
-    { value: "oauth2-code", label: "OAuth2" },
-];
-export const addConnectionMachine = setup({
-    types: {
-        context: {},
-        events: {},
-        input: {},
-    },
-    actors: {
-        ask,
-        askWithChoices,
-        askPassword,
-        createConnectionDefinition: fromCallback(({ sendBack, input: { developer: { token, slug: devSlug }, config, connectionType: connection_type, label, description, global, authorizeUrl, accessTokenUrl, clientId, clientSecret, scopes, }, }) => {
-            const spinner = new Spinner();
-            const add = async () => {
-                spinner.start("Creating connection definition...");
-                try {
-                    await addConnectionDefinition({
-                        token,
-                        devSlug,
-                        appId: config.id,
-                        major: config.major,
-                        connectionType: connection_type,
-                        label,
-                        description,
-                        global,
-                        accessTokenUrl,
-                        authorizeUrl,
-                        clientId,
-                        clientSecret,
-                        scopes,
-                    });
-                    spinner.success("Connection definition created");
-                    sendBack({ type: "Success" });
-                }
-                catch (error) {
-                    spinner.error(`Failed to create connection definition: ${chalk.red(error.message)}`);
-                    sendBack({ type: "Error", error: error.message });
-                }
-            };
-            add();
-        }),
-        loadDeveloperConfig,
-        loadAppConfig,
-        validateGlobal: fromCallback(({ sendBack, input: { developer, config, global } }) => {
-            const spinner = new Spinner();
-            spinner.start("Checking if global connection already exists..." + global);
-            fetchConnections({
-                token: developer.token,
-                devSlug: developer.slug,
-                appId: config.id,
-                major: config.major,
-            })
-                .then((connections) => {
-                const weHaveGlobal = connections.some((connection) => connection.global);
-                const weHaveUser = connections.some((connection) => !connection.global);
-                if (weHaveGlobal && weHaveUser) {
-                    spinner.stop();
-                    sendBack({
-                        type: "Error",
-                        error: "Both global and user connections already exist",
-                    });
-                }
-                else if (weHaveGlobal && global) {
-                    spinner.error("Global connection already exists");
-                    sendBack({ type: "Global Taken" });
-                }
-                else if (weHaveUser && !global) {
-                    spinner.error("A user connection already exists");
-                    sendBack({ type: "Global Taken" });
-                }
-                else {
-                    spinner.success("All good.");
-                    sendBack({ type: "Valid Global" });
-                }
-            })
-                .catch((error) => {
-                spinner.stop();
-                sendBack({ type: "Error", error: error.message });
-            });
-        }),
-    },
-    actions: {
-        printLogo,
-        showError,
-        showConfigInstructions: ({ context }) => printInstallInstructions(context.configError),
-        clearError: assign({
-            error: () => undefined,
-        }),
-        setError: assign({
-            error: (_, params) => params.error,
-        }),
-        setConnectionType: assign({
-            connectionType: (_, params) => params.output,
-        }),
-        setAuthorizeUrl: assign({
-            authorizeUrl: (_, params) => params.output,
-        }),
-        setAccessTokenUrl: assign({
-            accessTokenUrl: (_, params) => params.output,
-        }),
-        setScopes: assign({
-            scopes: (_, params) => params.output,
-        }),
-        setClientId: assign({
-            clientId: (_, params) => params.output,
-        }),
-        setClientSecret: assign({
-            clientSecret: (_, params) => params.output,
-        }),
-        setDeveloperConfig: assign({
-            developer: (_, params) => params,
-        }),
-        setInvalidAuthorizeUrl: assign({
-            error: (_, params) => {
-                const result = optionsSchema.shape.authorizeUrl
-                    .unwrap()
-                    .safeParse(params.authorizeUrl?.trim());
-                return result.success ? undefined : result.error.errors[0].message;
-            },
-        }),
-        setInvalidAccessTokenUrl: assign({
-            error: (_, params) => {
-                const result = optionsSchema.shape.accessTokenUrl
-                    .unwrap()
-                    .safeParse(params.accessTokenUrl?.trim());
-                return result.success ? undefined : result.error.errors[0].message;
-            },
-        }),
-        setInvalidScopes: assign({
-            error: (_, params) => {
-                const result = optionsSchema.shape.scopes.unwrap().safeParse(params.scopes?.trim());
-                return result.success ? undefined : result.error.errors[0].message;
-            },
-        }),
-        setInvalidClientId: assign({
-            error: (_, params) => {
-                const result = optionsSchema.shape.clientId
-                    .unwrap()
-                    .safeParse(params.clientId?.trim());
-                return result.success ? undefined : result.error.errors[0].message;
-            },
-        }),
-        setInvalidClientSecret: assign({
-            error: (_, params) => {
-                const result = optionsSchema.shape.clientSecret
-                    .unwrap()
-                    .safeParse(params.clientSecret?.trim());
-                return result.success ? undefined : result.error.errors[0].message;
-            },
-        }),
-        setConfigError: assign({
-            configError: (_, params) => params.configError,
-        }),
-        setLabel: assign({
-            label: (_, params) => params.output,
-        }),
-        setDescription: assign({
-            description: (_, params) => params.output,
-        }),
-        setGlobal: assign({
-            global: (_, params) => params.output === "true",
-        }),
-        setAppConfig: assign({
-            config: (_, params) => params.config,
-        }),
-        setGlobalTaken: assign({
-            error: () => "Global taken",
-        }),
-    },
-    guards: {
-        "have connection type": (_, params) => Boolean(params.connectionType),
-        "have label": (_, params) => Boolean(params.label),
-        "have description": (_, params) => Boolean(params.description),
-        "have authorize url": (_, params) => params.connectionType === "secret" ||
-            optionsSchema.shape.authorizeUrl.unwrap().safeParse(params.authorizeUrl?.trim())
-                .success,
-        "have access token url": (_, params) => params.connectionType === "secret" ||
-            optionsSchema.shape.accessTokenUrl.unwrap().safeParse(params.accessTokenUrl?.trim())
-                .success,
-        "have scopes": (_, params) => params.connectionType === "secret" ||
-            optionsSchema.shape.scopes.unwrap().safeParse(params.scopes?.trim()).success,
-        "have client id": (_, params) => params.connectionType === "secret" ||
-            optionsSchema.shape.clientId.unwrap().safeParse(params.clientId?.trim()).success,
-        "have global": (_, params) => params.global !== undefined,
-        "have client secret": (_, params) => params.connectionType === "secret" ||
-            optionsSchema.shape.clientSecret.unwrap().safeParse(params.clientSecret?.trim())
-                .success,
-        "is oauth": (_, params) => params.connectionType === "oauth2-code",
-    },
-}).createMachine({
-    context: ({ input }) => ({
-        developer: { slug: "", token: "" },
-        ...input,
-    }),
-    id: "Add Connection Machine",
-    states: {
-        "Loading Developer Config": {
-            invoke: {
-                src: "loadDeveloperConfig",
-            },
-            on: {
-                "Developer Config Loaded": {
-                    target: "Loading App Config",
-                    actions: { type: "setDeveloperConfig", params: ({ event }) => event },
-                },
-                "No Developer Config": {
-                    target: "Show config instructions",
-                    actions: { type: "setConfigError", params: ({ event }) => event },
-                },
-            },
-        },
-        "Show config instructions": {
-            type: "final",
-            entry: "showConfigInstructions",
-        },
-        "Loading App Config": {
-            invoke: {
-                src: "loadAppConfig",
-            },
-            on: {
-                "Error": {
-                    target: "Error",
-                    actions: { type: "setError", params: ({ event }) => event },
-                },
-                "App Config Loaded": {
-                    target: "Do we have a connection type?",
-                    actions: { type: "setAppConfig", params: ({ event }) => event },
-                    reenter: true,
-                },
-            },
-        },
-        "Error": {
-            type: "final",
-            entry: { type: "showError", params: ({ context }) => ({ error: context.error }) },
-        },
-        "Creating connection definition": {
-            invoke: {
-                src: "createConnectionDefinition",
-                input: ({ context }) => ({
-                    developer: context.developer,
-                    config: context.config,
-                    connectionType: context.connectionType,
-                    authorizeUrl: context.authorizeUrl,
-                    accessTokenUrl: context.accessTokenUrl,
-                    scopes: context.scopes,
-                    clientId: context.clientId,
-                    clientSecret: context.clientSecret,
-                    global: context.global,
-                    label: context.label,
-                    description: context.description,
-                }),
-            },
-            on: {
-                Error: {
-                    target: "Error",
-                    actions: { type: "setError", params: ({ event }) => event },
-                },
-                Success: "Success",
-            },
-        },
-        "Success": {
-            type: "final",
-        },
-        "Ask for Authorize URL": {
-            invoke: {
-                src: "ask",
-                input: {
-                    message: "e.g. https://authorization-server.com/oauth/authorize\nOAuth Authorize URL:",
-                    required: true,
-                    validate: (value) => {
-                        const result = optionsSchema.shape.authorizeUrl
-                            .unwrap()
-                            .safeParse(value.trim());
-                        return result.success ? true : result.error.errors[0].message;
-                    },
-                },
-                onDone: {
-                    target: "Do we have an access token url?",
-                    actions: { type: "setAuthorizeUrl", params: ({ event }) => event },
-                },
-            },
-        },
-        "Ask for Access Token URL": {
-            invoke: {
-                src: "ask",
-                input: {
-                    message: "e.g. https://authorization-server.com/oauth/token\nOAuth Access Token URL:",
-                    required: true,
-                    validate: (value) => {
-                        const result = optionsSchema.shape.accessTokenUrl
-                            .unwrap()
-                            .safeParse(value.trim());
-                        return result.success ? true : result.error.errors[0].message;
-                    },
-                },
-                onDone: {
-                    target: "Do we have scopes?",
-                    actions: { type: "setAccessTokenUrl", params: ({ event }) => event },
-                },
-            },
-        },
-        "Ask for Scopes": {
-            invoke: {
-                src: "ask",
-                input: {
-                    message: "e.g. read:user,read:org\nOAuth Scopes:",
-                    required: true,
-                    validate: (value) => {
-                        const result = optionsSchema.shape.scopes.unwrap().safeParse(value.trim());
-                        return result.success ? true : result.error.errors[0].message;
-                    },
-                },
-                onDone: {
-                    target: "Do we have a client id?",
-                    actions: { type: "setScopes", params: ({ event }) => event },
-                },
-            },
-        },
-        "Ask for Client ID": {
-            invoke: {
-                src: "ask",
-                input: {
-                    message: "OAuth Client ID:",
-                    required: true,
-                },
-                onDone: {
-                    target: "Do we have a client secret?",
-                    actions: { type: "setClientId", params: ({ event }) => event },
-                },
-            },
-        },
-        "Ask for Client Secret": {
-            invoke: {
-                src: "askPassword",
-                input: {
-                    message: "OAuth Client Secret:",
-                    required: true,
-                },
-                onDone: {
-                    target: "Creating connection definition",
-                    actions: { type: "setClientSecret", params: ({ event }) => event },
-                },
-            },
-        },
-        "Do we have an authorize url?": {
-            always: [
-                {
-                    target: "Do we have an access token url?",
-                    guard: { type: "have authorize url", params: ({ context }) => context },
-                },
-                {
-                    target: "Ask for Authorize URL",
-                },
-            ],
-        },
-        "Do we have an access token url?": {
-            always: [
-                {
-                    target: "Do we have scopes?",
-                    guard: { type: "have access token url", params: ({ context }) => context },
-                },
-                {
-                    target: "Ask for Access Token URL",
-                },
-            ],
-        },
-        "Do we have scopes?": {
-            always: [
-                {
-                    target: "Do we have a client id?",
-                    guard: { type: "have scopes", params: ({ context }) => context },
-                },
-                {
-                    target: "Ask for Scopes",
-                },
-            ],
-        },
-        "Do we have a client id?": {
-            always: [
-                {
-                    target: "Do we have a client secret?",
-                    guard: { type: "have client id", params: ({ context }) => context },
-                },
-                {
-                    target: "Ask for Client ID",
-                },
-            ],
-        },
-        "Do we have a client secret?": {
-            always: [
-                {
-                    target: "Creating connection definition",
-                    guard: { type: "have client secret", params: ({ context }) => context },
-                },
-                {
-                    target: "Ask for Client Secret",
-                },
-            ],
-        },
-        "Do we have a connection type?": {
-            always: [
-                {
-                    target: "Do we have a label?",
-                    guard: { type: "have connection type", params: ({ context }) => context },
-                    reenter: true,
-                },
-                "Ask for connection type",
-            ],
-        },
-        "Ask for connection type": {
-            invoke: {
-                src: "askWithChoices",
-                input: {
-                    message: "What type of connection would you like to add?",
-                    choices: [
-                        { name: "OAuth2 Code", value: "oauth2-code" },
-                        { name: "Secret", value: "secret" },
-                    ],
-                },
-                onDone: {
-                    target: "Do we have a label?",
-                    actions: { type: "setConnectionType", params: ({ event }) => event },
-                },
-            },
-        },
-        "Split on connection type": {
-            always: [
-                {
-                    target: "Do we have an authorize url?",
-                    guard: { type: "is oauth", params: ({ context }) => context },
-                },
-                {
-                    target: "Creating connection definition",
-                },
-            ],
-        },
-        "Do we have a label?": {
-            always: [
-                {
-                    target: "Do we have a description?",
-                    guard: { type: "have label", params: ({ context }) => context },
-                    reenter: true,
-                },
-                {
-                    target: "Ask for label",
-                },
-            ],
-        },
-        "Do we have a description?": {
-            always: [
-                {
-                    target: "Do we have global?",
-                    guard: { type: "have description", params: ({ context }) => context },
-                },
-                {
-                    target: "Ask for description",
-                },
-            ],
-        },
-        "Do we have global?": {
-            always: [
-                {
-                    target: "Validating Global",
-                    guard: { type: "have global", params: ({ context }) => context },
-                    reenter: true,
-                },
-                {
-                    target: "Ask for global",
-                },
-            ],
-        },
-        "Ask for label": {
-            invoke: {
-                src: "ask",
-                input: ({ context }) => ({
-                    message: "What would you like to call this connection?",
-                    required: true,
-                    default: context.connectionType === "oauth2-code"
-                        ? "Connection"
-                        : context.connectionType === "secret"
-                            ? "Access Token"
-                            : "",
-                }),
-                onDone: {
-                    target: "Do we have a description?",
-                    actions: { type: "setLabel", params: ({ event }) => event },
-                },
-            },
-        },
-        "Ask for description": {
-            invoke: {
-                src: "ask",
-                input: {
-                    message: "Description: (will be displayed in the UI)",
-                    required: true,
-                },
-                onDone: {
-                    target: "Do we have global?",
-                    actions: { type: "setDescription", params: ({ event }) => event },
-                },
-            },
-        },
-        "Ask for global": {
-            invoke: {
-                src: "askWithChoices",
-                input: ({ context }) => ({
-                    message: `A ${context.connectionType === "secret" ? "secret" : "token"} will be created for:`,
-                    choices: [
-                        { name: "The entire workspace", value: "true" },
-                        { name: "An individual user", value: "false" },
-                    ],
-                }),
-                onDone: {
-                    target: "Validating Global",
-                    actions: { type: "setGlobal", params: ({ event }) => event },
-                },
-            },
-        },
-        "Validating Global": {
-            on: {
-                "Global Taken": {
-                    target: "Ask for global",
-                    actions: "setGlobalTaken",
-                },
-                "Valid Global": {
-                    target: "Split on connection type",
-                    reenter: true,
-                },
-                "Error": {
-                    target: "Error",
-                    reenter: true,
-                    actions: { type: "setError", params: ({ event }) => event },
-                },
-            },
-            invoke: {
-                src: "validateGlobal",
-                input: ({ context }) => ({
-                    global: context.global,
-                    developer: context.developer,
-                    config: context.config,
-                }),
-            },
-        },
-    },
-    initial: "Loading Developer Config",
-    entry: "printLogo",
-});