@rustrak/client 0.3.10 → 0.3.12

package/dist/index.js

@@ -15,7 +15,11 @@ var offsetPaginatedResponseSchema = (itemSchema) => z.object({
   total_pages: z.number().int()
 });
 z.enum(["asc", "desc"]);
-z.enum(["digest_order", "last_seen"]);
+z.enum([
+  "digest_order",
+  "last_seen",
+  "event_count"
+]);
 z.enum(["open", "resolved", "muted", "all"]);
 var dateTimeSchema = z.string().datetime();
 var uuidSchema = z.string().uuid();
@@ -519,24 +523,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(),
@@ -569,7 +678,8 @@ var projectSchema = z.object({
   stored_event_count: z.number().int(),
   digested_event_count: z.number().int(),
   created_at: dateTimeSchema,
-  updated_at: dateTimeSchema
+  updated_at: dateTimeSchema,
+  platform: z.string().nullable()
 });
 var createProjectSchema = z.object({
   name: z.string().min(1),
@@ -590,6 +700,22 @@ var releaseHealthRowSchema = z.object({
   crash_free_users_rate: z.number().nullable()
 });
 var releaseHealthSchema = z.array(releaseHealthRowSchema);
+var sessionSummarySchema = z.object({
+  total: z.number().int(),
+  errored: z.number().int(),
+  crashed: z.number().int(),
+  abnormal: z.number().int(),
+  crash_free_sessions_rate: z.number().nullable(),
+  crash_free_users_rate: z.number().nullable(),
+  active_releases: z.number().int()
+});
+var sessionTimeseriesPointSchema = z.object({
+  bucket: dateTimeSchema,
+  total: z.number().int(),
+  crashed: z.number().int(),
+  crash_free_sessions_rate: z.number().nullable()
+});
+var sessionTimeseriesSchema = z.array(sessionTimeseriesPointSchema);
 var chunkUploadCapabilitySchema = z.object({
   url: z.string(),
   chunkSize: z.number().int(),
@@ -787,8 +913,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 +934,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 +948,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 +957,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
@@ -945,6 +1199,26 @@ var ProjectsResource = class extends BaseResource {
     await this.http.delete(`api/projects/${id}`);
   }
 };
+var ReleasesResource = class extends BaseResource {
+  /**
+   * Get issues first seen in a given release, most recently introduced first.
+   *
+   * @param projectId - Project ID
+   * @param release - Release version
+   * @param limit - Max issues to return (default: 10, max: 50)
+   */
+  async newIssues(projectId, release, limit) {
+    const searchParams = {};
+    if (limit !== void 0) {
+      searchParams.limit = limit.toString();
+    }
+    const data = await this.http.get(
+      `api/projects/${projectId}/releases/${encodeURIComponent(release)}/new-issues`,
+      { searchParams }
+    ).json();
+    return this.validate(data, z.array(issueSchema));
+  }
+};
 
 // src/resources/sessions.ts
 var SessionsResource = class extends BaseResource {
@@ -952,15 +1226,51 @@ var SessionsResource = class extends BaseResource {
    * Get per-release health stats for a project.
    * @param projectId - Project ID
    * @param period - Time window (e.g. '24h', '7d'). Defaults to '24h'.
+   * @param release - Scope to a single release (all environments), computed
+   *   server-side. Omit to get every release in the project.
    */
-  async stats(projectId, period) {
+  async stats(projectId, period, release) {
     const searchParams = {};
     if (period) {
       searchParams.period = period;
     }
+    if (release) {
+      searchParams.release = release;
+    }
     const data = await this.http.get(`api/projects/${projectId}/sessions/stats`, { searchParams }).json();
     return this.validate(data, releaseHealthSchema);
   }
+  /**
+   * Get project-wide session health, aggregated across all releases and environments.
+   * @param projectId - Project ID
+   * @param period - Time window (e.g. '24h', '7d'). Defaults to '24h'.
+   */
+  async summary(projectId, period) {
+    const searchParams = {};
+    if (period) {
+      searchParams.period = period;
+    }
+    const data = await this.http.get(`api/projects/${projectId}/sessions/summary`, { searchParams }).json();
+    return this.validate(data, sessionSummarySchema);
+  }
+  /**
+   * Get a time-bucketed session trend for a project, aggregated across all
+   * releases and environments.
+   * @param projectId - Project ID
+   * @param period - Time window (e.g. '24h', '7d'). Defaults to '24h'.
+   * @param interval - Bucket width in hours (default: 1, max: 24).
+   */
+  async timeseries(projectId, period, interval) {
+    const searchParams = {};
+    if (period) {
+      searchParams.period = period;
+    }
+    if (interval !== void 0) {
+      searchParams.interval = interval.toString();
+    }
+    const data = await this.http.get(`api/projects/${projectId}/sessions/timeseries`, { searchParams }).json();
+    return this.validate(data, sessionTimeseriesSchema);
+  }
 };
 
 // src/resources/sourcemaps.ts
@@ -1330,6 +1640,10 @@ var RustrakClient = class {
    * Sessions API resource (release health)
    */
   sessions;
+  /**
+   * Releases API resource (data scoped to a specific release)
+   */
+  releases;
   /**
    * Transactions API resource (performance monitoring)
    */
@@ -1365,6 +1679,7 @@ var RustrakClient = class {
     this.invitations = new InvitationsResource(this.http);
     this.members = new MembersResource(this.http);
     this.sessions = new SessionsResource(this.http);
+    this.releases = new ReleasesResource(this.http);
     this.transactions = new TransactionsResource(this.http);
     this.logs = new LogsResource(this.http);
     this.storage = new StorageResource(this.http);