@slates/proto 1.0.0-rc.2 → 1.0.0-rc.20

package/src/messages/index.ts

@@ -1,78 +1,132 @@
 export * from './action';
+export * from './adapter';
 export * from './auth';
 export * from './config';
 export * from './controlFlow';
+export * from './hub';
 export * from './identify';
+export * from './legacyTrigger';
+export * from './tracing';
+export * from './triggerGroup';
+export * from './webhookErrors';
 
-import { z } from 'zod';
+import type { z } from 'zod';
 import {
-  SlatesActionRequests,
+  type SlatesActionRequests,
+  type SlatesActionResponses,
   slatesActionRequestsByMethod,
-  SlatesActionResponses,
   slatesActionResponsesByMethod
 } from './action';
 import {
-  SlatesAuthNotifications,
+  type SlatesAdapterRequests,
+  type SlatesAdapterResponses,
+  slatesAdapterRequestsByMethod,
+  slatesAdapterResponsesByMethod
+} from './adapter';
+import {
+  type SlatesAuthNotifications,
+  type SlatesAuthRequests,
+  type SlatesAuthResponses,
   slatesAuthNotificationsByMethod,
-  SlatesAuthRequests,
   slatesAuthRequestsByMethod,
-  SlatesAuthResponses,
   slatesAuthResponsesByMethod
 } from './auth';
 import {
-  SlatesConfigNotifications,
+  type SlatesConfigNotifications,
+  type SlatesConfigRequests,
+  type SlatesConfigResponses,
   slatesConfigNotificationsByMethod,
-  SlatesConfigRequests,
   slatesConfigRequestsByMethod,
-  SlatesConfigResponses,
   slatesConfigResponsesByMethod
 } from './config';
 import {
-  SlatesControlFlowNotifications,
+  type SlatesControlFlowNotifications,
   slatesControlFlowNotificationsByMethod
 } from './controlFlow';
 import {
-  SlatesIdentifyRequests,
+  type SlatesHubNotifications,
+  type SlatesHubRequests,
+  type SlatesHubResponses,
+  slatesHubNotificationsByMethod,
+  slatesHubRequestsByMethod,
+  slatesHubResponsesByMethod
+} from './hub';
+import {
+  type SlatesIdentifyRequests,
+  type SlatesIdentifyResponses,
   slatesIdentifyRequestsByMethod,
-  SlatesIdentifyResponses,
   slatesIdentifyResponsesByMethod
 } from './identify';
+import {
+  type SlatesLegacyTriggerRequests,
+  type SlatesLegacyTriggerResponses,
+  slatesLegacyTriggerRequestsByMethod,
+  slatesLegacyTriggerResponsesByMethod
+} from './legacyTrigger';
+import {
+  type SlatesTriggerGroupRequests,
+  type SlatesTriggerGroupResponses,
+  slatesTriggerGroupRequestsByMethod,
+  slatesTriggerGroupResponsesByMethod
+} from './triggerGroup';
 
 export type SlatesNotifications =
   | SlatesAuthNotifications
   | SlatesConfigNotifications
-  | SlatesControlFlowNotifications;
+  | SlatesControlFlowNotifications
+  | SlatesHubNotifications;
 
 export type SlatesRequests =
   | SlatesActionRequests
+  | SlatesAdapterRequests
   | SlatesAuthRequests
   | SlatesConfigRequests
+  | SlatesIdentifyRequests
+  | SlatesLegacyTriggerRequests
+  | SlatesTriggerGroupRequests
+  | SlatesHubRequests
   | SlatesIdentifyRequests;
 
 export type SlatesResponses =
   | SlatesActionResponses
+  | SlatesAdapterResponses
   | SlatesAuthResponses
   | SlatesConfigResponses
+  | SlatesIdentifyResponses
+  | SlatesLegacyTriggerResponses
+  | SlatesTriggerGroupResponses
+  | SlatesHubResponses
   | SlatesIdentifyResponses;
 
 export let slatesResponsesByMethod = {
   ...slatesActionResponsesByMethod,
+  ...slatesAdapterResponsesByMethod,
   ...slatesAuthResponsesByMethod,
   ...slatesConfigResponsesByMethod,
+  ...slatesIdentifyResponsesByMethod,
+  ...slatesLegacyTriggerResponsesByMethod,
+  ...slatesTriggerGroupResponsesByMethod,
+  ...slatesHubResponsesByMethod,
   ...slatesIdentifyResponsesByMethod
 };
 
 export let slatesRequestsByMethod = {
   ...slatesActionRequestsByMethod,
+  ...slatesAdapterRequestsByMethod,
   ...slatesAuthRequestsByMethod,
   ...slatesConfigRequestsByMethod,
+  ...slatesIdentifyRequestsByMethod,
+  ...slatesLegacyTriggerRequestsByMethod,
+  ...slatesTriggerGroupRequestsByMethod,
+  ...slatesHubRequestsByMethod,
   ...slatesIdentifyRequestsByMethod
 };
 
 export let slatesNotificationsByMethod = {
   ...slatesAuthNotificationsByMethod,
   ...slatesConfigNotificationsByMethod,
-  ...slatesControlFlowNotificationsByMethod
+  ...slatesControlFlowNotificationsByMethod,
+  ...slatesHubNotificationsByMethod
 };
 
 export type SlatesResponsesByMethod = {

package/src/messages/legacyTrigger.ts

@@ -0,0 +1,149 @@
+import z from 'zod';
+import { slatesWebhookHttpResponse } from './action';
+import { withRequestTraces } from './tracing';
+
+export let slatesMessageActionTriggerEventsPollRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/action.trigger.poll_events'),
+  id: z.string(),
+  params: z.object({
+    actionId: z.string(),
+    state: z.any().nullable()
+  })
+});
+
+export type SlatesMessageActionTriggerEventsPollRequest = z.infer<
+  typeof slatesMessageActionTriggerEventsPollRequest
+>;
+
+export let slatesMessageActionTriggerEventsPollResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: withRequestTraces({
+    inputs: z.array(z.record(z.string(), z.any())),
+    updatedState: z.any().nullable().optional()
+  })
+});
+
+export type SlatesMessageActionTriggerEventsPollResponse = z.infer<
+  typeof slatesMessageActionTriggerEventsPollResponse
+>;
+
+export let slatesMessageActionTriggerWebhookHandleRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/action.trigger.webhook_handle'),
+  id: z.string(),
+  params: z.object({
+    actionId: z.string(),
+    url: z.string(),
+    method: z.string(),
+    headers: z.record(z.string(), z.string()),
+    body: z
+      .object({
+        encoding: z.literal('base64'),
+        content: z.string()
+      })
+      .nullable(),
+    state: z.any().nullable(),
+    registrationDetails: z.any().nullable().optional()
+  })
+});
+
+export type SlatesMessageActionTriggerWebhookHandleRequest = z.infer<
+  typeof slatesMessageActionTriggerWebhookHandleRequest
+>;
+
+export let slatesMessageActionTriggerWebhookHandleResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: withRequestTraces({
+    inputs: z.array(z.record(z.string(), z.any())),
+    updatedState: z.any().nullable().optional(),
+    response: slatesWebhookHttpResponse.nullable().optional()
+  })
+});
+
+export type SlatesMessageActionTriggerWebhookHandleResponse = z.infer<
+  typeof slatesMessageActionTriggerWebhookHandleResponse
+>;
+
+export let slatesMessageActionTriggerWebhookRegisterRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/action.trigger.webhook_register'),
+  id: z.string(),
+  params: z.object({
+    actionId: z.string(),
+    webhookBaseUrl: z.string()
+  })
+});
+
+export type SlatesMessageActionTriggerWebhookRegisterRequest = z.infer<
+  typeof slatesMessageActionTriggerWebhookRegisterRequest
+>;
+
+export let slatesMessageActionTriggerWebhookRegisterResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: withRequestTraces({
+    registrationDetails: z.any(),
+    state: z.any().optional()
+  })
+});
+
+export type SlatesMessageActionTriggerWebhookRegisterResponse = z.infer<
+  typeof slatesMessageActionTriggerWebhookRegisterResponse
+>;
+
+export let slatesMessageActionTriggerWebhookUnregisterRequest = z.object({
+  jsonrpc: z.literal('2.0'),
+  method: z.literal('slates/action.trigger.webhook_unregister'),
+  id: z.string(),
+  params: z.object({
+    actionId: z.string(),
+    webhookBaseUrl: z.string(),
+    registrationDetails: z.any(),
+    state: z.any().optional()
+  })
+});
+
+export type SlatesMessageActionTriggerWebhookUnregisterRequest = z.infer<
+  typeof slatesMessageActionTriggerWebhookUnregisterRequest
+>;
+
+export let slatesMessageActionTriggerWebhookUnregisterResponse = z.object({
+  jsonrpc: z.literal('2.0'),
+  id: z.string(),
+  result: withRequestTraces({})
+});
+
+export type SlatesMessageActionTriggerWebhookUnregisterResponse = z.infer<
+  typeof slatesMessageActionTriggerWebhookUnregisterResponse
+>;
+
+export type SlatesLegacyTriggerRequests =
+  | SlatesMessageActionTriggerEventsPollRequest
+  | SlatesMessageActionTriggerWebhookHandleRequest
+  | SlatesMessageActionTriggerWebhookRegisterRequest
+  | SlatesMessageActionTriggerWebhookUnregisterRequest;
+
+export type SlatesLegacyTriggerResponses =
+  | SlatesMessageActionTriggerEventsPollResponse
+  | SlatesMessageActionTriggerWebhookHandleResponse
+  | SlatesMessageActionTriggerWebhookRegisterResponse
+  | SlatesMessageActionTriggerWebhookUnregisterResponse;
+
+export let slatesLegacyTriggerResponsesByMethod = {
+  'slates/action.trigger.poll_events': slatesMessageActionTriggerEventsPollResponse,
+  'slates/action.trigger.webhook_handle': slatesMessageActionTriggerWebhookHandleResponse,
+  'slates/action.trigger.webhook_register': slatesMessageActionTriggerWebhookRegisterResponse,
+  'slates/action.trigger.webhook_unregister':
+    slatesMessageActionTriggerWebhookUnregisterResponse
+};
+
+export let slatesLegacyTriggerRequestsByMethod = {
+  'slates/action.trigger.poll_events': slatesMessageActionTriggerEventsPollRequest,
+  'slates/action.trigger.webhook_handle': slatesMessageActionTriggerWebhookHandleRequest,
+  'slates/action.trigger.webhook_register': slatesMessageActionTriggerWebhookRegisterRequest,
+  'slates/action.trigger.webhook_unregister':
+    slatesMessageActionTriggerWebhookUnregisterRequest
+};

package/src/messages/tracing.ts

@@ -0,0 +1,38 @@
+import z from 'zod';
+
+export let slatesRequestTraceTextBody = z.object({
+  contentType: z.string().optional(),
+  text: z.string(),
+  truncated: z.boolean().optional()
+});
+
+export let slatesRequestTrace = z.object({
+  startedAt: z.string(),
+  durationMs: z.number().nonnegative(),
+  request: z.object({
+    method: z.string(),
+    url: z.string(),
+    headers: z.record(z.string(), z.string()).optional(),
+    body: slatesRequestTraceTextBody.optional()
+  }),
+  response: z
+    .object({
+      status: z.number(),
+      statusText: z.string().optional(),
+      headers: z.record(z.string(), z.string()).optional(),
+      body: slatesRequestTraceTextBody.optional()
+    })
+    .optional(),
+  error: z
+    .object({
+      code: z.string().optional(),
+      message: z.string()
+    })
+    .optional()
+});
+
+export let withRequestTraces = <Shape extends z.ZodRawShape>(shape: Shape) =>
+  z.object({
+    ...shape,
+    requestTraces: z.array(slatesRequestTrace).optional()
+  });