@slates/provider 1.0.0-rc.22 → 1.0.0-rc.24

package/dist/index.cjs

@@ -50,6 +50,8 @@ __export(index_exports, {
   SlateSpecification: () => SlateSpecification,
   SlateTool: () => SlateTool,
   SlateTrigger: () => SlateTrigger,
+  SlateTriggerGroup: () => SlateTriggerGroup,
+  SlateTriggerGroupBuilder: () => SlateTriggerGroupBuilder,
   adapterSpec: () => adapterSpec,
   allOf: () => allOf,
   anyOf: () => anyOf,
@@ -101,6 +103,7 @@ __export(index_exports, {
   statusLabelForApiError: () => statusLabelForApiError,
   tool: () => tool,
   trigger: () => trigger,
+  triggerGroup: () => triggerGroup,
   uploadAttachmentDirect: () => uploadAttachmentDirect,
   validateScopes: () => validateScopes,
   verifyHmacSignature: () => verifyHmacSignature
@@ -934,7 +937,9 @@ var SlateActionBuilder = class {
   #scopes;
   #authMethods;
   #toolParams = null;
-  #triggerParams = null;
+  #triggerGroup = null;
+  #triggerMatches = null;
+  #triggerMap = null;
   #interfaceLocked = false;
   input(schema) {
     if (this.#interfaceLocked) {
@@ -984,32 +989,25 @@ var SlateActionBuilder = class {
     };
     return this;
   }
-  webhook(props) {
+  triggerGroup(group) {
     if (this.type !== "trigger") {
-      throw new SlateDeclarationError("handleEvent can only be set for trigger actions");
+      throw new SlateDeclarationError("triggerGroup can only be set for trigger actions");
     }
-    this.#triggerParams = {
-      type: "trigger",
-      source: "webhook",
-      handleEvent: props.handleEvent,
-      handleRequest: props.handleRequest,
-      autoRegisterWebhook: props.autoRegisterWebhook,
-      autoUnregisterWebhook: props.autoUnregisterWebhook,
-      http: props.http
-    };
+    this.#triggerGroup = group;
     return this;
   }
-  polling(props) {
+  matches(handler) {
     if (this.type !== "trigger") {
-      throw new SlateDeclarationError("handleEvent can only be set for trigger actions");
+      throw new SlateDeclarationError("matches can only be set for trigger actions");
     }
-    this.#triggerParams = {
-      type: "trigger",
-      source: "polling",
-      polling: props.options,
-      pollEvents: props.pollEvents,
-      handleEvent: props.handleEvent
-    };
+    this.#triggerMatches = handler;
+    return this;
+  }
+  map(handler) {
+    if (this.type !== "trigger") {
+      throw new SlateDeclarationError("map can only be set for trigger actions");
+    }
+    this.#triggerMap = handler;
     return this;
   }
   build() {
@@ -1030,9 +1028,21 @@ var SlateActionBuilder = class {
     if (this.type === "tool" && !this.#toolParams) {
       throw new SlateDeclarationError("Tool invocation handler is not defined");
     }
-    if (this.type === "trigger" && !this.#triggerParams) {
-      throw new SlateDeclarationError("Trigger event handlers are not defined");
+    if (this.type === "trigger" && !this.#triggerGroup) {
+      throw new SlateDeclarationError("Trigger group is not defined");
+    }
+    if (this.type === "trigger" && !this.#triggerMatches) {
+      throw new SlateDeclarationError("Trigger matches handler is not defined");
     }
+    if (this.type === "trigger" && !this.#triggerMap) {
+      throw new SlateDeclarationError("Trigger map handler is not defined");
+    }
+    let triggerParams = this.type === "trigger" ? {
+      type: "trigger",
+      triggerGroup: this.#triggerGroup,
+      matches: this.#triggerMatches,
+      map: this.#triggerMap
+    } : null;
     return this.factory({
       ...this.params,
       scopes,
@@ -1043,7 +1053,7 @@ var SlateActionBuilder = class {
       inputSchema: this.#inputSchema,
       outputSchema: this.#outputSchema,
       ...this.#toolParams,
-      ...this.#triggerParams
+      ...triggerParams
     });
   }
 };
@@ -1209,28 +1219,15 @@ var SlatePublicTool = class {
 var publicTool = (spec2, params) => SlatePublicTool.create(spec2, params);
 
 // src/action/trigger.ts
-var SlateDefaultPollingIntervalSeconds = 60 * 10;
 var SlateTrigger = class _SlateTrigger extends SlateAction {
-  #source;
-  #polling;
-  #handleEvent;
-  #handleRequest;
-  #http;
-  #pollEvents;
-  #autoRegisterWebhook;
-  #autoUnregisterWebhook;
+  #triggerGroup;
+  #matches;
+  #map;
   constructor(spec2, inputSchema, outputSchema, params) {
     super("trigger", spec2, inputSchema, outputSchema, params);
-    this.#source = params.source;
-    this.#polling = params.polling || {
-      intervalInSeconds: SlateDefaultPollingIntervalSeconds
-    };
-    this.#handleEvent = params.handleEvent;
-    this.#handleRequest = params.handleRequest;
-    this.#http = params.http;
-    this.#pollEvents = params.pollEvents;
-    this.#autoRegisterWebhook = params.autoRegisterWebhook;
-    this.#autoUnregisterWebhook = params.autoUnregisterWebhook;
+    this.#triggerGroup = params.triggerGroup;
+    this.#matches = params.matches;
+    this.#map = params.map;
   }
   static create(spec2, params) {
     return new SlateActionBuilder("trigger", spec2, params, (params2) => {
@@ -1238,32 +1235,126 @@ var SlateTrigger = class _SlateTrigger extends SlateAction {
       return new _SlateTrigger(spec2, params2.inputSchema, params2.outputSchema, params2);
     });
   }
-  get polling() {
-    return this.#polling;
+  get triggerGroup() {
+    return this.#triggerGroup;
+  }
+  get matches() {
+    return this.#matches;
+  }
+  get map() {
+    return this.#map;
+  }
+};
+var trigger = (spec2, params) => SlateTrigger.create(spec2, params);
+
+// src/action/triggerGroup.ts
+var import_zod2 = require("zod");
+var SlateDefaultPollingIntervalSeconds = 60 * 10;
+var SlateTriggerGroup = class _SlateTriggerGroup {
+  constructor(_spec, _params) {
+    this._spec = _spec;
+    this._params = _params;
+  }
+  _spec;
+  _params;
+  static create(spec2, params) {
+    return new SlateTriggerGroupBuilder(spec2, params, (p) => new _SlateTriggerGroup(spec2, p));
+  }
+  get spec() {
+    return this._spec;
+  }
+  get key() {
+    return this._params.key;
+  }
+  get name() {
+    return this._params.name;
+  }
+  get description() {
+    return this._params.description;
+  }
+  get metadata() {
+    return this._params.metadata;
+  }
+  get eventSchema() {
+    return this._params.eventSchema ?? import_zod2.z.object({}).passthrough();
   }
   get source() {
-    return this.#source;
+    return this._params.source;
   }
-  get handleEvent() {
-    return this.#handleEvent;
+  get polling() {
+    return this._params.polling;
   }
-  get handleRequest() {
-    return this.#handleRequest;
+  get webhook() {
+    return this._params.webhook;
   }
-  get http() {
-    return this.#http;
+  get routingMatchers() {
+    return this._params.routingMatchers;
   }
-  get pollEvents() {
-    return this.#pollEvents;
+};
+var SlateTriggerGroupBuilder = class {
+  constructor(spec2, params, factory) {
+    this.spec = spec2;
+    this.params = params;
+    this.factory = factory;
+  }
+  spec;
+  params;
+  factory;
+  #source = null;
+  #polling = null;
+  #webhook = null;
+  #routingMatchers = null;
+  polling(props) {
+    if (this.#source) {
+      throw new SlateDeclarationError("Trigger group invocation is already defined");
+    }
+    this.#source = "polling";
+    this.#polling = {
+      intervalSeconds: props.intervalSeconds ?? SlateDefaultPollingIntervalSeconds,
+      pollEvents: props.pollEvents
+    };
+    return this;
+  }
+  webhook(props) {
+    if (this.#source) {
+      throw new SlateDeclarationError("Trigger group invocation is already defined");
+    }
+    if (!!props.autoRegistration === !!props.manualRegistration) {
+      throw new SlateDeclarationError(
+        "Webhook trigger groups require exactly one of autoRegistration or manualRegistration"
+      );
+    }
+    this.#source = "webhook";
+    this.#webhook = {
+      autoRegistration: props.autoRegistration,
+      manualRegistration: props.manualRegistration,
+      process: props.process
+    };
+    return this;
   }
-  get autoRegisterWebhook() {
-    return this.#autoRegisterWebhook;
+  routingMatchers(handler) {
+    this.#routingMatchers = handler;
+    return this;
   }
-  get autoUnregisterWebhook() {
-    return this.#autoUnregisterWebhook;
+  build() {
+    if (!this.#source) {
+      throw new SlateDeclarationError(
+        "Trigger group invocation (polling or webhook) is not defined"
+      );
+    }
+    if (!this.#routingMatchers) {
+      throw new SlateDeclarationError("Trigger group routing matchers handler is not defined");
+    }
+    return this.factory({
+      ...this.params,
+      source: this.#source,
+      polling: this.#polling ?? void 0,
+      webhook: this.#webhook ?? void 0,
+      routingMatchers: this.#routingMatchers
+    });
   }
 };
-var trigger = (spec2, params) => SlateTrigger.create(spec2, params);
+var triggerGroup = (spec2, params) => SlateTriggerGroup.create(spec2, params);
 
 // src/action/attachment.ts
 var createUrlAttachment = (url, opts = {}) => {
@@ -2690,14 +2781,16 @@ var setIfDefined = (target, key, value) => {
 
 // src/specification/slate.ts
 var Slate = class _Slate {
-  constructor(_spec, _actions, _adapters) {
+  constructor(_spec, _actions, _adapters, _triggerGroups) {
     this._spec = _spec;
     this._actions = _actions;
     this._adapters = _adapters;
+    this._triggerGroups = _triggerGroups;
   }
   _spec;
   _actions;
   _adapters;
+  _triggerGroups;
   static create(params) {
     let adapters = params.adapters ?? [];
     let actions = [...params.triggers, ...params.tools];
@@ -2723,7 +2816,25 @@ var Slate = class _Slate {
         }
       }
     }
-    return new _Slate(params.spec, actions, adapters);
+    let triggerGroups = params.triggerGroups ?? [];
+    let seenTriggerGroupKeys = /* @__PURE__ */ new Set();
+    for (let group of triggerGroups) {
+      if (seenTriggerGroupKeys.has(group.key)) {
+        throw new SlateDeclarationError(
+          `Trigger group "${group.key}" is registered more than once`
+        );
+      }
+      seenTriggerGroupKeys.add(group.key);
+    }
+    let manualWebhookTriggerGroups = triggerGroups.filter(
+      (group) => group.source === "webhook" && group.webhook?.manualRegistration
+    );
+    if (manualWebhookTriggerGroups.length > 1) {
+      throw new SlateDeclarationError(
+        `Only one trigger group may use manual webhook registration, but found: ${manualWebhookTriggerGroups.map((group) => group.key).join(", ")}`
+      );
+    }
+    return new _Slate(params.spec, actions, adapters, triggerGroups);
   }
   get spec() {
     return this._spec;
@@ -2734,10 +2845,13 @@ var Slate = class _Slate {
   get adapters() {
     return this._adapters;
   }
+  get triggerGroups() {
+    return this._triggerGroups;
+  }
 };
 
 // src/specification/specification.ts
-var import_zod2 = __toESM(require("zod"), 1);
+var import_zod3 = __toESM(require("zod"), 1);
 var SlateSpecification = class _SlateSpecification {
   constructor(_config, _auth, _params) {
     this._config = _config;
@@ -2754,7 +2868,7 @@ var SlateSpecification = class _SlateSpecification {
     return this._config.configSchema;
   }
   get authSchema() {
-    return "outputSchema" in this._auth ? this._auth.outputSchema : import_zod2.default.object({});
+    return "outputSchema" in this._auth ? this._auth.outputSchema : import_zod3.default.object({});
   }
   get config() {
     return this._config;
@@ -2854,6 +2968,8 @@ var getMetaWebhookVerificationResponse = (request, expectedVerifyToken) => {
   SlateSpecification,
   SlateTool,
   SlateTrigger,
+  SlateTriggerGroup,
+  SlateTriggerGroupBuilder,
   adapterSpec,
   allOf,
   anyOf,
@@ -2905,6 +3021,7 @@ var getMetaWebhookVerificationResponse = (request, expectedVerifyToken) => {
   statusLabelForApiError,
   tool,
   trigger,
+  triggerGroup,
   uploadAttachmentDirect,
   validateScopes,
   verifyHmacSignature