@automate.ax/api-contract 0.76.0 → 0.77.1

package/src/account.ts

@@ -1,9 +1,87 @@
 import { oc } from "@orpc/contract"
 import * as z from "zod"
+import { cursorPageOutputSchema, cursorPaginationInputSchema } from "./schemas"
 
-export const integrationAccountOutputSchema = z.object({
+const INTEGRATION_FORM_FIELD_SCHEMA = z.discriminatedUnion("input", [
+  z.object({
+    default: z.boolean().optional(),
+    description: z.string().optional(),
+    input: z.literal("boolean"),
+    label: z.string(),
+    name: z.string(),
+    required: z.boolean(),
+  }),
+  z.object({
+    default: z.number().optional(),
+    description: z.string().optional(),
+    input: z.literal("number"),
+    label: z.string(),
+    name: z.string(),
+    placeholder: z.string().optional(),
+    required: z.boolean(),
+  }),
+  z.object({
+    description: z.string().optional(),
+    input: z.literal("password"),
+    label: z.string(),
+    name: z.string(),
+    placeholder: z.string().optional(),
+    required: z.boolean(),
+  }),
+  z.object({
+    default: z.string().optional(),
+    description: z.string().optional(),
+    input: z.enum(["email", "text", "url"]),
+    label: z.string(),
+    name: z.string(),
+    placeholder: z.string().optional(),
+    required: z.boolean(),
+  }),
+])
+
+export const integrationServiceOutputSchema = z.object({
+  connectionMethods: z
+    .discriminatedUnion("type", [
+      z.object({
+        description: z.string().optional(),
+        id: z.string(),
+        name: z.string(),
+        type: z.literal("redirect"),
+      }),
+      z.object({
+        description: z.string().optional(),
+        fields: INTEGRATION_FORM_FIELD_SCHEMA.array(),
+        id: z.string(),
+        name: z.string(),
+        type: z.literal("form"),
+      }),
+    ])
+    .array(),
+  connectionNotice: z
+    .object({
+      action: z.object({ href: z.string(), label: z.string() }),
+      description: z.string(),
+      title: z.string(),
+    })
+    .optional(),
+  description: z.string().optional(),
+  icon: z.string().optional(),
+  id: z.string(),
+  name: z.string(),
+  preferredConnectionMethodId: z.string().optional(),
+})
+
+export const integrationAccountRevocationOutputSchema = z.object({
+  completedAt: z.date().nullable(),
+  error: z.string().nullable(),
+  id: z.string(),
+  requestedAt: z.date(),
+  status: z.enum(["pending", "succeeded", "failed", "unsupported"]),
+})
+
+export const integrationAccountBindingOutputSchema = z.object({
   checkedAt: z.date().nullable(),
-  connectionId: z.string().min(1),
+  connectionMethodId: z.string().min(1),
   error: z
     .object({
       code: z.string(),
@@ -17,11 +95,90 @@ export const integrationAccountOutputSchema = z.object({
   serviceSub: z.string(),
 })
 
+export const integrationAccountOutputSchema =
+  integrationAccountBindingOutputSchema.extend({
+    revokedAt: z.date().nullable(),
+    revocation: integrationAccountRevocationOutputSchema.nullable(),
+    status: z.enum([
+      "active",
+      "revocation_pending",
+      "revocation_failed",
+      "revoked",
+    ]),
+  })
+
+export const integrationAccountRevocationImpactOutputSchema = z.object({
+  accessibleOrganizations: z
+    .object({
+      id: z.string(),
+      name: z.string(),
+      projects: z
+        .object({
+          automations: z
+            .object({
+              enabled: z.boolean(),
+              id: z.string(),
+              identityKey: z.string(),
+            })
+            .array(),
+          id: z.string(),
+          name: z.string(),
+          pendingDeployments: z
+            .object({
+              id: z.string(),
+              status: z.enum([
+                "awaiting_authorization",
+                "configuring",
+                "publishing",
+              ]),
+            })
+            .array(),
+        })
+        .array(),
+    })
+    .array(),
+  account: integrationAccountOutputSchema
+    .pick({
+      id: true,
+      label: true,
+      revokedAt: true,
+      revocation: true,
+      serviceId: true,
+      serviceSub: true,
+      status: true,
+    })
+    .extend({
+      connectionMethodId: z.string(),
+      providerRevocationSupported: z.boolean(),
+    }),
+  hiddenOrganizationCount: z.number().int().nonnegative(),
+  totals: z.object({
+    automations: z.number().int().nonnegative(),
+    organizations: z.number().int().positive(),
+    pendingDeployments: z.number().int().nonnegative(),
+    projects: z.number().int().nonnegative(),
+  }),
+})
+
+const organizationAccountInputSchema = z.object({
+  accountId: z.string(),
+  organizationId: z.string(),
+})
+
 export const accountContract = {
   beginConnection: oc
+    .route({
+      description: "Starts an OAuth-style organization account connection.",
+      method: "POST",
+      operationId: "beginIntegrationAccountConnection",
+      path: "/organizations/{organizationId}/integration-account-connections",
+      successStatus: 201,
+      summary: "Begin integration account connection",
+      tags: ["Integration Accounts"],
+    })
     .input(
       z.object({
-        connectionId: z.string().min(1),
+        connectionMethodId: z.string().min(1),
         organizationId: z.string(),
         scopes: z.string().array().default([]),
         serviceId: z.string().min(1),
@@ -29,6 +186,14 @@ export const accountContract = {
     )
     .output(z.object({ flowId: z.string(), url: z.url() })),
   connectionStatus: oc
+    .route({
+      description: "Returns the current state of a redirect connection flow.",
+      method: "GET",
+      operationId: "getIntegrationAccountConnection",
+      path: "/organizations/{organizationId}/integration-account-connections/{flowId}",
+      summary: "Get integration account connection",
+      tags: ["Integration Accounts"],
+    })
     .input(
       z.object({
         flowId: z.string(),
@@ -38,27 +203,107 @@ export const accountContract = {
     .output(
       z.discriminatedUnion("status", [
         z.object({ status: z.literal("pending") }),
-        z.object({ status: z.literal("succeeded") }),
+        z.object({
+          accountId: z.string().nullable(),
+          status: z.literal("succeeded"),
+        }),
         z.object({ message: z.string(), status: z.literal("failed") }),
       ]),
     ),
-  delete: oc
-    .input(
+  disconnect: oc
+    .route({
+      description:
+        "Removes an integration account from one organization without revoking it elsewhere.",
+      method: "DELETE",
+      operationId: "disconnectIntegrationAccount",
+      path: "/organizations/{organizationId}/integration-accounts/{accountId}",
+      summary: "Disconnect integration account",
+      tags: ["Integration Accounts"],
+    })
+    .input(organizationAccountInputSchema)
+    .output(z.object({ txid: z.number().int().nonnegative() })),
+  get: oc
+    .route({
+      description: "Returns one integration account linked to an organization.",
+      method: "GET",
+      operationId: "getIntegrationAccount",
+      path: "/organizations/{organizationId}/integration-accounts/{accountId}",
+      summary: "Get integration account",
+      tags: ["Integration Accounts"],
+    })
+    .input(organizationAccountInputSchema)
+    .output(integrationAccountOutputSchema),
+  list: oc
+    .route({
+      description: "Lists integration accounts linked to an organization.",
+      method: "GET",
+      operationId: "listIntegrationAccounts",
+      path: "/organizations/{organizationId}/integration-accounts",
+      summary: "List integration accounts",
+      tags: ["Integration Accounts"],
+    })
+    .input(cursorPaginationInputSchema.extend({ organizationId: z.string() }))
+    .output(
+      cursorPageOutputSchema(
+        integrationAccountOutputSchema.extend({ createdAt: z.date() }),
+      ),
+    ),
+  listServices: oc
+    .route({
+      description:
+        "Lists enabled integration services and their connection methods.",
+      method: "GET",
+      operationId: "listIntegrationServices",
+      path: "/integration-services",
+      summary: "List integration services",
+      tags: ["Integration Accounts"],
+    })
+    .input(z.object({}).default({}))
+    .output(integrationServiceOutputSchema.array()),
+  revocationImpact: oc
+    .route({
+      description:
+        "Previews platform-wide revocation while redacting inaccessible organizations.",
+      method: "GET",
+      operationId: "getIntegrationAccountRevocationImpact",
+      path: "/organizations/{organizationId}/integration-accounts/{accountId}/revocation-impact",
+      summary: "Preview integration account revocation",
+      tags: ["Integration Accounts"],
+    })
+    .input(organizationAccountInputSchema)
+    .output(integrationAccountRevocationImpactOutputSchema),
+  revoke: oc
+    .route({
+      description:
+        "Immediately blocks and globally revokes a shared integration account.",
+      method: "POST",
+      operationId: "revokeIntegrationAccount",
+      path: "/organizations/{organizationId}/integration-accounts/{accountId}/revoke",
+      successStatus: 202,
+      summary: "Revoke integration account",
+      tags: ["Integration Accounts"],
+    })
+    .input(organizationAccountInputSchema)
+    .output(
       z.object({
-        accountId: z.string(),
-        organizationId: z.string(),
+        revocation: integrationAccountRevocationOutputSchema,
+        txid: z.number().int().nonnegative(),
       }),
-    )
-    .output(z.object({ txid: z.number().int().nonnegative() })),
-  get: oc.input(z.object({ organizationId: z.string() })).output(
-    z.object({
-      accounts: integrationAccountOutputSchema.array(),
-    }),
-  ),
+    ),
   submitCredentials: oc
+    .route({
+      description:
+        "Validates secret form credentials and links the resulting account.",
+      method: "POST",
+      operationId: "connectIntegrationAccountCredentials",
+      path: "/organizations/{organizationId}/integration-account-credentials",
+      successStatus: 201,
+      summary: "Connect integration account credentials",
+      tags: ["Integration Accounts"],
+    })
     .input(
       z.object({
-        connectionId: z.string().min(1),
+        connectionMethodId: z.string().min(1),
         data: z.record(
           z.string(),
           z.union([z.string(), z.number(), z.boolean()]),
@@ -67,5 +312,5 @@ export const accountContract = {
         serviceId: z.string().min(1),
       }),
     )
-    .output(z.void()),
+    .output(z.object({ accountId: z.string() })),
 }

package/src/api-key.ts

@@ -1,6 +1,10 @@
 import { oc } from "@orpc/contract"
 import * as z from "zod"
-import { reasonableNameSchema } from "./schemas"
+import {
+  cursorPageOutputSchema,
+  cursorPaginationInputSchema,
+  reasonableNameSchema,
+} from "./schemas"
 
 export const organizationApiKeyOutputSchema = z.object({
   id: z.string(),
@@ -59,8 +63,8 @@ export const apiKeyContract = {
         "Lists API keys owned by an organization. Requires apiKey:read.",
       tags: ["API Keys"],
     })
-    .input(z.object({ organizationId: z.string() }))
-    .output(organizationApiKeyOutputSchema.array()),
+    .input(cursorPaginationInputSchema.extend({ organizationId: z.string() }))
+    .output(cursorPageOutputSchema(organizationApiKeyOutputSchema)),
   update: oc
     .route({
       method: "PATCH",

package/src/authorization.ts

@@ -22,7 +22,7 @@ export const authorizationContract = {
     .input(
       z.object({
         binding: z.string().min(1),
-        connectionId: z.string().min(1),
+        connectionMethodId: z.string().min(1),
         deploymentId: z.string(),
         serviceId: z.string().min(1),
       }),
@@ -47,6 +47,15 @@ export const authorizationContract = {
       }),
     ),
   get: oc
+    .route({
+      method: "GET",
+      path: "/deployments/{deploymentId}/authorization",
+      operationId: "getDeploymentAuthorization",
+      summary: "Get deployment authorization",
+      description:
+        "Returns connected accounts and the authorization requirements for a deployment.",
+      tags: ["Deployments"],
+    })
     .input(
       z.object({
         deploymentId: z.string(),
@@ -57,7 +66,7 @@ export const authorizationContract = {
         accounts: z
           .object({
             checkedAt: z.date().nullable(),
-            connectionId: z.string().min(1),
+            connectionMethodId: z.string().min(1),
             error: z
               .object({
                 code: z.string(),
@@ -77,7 +86,7 @@ export const authorizationContract = {
             binding: z.string(),
             connections: z
               .object({
-                connectionId: z.string().min(1),
+                connectionMethodId: z.string().min(1),
                 minimalScopes: z.string().array(),
                 requiredScopes: SCOPE_REQUIREMENT_SCHEMA.array(),
               })
@@ -91,13 +100,22 @@ export const authorizationContract = {
       }),
     ),
   proceed: oc
+    .route({
+      method: "POST",
+      path: "/deployments/{deploymentId}/authorization/proceed",
+      operationId: "proceedWithDeploymentAuthorization",
+      summary: "Proceed with deployment authorization",
+      description:
+        "Continues a deployment after every integration requirement is satisfied.",
+      tags: ["Deployments"],
+    })
     .input(z.object({ deploymentId: z.string() }))
     .output(z.object({ txid: z.number().int().nonnegative() })),
   submitCredentials: oc
     .input(
       z.object({
         binding: z.string().min(1),
-        connectionId: z.string().min(1),
+        connectionMethodId: z.string().min(1),
         data: z.record(
           z.string(),
           z.union([z.string(), z.number(), z.boolean()]),

package/src/automation.ts

@@ -1,24 +1,81 @@
 import { encodableSchema } from "@automate.ax/codec"
 import { oc } from "@orpc/contract"
 import * as z from "zod"
+import { integrationAccountBindingOutputSchema } from "./account"
 import { automationErrorSchema } from "./errors"
+import { cursorPageOutputSchema, cursorPaginationInputSchema } from "./schemas"
+
+const TRIGGER_PRESENTATION_VALUE_SCHEMA = z.object({
+  copyable: z.boolean().optional(),
+  value: z.string(),
+})
+
+export const automationOutputSchema = z.object({
+  accountBindings: z
+    .object({
+      account: integrationAccountBindingOutputSchema.nullable(),
+      binding: z.string(),
+      serviceId: z.string(),
+    })
+    .array(),
+  activeDeploymentId: z.string(),
+  createdAt: z.date(),
+  description: z.string(),
+  enabled: z.boolean(),
+  id: z.string(),
+  identityKey: z.string(),
+  project: z.object({
+    id: z.string(),
+    name: z.string(),
+    organization: z.object({
+      id: z.string(),
+      name: z.string(),
+    }),
+  }),
+  triggers: z
+    .object({
+      details: TRIGGER_PRESENTATION_VALUE_SCHEMA.extend({
+        label: z.string(),
+      }).array(),
+      hookSlot: z.number().int().nonnegative(),
+      id: z.string(),
+      name: z.string(),
+      primary: TRIGGER_PRESENTATION_VALUE_SCHEMA.optional(),
+      scopePath: z.number().int().nonnegative().array(),
+      type: z.string(),
+    })
+    .array(),
+  updatedAt: z.date(),
+})
 
 export const automationExecutionStatusSchema = z.enum([
   "running",
-  "completed",
+  "settled",
   "failed",
 ])
 
 const EXECUTION_SUMMARY_SCHEMA = z.object({
-  completedAt: z.date().nullable(),
   createdAt: z.date(),
   eventTypes: z.string().array(),
   failure: automationErrorSchema.nullable(),
   id: z.string(),
+  settledAt: z.date().nullable(),
   status: automationExecutionStatusSchema,
 })
 
 export const automationContract = {
+  get: oc
+    .route({
+      method: "GET",
+      path: "/automations/{automationId}",
+      operationId: "getAutomation",
+      summary: "Get automation",
+      description:
+        "Returns an active automation with its triggers and integration account bindings.",
+      tags: ["Automations"],
+    })
+    .input(z.object({ automationId: z.string() }))
+    .output(automationOutputSchema),
   getExecution: oc
     .input(
       z.object({
@@ -62,6 +119,27 @@ export const automationContract = {
           .array(),
       }),
     ),
+  list: oc
+    .route({
+      method: "GET",
+      path: "/automations",
+      operationId: "listAutomations",
+      summary: "List automations",
+      description:
+        "Lists active automations visible to the caller, optionally filtered by organization, project, state, or query.",
+      tags: ["Automations"],
+    })
+    .input(
+      cursorPaginationInputSchema
+        .extend({
+          enabled: z.boolean().optional(),
+          organizationId: z.string().optional(),
+          projectId: z.string().optional(),
+          query: z.string().min(1).optional(),
+        })
+        .prefault({}),
+    )
+    .output(cursorPageOutputSchema(automationOutputSchema)),
   listExecutions: oc
     .input(
       z.object({
@@ -71,6 +149,15 @@ export const automationContract = {
     )
     .output(EXECUTION_SUMMARY_SCHEMA.array()),
   update: oc
+    .route({
+      method: "PATCH",
+      path: "/automations/{automationId}",
+      operationId: "updateAutomation",
+      summary: "Update automation",
+      description:
+        "Enables or disables an automation. Requires project:update.",
+      tags: ["Automations"],
+    })
     .input(
       z.object({
         automationId: z.string(),