attio 0.0.1-experimental.20240925 → 0.0.1-experimental.20240926.1

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

@@ -7,14 +7,18 @@ const addConnectionSchema = z.object({
     app_id: z.string(),
     connection_definition_id: z.string(),
 });
-export async function addConnectionDefinition({ token, devSlug, appId, connection, clientId, clientSecret, authorizeUrl, accessTokenUrl, scopes, }) {
+export async function addConnectionDefinition({ token, devSlug, appId, slug, label, description, allowMultiple, global, connectionType, clientId, clientSecret, authorizeUrl, accessTokenUrl, major, scopes, }) {
     const connectionDefinitionId = uuid();
     const body = {
-        connection_type: connection.connection_type,
-        audience: connection.audience,
-        major: 1,
+        connection_type: connectionType,
+        slug,
+        label,
+        description,
+        allow_multiple: allowMultiple,
+        global,
+        major,
     };
-    if (connection.connection_type === "oauth2-code") {
+    if (connectionType === "oauth2-code") {
         body.authorize_url = authorizeUrl;
         body.access_token_url = accessTokenUrl;
         body.client_id = clientId;

package/lib/api/fetch-connections.js

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

package/lib/api/start-graphql-server.js

@@ -0,0 +1,32 @@
+import { graphqlServer } from "@hono/graphql-server";
+import { serve } from "@hono/node-server";
+import fs from "fs";
+import { buildSchema } from "graphql";
+import { Hono } from "hono";
+import path, { dirname } from "path";
+import { fileURLToPath } from "url";
+import { findAvailablePort } from "../util/find-available-port.js";
+export function startGraphqlServer(sendBack) {
+    let server = null;
+    const startServer = async () => {
+        const currentFilePath = fileURLToPath(import.meta.url);
+        const currentDirPath = dirname(currentFilePath);
+        const schemaPath = path.resolve(currentDirPath, "..", "schema.graphql");
+        const schemaString = fs.readFileSync(schemaPath, "utf8");
+        const port = await findAvailablePort(8700);
+        const schema = buildSchema(schemaString);
+        const app = new Hono();
+        const rootResolver = () => {
+            return {};
+        };
+        app.use("/graphql", graphqlServer({ schema, rootResolver, graphiql: true }));
+        server = serve({ fetch: app.fetch, port });
+        sendBack({ type: "GraphQL Server Started", port });
+    };
+    startServer();
+    return () => {
+        if (!server)
+            return;
+        server.close();
+    };
+}

package/lib/client/forms/build.d.ts

@@ -14,7 +14,7 @@ export interface Form<TSchema> {
     }) => JSX.Element;
     Input: React.FC<{
         label: string;
-        data: PathTo<TSchema, "string" | "number">;
+        data: PathTo<TSchema, "string" | "number" | "connection">;
         placeholder?: string;
         disabled?: boolean;
     }>;

package/lib/client/forms/connection.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A connection form value.
+ */
+export interface FormConnection {
+    type: "connection";
+    isOptional: boolean;
+    optional(): FormConnection;
+}
+export interface Connection {
+    connectionId: string;
+}
+/**
+ * Create a new connection form value.
+ */
+export declare function connection({ connectionSlug }: {
+    connectionSlug: string;
+}): FormConnection;

package/lib/client/forms/index.d.ts

@@ -2,3 +2,4 @@ export { build } from "./build";
 export { array } from "./array";
 export { number } from "./number";
 export { string } from "./string";
+export { connection } from "./connection";

package/lib/client/forms/path.d.ts

@@ -1,11 +1,12 @@
 import { Prettify } from "../util/prettify";
 import { FormArray } from "./array";
+import { FormConnection, Connection } from "./connection";
 import { FormNumber } from "./number";
 import { FormString } from "./string";
 type Assert<TCat, TAnimal> = TCat extends TAnimal ? TCat : never;
 type Join<A extends string | number | null, B extends string | number> = A extends null ? B : `${A}.${B}`;
-export type ValueType = "string" | "number" | "array";
-export type SchemaNode = FormString | FormNumber | FormArray<any> | {
+export type ValueType = "string" | "number" | "array" | "connection";
+export type SchemaNode = FormString | FormNumber | FormConnection | FormArray<any> | {
     type: "object";
 };
 type PathWithTypeRecursive<TState, TRoot extends string | number | null> = TState extends FormString ? {
@@ -14,6 +15,9 @@ type PathWithTypeRecursive<TState, TRoot extends string | number | null> = TStat
 } : TState extends FormNumber ? {
     path: TRoot;
     type: "number";
+} : TState extends FormConnection ? {
+    path: TRoot;
+    type: "connection";
 } : TState extends FormArray<infer TElement> ? {
     path: TRoot;
     type: "array";
@@ -28,7 +32,7 @@ export type Path<TState> = PathWithType<TState>["path"];
 export type PathTo<TState, TType extends ValueType> = Extract<PathWithType<TState>, {
     type: TType;
 }>["path"];
-export type ValueOf<TState> = TState extends FormString ? string : TState extends FormNumber ? number : TState extends FormArray<infer TElement> ? Array<ValueOf<TElement>> : {
+export type ValueOf<TState> = TState extends FormString ? string : TState extends FormNumber ? number : TState extends FormConnection ? Connection : TState extends FormArray<infer TElement> ? Array<ValueOf<TElement>> : {
     [K in keyof TState]: K extends string ? ValueOf<TState[K]> : never;
 };
 export {};

package/lib/client/index.d.ts

@@ -4,5 +4,6 @@ export * as Forms from "./forms/index.js";
 export { FormArray } from "./forms/array.js";
 export { FormNumber } from "./forms/number.js";
 export { FormString } from "./forms/string.js";
+export { FormConnection, Connection } from "./forms/connection.js";
 export * from "./forms/path.js";
 export { Form } from "./forms/build.js";

package/lib/commands/connection/add.js

@@ -8,17 +8,27 @@ import { z } from "zod";
 import { InitialInstructions } from "../../components/InitialInstructions.js";
 import { Logo } from "../../components/Logo.js";
 import { Select } from "../../components/Select.js";
-import { addConnectionMachine, audiences, connectionTypes, } from "../../machines/add-connection-machine.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
+        .string()
+        .optional()
+        .describe(option({ description: "A unique slug for your connection" })),
+    label: z
+        .string()
+        .optional()
+        .describe(option({ description: "The label for your connection that will be displayed to users" })),
+    description: z
+        .string()
+        .optional()
+        .describe(option({
+        description: "A more detailed description of your connection that will be displayed to users",
+    })),
     type: z
         .enum(["secret", "oauth2-code"])
         .optional()
         .describe(option({ description: "The type of connection to create" })),
-    audience: z
-        .enum(["workspace", "workspace-member"])
-        .optional()
-        .describe(option({ description: "The audience for the connection" })),
     authorizeUrl: z
         .string()
         .url("Invalid URL, e.g. https://authorization-server.com/authorize")
@@ -51,11 +61,13 @@ export const options = z.object({
         .default(false)
         .describe(option({ description: "Run in development mode (additional debugging info)" })),
 });
-export default function AddConnection({ options: { type: connectionType, audience, authorizeUrl, accessTokenUrl, scopes, clientId, clientSecret, dev, }, }) {
+export default function AddConnection({ options: { slug, label, description, type: connectionType, authorizeUrl, accessTokenUrl, scopes, clientId, clientSecret, dev, }, }) {
     const [snapshot, send] = useMachine(addConnectionMachine, {
         input: {
+            slug,
+            label,
+            description,
             connectionType,
-            audience,
             authorizeUrl,
             accessTokenUrl,
             scopes,
@@ -69,22 +81,41 @@ export default function AddConnection({ options: { type: connectionType, audienc
         React.createElement(Logo, null),
         React.createElement(Box, { flexDirection: "column" },
             snapshot.matches("Show config instructions") && (React.createElement(InitialInstructions, { reason: snapshot.context.configError })),
-            snapshot.matches("Already have a connection") && (React.createElement(React.Fragment, null,
+            snapshot.matches("Ask for slug") && (React.createElement(React.Fragment, null,
                 React.createElement(Box, null,
-                    React.createElement(Text, { color: "redBright" }, "This app already has a connection."),
-                    React.createElement(Text, null, " To change it, you first must remove it with:")),
-                React.createElement(Box, { flexDirection: "column", borderStyle: "round", width: 27, paddingX: 1, marginBottom: 1 },
-                    React.createElement(Text, null, "attio connection remove")))),
+                    React.createElement(Text, null, "Unique Slug: "),
+                    React.createElement(TextInput, { value: snapshot.context.slug ?? "", placeholder: "my-access-token", onChange: (slug) => send({ type: "Update Slug", slug }), 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(TextInput, { value: snapshot.context.label ?? "", placeholder: "My Awesome Connection", 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(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,
                     React.createElement(Text, null, "What type of connection will this be?")),
                 React.createElement(Box, null,
                     React.createElement(Select, { items: connectionTypes, onSelect: (connectionType) => send({ type: "Choose Connection Type", connectionType }) })))),
-            snapshot.matches("Ask for audience") && (React.createElement(React.Fragment, null,
+            snapshot.matches("Ask for global") && (React.createElement(React.Fragment, null,
+                React.createElement(Box, null,
+                    React.createElement(Text, null, "Should users of your app be allowed to add multiple connections?")),
+                React.createElement(Box, null,
+                    React.createElement(Select, { items: [
+                            { value: true, label: "Yes" },
+                            { value: false, label: "No" },
+                        ], 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, "What is the audience of this connection?")),
+                    React.createElement(Text, null, "Should this connection be allowed to be used multiple times?")),
                 React.createElement(Box, null,
-                    React.createElement(Select, { items: audiences, onSelect: (audience) => send({ type: "Choose Audience", audience }) })))),
+                    React.createElement(Select, { items: [
+                            { value: true, label: "Yes" },
+                            { value: false, label: "No" },
+                        ], 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, "OAuth Authorize URL: "),

package/lib/commands/dev.js

@@ -88,7 +88,9 @@ export default function Dev({ options: { debug } }) {
                     React.createElement(Text, { color: "redBright" }, "\u274C Upload Error"),
                     React.createElement(Text, null,
                         "\u2013 ",
-                        snapshot.context.uploadError?.message))))),
+                        snapshot.context.uploadError?.message)))),
+            snapshot.matches({ Watching: { Graphql: "Started" } }) && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+                React.createElement(Text, null, "Press \"o\" to open GraphQL Explorer")))),
         hasErrors && (React.createElement(ScrollBox, { borderStyle: "round", padding: 1 },
             jsError && renderBuildErrors(jsError),
             tsErrors && renderTypeScriptErrors(tsErrors)))));