@slates/provider-handler 1.0.0-rc.36 → 1.0.0-rc.38

package/dist/index.cjs

@@ -113,6 +113,7 @@ var mapAuthMethod = (slate, m) => ({
     description: s.description
   })) : void 0,
   adapters: "adapters" in m ? m.adapters : void 0,
+  ..."syncTokensAcrossConnections" in m && m.syncTokensAcrossConnections ? { syncTokensAcrossConnections: true } : {},
   inputSchema: toJsonSchema(m.inputSchema ?? import_zod.default.object({})),
   outputSchema: toJsonSchema(slate.spec.auth.outputSchema),
   capabilities: {
@@ -253,7 +254,7 @@ var mapTriggerGroup = (group) => ({
   invocation: group.source === "polling" ? {
     type: "polling",
     intervalSeconds: group.polling?.intervalSeconds ?? import_provider.SlateDefaultPollingIntervalSeconds
-  } : {
+  } : group.source === "gateway" ? { type: "gateway" } : {
     type: "webhook",
     registration: group.webhook?.manualRegistration ? {
       mode: "manual",
@@ -1496,6 +1497,91 @@ var createProviderHandler = (slate, listeners) => (0, import_proto.createSlatesP
       }))
     });
   });
+  let getGatewayTriggerGroup = (triggerGroupId) => {
+    let group = getTriggerGroup(slate, triggerGroupId);
+    if (group.source !== "gateway" || !group.gateway) {
+      throw new import_error4.ServiceError(
+        (0, import_error4.badRequestError)({
+          message: `Trigger group does not support gateway connections: ${triggerGroupId}`
+        })
+      );
+    }
+    return { group, gateway: group.gateway };
+  };
+  manager.onRequest("slates/trigger_group.gateway.connect", async ({ params }) => {
+    let ctx = getContextFull();
+    let { group, gateway } = getGatewayTriggerGroup(params.triggerGroupId);
+    let context = new import_provider2.SlateContext(
+      ctx.config,
+      { state: params.state },
+      ctx.auth?.output,
+      slate.spec,
+      logger
+    );
+    let res = await traceProviderCall(
+      {
+        component: "action",
+        functionName: "gatewayConnect",
+        message: `Preparing gateway connection for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: () => `Prepared gateway connection for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while preparing a gateway connection`,
+        metadata: {
+          triggerGroupId: group.key,
+          triggerGroupName: group.name,
+          hasPreviousState: params.state !== null
+        }
+      },
+      () => (0, import_provider2.runWithContext)(context, () => gateway.connect(context))
+    );
+    return withRequestTraces(context, { url: res.url, state: res.state });
+  });
+  manager.onRequest("slates/trigger_group.gateway.receive", async ({ params }) => {
+    let ctx = getContextFull();
+    let { group, gateway } = getGatewayTriggerGroup(params.triggerGroupId);
+    let context = new import_provider2.SlateContext(
+      ctx.config,
+      { state: params.state, frames: params.frames, closed: params.closed ?? null },
+      ctx.auth?.output,
+      slate.spec,
+      logger
+    );
+    let res = await traceProviderCall(
+      {
+        component: "action",
+        functionName: "gatewayReceive",
+        message: `Handling ${params.frames.length} gateway frame(s) for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: (result) => `Handled gateway frames for trigger group ${formatEntityLabel(group.name, group.key)} (${result.events?.length ?? 0} event(s))`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while handling gateway frames`,
+        metadata: {
+          triggerGroupId: group.key,
+          triggerGroupName: group.name,
+          frameCount: params.frames.length,
+          closed: params.closed ?? null
+        },
+        onSuccess: (result) => ({
+          eventCount: result.events?.length ?? 0,
+          sendCount: result.send?.length ?? 0,
+          close: result.close ?? null
+        })
+      },
+      () => (0, import_provider2.runWithContext)(context, () => gateway.receive(context))
+    );
+    return withRequestTraces(context, {
+      state: res.state,
+      // Outbound frames (e.g. IDENTIFY) embed credentials; the hub restores them at the socket.
+      send: new import_provider2.AuthConfigSecretRedactor(
+        context._getAuthConfigForRedaction()
+      ).redactEmbedded(res.send ?? []),
+      heartbeat: res.heartbeat ?? null,
+      heartbeatAcked: res.heartbeatAcked,
+      close: res.close ?? null,
+      events: (res.events ?? []).map((event) => ({
+        payload: event.payload,
+        idempotencyKey: event.idempotencyKey,
+        triggerIds: evaluateTriggerMatches(slate, group.key, event.payload)
+      }))
+    });
+  });
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/index.module.js

@@ -10,6 +10,7 @@ import {
   SLATES_PROTOCOL_VERSION
 } from "@slates/proto";
 import {
+  AuthConfigSecretRedactor,
   redactUrlAttachmentSecrets,
   runWithContext,
   SlateContext,
@@ -96,6 +97,7 @@ var mapAuthMethod = (slate, m) => ({
     description: s.description
   })) : void 0,
   adapters: "adapters" in m ? m.adapters : void 0,
+  ..."syncTokensAcrossConnections" in m && m.syncTokensAcrossConnections ? { syncTokensAcrossConnections: true } : {},
   inputSchema: toJsonSchema(m.inputSchema ?? z.object({})),
   outputSchema: toJsonSchema(slate.spec.auth.outputSchema),
   capabilities: {
@@ -236,7 +238,7 @@ var mapTriggerGroup = (group) => ({
   invocation: group.source === "polling" ? {
     type: "polling",
     intervalSeconds: group.polling?.intervalSeconds ?? SlateDefaultPollingIntervalSeconds
-  } : {
+  } : group.source === "gateway" ? { type: "gateway" } : {
     type: "webhook",
     registration: group.webhook?.manualRegistration ? {
       mode: "manual",
@@ -1479,6 +1481,91 @@ var createProviderHandler = (slate, listeners) => createSlatesProviderProtoHandl
       }))
     });
   });
+  let getGatewayTriggerGroup = (triggerGroupId) => {
+    let group = getTriggerGroup(slate, triggerGroupId);
+    if (group.source !== "gateway" || !group.gateway) {
+      throw new ServiceError4(
+        badRequestError3({
+          message: `Trigger group does not support gateway connections: ${triggerGroupId}`
+        })
+      );
+    }
+    return { group, gateway: group.gateway };
+  };
+  manager.onRequest("slates/trigger_group.gateway.connect", async ({ params }) => {
+    let ctx = getContextFull();
+    let { group, gateway } = getGatewayTriggerGroup(params.triggerGroupId);
+    let context = new SlateContext(
+      ctx.config,
+      { state: params.state },
+      ctx.auth?.output,
+      slate.spec,
+      logger
+    );
+    let res = await traceProviderCall(
+      {
+        component: "action",
+        functionName: "gatewayConnect",
+        message: `Preparing gateway connection for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: () => `Prepared gateway connection for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while preparing a gateway connection`,
+        metadata: {
+          triggerGroupId: group.key,
+          triggerGroupName: group.name,
+          hasPreviousState: params.state !== null
+        }
+      },
+      () => runWithContext(context, () => gateway.connect(context))
+    );
+    return withRequestTraces(context, { url: res.url, state: res.state });
+  });
+  manager.onRequest("slates/trigger_group.gateway.receive", async ({ params }) => {
+    let ctx = getContextFull();
+    let { group, gateway } = getGatewayTriggerGroup(params.triggerGroupId);
+    let context = new SlateContext(
+      ctx.config,
+      { state: params.state, frames: params.frames, closed: params.closed ?? null },
+      ctx.auth?.output,
+      slate.spec,
+      logger
+    );
+    let res = await traceProviderCall(
+      {
+        component: "action",
+        functionName: "gatewayReceive",
+        message: `Handling ${params.frames.length} gateway frame(s) for trigger group ${formatEntityLabel(group.name, group.key)}`,
+        successMessage: (result) => `Handled gateway frames for trigger group ${formatEntityLabel(group.name, group.key)} (${result.events?.length ?? 0} event(s))`,
+        errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while handling gateway frames`,
+        metadata: {
+          triggerGroupId: group.key,
+          triggerGroupName: group.name,
+          frameCount: params.frames.length,
+          closed: params.closed ?? null
+        },
+        onSuccess: (result) => ({
+          eventCount: result.events?.length ?? 0,
+          sendCount: result.send?.length ?? 0,
+          close: result.close ?? null
+        })
+      },
+      () => runWithContext(context, () => gateway.receive(context))
+    );
+    return withRequestTraces(context, {
+      state: res.state,
+      // Outbound frames (e.g. IDENTIFY) embed credentials; the hub restores them at the socket.
+      send: new AuthConfigSecretRedactor(
+        context._getAuthConfigForRedaction()
+      ).redactEmbedded(res.send ?? []),
+      heartbeat: res.heartbeat ?? null,
+      heartbeatAcked: res.heartbeatAcked,
+      close: res.close ?? null,
+      events: (res.events ?? []).map((event) => ({
+        payload: event.payload,
+        idempotencyKey: event.idempotencyKey,
+        triggerIds: evaluateTriggerMatches(slate, group.key, event.payload)
+      }))
+    });
+  });
 });
 export {
   createProviderHandler

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/provider-handler",
-  "version": "1.0.0-rc.36",
+  "version": "1.0.0-rc.38",
   "publishConfig": {
     "access": "public"
   },
@@ -32,8 +32,8 @@
   },
   "dependencies": {
     "@lowerdeck/error": "^1.1.0",
-    "@slates/proto": "1.0.0-rc.22",
-    "@slates/provider": "1.0.0-rc.26",
+    "@slates/proto": "1.0.0-rc.24",
+    "@slates/provider": "1.0.0-rc.28",
     "p-queue": "^6.6.2",
     "zod": "^4.2.1"
   },

package/src/index.ts

@@ -10,6 +10,7 @@ import {
   type SlatesParticipant
 } from '@slates/proto';
 import {
+  AuthConfigSecretRedactor,
   redactUrlAttachmentSecrets,
   runWithContext,
   type Slate,
@@ -1446,4 +1447,98 @@ export let createProviderHandler = <ConfigType extends {}, AuthType extends {}>(
         }))
       });
     });
+
+    let getGatewayTriggerGroup = (triggerGroupId: string) => {
+      let group = getTriggerGroup(slate, triggerGroupId);
+      if (group.source !== 'gateway' || !group.gateway) {
+        throw new ServiceError(
+          badRequestError({
+            message: `Trigger group does not support gateway connections: ${triggerGroupId}`
+          })
+        );
+      }
+      return { group, gateway: group.gateway };
+    };
+
+    manager.onRequest('slates/trigger_group.gateway.connect', async ({ params }) => {
+      let ctx = getContextFull();
+      let { group, gateway } = getGatewayTriggerGroup(params.triggerGroupId);
+
+      let context = new SlateContext(
+        ctx.config,
+        { state: params.state },
+        ctx.auth?.output!,
+        slate.spec,
+        logger
+      );
+      let res = await traceProviderCall(
+        {
+          component: 'action',
+          functionName: 'gatewayConnect',
+          message: `Preparing gateway connection for trigger group ${formatEntityLabel(group.name, group.key)}`,
+          successMessage: () =>
+            `Prepared gateway connection for trigger group ${formatEntityLabel(group.name, group.key)}`,
+          errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while preparing a gateway connection`,
+          metadata: {
+            triggerGroupId: group.key,
+            triggerGroupName: group.name,
+            hasPreviousState: params.state !== null
+          }
+        },
+        () => runWithContext(context, () => gateway.connect(context))
+      );
+
+      return withRequestTraces(context, { url: res.url, state: res.state });
+    });
+
+    manager.onRequest('slates/trigger_group.gateway.receive', async ({ params }) => {
+      let ctx = getContextFull();
+      let { group, gateway } = getGatewayTriggerGroup(params.triggerGroupId);
+
+      let context = new SlateContext(
+        ctx.config,
+        { state: params.state, frames: params.frames, closed: params.closed ?? null },
+        ctx.auth?.output!,
+        slate.spec,
+        logger
+      );
+      let res = await traceProviderCall(
+        {
+          component: 'action',
+          functionName: 'gatewayReceive',
+          message: `Handling ${params.frames.length} gateway frame(s) for trigger group ${formatEntityLabel(group.name, group.key)}`,
+          successMessage: result =>
+            `Handled gateway frames for trigger group ${formatEntityLabel(group.name, group.key)} (${result.events?.length ?? 0} event(s))`,
+          errorMessage: `Trigger group ${formatEntityLabel(group.name, group.key)} failed while handling gateway frames`,
+          metadata: {
+            triggerGroupId: group.key,
+            triggerGroupName: group.name,
+            frameCount: params.frames.length,
+            closed: params.closed ?? null
+          },
+          onSuccess: result => ({
+            eventCount: result.events?.length ?? 0,
+            sendCount: result.send?.length ?? 0,
+            close: result.close ?? null
+          })
+        },
+        () => runWithContext(context, () => gateway.receive(context))
+      );
+
+      return withRequestTraces(context, {
+        state: res.state,
+        // Outbound frames (e.g. IDENTIFY) embed credentials; the hub restores them at the socket.
+        send: new AuthConfigSecretRedactor(
+          context._getAuthConfigForRedaction()
+        ).redactEmbedded(res.send ?? []),
+        heartbeat: res.heartbeat ?? null,
+        heartbeatAcked: res.heartbeatAcked,
+        close: res.close ?? null,
+        events: (res.events ?? []).map(event => ({
+          payload: event.payload,
+          idempotencyKey: event.idempotencyKey,
+          triggerIds: evaluateTriggerMatches(slate, group.key, event.payload)
+        }))
+      });
+    });
   });

package/src/spec.test.ts

@@ -9,7 +9,8 @@ import {
   getTriggersForGroup,
   isMappableTrigger,
   mapAction,
-  mapAdapter
+  mapAdapter,
+  mapAuthMethod
 } from './spec';
 
 let baseAction = {
@@ -145,3 +146,25 @@ describe('adapter exposure', () => {
     });
   });
 });
+
+describe('mapAuthMethod', () => {
+  let slate: any = { spec: { auth: { outputSchema: z.object({ token: z.string() }) } } };
+  let oauthMethod: any = {
+    type: 'auth.oauth',
+    key: 'oauth',
+    name: 'OAuth',
+    scopes: [],
+    getAuthorizationUrl: async () => ({ url: '' }),
+    handleCallback: async () => ({ output: { token: '' } })
+  };
+
+  it('emits syncTokensAcrossConnections only when the method opts in', () => {
+    expect(
+      mapAuthMethod(slate, { ...oauthMethod, syncTokensAcrossConnections: true })
+    ).toMatchObject({ syncTokensAcrossConnections: true });
+
+    for (let method of [oauthMethod, { ...oauthMethod, syncTokensAcrossConnections: false }]) {
+      expect(mapAuthMethod(slate, method)).not.toHaveProperty('syncTokensAcrossConnections');
+    }
+  });
+});

package/src/spec.ts

@@ -49,6 +49,10 @@ export let mapAuthMethod = <ConfigType extends {}, AuthType extends {}>(
 
   adapters: 'adapters' in m ? m.adapters : undefined,
 
+  ...('syncTokensAcrossConnections' in m && m.syncTokensAcrossConnections
+    ? { syncTokensAcrossConnections: true }
+    : {}),
+
   inputSchema: toJsonSchema(m.inputSchema ?? z.object({})),
   outputSchema: toJsonSchema(slate.spec.auth.outputSchema),
 
@@ -278,18 +282,20 @@ export let mapTriggerGroup = <ConfigType extends {}, AuthType extends {}>(
           type: 'polling',
           intervalSeconds: group.polling?.intervalSeconds ?? SlateDefaultPollingIntervalSeconds
         }
-      : {
-          type: 'webhook',
-          registration: group.webhook?.manualRegistration
-            ? {
-                mode: 'manual',
-                userConfigSchema: toJsonSchema(
-                  group.webhook.manualRegistration.userConfigSchema
-                ),
-                fullConfigSchema: toJsonSchema(
-                  group.webhook.manualRegistration.fullConfigSchema
-                )
-              }
-            : { mode: 'auto' }
-        }
+      : group.source === 'gateway'
+        ? { type: 'gateway' }
+        : {
+            type: 'webhook',
+            registration: group.webhook?.manualRegistration
+              ? {
+                  mode: 'manual',
+                  userConfigSchema: toJsonSchema(
+                    group.webhook.manualRegistration.userConfigSchema
+                  ),
+                  fullConfigSchema: toJsonSchema(
+                    group.webhook.manualRegistration.fullConfigSchema
+                  )
+                }
+              : { mode: 'auto' }
+          }
 });