@sentry/junior-sentry 0.265.0 → 0.267.0

package/README.md

@@ -52,6 +52,8 @@ Junior verifies `Sentry-Hook-Signature`, reads the org slug from the signed payl
 - `issue.created` for `org/project#issueId` and `org/project`.
 - `metric_alert.critical`, `metric_alert.warning`, and `metric_alert.resolved` for `metric-alert:org/alertRuleId` and for `org/project` of each project on the alert rule.
 
+Each event has trusted data from Sentry. Issue events have `issueId`, `level`, `priority`, `issueCategory`, `issueType`, and `url` when Sentry sends them. Metric alert events have `alertRuleId`, `incidentId`, and `url`. On `org/project`, watches and event automations can filter issue events on `level`, `priority`, and `issueCategory`, and metric alert events on `alertRuleId`. The issue title, culprit, and alert description stay untrusted text.
+
 Create watches/event automations before the webhook arrives; unmatched deliveries are not replayed.
 
 Full guide: https://junior.sentry.dev/extend/sentry-plugin/

package/dist/{chunk-KK3VWIJ2.js → chunk-6QQNR5HC.js}

@@ -1,5 +1,61 @@
+// src/events/issue.ts
+import {
+  eventMatchFieldsSchema as eventMatchFieldsSchema2
+} from "@sentry/junior-plugin-api";
+
+// src/events/scope.ts
+import {
+  eventMatchFieldsSchema
+} from "@sentry/junior-plugin-api";
+import { z } from "zod";
+var sentrySlugDataSchema = z.string().min(1).toLowerCase();
+function sentryProjectsMatchFields(events) {
+  return eventMatchFieldsSchema.parse({
+    projects: {
+      kind: "string",
+      case: "lower",
+      list: true,
+      description: "lowercase Sentry project slugs, such as junior; an issue has one, a metric alert has the projects of its rule",
+      events
+    }
+  });
+}
+
 // src/events/issue.ts
 var SENTRY_ISSUE_EVENTS = ["issue.created"];
+var SENTRY_ISSUE_LEVELS = [
+  "fatal",
+  "error",
+  "warning",
+  "info",
+  "debug"
+];
+var SENTRY_ISSUE_PRIORITIES = ["high", "medium", "low"];
+var SENTRY_ISSUE_MATCH_FIELDS = eventMatchFieldsSchema2.parse({
+  ...sentryProjectsMatchFields(SENTRY_ISSUE_EVENTS),
+  issueId: {
+    kind: "string",
+    description: "numeric Sentry issue id as text, such as 7513266773",
+    events: [...SENTRY_ISSUE_EVENTS]
+  },
+  level: {
+    kind: "string",
+    description: "issue level: fatal, error, warning, info, or debug",
+    enum: [...SENTRY_ISSUE_LEVELS],
+    events: [...SENTRY_ISSUE_EVENTS]
+  },
+  priority: {
+    kind: "string",
+    description: "issue priority: high, medium, or low",
+    enum: [...SENTRY_ISSUE_PRIORITIES],
+    events: [...SENTRY_ISSUE_EVENTS]
+  },
+  issueCategory: {
+    kind: "string",
+    description: "kind of problem, such as error, performance, cron, or feedback",
+    events: [...SENTRY_ISSUE_EVENTS]
+  }
+});
 function sentryIssueResource(input) {
   return {
     identifier: `${input.org}/${input.project}#${input.issueId}`,
@@ -16,6 +72,14 @@ function sentryProjectResource(input) {
 }
 
 // src/events/metric-alert.ts
+import {
+  eventMatchFieldsSchema as eventMatchFieldsSchema3
+} from "@sentry/junior-plugin-api";
+var SENTRY_METRIC_ALERT_ACTIONS = [
+  "critical",
+  "warning",
+  "resolved"
+];
 var SENTRY_METRIC_ALERT_EVENTS = [
   "metric_alert.critical",
   "metric_alert.warning",
@@ -25,6 +89,14 @@ var SENTRY_METRIC_ALERT_SUGGESTED_EVENTS = [
   "metric_alert.critical",
   "metric_alert.warning"
 ];
+var SENTRY_METRIC_ALERT_MATCH_FIELDS = eventMatchFieldsSchema3.parse({
+  ...sentryProjectsMatchFields(SENTRY_METRIC_ALERT_EVENTS),
+  alertRuleId: {
+    kind: "string",
+    description: "id of the Sentry metric alert rule, such as 7",
+    events: [...SENTRY_METRIC_ALERT_EVENTS]
+  }
+});
 var SENTRY_METRIC_ALERT_IDENTIFIER = {
   format: "metric-alert:org/alertRuleId",
   pattern: String.raw`^metric-alert:[^\s/:#]+\/\d+$`
@@ -38,52 +110,55 @@ function sentryMetricAlertResource(input) {
 }
 
 // src/webhooks/events.ts
-import { z } from "zod";
-var issueWebhookSchema = z.object({
-  action: z.string(),
-  data: z.object({
-    issue: z.object({
-      culprit: z.string().optional(),
-      firstSeen: z.string().optional(),
-      id: z.string().min(1),
-      issueCategory: z.string().optional(),
-      issueType: z.string().optional(),
-      level: z.string().optional(),
-      priority: z.string().optional(),
-      project: z.object({ slug: z.string().min(1) }).passthrough(),
-      status: z.string().optional(),
-      substatus: z.string().optional().nullable(),
-      title: z.string().optional(),
-      url: z.string().url(),
-      web_url: z.string().url().optional()
+import {
+  eventDataSchema
+} from "@sentry/junior-plugin-api";
+import { z as z2 } from "zod";
+var issueLevelSchema = z2.enum(SENTRY_ISSUE_LEVELS).optional().catch(void 0);
+var issuePrioritySchema = z2.enum(SENTRY_ISSUE_PRIORITIES).optional().catch(void 0);
+var issueWebhookSchema = z2.object({
+  action: z2.literal("created"),
+  data: z2.object({
+    issue: z2.object({
+      culprit: z2.string().optional(),
+      firstSeen: z2.string().optional(),
+      id: z2.string().min(1),
+      issueCategory: z2.string().optional(),
+      issueType: z2.string().optional(),
+      level: issueLevelSchema,
+      priority: issuePrioritySchema,
+      project: z2.object({ slug: z2.string().min(1) }).passthrough(),
+      title: z2.string().optional(),
+      url: z2.string().url(),
+      web_url: z2.string().url().optional()
     }).passthrough()
   }),
-  installation: z.object({ uuid: z.string().min(1) }).passthrough()
+  installation: z2.object({ uuid: z2.string().min(1) }).passthrough()
 }).passthrough();
-var metricAlertWebhookSchema = z.object({
-  action: z.string(),
-  data: z.object({
-    description_text: z.string().optional(),
-    description_title: z.string().optional(),
-    metric_alert: z.object({
-      alert_rule: z.object({
-        id: z.coerce.string().min(1),
-        projects: z.array(z.string().min(1)).optional()
+var metricAlertWebhookSchema = z2.object({
+  action: z2.enum(SENTRY_METRIC_ALERT_ACTIONS),
+  data: z2.object({
+    description_text: z2.string().optional(),
+    description_title: z2.string().optional(),
+    metric_alert: z2.object({
+      alert_rule: z2.object({
+        id: z2.coerce.string().min(1),
+        projects: z2.array(z2.string().min(1)).optional()
       }).passthrough(),
-      id: z.coerce.string().min(1)
+      id: z2.coerce.string().min(1)
     }).passthrough(),
-    web_url: z.string().url()
+    web_url: z2.string().url()
   }),
-  installation: z.object({ uuid: z.string().min(1) }).passthrough()
+  installation: z2.object({ uuid: z2.string().min(1) }).passthrough()
 }).passthrough();
-function organizationSlug(issueApiUrl) {
-  try {
-    const segments = new URL(issueApiUrl).pathname.split("/").filter(Boolean);
-    const organizationsIndex = segments.indexOf("organizations");
-    return organizationsIndex >= 0 ? segments[organizationsIndex + 1] : void 0;
-  } catch {
-    return void 0;
-  }
+function organizationSlug(url) {
+  const parsed = z2.url().safeParse(url);
+  if (!parsed.success) return void 0;
+  const { hostname, pathname } = new URL(parsed.data);
+  const segments = pathname.split("/").filter(Boolean);
+  const index = segments.indexOf("organizations");
+  const slug = index >= 0 ? segments[index + 1] : hostname.split(".").length >= 3 ? hostname.split(".")[0] : void 0;
+  return slug?.toLowerCase() || void 0;
 }
 function providerTime(value) {
   if (!value) return void 0;
@@ -97,28 +172,59 @@ function providerTime(value) {
 function issueText(issue) {
   const parts = [
     issue.title ? `Title: ${issue.title}` : void 0,
-    issue.culprit ? `Culprit: ${issue.culprit}` : void 0,
-    issue.level ? `Level: ${issue.level}` : void 0,
-    issue.priority ? `Priority: ${issue.priority}` : void 0,
-    issue.issueCategory ? `Category: ${issue.issueCategory}` : void 0,
-    issue.issueType ? `Type: ${issue.issueType}` : void 0,
-    issue.status ? `Status: ${issue.status}` : void 0,
-    issue.substatus ? `Substatus: ${issue.substatus}` : void 0,
-    issue.web_url ? `URL: ${issue.web_url}` : void 0
+    issue.culprit ? `Culprit: ${issue.culprit}` : void 0
   ].filter((part) => part !== void 0);
   return parts.length > 0 ? parts.join("\n") : void 0;
 }
-function webOrganizationSlug(webUrl) {
-  const fromPath = organizationSlug(webUrl);
-  if (fromPath) return fromPath;
-  const labels = new URL(webUrl).hostname.split(".");
-  return labels.length >= 3 ? labels[0] : void 0;
+var issueEventDataSchema = z2.object({
+  projects: z2.array(sentrySlugDataSchema).length(1),
+  issueId: z2.string().min(1),
+  level: z2.enum(SENTRY_ISSUE_LEVELS).optional(),
+  priority: z2.enum(SENTRY_ISSUE_PRIORITIES).optional(),
+  issueCategory: z2.string().min(1).optional(),
+  issueType: z2.string().min(1).optional(),
+  url: z2.string().url().optional()
+}).strict();
+function issueData(issue) {
+  return issueEventDataSchema.parse(
+    definedValues({
+      projects: [issue.project.slug],
+      issueId: issue.id,
+      level: issue.level,
+      priority: issue.priority,
+      issueCategory: issue.issueCategory || void 0,
+      issueType: issue.issueType || void 0,
+      url: issue.web_url
+    })
+  );
+}
+var metricAlertEventDataSchema = z2.object({
+  projects: z2.array(sentrySlugDataSchema).min(1).optional(),
+  alertRuleId: z2.string().min(1),
+  incidentId: z2.string().min(1),
+  url: z2.string().url()
+}).strict();
+function definedValues(data) {
+  return Object.fromEntries(
+    Object.entries(data).filter(([, value]) => value !== void 0)
+  );
+}
+function metricAlertData(input, projects) {
+  const data = metricAlertEventDataSchema.parse(
+    definedValues({
+      ...input,
+      projects: projects.length > 0 ? projects : void 0
+    })
+  );
+  if (eventDataSchema.safeParse(data).success) return data;
+  const { projects: _projects, ...rest } = data;
+  return rest;
 }
 function normalizeIssueEvents(input) {
   const parsed = issueWebhookSchema.safeParse(input.body);
-  if (!parsed.success || parsed.data.action !== "created") return [];
+  if (!parsed.success) return [];
   const issue = parsed.data.data.issue;
-  const org = organizationSlug(issue.url)?.toLowerCase();
+  const org = organizationSlug(issue.url);
   if (!org) return [];
   const issueResource = sentryIssueResource({
     issueId: issue.id,
@@ -137,8 +243,10 @@ function normalizeIssueEvents(input) {
     // idempotency across repeated deliveries of the same lifecycle event.
     eventKey: `sentry:${issueResource.identifier}:${eventType}`,
     eventType,
+    objectType: "task",
     occurredAtMs,
     trustedSummary: `${issueResource.label} was created.`,
+    data: issueData(issue),
     ...untrustedText ? { untrustedText } : void 0
   };
   return [
@@ -150,30 +258,33 @@ function normalizeMetricAlertEvents(input) {
   const parsed = metricAlertWebhookSchema.safeParse(input.body);
   if (!parsed.success) return [];
   const eventType = `metric_alert.${parsed.data.action}`;
-  if (!SENTRY_METRIC_ALERT_EVENTS.includes(eventType)) {
-    return [];
-  }
   const { data } = parsed.data;
-  const org = webOrganizationSlug(data.web_url)?.toLowerCase();
+  const org = organizationSlug(data.web_url);
   if (!org) return [];
   const alertRuleId = data.metric_alert.alert_rule.id;
   const incidentId = data.metric_alert.id;
   const resource = sentryMetricAlertResource({ alertRuleId, org });
-  const untrustedText = [
-    data.description_title,
-    data.description_text,
-    `URL: ${data.web_url}`
-  ].filter((part) => Boolean(part)).join("\n");
+  const untrustedText = [data.description_title, data.description_text].filter((part) => Boolean(part)).join("\n");
+  const projects = [
+    ...new Set(
+      (data.metric_alert.alert_rule.projects ?? []).map(
+        (project) => project.toLowerCase()
+      )
+    )
+  ];
   const event = {
     // One event per incident state. Sentry retries get new Request-IDs.
     eventKey: `sentry:${resource.identifier}:${incidentId}:${eventType}`,
     eventType,
+    objectType: "item",
     occurredAtMs: providerTime(input.hookTimestamp) ?? Date.now(),
     trustedSummary: `${resource.label} is ${parsed.data.action}.`,
-    data: { alertRuleId, incidentId, url: data.web_url },
-    untrustedText
+    data: metricAlertData(
+      { alertRuleId, incidentId, url: data.web_url },
+      projects
+    ),
+    ...untrustedText ? { untrustedText } : void 0
   };
-  const projects = [...new Set(data.metric_alert.alert_rule.projects ?? [])];
   return [
     { ...event, identifier: resource.identifier },
     ...projects.map((project) => ({
@@ -253,10 +364,12 @@ function sentryWebhookSecret() {
 
 export {
   SENTRY_ISSUE_EVENTS,
+  SENTRY_ISSUE_MATCH_FIELDS,
   sentryIssueResource,
   sentryProjectResource,
   SENTRY_METRIC_ALERT_EVENTS,
   SENTRY_METRIC_ALERT_SUGGESTED_EVENTS,
+  SENTRY_METRIC_ALERT_MATCH_FIELDS,
   SENTRY_METRIC_ALERT_IDENTIFIER,
   normalizeSentryEvents,
   createSentryWebhookRoute,

package/dist/events/issue.d.ts

@@ -1,5 +1,18 @@
-import type { SubscribableResource } from "@sentry/junior-plugin-api";
+import { type SubscribableResource } from "@sentry/junior-plugin-api";
 export declare const SENTRY_ISSUE_EVENTS: readonly ["issue.created"];
+/** Issue levels that Sentry sets, from most to least severe. */
+export declare const SENTRY_ISSUE_LEVELS: readonly ["fatal", "error", "warning", "info", "debug"];
+/** Issue priorities that Sentry sets. */
+export declare const SENTRY_ISSUE_PRIORITIES: readonly ["high", "medium", "low"];
+/** Trusted values that Sentry issue events set, when the webhook has them. */
+export declare const SENTRY_ISSUE_MATCH_FIELDS: Record<string, {
+    kind: "boolean" | "number" | "string";
+    description: string;
+    enum?: string[] | undefined;
+    list?: true | undefined;
+    case?: "lower" | "upper" | undefined;
+    events?: string[] | undefined;
+}>;
 /** Build the stable Sentry issue identity shared by tools and webhooks. */
 export declare function sentryIssueResource(input: {
     issueId: string;

package/dist/events/metric-alert.d.ts

@@ -1,7 +1,21 @@
-import type { SubscribableResource } from "@sentry/junior-plugin-api";
+import { type SubscribableResource } from "@sentry/junior-plugin-api";
+/** The `action` values of Sentry metric alert webhooks. */
+export declare const SENTRY_METRIC_ALERT_ACTIONS: readonly ["critical", "warning", "resolved"];
 /** Metric alert states, named after Sentry's `metric_alert.<action>` webhooks. */
 export declare const SENTRY_METRIC_ALERT_EVENTS: readonly ["metric_alert.critical", "metric_alert.warning", "metric_alert.resolved"];
 export declare const SENTRY_METRIC_ALERT_SUGGESTED_EVENTS: string[];
+/**
+ * Trusted values that Sentry metric alert events set. `projects` is missing
+ * when the rule lists no projects or too many to fit in event data.
+ */
+export declare const SENTRY_METRIC_ALERT_MATCH_FIELDS: Record<string, {
+    kind: "boolean" | "number" | "string";
+    description: string;
+    enum?: string[] | undefined;
+    list?: true | undefined;
+    case?: "lower" | "upper" | undefined;
+    events?: string[] | undefined;
+}>;
 /** The identifier shape that `sentryMetricAlertResource` builds. */
 export declare const SENTRY_METRIC_ALERT_IDENTIFIER: {
     format: string;

package/dist/events/scope.d.ts

@@ -0,0 +1,17 @@
+import { type EventMatchFields } from "@sentry/junior-plugin-api";
+import { z } from "zod";
+/**
+ * A project slug in event data. It is lowercase, the same form as
+ * identifiers, because the plugin lowercases every identifier.
+ */
+export declare const sentrySlugDataSchema: z.ZodString;
+/**
+ * Filter on the projects of a Sentry event. `projects` is a list on every
+ * event, so one filter fits an issue, which has one project, and a metric
+ * alert, whose rule can cover several projects.
+ *
+ * There is no `org` filter. One Sentry integration belongs to one org, and
+ * its webhook secret scopes every delivery to that org. So `org` is the same
+ * on every event of an install, and a filter on it cannot narrow anything.
+ */
+export declare function sentryProjectsMatchFields(events: readonly string[]): EventMatchFields;

package/dist/index.js

@@ -1,15 +1,18 @@
 import {
   SENTRY_ISSUE_EVENTS,
+  SENTRY_ISSUE_MATCH_FIELDS,
   SENTRY_METRIC_ALERT_EVENTS,
   SENTRY_METRIC_ALERT_IDENTIFIER,
+  SENTRY_METRIC_ALERT_MATCH_FIELDS,
   SENTRY_METRIC_ALERT_SUGGESTED_EVENTS,
   createSentryWebhookRoute,
   sentryWebhookSecret
-} from "./chunk-KK3VWIJ2.js";
+} from "./chunk-6QQNR5HC.js";
 
 // src/index.ts
 import {
-  defineJuniorPlugin
+  defineJuniorPlugin,
+  mergeEventMatchFields
 } from "@sentry/junior-plugin-api";
 
 // src/org-read.ts
@@ -101,7 +104,8 @@ function sentryPlugin() {
         {
           type: "issue",
           supportedEvents: [...SENTRY_ISSUE_EVENTS],
-          suggestedEvents: [...SENTRY_ISSUE_EVENTS]
+          suggestedEvents: [...SENTRY_ISSUE_EVENTS],
+          matchFields: SENTRY_ISSUE_MATCH_FIELDS
         },
         {
           type: "project",
@@ -112,15 +116,28 @@ function sentryPlugin() {
           suggestedEvents: [
             ...SENTRY_ISSUE_EVENTS,
             ...SENTRY_METRIC_ALERT_SUGGESTED_EVENTS
-          ]
+          ],
+          matchFields: mergeEventMatchFields(
+            SENTRY_ISSUE_MATCH_FIELDS,
+            SENTRY_METRIC_ALERT_MATCH_FIELDS
+          )
         },
         {
           type: "metric_alert",
           identifier: SENTRY_METRIC_ALERT_IDENTIFIER,
           supportedEvents: [...SENTRY_METRIC_ALERT_EVENTS],
-          suggestedEvents: SENTRY_METRIC_ALERT_SUGGESTED_EVENTS
+          suggestedEvents: SENTRY_METRIC_ALERT_SUGGESTED_EVENTS,
+          matchFields: SENTRY_METRIC_ALERT_MATCH_FIELDS
         }
       ],
+      // One install is one Sentry org. Issue and metric alert events carry
+      // alert facts, and Junior adds nothing to Sentry, so they can run for
+      // every project. Use the `projects` filter to narrow them.
+      events: Object.fromEntries(
+        [...SENTRY_ISSUE_EVENTS, ...SENTRY_METRIC_ALERT_EVENTS].map(
+          (eventType) => [eventType, { reach: "all" }]
+        )
+      ),
       isEnabled: () => Boolean(sentryWebhookSecret()),
       normalizeIdentifier: (identifier) => identifier.toLowerCase()
     },

package/dist/testing.js

@@ -4,7 +4,7 @@ import {
   sentryIssueResource,
   sentryProjectResource,
   sentryWebhookSecret
-} from "./chunk-KK3VWIJ2.js";
+} from "./chunk-6QQNR5HC.js";
 export {
   createSentryWebhookRoute,
   normalizeSentryEvents,

package/dist/webhooks/events.d.ts

@@ -1,4 +1,4 @@
-import type { EventInput } from "@sentry/junior-plugin-api";
+import { type EventInput } from "@sentry/junior-plugin-api";
 interface WebhookInput {
     body: unknown;
     hookResource: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-sentry",
-  "version": "0.265.0",
+  "version": "0.267.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -27,7 +27,7 @@
   ],
   "dependencies": {
     "zod": "^4.5.4",
-    "@sentry/junior-plugin-api": "0.265.0"
+    "@sentry/junior-plugin-api": "0.267.0"
   },
   "devDependencies": {
     "@oxlint/plugins": "1.79.0",
@@ -35,7 +35,8 @@
     "oxlint": "^1.79.0",
     "tsup": "^8.5.1",
     "typescript": "^7.0.2",
-    "vitest": "^4.1.12"
+    "vitest": "^4.1.12",
+    "@sentry/junior-testing": "0.0.0"
   },
   "scripts": {
     "build": "tsup && tsc -p tsconfig.build.json --emitDeclarationOnly",