attio 0.0.1-experimental.20241008.1 → 0.0.1-experimental.20241008.3

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

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

package/lib/api/fetch-connections.js

@@ -8,7 +8,6 @@ const connectionDefinitionsResponseSchema = z.object({
         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, }) {

package/lib/commands/connection/add.js

@@ -29,7 +29,6 @@ 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")
@@ -62,7 +61,7 @@ export const options = z.object({
         .default(false)
         .describe(option({ description: "Run in development mode (additional debugging info)" })),
 });
-export default function AddConnection({ options: { key, label, description, type: connectionType, authorizeUrl, accessTokenUrl, allowMultiple, scopes, clientId, clientSecret, dev, }, }) {
+export default function AddConnection({ options: { key, label, description, type: connectionType, authorizeUrl, accessTokenUrl, scopes, clientId, clientSecret, dev, }, }) {
     const [snapshot, send] = useMachine(addConnectionMachine, {
         input: {
             key,
@@ -71,7 +70,6 @@ export default function AddConnection({ options: { key, label, description, type
             connectionType,
             authorizeUrl,
             accessTokenUrl,
-            allowMultiple,
             scopes,
             clientId,
             clientSecret,
@@ -203,34 +201,6 @@ export default function AddConnection({ options: { key, label, description, type
                             { 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, 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: 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")),

package/lib/commands/connection/list.js

@@ -43,10 +43,9 @@ export default function ListConnections({ options: { dev } }) {
             snapshot.context.connections &&
             snapshot.context.connections && (React.createElement(Box, null,
             React.createElement(Table, { rows: Object.entries(snapshot.context.connections).map(([slug, connection]) => ({
-                    "Slug": slug,
-                    "Label": connection.label,
-                    "Global": connection.global ? "Yes" : "No",
-                    "Allow Multiple": connection.allow_multiple ? "Yes" : "No",
-                    "Type": connectionTypeNames[connection.connection_type],
+                    Slug: slug,
+                    Label: connection.label,
+                    Global: connection.global ? "Yes" : "No",
+                    Type: connectionTypeNames[connection.connection_type],
                 })) })))));
 }

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

@@ -17,7 +17,7 @@ export const addConnectionMachine = setup({
         input: {},
     },
     actors: {
-        "createConnectionDefinition": fromCallback(({ sendBack, input: { developer: { token, slug: devSlug }, config, connectionType: connection_type, key, label, description, allowMultiple, global, authorizeUrl, accessTokenUrl, clientId, clientSecret, scopes, }, }) => {
+        "createConnectionDefinition": fromCallback(({ sendBack, input: { developer: { token, slug: devSlug }, config, connectionType: connection_type, key, label, description, global, authorizeUrl, accessTokenUrl, clientId, clientSecret, scopes, }, }) => {
             const add = async () => {
                 try {
                     await addConnectionDefinition({
@@ -29,7 +29,6 @@ export const addConnectionMachine = setup({
                         key,
                         label,
                         description,
-                        allowMultiple,
                         global,
                         accessTokenUrl,
                         authorizeUrl,
@@ -188,9 +187,6 @@ export const addConnectionMachine = setup({
         setGlobal: assign({
             global: (_, params) => params.global,
         }),
-        setAllowMultiple: assign({
-            allowMultiple: (_, params) => params.allowMultiple,
-        }),
         setAppConfig: assign({
             config: (_, params) => params.config,
         }),
@@ -215,7 +211,6 @@ export const addConnectionMachine = setup({
         "have client id": (_, params) => params.connectionType === "secret" ||
             options.shape.clientId.unwrap().safeParse(params.clientId?.trim()).success,
         "have global": (_, params) => params.global !== undefined,
-        "have allow multiple": (_, params) => params.allowMultiple !== undefined,
         "have client secret": (_, params) => params.connectionType === "secret" ||
             options.shape.clientSecret.unwrap().safeParse(params.clientSecret?.trim()).success,
         "is oauth": (_, params) => params.connectionType === "oauth2-code",
@@ -277,7 +272,6 @@ export const addConnectionMachine = setup({
                     clientId: context.clientId,
                     clientSecret: context.clientSecret,
                     global: context.global,
-                    allowMultiple: context.allowMultiple,
                     label: context.label,
                     description: context.description,
                     key: context.key,
@@ -310,7 +304,7 @@ export const addConnectionMachine = setup({
                         actions: { type: "setInvalidAuthorizeUrl", params: ({ context }) => context },
                     },
                 ],
-                "Previous": "Ask for allow multiple",
+                "Previous": "Ask for global",
                 "Next": {
                     target: "Ask for Access Token URL",
                     guard: { type: "have authorize url", params: ({ context }) => context },
@@ -564,25 +558,14 @@ export const addConnectionMachine = setup({
             ],
         },
         "Do we have global?": {
-            always: [
-                {
-                    target: "Do we have allow multiple?",
-                    guard: { type: "have global", params: ({ context }) => context },
-                },
-                {
-                    target: "Ask for global",
-                },
-            ],
-        },
-        "Do we have allow multiple?": {
             always: [
                 {
                     target: "Split on connection type",
-                    guard: { type: "have allow multiple", params: ({ context }) => context },
+                    guard: { type: "have global", params: ({ context }) => context },
                     reenter: true,
                 },
                 {
-                    target: "Ask for allow multiple",
+                    target: "Ask for global",
                 },
             ],
         },
@@ -629,28 +612,16 @@ export const addConnectionMachine = setup({
         "Ask for global": {
             on: {
                 "Choose Global": {
-                    target: "Do we have allow multiple?",
+                    target: "Split on connection type",
                     actions: { type: "setGlobal", params: ({ event }) => event },
+                    reenter: true,
                 },
                 "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: "Split on connection type",
-                    actions: { type: "setAllowMultiple", params: ({ event }) => event },
+                    guard: { type: "have global", params: ({ context }) => context },
                     reenter: true,
                 },
-                "Previous": "Ask for global",
-                "Next": {
-                    target: "Split on connection type",
-                    guard: { type: "have allow multiple", params: ({ context }) => context },
-                },
             },
         },
     },

package/package.json

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