@rustrak/client 0.3.10 → 0.3.12

package/dist/index.cjs

@@ -21,7 +21,11 @@ var offsetPaginatedResponseSchema = (itemSchema) => zod.z.object({
   total_pages: zod.z.number().int()
 });
 zod.z.enum(["asc", "desc"]);
-zod.z.enum(["digest_order", "last_seen"]);
+zod.z.enum([
+  "digest_order",
+  "last_seen",
+  "event_count"
+]);
 zod.z.enum(["open", "resolved", "muted", "all"]);
 var dateTimeSchema = zod.z.string().datetime();
 var uuidSchema = zod.z.string().uuid();
@@ -525,24 +529,129 @@ var eventDetailSchema = zod.z.object({
   data: zod.z.record(zod.z.string(), zod.z.any())
   // Full Sentry event JSON
 });
+var issueStatusSchema = zod.z.enum(["unresolved", "resolved", "ignored"]);
+var issuePrioritySchema = zod.z.enum(["low", "medium", "high"]);
 var issueSchema = zod.z.object({
   id: uuidSchema,
   project_id: zod.z.number().int(),
   short_id: zod.z.string(),
   title: zod.z.string(),
   value: zod.z.string(),
+  culprit: zod.z.string(),
+  logger: zod.z.string(),
   first_seen: dateTimeSchema,
   last_seen: dateTimeSchema,
   event_count: zod.z.number().int(),
   level: zod.z.string().nullable(),
   platform: zod.z.string().nullable(),
+  // Status model (#165)
+  status: issueStatusSchema,
+  substatus: zod.z.string().nullable(),
+  priority: issuePrioritySchema.nullable(),
+  assigned_to: zod.z.number().int().nullable(),
+  assignee_type: zod.z.string().nullable(),
+  issue_type: zod.z.string(),
+  issue_category: zod.z.string(),
+  first_release: zod.z.string(),
+  last_release: zod.z.string(),
+  status_details: zod.z.record(zod.z.string(), zod.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: zod.z.number().int().optional().default(0),
+  // Per-user fields — only present when the request carries a user session.
+  is_bookmarked: zod.z.boolean().optional(),
+  is_subscribed: zod.z.boolean().optional(),
+  has_seen: zod.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: zod.z.number().int().optional(),
+  trend: zod.z.array(zod.z.number().int()).optional(),
+  // Deprecated, derived from `status`; kept for backward compatibility.
   is_resolved: zod.z.boolean(),
   is_muted: zod.z.boolean()
 });
 var updateIssueStateSchema = zod.z.object({
+  status: zod.z.union([issueStatusSchema, zod.z.literal("resolvedInNextRelease")]).optional(),
+  substatus: zod.z.string().optional(),
+  priority: issuePrioritySchema.optional(),
+  assigned_to: zod.z.number().int().nullable().optional(),
+  assignee_type: zod.z.string().nullable().optional(),
   is_resolved: zod.z.boolean().optional(),
   is_muted: zod.z.boolean().optional()
 });
+var issueHashSchema = zod.z.object({
+  id: zod.z.number().int(),
+  project_id: zod.z.number().int(),
+  issue_id: uuidSchema,
+  grouping_key: zod.z.string(),
+  grouping_key_hash: zod.z.string(),
+  created_at: dateTimeSchema
+});
+var tagValueCountSchema = zod.z.object({
+  value: zod.z.string(),
+  count: zod.z.number().int()
+});
+var issueTagValueSchema = zod.z.object({
+  key: zod.z.string(),
+  name: zod.z.string(),
+  value: zod.z.string(),
+  count: zod.z.number().int(),
+  first_seen: dateTimeSchema,
+  last_seen: dateTimeSchema
+});
+var tagSummarySchema = zod.z.object({
+  key: zod.z.string(),
+  total_values: zod.z.number().int(),
+  top_values: zod.z.array(tagValueCountSchema)
+});
+var issueAggregatesSchema = zod.z.object({
+  user_count: zod.z.number().int(),
+  tags: zod.z.array(tagSummarySchema)
+});
+zod.z.enum(["24h", "30d"]);
+var issueStatsSchema = zod.z.object({
+  data: zod.z.array(zod.z.tuple([zod.z.number(), zod.z.number()]))
+});
+var activityEntrySchema = zod.z.object({
+  id: uuidSchema,
+  issue_id: uuidSchema,
+  user_id: zod.z.number().int().nullable(),
+  type: zod.z.string(),
+  data: zod.z.string(),
+  created_at: dateTimeSchema
+});
+var userReportSchema = zod.z.object({
+  id: uuidSchema,
+  project_id: zod.z.number().int(),
+  issue_id: uuidSchema.nullable(),
+  event_id: uuidSchema.nullable(),
+  name: zod.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: zod.z.union([zod.z.email(), zod.z.literal("")]),
+  comments: zod.z.string(),
+  created_at: dateTimeSchema
+});
+var createCommentSchema = zod.z.object({
+  text: zod.z.string()
+});
+var createUserReportSchema = zod.z.object({
+  name: zod.z.string().optional(),
+  email: zod.z.email().optional(),
+  comments: zod.z.string().optional(),
+  event_id: uuidSchema.optional()
+});
+var bulkUpdateIssuesSchema = zod.z.object({
+  ids: zod.z.array(uuidSchema),
+  status: zod.z.union([issueStatusSchema, zod.z.literal("resolvedInNextRelease")]).optional(),
+  priority: issuePrioritySchema.optional()
+});
+var bulkDeleteIssuesSchema = zod.z.object({
+  ids: zod.z.array(uuidSchema)
+});
+var createDeploySchema = zod.z.object({
+  version: zod.z.string()
+});
 var logSchema = zod.z.object({
   id: uuidSchema,
   trace_id: zod.z.string().nullable(),
@@ -575,7 +684,8 @@ var projectSchema = zod.z.object({
   stored_event_count: zod.z.number().int(),
   digested_event_count: zod.z.number().int(),
   created_at: dateTimeSchema,
-  updated_at: dateTimeSchema
+  updated_at: dateTimeSchema,
+  platform: zod.z.string().nullable()
 });
 var createProjectSchema = zod.z.object({
   name: zod.z.string().min(1),
@@ -596,6 +706,22 @@ var releaseHealthRowSchema = zod.z.object({
   crash_free_users_rate: zod.z.number().nullable()
 });
 var releaseHealthSchema = zod.z.array(releaseHealthRowSchema);
+var sessionSummarySchema = zod.z.object({
+  total: zod.z.number().int(),
+  errored: zod.z.number().int(),
+  crashed: zod.z.number().int(),
+  abnormal: zod.z.number().int(),
+  crash_free_sessions_rate: zod.z.number().nullable(),
+  crash_free_users_rate: zod.z.number().nullable(),
+  active_releases: zod.z.number().int()
+});
+var sessionTimeseriesPointSchema = zod.z.object({
+  bucket: dateTimeSchema,
+  total: zod.z.number().int(),
+  crashed: zod.z.number().int(),
+  crash_free_sessions_rate: zod.z.number().nullable()
+});
+var sessionTimeseriesSchema = zod.z.array(sessionTimeseriesPointSchema);
 var chunkUploadCapabilitySchema = zod.z.object({
   url: zod.z.string(),
   chunkSize: zod.z.number().int(),
@@ -793,8 +919,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
@@ -816,6 +940,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));
   }
@@ -827,7 +954,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);
@@ -836,12 +963,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, zod.z.object({ updated: zod.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, zod.z.object({ deleted: zod.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, zod.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, zod.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, zod.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, zod.z.object({ is_bookmarked: zod.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, zod.z.object({ is_subscribed: zod.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, zod.z.object({ has_seen: zod.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, zod.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,
+      zod.z.object({ version: zod.z.string(), finalized: zod.z.number().int() })
+    );
+  }
 };
 
 // src/resources/logs.ts
@@ -951,6 +1205,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, zod.z.array(issueSchema));
+  }
+};
 
 // src/resources/sessions.ts
 var SessionsResource = class extends BaseResource {
@@ -958,15 +1232,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
@@ -1336,6 +1646,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)
    */
@@ -1371,6 +1685,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);