attio 0.0.1-experimental.20241003.1 → 0.0.1-experimental.20241007.1

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

@@ -7,11 +7,11 @@ const addConnectionSchema = z.object({
     app_id: z.string(),
     connection_definition_id: z.string(),
 });
-export async function addConnectionDefinition({ token, devSlug, appId, slug, label, description, allowMultiple, global, connectionType, clientId, clientSecret, authorizeUrl, accessTokenUrl, major, scopes, }) {
+export async function addConnectionDefinition({ token, devSlug, appId, key, label, description, allowMultiple, global, connectionType, clientId, clientSecret, authorizeUrl, accessTokenUrl, major, scopes, }) {
     const connectionDefinitionId = uuid();
     const body = {
         connection_type: connectionType,
-        slug,
+        slug: key,
         label,
         description,
         allow_multiple: allowMultiple,

package/lib/commands/connection/add.js

@@ -11,10 +11,10 @@ import { Select } from "../../components/Select.js";
 import { addConnectionMachine, connectionTypes } from "../../machines/add-connection-machine.js";
 export const description = "Create a new connection for your Attio app";
 export const options = z.object({
-    slug: z
+    key: z
         .string()
         .optional()
-        .describe(option({ description: "A unique slug for your connection" })),
+        .describe(option({ description: "A unique key for your connection" })),
     label: z
         .string()
         .optional()
@@ -29,6 +29,7 @@ export const options = z.object({
         .enum(["secret", "oauth2-code"])
         .optional()
         .describe(option({ description: "The type of connection to create" })),
+    allowMultiple: z.boolean().optional().default(false),
     authorizeUrl: z
         .string()
         .url("Invalid URL, e.g. https://authorization-server.com/authorize")
@@ -61,15 +62,16 @@ export const options = z.object({
         .default(false)
         .describe(option({ description: "Run in development mode (additional debugging info)" })),
 });
-export default function AddConnection({ options: { slug, label, description, type: connectionType, authorizeUrl, accessTokenUrl, scopes, clientId, clientSecret, dev, }, }) {
+export default function AddConnection({ options: { key, label, description, type: connectionType, authorizeUrl, accessTokenUrl, allowMultiple, scopes, clientId, clientSecret, dev, }, }) {
     const [snapshot, send] = useMachine(addConnectionMachine, {
         input: {
-            slug,
+            key,
             label,
             description,
             connectionType,
             authorizeUrl,
             accessTokenUrl,
+            allowMultiple,
             scopes,
             clientId,
             clientSecret,
@@ -81,19 +83,107 @@ export default function AddConnection({ options: { slug, label, description, typ
         React.createElement(Logo, null),
         React.createElement(Box, { flexDirection: "column" },
             snapshot.matches("Show config instructions") && (React.createElement(InitialInstructions, { reason: snapshot.context.configError })),
-            snapshot.matches("Ask for slug") && (React.createElement(React.Fragment, null,
-                React.createElement(Box, null,
-                    React.createElement(Text, null, "Unique Slug: "),
-                    React.createElement(TextInput, { value: snapshot.context.slug ?? "", onChange: (slug) => send({ type: "Update Slug", slug }), onSubmit: () => send({ type: "Submit" }) })))),
+            React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+                snapshot.context.connectionType && (React.createElement(Box, null,
+                    React.createElement(Text, null, "Connection Type: "),
+                    React.createElement(Text, { color: "green" }, snapshot.context.connectionType === "oauth2-code"
+                        ? "OAuth2 Code"
+                        : "Secret"))),
+                snapshot.context.label && !snapshot.matches("Ask for label") && (React.createElement(Box, null,
+                    React.createElement(Text, null, "Label: "),
+                    React.createElement(Text, { color: "green" }, snapshot.context.label))),
+                snapshot.context.key && !snapshot.matches("Ask for key") && (React.createElement(Box, null,
+                    React.createElement(Text, null, "Connection Key: "),
+                    React.createElement(Text, { color: "green" }, snapshot.context.key))),
+                snapshot.context.description && !snapshot.matches("Ask for description") && (React.createElement(Box, null,
+                    React.createElement(Text, null, "Description: "),
+                    React.createElement(Text, { color: "green" }, snapshot.context.description))),
+                snapshot.context.global !== undefined &&
+                    !snapshot.matches("Ask for global") && (React.createElement(Box, null,
+                    React.createElement(Text, null,
+                        snapshot.context.connectionType === "secret"
+                            ? "Secret"
+                            : "Token",
+                        " ",
+                        "will be created for:",
+                        " "),
+                    React.createElement(Text, { color: "green" }, snapshot.context.global
+                        ? "The entire workspace"
+                        : "An individual user"))),
+                snapshot.context.connectionType === "oauth2-code" && (React.createElement(React.Fragment, null,
+                    snapshot.context.authorizeUrl &&
+                        !snapshot.matches("Ask for Authorize URL") && (React.createElement(Box, null,
+                        React.createElement(Text, null, "Authorize URL: "),
+                        React.createElement(Text, { color: "green" }, snapshot.context.authorizeUrl))),
+                    snapshot.context.accessTokenUrl &&
+                        !snapshot.matches("Ask for Access Token URL") && (React.createElement(Box, null,
+                        React.createElement(Text, null, "Access Token URL: "),
+                        React.createElement(Text, { color: "green" }, snapshot.context.accessTokenUrl))),
+                    snapshot.context.scopes && !snapshot.matches("Ask for Scopes") && (React.createElement(Box, null,
+                        React.createElement(Text, null, "Scopes: "),
+                        React.createElement(Text, { color: "green" }, snapshot.context.scopes))),
+                    snapshot.context.clientId &&
+                        !snapshot.matches("Ask for Client ID") && (React.createElement(Box, null,
+                        React.createElement(Text, null, "Client ID: "),
+                        React.createElement(Text, { color: "green" }, snapshot.context.clientId)))))),
+            snapshot.matches("Ask for key") && (React.createElement(React.Fragment, null,
+                React.createElement(Box, { flexDirection: "column" },
+                    React.createElement(Box, { flexDirection: "column", margin: 1, borderStyle: "round", padding: 1 },
+                        React.createElement(Text, null,
+                            "import ",
+                            "{",
+                            " connections ",
+                            "}",
+                            " from \"attio/server\""),
+                        React.createElement(Box, { marginY: 1 },
+                            React.createElement(Text, null, "...")),
+                        React.createElement(Text, null,
+                            "const response = await fetch(\"https://api.yourdomain.com/your-endpoint\", ",
+                            "{"),
+                        React.createElement(Text, null,
+                            "  ",
+                            "method: \"GET\","),
+                        React.createElement(Text, null,
+                            "  ",
+                            "headers: ",
+                            "{"),
+                        React.createElement(Text, null,
+                            "    ",
+                            "\"Content-Type\": \"application/json\","),
+                        React.createElement(Box, { flexWrap: "wrap" },
+                            React.createElement(Text, null,
+                                "    ",
+                                "Authorization: `Bearer $",
+                                "{",
+                                "connections"),
+                            React.createElement(Text, null, snapshot.context.key?.includes("-") ? '["' : "."),
+                            React.createElement(Text, { color: "yellowBright" }, snapshot.context.key),
+                            snapshot.context.key?.includes("-") && React.createElement(Text, null, "\"]"),
+                            React.createElement(Text, null,
+                                "}",
+                                "`,")),
+                        React.createElement(Box, { marginLeft: 41 + (snapshot.context.key?.includes("-") ? 1 : 0) },
+                            React.createElement(Text, { color: "cyan" }, "^".repeat(snapshot.context.key?.length ?? 0))),
+                        React.createElement(Text, null, "  }"),
+                        React.createElement(Text, null,
+                            "}",
+                            ");")),
+                    React.createElement(Box, null,
+                        React.createElement(Text, null, "Unique Connection Key: "),
+                        React.createElement(TextInput, { value: snapshot.context.key ?? "", onChange: (key) => send({ type: "Update Key", key }), onSubmit: () => send({ type: "Submit" }) }))))),
             snapshot.matches("Ask for label") && (React.createElement(React.Fragment, null,
                 React.createElement(Box, null,
-                    React.createElement(Text, null, "Provide a label for your connection. This will be displayed to users. (You can edit this later)")),
-                React.createElement(Box, null,
+                    React.createElement(Text, null, "Provide a label for your connection. This is what your users will see.")),
+                React.createElement(Box, { marginTop: 1 },
+                    React.createElement(Text, null, "> "),
                     React.createElement(TextInput, { value: snapshot.context.label ?? "", onChange: (label) => send({ type: "Update Label", label }), onSubmit: () => send({ type: "Submit" }) })))),
             snapshot.matches("Ask for description") && (React.createElement(React.Fragment, null,
                 React.createElement(Box, null,
-                    React.createElement(Text, null, "Provide an optional detailed description for your connection. This will be displayed to users. (You can edit this later)")),
-                React.createElement(Box, null,
+                    React.createElement(Text, null, "Provide an optional detailed description for your connection.")),
+                React.createElement(Box, { marginTop: 1 },
+                    React.createElement(Text, null, "This will be displayed to users. (You can edit this later)")),
+                React.createElement(Box, { marginTop: 1 },
+                    React.createElement(Text, null, "> "),
                     React.createElement(TextInput, { value: snapshot.context.description ?? "", onChange: (description) => send({ type: "Update Description", description }), onSubmit: () => send({ type: "Submit" }) })))),
             snapshot.matches("Ask for connection type") && (React.createElement(React.Fragment, null,
                 React.createElement(Box, null,
@@ -102,30 +192,61 @@ export default function AddConnection({ options: { slug, label, description, typ
                     React.createElement(Select, { items: connectionTypes, onSelect: (connectionType) => send({ type: "Choose Connection Type", connectionType }) })))),
             snapshot.matches("Ask for global") && (React.createElement(React.Fragment, null,
                 React.createElement(Box, null,
-                    React.createElement(Text, null, "Is this a global connection?")),
+                    React.createElement(Text, null,
+                        "A",
+                        " ",
+                        snapshot.context.connectionType === "secret" ? "secret" : "token",
+                        " ",
+                        "will be created for:")),
                 React.createElement(Box, null,
                     React.createElement(Select, { items: [
-                            { value: true, label: "Yes" },
-                            { value: false, label: "No" },
+                            { value: false, label: "An individual user" },
+                            { value: true, label: "The entire workspace" },
                         ], onSelect: (global) => send({ type: "Choose Global", global }) })))),
             snapshot.matches("Ask for allow multiple") && (React.createElement(React.Fragment, null,
                 React.createElement(Box, null,
-                    React.createElement(Text, null, "Should this connection be allowed to be used multiple times?")),
+                    React.createElement(Text, null, snapshot.context.global
+                        ? `${snapshot.context.connectionType === "secret"
+                            ? "Secrets"
+                            : "Tokens"} should be:`
+                        : `A user should be able to:`)),
                 React.createElement(Box, null,
                     React.createElement(Select, { items: [
-                            { value: true, label: "Yes" },
-                            { value: false, label: "No" },
+                            {
+                                value: false,
+                                label: snapshot.context.global
+                                    ? "Limited to one per workspace"
+                                    : `Create only one ${snapshot.context.connectionType === "secret"
+                                        ? "secret"
+                                        : "token"} that remains private`,
+                            },
+                            {
+                                value: true,
+                                label: snapshot.context.global
+                                    ? `Unlimited; users can add multiple ${snapshot.context.connectionType === "secret"
+                                        ? "secrets"
+                                        : "token"} to each workspace`
+                                    : `Create multiple ${snapshot.context.connectionType === "secret"
+                                        ? "secrets"
+                                        : "tokens"} and share them with other users`,
+                            },
                         ], onSelect: (allowMultiple) => send({ type: "Choose Allow Multiple", allowMultiple }) })))),
             snapshot.matches("Ask for Authorize URL") && (React.createElement(React.Fragment, null,
                 React.createElement(Box, null,
+                    React.createElement(Text, null, "e.g. https://authorization-server.com/oauth/authorize")),
+                React.createElement(Box, { marginTop: 1 },
                     React.createElement(Text, null, "OAuth Authorize URL: "),
                     React.createElement(TextInput, { value: snapshot.context.authorizeUrl ?? "", onChange: (authorizeUrl) => send({ type: "Update Authorize URL", authorizeUrl }), onSubmit: () => send({ type: "Submit" }) })))),
             snapshot.matches("Ask for Access Token URL") && (React.createElement(React.Fragment, null,
                 React.createElement(Box, null,
+                    React.createElement(Text, null, "e.g. https://authorization-server.com/oauth/token")),
+                React.createElement(Box, { marginTop: 1 },
                     React.createElement(Text, null, "OAuth Access Token URL: "),
                     React.createElement(TextInput, { value: snapshot.context.accessTokenUrl ?? "", onChange: (accessTokenUrl) => send({ type: "Update Access Token URL", accessTokenUrl }), onSubmit: () => send({ type: "Submit" }) })))),
             snapshot.matches("Ask for Scopes") && (React.createElement(React.Fragment, null,
                 React.createElement(Box, null,
+                    React.createElement(Text, null, "e.g. profile,email,read,write")),
+                React.createElement(Box, { marginTop: 1 },
                     React.createElement(Text, null, "OAuth Scopes: (separated by commas) "),
                     React.createElement(TextInput, { value: snapshot.context.scopes ?? "", onChange: (scopes) => send({ type: "Update Scopes", scopes }), onSubmit: () => send({ type: "Submit" }) })))),
             snapshot.matches("Ask for Client ID") && (React.createElement(React.Fragment, null,

package/lib/graphql/generate-operations.js

@@ -24,7 +24,7 @@ function findGeneratedFiles(dir) {
     for (const entry of entries) {
         const fullPath = path.join(dir, entry.name);
         if (entry.isDirectory()) {
-            files.push(...findGraphQLFiles(fullPath));
+            files.push(...findGeneratedFiles(fullPath));
         }
         else if (entry.isFile() && path.extname(entry.name) === ".graphql.d.ts") {
             files.push(fullPath);
@@ -44,7 +44,7 @@ function generateTypeDefinition(type) {
         return generateTypeDefinition(type.ofType);
     }
     if (isListType(type)) {
-        return `${generateTypeDefinition(type.ofType)}`;
+        return `(${generateTypeDefinition(type.ofType)})[]`;
     }
     if (isObjectType(type) || isInputObjectType(type)) {
         return type.name;
@@ -84,12 +84,18 @@ function generateTypeDefinitionFromSelectionSet(selectionSet, parentType) {
             if (selection.selectionSet) {
                 if (isObjectType(getNamedType(fieldType))) {
                     fieldTypeDefinition = generateTypeDefinitionFromSelectionSet(selection.selectionSet, getNamedType(fieldType));
+                    if (isListType(fieldType)) {
+                        fieldTypeDefinition = `(${fieldTypeDefinition})[]`;
+                    }
                 }
             }
             else {
                 fieldTypeDefinition = generateTypeDefinition(fieldType);
+                if (isListType(fieldType) && !isNonNullType(fieldType.ofType)) {
+                    fieldTypeDefinition = `(${generateTypeDefinition(fieldType.ofType)} | null)[]`;
+                }
             }
-            return `${selection.name.value}: ${fieldTypeDefinition}${isListType(fieldType) ? "[]" : ""}`;
+            return `${selection.name.value}: ${fieldTypeDefinition} ${isNonNullType(fieldType) ? "" : " | null"}`;
         }
         return "";
     })

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

@@ -1,3 +1,4 @@
+import readline from "readline";
 import { assign, setup, fromCallback } from "xstate";
 import { addConnectionDefinition } from "../api/add-connection-definition.js";
 import { fetchConnections } from "../api/fetch-connections.js";
@@ -16,7 +17,7 @@ export const addConnectionMachine = setup({
         input: {},
     },
     actors: {
-        createConnectionDefinition: fromCallback(({ sendBack, input: { developer: { token, slug: devSlug }, config, connectionType: connection_type, slug, label, description, allowMultiple, global, authorizeUrl, accessTokenUrl, clientId, clientSecret, scopes, }, }) => {
+        "createConnectionDefinition": fromCallback(({ sendBack, input: { developer: { token, slug: devSlug }, config, connectionType: connection_type, key, label, description, allowMultiple, global, authorizeUrl, accessTokenUrl, clientId, clientSecret, scopes, }, }) => {
             const add = async () => {
                 try {
                     await addConnectionDefinition({
@@ -25,7 +26,7 @@ export const addConnectionMachine = setup({
                         appId: config.id,
                         major: config.major,
                         connectionType: connection_type,
-                        slug,
+                        key,
                         label,
                         description,
                         allowMultiple,
@@ -50,18 +51,45 @@ export const addConnectionMachine = setup({
         }),
         loadDeveloperConfig,
         loadAppConfig,
-        validateSlug: fromCallback(({ sendBack, input: { slug, developer, config } }) => {
+        "keyboard-navigation": fromCallback(({ sendBack }) => {
+            readline.emitKeypressEvents(process.stdin);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(true);
+            }
+            const handleKeyPress = (_, key) => {
+                if (key.meta) {
+                    switch (key.name) {
+                        case "down":
+                            sendBack({ type: "Next" });
+                            break;
+                        case "up":
+                            sendBack({ type: "Previous" });
+                            break;
+                        default:
+                            break;
+                    }
+                }
+            };
+            process.stdin.on("keypress", handleKeyPress);
+            return () => {
+                process.stdin.removeListener("keypress", handleKeyPress);
+                if (process.stdin.isTTY) {
+                    process.stdin.setRawMode(false);
+                }
+            };
+        }),
+        "validateKey": fromCallback(({ sendBack, input: { key, developer, config } }) => {
             fetchConnections({
                 token: developer.token,
                 devSlug: developer.slug,
                 appId: config.id,
                 major: config.major,
             }).then((connections) => {
-                if (connections[slug]) {
-                    sendBack({ type: "Slug Taken" });
+                if (connections[key]) {
+                    sendBack({ type: "Key Taken" });
                 }
                 else {
-                    sendBack({ type: "Valid Slug" });
+                    sendBack({ type: "Valid Key" });
                 }
             });
         }),
@@ -70,6 +98,21 @@ export const addConnectionMachine = setup({
         clearError: assign({
             error: () => undefined,
         }),
+        initializeLabel: assign({
+            label: (_, params) => {
+                if (params.label?.trim())
+                    return params.label;
+                switch (params.connectionType) {
+                    case "oauth2-code":
+                        return "Connection";
+                    case "secret":
+                    case undefined:
+                        return "Access Token";
+                    default:
+                        return params.connectionType;
+                }
+            },
+        }),
         setError: assign({
             error: (_, params) => params.error,
         }),
@@ -94,8 +137,8 @@ export const addConnectionMachine = setup({
         setDeveloperConfig: assign({
             developer: (_, params) => params,
         }),
-        setSlug: assign({
-            slug: (_, params) => slugifyExtension(params.slug, false),
+        setKey: assign({
+            key: (_, params) => slugifyExtension(params.key, false),
         }),
         setInvalidAuthorizeUrl: assign({
             error: (_, params) => {
@@ -151,13 +194,16 @@ export const addConnectionMachine = setup({
         setAppConfig: assign({
             config: (_, params) => params.config,
         }),
-        setSlugTaken: assign({
-            error: () => "Slug taken",
+        setKeyTaken: assign({
+            error: () => "Key taken",
+        }),
+        slugifyLabel: assign({
+            key: (_, params) => slugifyExtension(params.label, true),
         }),
     },
     guards: {
         "have connection type": (_, params) => Boolean(params.connectionType),
-        "have slug": (_, params) => Boolean(params.slug),
+        "have key": (_, params) => Boolean(params.key),
         "have label": (_, params) => Boolean(params.label),
         "have description": (_, params) => Boolean(params.description),
         "have authorize url": (_, params) => params.connectionType === "secret" ||
@@ -208,12 +254,11 @@ export const addConnectionMachine = setup({
                     target: "Error",
                     actions: { type: "setError", params: ({ event }) => event },
                 },
-                "App Config Loaded": [
-                    {
-                        target: "Do we have a slug?",
-                        actions: { type: "setAppConfig", params: ({ event }) => event },
-                    },
-                ],
+                "App Config Loaded": {
+                    target: "Do we have a connection type?",
+                    actions: { type: "setAppConfig", params: ({ event }) => event },
+                    reenter: true,
+                },
             },
         },
         "Error": {
@@ -235,7 +280,7 @@ export const addConnectionMachine = setup({
                     allowMultiple: context.allowMultiple,
                     label: context.label,
                     description: context.description,
-                    slug: context.slug,
+                    key: context.key,
                 }),
             },
             on: {
@@ -258,12 +303,18 @@ export const addConnectionMachine = setup({
                     {
                         target: "Do we have an access token url?",
                         guard: { type: "have authorize url", params: ({ context }) => context },
+                        actions: "clearError",
                     },
                     {
                         target: "Ask for Authorize URL",
                         actions: { type: "setInvalidAuthorizeUrl", params: ({ context }) => context },
                     },
                 ],
+                "Previous": "Ask for allow multiple",
+                "Next": {
+                    target: "Ask for Access Token URL",
+                    guard: { type: "have authorize url", params: ({ context }) => context },
+                },
             },
         },
         "Ask for Access Token URL": {
@@ -272,6 +323,7 @@ export const addConnectionMachine = setup({
                     {
                         target: "Do we have scopes?",
                         guard: { type: "have access token url", params: ({ context }) => context },
+                        actions: "clearError",
                     },
                     {
                         target: "Ask for Access Token URL",
@@ -281,6 +333,11 @@ export const addConnectionMachine = setup({
                 "Update Access Token URL": {
                     actions: { type: "setAccessTokenUrl", params: ({ event }) => event },
                 },
+                "Previous": "Ask for Authorize URL",
+                "Next": {
+                    target: "Ask for Scopes",
+                    guard: { type: "have access token url", params: ({ context }) => context },
+                },
             },
         },
         "Ask for Scopes": {
@@ -292,12 +349,18 @@ export const addConnectionMachine = setup({
                     {
                         target: "Do we have a client id?",
                         guard: { type: "have scopes", params: ({ context }) => context },
+                        actions: "clearError",
                     },
                     {
                         target: "Ask for Scopes",
                         actions: { type: "setInvalidScopes", params: ({ context }) => context },
                     },
                 ],
+                "Previous": "Ask for Access Token URL",
+                "Next": {
+                    target: "Ask for Client ID",
+                    guard: { type: "have scopes", params: ({ context }) => context },
+                },
             },
         },
         "Ask for Client ID": {
@@ -309,12 +372,18 @@ export const addConnectionMachine = setup({
                     {
                         target: "Do we have a client secret?",
                         guard: { type: "have client id", params: ({ context }) => context },
+                        actions: "clearError",
                     },
                     {
                         target: "Ask for Client ID",
                         actions: { type: "setInvalidClientId", params: ({ context }) => context },
                     },
                 ],
+                "Previous": "Ask for Scopes",
+                "Next": {
+                    target: "Ask for Client Secret",
+                    guard: { type: "have client id", params: ({ context }) => context },
+                },
             },
         },
         "Ask for Client Secret": {
@@ -326,8 +395,14 @@ export const addConnectionMachine = setup({
                     {
                         target: "Creating connection definition",
                         guard: { type: "have client secret", params: ({ context }) => context },
+                        actions: "clearError",
+                    },
+                    {
+                        target: "Ask for Client Secret",
+                        actions: { type: "setInvalidClientSecret", params: ({ context }) => context },
                     },
                 ],
+                "Previous": "Ask for Client ID",
             },
         },
         "Do we have an authorize url?": {
@@ -385,49 +460,58 @@ export const addConnectionMachine = setup({
                 },
             ],
         },
-        "Do we have a slug?": {
+        "Do we have a key?": {
             always: [
                 {
-                    target: "Validating Slug",
-                    guard: { type: "have slug", params: ({ context }) => context },
+                    target: "Validating Key",
+                    guard: { type: "have key", params: ({ context }) => context },
                 },
                 {
-                    target: "Ask for slug",
+                    target: "Ask for key",
+                    actions: {
+                        type: "slugifyLabel",
+                        params: ({ context }) => ({ label: context.label }),
+                    },
                 },
             ],
         },
-        "Validating Slug": {
+        "Validating Key": {
             on: {
-                "Slug Taken": {
-                    target: "Ask for slug",
-                    actions: "setSlugTaken",
+                "Key Taken": {
+                    target: "Ask for key",
+                    actions: "setKeyTaken",
                 },
-                "Valid Slug": {
-                    target: "Do we have a label?",
+                "Valid Key": {
+                    target: "Do we have a description?",
+                    reenter: true,
+                    actions: "clearError",
                 },
             },
             invoke: {
-                src: "validateSlug",
+                src: "validateKey",
                 input: ({ context }) => ({
-                    slug: context.slug,
+                    key: context.key,
                     developer: context.developer,
                     config: context.config,
                 }),
             },
         },
-        "Ask for slug": {
+        "Ask for key": {
             on: {
-                "Update Slug": {
-                    actions: { type: "setSlug", params: ({ event }) => event },
+                "Update Key": {
+                    actions: { type: "setKey", params: ({ event }) => event },
                 },
-                "Submit": "Validating Slug",
+                "Submit": "Validating Key",
+                "Previous": "Ask for label",
+                "Next": "Validating Key",
             },
         },
         "Do we have a connection type?": {
             always: [
                 {
-                    target: "Split on connection type",
+                    target: "Do we have a label?",
                     guard: { type: "have connection type", params: ({ context }) => context },
+                    reenter: true,
                 },
                 "Ask for connection type",
             ],
@@ -435,8 +519,13 @@ export const addConnectionMachine = setup({
         "Ask for connection type": {
             on: {
                 "Choose Connection Type": {
-                    target: "Split on connection type",
-                    actions: { type: "setConnectionType", params: ({ event }) => event },
+                    target: "Do we have a label?",
+                    actions: [{ type: "setConnectionType", params: ({ event }) => event }],
+                    reenter: true,
+                },
+                "Next": {
+                    target: "Ask for label",
+                    guard: { type: "have connection type", params: ({ context }) => context },
                 },
             },
         },
@@ -454,8 +543,9 @@ export const addConnectionMachine = setup({
         "Do we have a label?": {
             always: [
                 {
-                    target: "Do we have a description?",
+                    target: "Do we have a key?",
                     guard: { type: "have label", params: ({ context }) => context },
+                    reenter: true,
                 },
                 {
                     target: "Ask for label",
@@ -487,8 +577,9 @@ export const addConnectionMachine = setup({
         "Do we have allow multiple?": {
             always: [
                 {
-                    target: "Do we have a connection type?",
+                    target: "Split on connection type",
                     guard: { type: "have allow multiple", params: ({ context }) => context },
+                    reenter: true,
                 },
                 {
                     target: "Ask for allow multiple",
@@ -498,13 +589,25 @@ export const addConnectionMachine = setup({
         "Ask for label": {
             on: {
                 "Submit": {
-                    target: "Do we have a description?",
+                    target: "Do we have a key?",
                     guard: { type: "have label", params: ({ context }) => context },
+                    reenter: true,
                 },
                 "Update Label": {
                     actions: { type: "setLabel", params: ({ event }) => event },
                 },
+                "Previous": "Ask for connection type",
+                "Next": {
+                    target: "Ask for key",
+                    guard: { type: "have label", params: ({ context }) => context },
+                },
             },
+            entry: [
+                {
+                    type: "initializeLabel",
+                    params: ({ context }) => context,
+                },
+            ],
         },
         "Ask for description": {
             on: {
@@ -514,6 +617,12 @@ export const addConnectionMachine = setup({
                 "Submit": {
                     target: "Do we have global?",
                     guard: { type: "have description", params: ({ context }) => context },
+                    actions: "clearError",
+                },
+                "Previous": "Ask for key",
+                "Next": {
+                    target: "Ask for global",
+                    guard: { type: "have description", params: ({ context }) => context },
                 },
             },
         },
@@ -523,16 +632,30 @@ export const addConnectionMachine = setup({
                     target: "Do we have allow multiple?",
                     actions: { type: "setGlobal", params: ({ event }) => event },
                 },
+                "Previous": "Ask for description",
+                "Next": {
+                    target: "Ask for allow multiple",
+                    guard: { type: "have global", params: ({ context }) => context },
+                },
             },
         },
         "Ask for allow multiple": {
             on: {
                 "Choose Allow Multiple": {
-                    target: "Do we have a connection type?",
+                    target: "Split on connection type",
                     actions: { type: "setAllowMultiple", params: ({ event }) => event },
+                    reenter: true,
+                },
+                "Previous": "Ask for global",
+                "Next": {
+                    target: "Split on connection type",
+                    guard: { type: "have allow multiple", params: ({ context }) => context },
                 },
             },
         },
     },
     initial: "Loading Developer Config",
+    invoke: {
+        src: "keyboard-navigation",
+    },
 });

package/lib/util/find-available-port.js

@@ -1,21 +1,26 @@
 import net from "net";
-export async function findAvailablePort(startPort) {
-    return new Promise((resolve, reject) => {
-        const server = net.createServer();
-        const tryPort = (port) => {
-            server.once("error", (err) => {
-                if (err.code === "EADDRINUSE") {
-                    tryPort(port + 1);
-                }
-                else {
-                    reject(err);
-                }
-            });
-            server.once("listening", () => {
-                server.close(() => resolve(port));
-            });
-            server.listen(port);
-        };
-        tryPort(startPort);
+async function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const tester = net.createConnection(port, "127.0.0.1");
+        tester.once("error", (err) => {
+            if (err.code === "ECONNREFUSED") {
+                resolve(true);
+            }
+            else {
+                resolve(false);
+            }
+        });
+        tester.once("connect", () => {
+            tester.end();
+            resolve(false);
+        });
     });
 }
+export async function findAvailablePort(startPort, maxAttempts = 100) {
+    for (let port = startPort; port < startPort + maxAttempts; port++) {
+        if (await isPortAvailable(port)) {
+            return port;
+        }
+    }
+    throw new Error(`Could not find an available port after ${maxAttempts} attempts`);
+}

package/lib/util/slugify-extension.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attio",
-  "version": "0.0.1-experimental.20241003.1",
+  "version": "0.0.1-experimental.20241007.1",
   "bin": "lib/attio.js",
   "type": "module",
   "files": [

package/schema.graphql

@@ -88,6 +88,7 @@ type PeopleRecord implements Record {
   last_email_interaction: Interaction
   first_interaction: Interaction
   last_interaction: Interaction
+  next_interaction: Interaction
   associated_deals: [DealsRecord!]
   associated_users: [UsersRecord!]
   list_entries: [Record!]
@@ -106,7 +107,7 @@ interface Record {
   url: String!
 }
 
-union AttributeValue = RecordReferenceValue | MultiRecordReferenceValue | PersonalNameValue | MultiPersonalNameValue | TextValue | MultiTextValue | DateValue | MultiDateValue | TimestampValue | MultiTimestampValue | NumberValue | MultiNumberValue | EmailAddressValue | MultiEmailAddressValue | DomainValue | MultiDomainValue | LocationValue | MultiLocationValue | InteractionValue | MultiInteractionValue | SelectValue | MultiSelectValue | PipelineValue | MultiPipelineValue | CheckboxValue | MultiCheckboxValue | RatingValue | MultiRatingValue | PhoneNumberValue | MultiPhoneNumberValue | CurrencyValue | MultiCurrencyValue | ActorReferenceValue | MultiActorReferenceValue
+union AttributeValue = RecordReferenceValue | MultiRecordReferenceValue | PersonalNameValue | TextValue | DateValue | TimestampValue | NumberValue | MultiEmailAddressValue | DomainValue | MultiDomainValue | LocationValue | InteractionValue | SelectValue | MultiSelectValue | PipelineValue | CheckboxValue | RatingValue | PhoneNumberValue | MultiPhoneNumberValue | CurrencyValue | ActorReferenceValue | MultiActorReferenceValue
 
 type RecordReferenceValue {
   value: Record
@@ -126,46 +127,22 @@ type PersonalName {
   full: String
 }
 
-type MultiPersonalNameValue {
-  values: [PersonalName]
-}
-
 type TextValue {
   value: String
 }
 
-type MultiTextValue {
-  values: [String]
-}
-
 type DateValue {
   value: String
 }
 
-type MultiDateValue {
-  values: [String]
-}
-
 type TimestampValue {
   value: String
 }
 
-type MultiTimestampValue {
-  values: [String]
-}
-
 type NumberValue {
   value: Float
 }
 
-type MultiNumberValue {
-  values: [Float]
-}
-
-type EmailAddressValue {
-  value: String
-}
-
 type MultiEmailAddressValue {
   values: [String]
 }
@@ -195,10 +172,6 @@ type Location {
   longitude: String
 }
 
-type MultiLocationValue {
-  values: [Location]
-}
-
 type InteractionValue {
   value: Interaction
 }
@@ -207,10 +180,6 @@ type Interaction {
   timestamp: String!
 }
 
-type MultiInteractionValue {
-  values: [Interaction]
-}
-
 type SelectValue {
   value: SelectOption
 }
@@ -233,26 +202,14 @@ type PipelineStage {
   id: String!
 }
 
-type MultiPipelineValue {
-  values: [PipelineStage]
-}
-
 type CheckboxValue {
   value: Boolean!
 }
 
-type MultiCheckboxValue {
-  values: [Boolean!]
-}
-
 type RatingValue {
   value: Int!
 }
 
-type MultiRatingValue {
-  values: [Int!]
-}
-
 type PhoneNumberValue {
   value: String
 }
@@ -270,10 +227,6 @@ type Money {
   currency: String!
 }
 
-type MultiCurrencyValue {
-  values: [Money]
-}
-
 type ActorReferenceValue {
   value: Actor
 }
@@ -328,6 +281,7 @@ type CompaniesRecord implements Record {
   last_email_interaction: Interaction
   first_interaction: Interaction
   last_interaction: Interaction
+  next_interaction: Interaction
   associated_deals: [DealsRecord!]
   associated_workspaces: [WorkspacesRecord!]
   list_entries: [Record!]