@rustrak/client 0.3.10 → 0.3.11

package/dist/index.js

@@ -519,24 +519,129 @@ var eventDetailSchema = z.object({
   data: z.record(z.string(), z.any())
   // Full Sentry event JSON
 });
+var issueStatusSchema = z.enum(["unresolved", "resolved", "ignored"]);
+var issuePrioritySchema = z.enum(["low", "medium", "high"]);
 var issueSchema = z.object({
   id: uuidSchema,
   project_id: z.number().int(),
   short_id: z.string(),
   title: z.string(),
   value: z.string(),
+  culprit: z.string(),
+  logger: z.string(),
   first_seen: dateTimeSchema,
   last_seen: dateTimeSchema,
   event_count: z.number().int(),
   level: z.string().nullable(),
   platform: z.string().nullable(),
+  // Status model (#165)
+  status: issueStatusSchema,
+  substatus: z.string().nullable(),
+  priority: issuePrioritySchema.nullable(),
+  assigned_to: z.number().int().nullable(),
+  assignee_type: z.string().nullable(),
+  issue_type: z.string(),
+  issue_category: z.string(),
+  first_release: z.string(),
+  last_release: z.string(),
+  status_details: z.record(z.string(), z.unknown()),
+  // Aggregate enrichment — only the single-issue GET populates this; the list
+  // and PATCH endpoints return the lean response, so default to 0 when absent.
+  user_report_count: z.number().int().optional().default(0),
+  // Per-user fields — only present when the request carries a user session.
+  is_bookmarked: z.boolean().optional(),
+  is_subscribed: z.boolean().optional(),
+  has_seen: z.boolean().optional(),
+  // Bulk list stats — only the list endpoint populates these (computed once
+  // per page); the single-issue GET and PATCH responses omit them.
+  user_count: z.number().int().optional(),
+  trend: z.array(z.number().int()).optional(),
+  // Deprecated, derived from `status`; kept for backward compatibility.
   is_resolved: z.boolean(),
   is_muted: z.boolean()
 });
 var updateIssueStateSchema = z.object({
+  status: z.union([issueStatusSchema, z.literal("resolvedInNextRelease")]).optional(),
+  substatus: z.string().optional(),
+  priority: issuePrioritySchema.optional(),
+  assigned_to: z.number().int().nullable().optional(),
+  assignee_type: z.string().nullable().optional(),
   is_resolved: z.boolean().optional(),
   is_muted: z.boolean().optional()
 });
+var issueHashSchema = z.object({
+  id: z.number().int(),
+  project_id: z.number().int(),
+  issue_id: uuidSchema,
+  grouping_key: z.string(),
+  grouping_key_hash: z.string(),
+  created_at: dateTimeSchema
+});
+var tagValueCountSchema = z.object({
+  value: z.string(),
+  count: z.number().int()
+});
+var issueTagValueSchema = z.object({
+  key: z.string(),
+  name: z.string(),
+  value: z.string(),
+  count: z.number().int(),
+  first_seen: dateTimeSchema,
+  last_seen: dateTimeSchema
+});
+var tagSummarySchema = z.object({
+  key: z.string(),
+  total_values: z.number().int(),
+  top_values: z.array(tagValueCountSchema)
+});
+var issueAggregatesSchema = z.object({
+  user_count: z.number().int(),
+  tags: z.array(tagSummarySchema)
+});
+z.enum(["24h", "30d"]);
+var issueStatsSchema = z.object({
+  data: z.array(z.tuple([z.number(), z.number()]))
+});
+var activityEntrySchema = z.object({
+  id: uuidSchema,
+  issue_id: uuidSchema,
+  user_id: z.number().int().nullable(),
+  type: z.string(),
+  data: z.string(),
+  created_at: dateTimeSchema
+});
+var userReportSchema = z.object({
+  id: uuidSchema,
+  project_id: z.number().int(),
+  issue_id: uuidSchema.nullable(),
+  event_id: uuidSchema.nullable(),
+  name: z.string(),
+  // Server stores '' for anonymous reports (column DEFAULT '' / unwrap_or_default),
+  // matching real Sentry's own save_userreport(report.get("email", "")) — accept it.
+  email: z.union([z.email(), z.literal("")]),
+  comments: z.string(),
+  created_at: dateTimeSchema
+});
+var createCommentSchema = z.object({
+  text: z.string()
+});
+var createUserReportSchema = z.object({
+  name: z.string().optional(),
+  email: z.email().optional(),
+  comments: z.string().optional(),
+  event_id: uuidSchema.optional()
+});
+var bulkUpdateIssuesSchema = z.object({
+  ids: z.array(uuidSchema),
+  status: z.union([issueStatusSchema, z.literal("resolvedInNextRelease")]).optional(),
+  priority: issuePrioritySchema.optional()
+});
+var bulkDeleteIssuesSchema = z.object({
+  ids: z.array(uuidSchema)
+});
+var createDeploySchema = z.object({
+  version: z.string()
+});
 var logSchema = z.object({
   id: uuidSchema,
   trace_id: z.string().nullable(),
@@ -787,8 +892,6 @@ var InvitationsResource = class extends BaseResource {
     await this.http.delete(`api/invitations/${token}`);
   }
 };
-
-// src/resources/issues.ts
 var IssuesResource = class extends BaseResource {
   /**
    * List issues for a project with offset-based pagination
@@ -810,6 +913,9 @@ var IssuesResource = class extends BaseResource {
     if (options?.filter) {
       searchParams.filter = options.filter;
     }
+    if (options?.q) {
+      searchParams.q = options.q;
+    }
     const data = await this.http.get(`api/projects/${projectId}/issues`, { searchParams }).json();
     return this.validate(data, offsetPaginatedResponseSchema(issueSchema));
   }
@@ -821,7 +927,7 @@ var IssuesResource = class extends BaseResource {
     return this.validate(data, issueSchema);
   }
   /**
-   * Update issue state (resolve, mute, etc.)
+   * Update issue state (status, substatus, priority, assignment, …)
    */
   async updateState(projectId, issueId, input) {
     const validatedInput = this.validate(input, updateIssueStateSchema);
@@ -830,12 +936,139 @@ var IssuesResource = class extends BaseResource {
     }).json();
     return this.validate(data, issueSchema);
   }
+  /**
+   * Resolve an issue in the next release (suppresses regression until a deploy).
+   */
+  async resolveInNextRelease(projectId, issueId) {
+    return this.updateState(projectId, issueId, {
+      status: "resolvedInNextRelease"
+    });
+  }
   /**
    * Delete an issue
    */
   async delete(projectId, issueId) {
     await this.http.delete(`api/projects/${projectId}/issues/${issueId}`);
   }
+  /**
+   * Bulk-mutate issues (status and/or priority).
+   */
+  async bulkUpdate(projectId, input) {
+    const validatedInput = this.validate(input, bulkUpdateIssuesSchema);
+    const data = await this.http.put(`api/projects/${projectId}/issues`, { json: validatedInput }).json();
+    return this.validate(data, z.object({ updated: z.number().int() }));
+  }
+  /**
+   * Bulk-delete issues.
+   */
+  async bulkDelete(projectId, input) {
+    const validatedInput = this.validate(input, bulkDeleteIssuesSchema);
+    const data = await this.http.delete(`api/projects/${projectId}/issues`, { json: validatedInput }).json();
+    return this.validate(data, z.object({ deleted: z.number().int() }));
+  }
+  /**
+   * List the grouping hashes that map to an issue.
+   */
+  async getHashes(projectId, issueId) {
+    const data = await this.http.get(`api/projects/${projectId}/issues/${issueId}/hashes`).json();
+    return this.validate(data, z.array(issueHashSchema));
+  }
+  /**
+   * List the distinct values (with counts) for a tag key across the issue.
+   * Returns a bare list, one entry per value (Sentry-compatible shape).
+   */
+  async getTagValues(projectId, issueId, key) {
+    const data = await this.http.get(
+      `api/projects/${projectId}/issues/${issueId}/tags/${encodeURIComponent(key)}`
+    ).json();
+    return this.validate(data, z.array(issueTagValueSchema));
+  }
+  /**
+   * Fetch per-issue aggregates (unique user count + top tags).
+   */
+  async getAggregates(projectId, issueId) {
+    const data = await this.http.get(`api/projects/${projectId}/issues/${issueId}/aggregates`).json();
+    return this.validate(data, issueAggregatesSchema);
+  }
+  /**
+   * Fetch a zero-filled event-count timeseries (24h or 30d).
+   */
+  async getStats(projectId, issueId, window = "24h") {
+    const data = await this.http.get(`api/projects/${projectId}/issues/${issueId}/stats`, {
+      searchParams: { window }
+    }).json();
+    return this.validate(data, issueStatsSchema);
+  }
+  /**
+   * List an issue's activity log (status changes, comments/notes, …).
+   */
+  async getActivity(projectId, issueId) {
+    const data = await this.http.get(`api/projects/${projectId}/issues/${issueId}/activity`).json();
+    return this.validate(data, z.array(activityEntrySchema));
+  }
+  /**
+   * Add a comment (note) to an issue.
+   */
+  async addComment(projectId, issueId, input) {
+    const validatedInput = this.validate(input, createCommentSchema);
+    const data = await this.http.post(`api/projects/${projectId}/issues/${issueId}/comments`, {
+      json: validatedInput
+    }).json();
+    return this.validate(data, activityEntrySchema);
+  }
+  /**
+   * Set or clear the current user's bookmark on an issue.
+   */
+  async setBookmark(projectId, issueId, enabled) {
+    const data = await this.http.put(`api/projects/${projectId}/issues/${issueId}/bookmark`, {
+      json: { enabled }
+    }).json();
+    return this.validate(data, z.object({ is_bookmarked: z.boolean() }));
+  }
+  /**
+   * Set or clear the current user's subscription to an issue.
+   */
+  async setSubscription(projectId, issueId, enabled) {
+    const data = await this.http.put(`api/projects/${projectId}/issues/${issueId}/subscription`, {
+      json: { enabled }
+    }).json();
+    return this.validate(data, z.object({ is_subscribed: z.boolean() }));
+  }
+  /**
+   * Mark the issue as seen by the current user.
+   */
+  async markSeen(projectId, issueId) {
+    const data = await this.http.post(`api/projects/${projectId}/issues/${issueId}/seen`).json();
+    return this.validate(data, z.object({ has_seen: z.boolean() }));
+  }
+  /**
+   * List user feedback reports for an issue.
+   */
+  async listUserReports(projectId, issueId) {
+    const data = await this.http.get(`api/projects/${projectId}/issues/${issueId}/user-reports`).json();
+    return this.validate(data, z.array(userReportSchema));
+  }
+  /**
+   * Attach a user feedback report to an issue.
+   */
+  async createUserReport(projectId, issueId, input) {
+    const validatedInput = this.validate(input, createUserReportSchema);
+    const data = await this.http.post(`api/projects/${projectId}/issues/${issueId}/user-reports`, {
+      json: validatedInput
+    }).json();
+    return this.validate(data, userReportSchema);
+  }
+  /**
+   * Record a deploy of a release, finalizing resolve-in-next-release issues.
+   */
+  async createDeploy(projectId, input) {
+    const validatedInput = this.validate(input, createDeploySchema);
+    const data = await this.http.post(`api/projects/${projectId}/deploys`, { json: validatedInput }).json();
+    return this.validate(
+      data,
+      z.object({ version: z.string(), finalized: z.number().int() })
+    );
+  }
 };
 
 // src/resources/logs.ts