@rustrak/client 0.16.4 → 0.18.0

package/dist/index.js

@@ -128,13 +128,24 @@ var alertRuleChannelInputSchema = z.object({
   integration_id: z.number().int(),
   routing_override: z.record(z.string(), z.unknown()).default({})
 });
+var alertRuleConditionsSchema = z.object({
+  /** The quietest level that still fires. The server takes `null` as absent. */
+  min_level: z.enum(["debug", "info", "warning", "error", "fatal"]).nullish(),
+  /** When non-empty, the only environments that fire. */
+  environments: z.array(z.string()).optional(),
+  /** A new issue fires when it reaches this many events, not on its first. */
+  min_events: z.number().int().min(1).nullish()
+});
 var alertRuleSchema = z.object({
   id: z.number().int(),
   project_id: z.number().int(),
   name: z.string(),
   alert_type: alertTypeSchema,
   is_enabled: z.boolean(),
-  conditions: z.record(z.string(), z.unknown()),
+  // A rule stored before the filters existed may hold any object. The server
+  // evaluates one it cannot read as no filters; one bad row must not fail the
+  // whole list either.
+  conditions: alertRuleConditionsSchema.catch({}),
   cooldown_minutes: z.number().int(),
   last_triggered_at: dateTimeSchema.nullable(),
   created_at: dateTimeSchema,
@@ -147,13 +158,13 @@ var createAlertRuleSchema = z.object({
   alert_type: alertTypeSchema,
   channels: z.array(alertRuleChannelInputSchema).default([]),
   is_enabled: z.boolean().optional(),
-  conditions: z.record(z.string(), z.unknown()).optional(),
+  conditions: alertRuleConditionsSchema.optional(),
   cooldown_minutes: z.number().int().min(0).optional()
 });
 var updateAlertRuleSchema = z.object({
   name: z.string().min(1).optional(),
   is_enabled: z.boolean().optional(),
-  conditions: z.record(z.string(), z.unknown()).optional(),
+  conditions: alertRuleConditionsSchema.optional(),
   cooldown_minutes: z.number().int().min(0).optional(),
   channels: z.array(alertRuleChannelInputSchema).optional()
 });
@@ -225,6 +236,89 @@ var eventDetailSchema = z.object({
   data: z.record(z.string(), z.any())
   // Full Sentry event JSON
 });
+var gitHubAppSchema = z.object({
+  app_id: z.number().int(),
+  slug: z.string(),
+  html_url: z.string(),
+  owner_login: z.string(),
+  install_url: z.string(),
+  last_webhook_at: dateTimeSchema.nullable(),
+  created_at: dateTimeSchema
+});
+var gitHubInstallationSchema = z.object({
+  id: z.number().int(),
+  account_login: z.string(),
+  account_type: z.string(),
+  suspended: z.boolean(),
+  created_at: dateTimeSchema
+});
+var gitHubStatusSchema = z.object({
+  app: gitHubAppSchema.nullable(),
+  installations: z.array(gitHubInstallationSchema),
+  webhook_url: z.string()
+});
+var gitHubManifestSchema = z.object({
+  action_url: z.string(),
+  manifest: z.string()
+});
+var gitHubRepositorySchema = z.object({
+  installation_id: z.number().int(),
+  full_name: z.string(),
+  default_branch: z.string(),
+  private: z.boolean(),
+  html_url: z.string()
+});
+var codeMappingSchema = z.object({
+  stack_root: z.string(),
+  source_root: z.string()
+});
+var projectRepositorySchema = z.object({
+  project_id: z.number().int(),
+  installation_id: z.number().int(),
+  repo_full_name: z.string(),
+  default_branch: z.string(),
+  html_url: z.string(),
+  code_mappings: z.array(codeMappingSchema),
+  /** Open a GitHub issue for new issues that pass `auto_create_conditions`. */
+  auto_create_issues: z.boolean(),
+  auto_create_conditions: alertRuleConditionsSchema,
+  codeowners_rules: z.number().int().nullable(),
+  codeowners_synced_at: dateTimeSchema.nullable()
+});
+var updateProjectRepositorySchema = z.object({
+  installation_id: z.number().int(),
+  repo_full_name: z.string().min(1),
+  code_mappings: z.array(codeMappingSchema).optional(),
+  auto_create_issues: z.boolean().optional(),
+  auto_create_conditions: alertRuleConditionsSchema.optional()
+});
+var issueLinkSchema = z.object({
+  id: z.number().int(),
+  issue_id: z.string(),
+  repo_full_name: z.string(),
+  number: z.number().int(),
+  title: z.string(),
+  url: z.string(),
+  state: z.string(),
+  created_at: dateTimeSchema
+});
+var repoCommitSchema = z.object({
+  repo_full_name: z.string(),
+  sha: z.string(),
+  message: z.string(),
+  author_name: z.string(),
+  author_login: z.string().nullable(),
+  url: z.string(),
+  committed_at: dateTimeSchema
+});
+var issueGitHubSchema = z.object({
+  links: z.array(issueLinkSchema),
+  suspect_commits: z.array(repoCommitSchema),
+  owners: z.array(z.string())
+});
+var gitHubLoginSchema = z.object({
+  login: z.string().nullable()
+});
 var globalRoleSchema = z.enum(["admin", "member"]);
 var teamMemberSchema = z.object({
   id: z.number().int(),
@@ -408,6 +502,96 @@ var upsertProjectMemberSchema = z.object({
   user_id: z.number().int(),
   role: projectRoleSchema
 });
+var intervalUnitSchema = z.enum([
+  "minute",
+  "hour",
+  "day",
+  "week",
+  "month",
+  "year"
+]);
+var scheduleSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("crontab"), value: z.string() }),
+  z.object({
+    type: z.literal("interval"),
+    value: z.number().int().min(1),
+    unit: intervalUnitSchema
+  })
+]);
+var previewScheduleSchema = z.object({
+  schedule: scheduleSchema,
+  /** IANA zone the schedule is read in. Defaults to UTC. */
+  timezone: z.string().optional()
+});
+var schedulePreviewSchema = z.object({
+  next_runs: z.array(dateTimeSchema)
+});
+
+// src/schemas/monitor.ts
+var monitorConfigSchema = z.object({
+  schedule: scheduleSchema,
+  checkin_margin: z.number().int(),
+  max_runtime: z.number().int(),
+  timezone: z.string(),
+  failure_issue_threshold: z.number().int(),
+  recovery_threshold: z.number().int()
+});
+var monitorConfigInputSchema = z.object({
+  schedule: scheduleSchema.optional(),
+  checkin_margin: z.number().int().min(1).optional(),
+  max_runtime: z.number().int().min(1).optional(),
+  timezone: z.string().optional(),
+  failure_issue_threshold: z.number().int().min(1).max(720).optional(),
+  recovery_threshold: z.number().int().min(1).max(720).optional()
+});
+var checkInStatusSchema = z.enum([
+  "ok",
+  "error",
+  "in_progress",
+  "missed",
+  "timeout",
+  "unknown"
+]);
+var monitorEnvironmentStatusSchema = z.enum(["active", "ok", "error"]);
+var checkInSchema = z.object({
+  id: uuidSchema,
+  environment: z.string(),
+  status: checkInStatusSchema,
+  duration_ms: z.number().int().nullable(),
+  date_added: dateTimeSchema,
+  date_updated: dateTimeSchema,
+  expected_time: dateTimeSchema.nullable()
+});
+var monitorEnvironmentSchema = z.object({
+  id: uuidSchema,
+  environment: z.string(),
+  status: monitorEnvironmentStatusSchema,
+  next_checkin: dateTimeSchema.nullable(),
+  next_checkin_latest: dateTimeSchema.nullable(),
+  last_checkin: dateTimeSchema.nullable(),
+  /** Newest first. */
+  recent_checkins: z.array(checkInSchema)
+});
+var monitorSchema = z.object({
+  id: uuidSchema,
+  slug: z.string(),
+  name: z.string(),
+  config: monitorConfigSchema,
+  is_muted: z.boolean(),
+  created_at: dateTimeSchema,
+  environments: z.array(monitorEnvironmentSchema)
+});
+var createMonitorSchema = z.object({
+  name: z.string().trim().min(1).max(128),
+  /** Derived from `name` when left out. */
+  slug: z.string().min(1).max(50).optional(),
+  config: monitorConfigInputSchema
+});
+var updateMonitorSchema = z.object({
+  name: z.string().trim().min(1).max(128).optional(),
+  config: monitorConfigInputSchema.optional(),
+  is_muted: z.boolean().optional()
+});
 var metricDeltaSchema = z.object({
   current: z.number().int(),
   /**
@@ -580,14 +764,21 @@ var projectStorageSchema = z.object({
   spans_count: z.number(),
   logs_count: z.number(),
   source_maps_count: z.number(),
-  estimated_bytes: z.number()
+  /** `events_bytes + transactions_bytes + logs_bytes`. */
+  estimated_bytes: z.number(),
+  events_bytes: z.number(),
+  /** Transactions with their spans. */
+  transactions_bytes: z.number(),
+  logs_bytes: z.number()
 });
 var cleanupCountsSchema = z.object({
   events: z.number(),
   transactions: z.number(),
   spans: z.number(),
   logs: z.number(),
-  issues_removed: z.number()
+  issues_removed: z.number(),
+  /** Unused source maps deleted; only a retention cleanup removes them. */
+  source_maps: z.number().default(0)
 });
 var cleanupStatusSchema = z.object({
   state: z.enum(["idle", "running", "completed", "failed"]),
@@ -600,6 +791,53 @@ var sourceMapGcResultSchema = z.object({
   files_removed: z.number(),
   bytes_freed: z.number()
 });
+var kindAgeSchema = z.object({
+  counts: z.array(z.number()),
+  oldest: dateTimeSchema.nullable()
+});
+var storageAgeSchema = z.object({
+  bucket_days: z.array(z.number()),
+  projects: z.array(
+    z.object({
+      project_id: z.number(),
+      events: kindAgeSchema,
+      transactions: kindAgeSchema,
+      logs: kindAgeSchema
+    })
+  )
+});
+var retentionDaysSchema = z.number().int().min(1).max(36500).nullable();
+var retentionWindowsSchema = z.object({
+  events_days: retentionDaysSchema,
+  /** Transactions with their spans. */
+  transactions_days: retentionDaysSchema,
+  logs_days: retentionDaysSchema
+});
+var projectRetentionSchema = retentionWindowsSchema.extend({
+  project_id: z.number().int()
+});
+var retentionSettingsSchema = z.object({
+  defaults: retentionWindowsSchema,
+  overrides: z.array(projectRetentionSchema),
+  frequency: z.enum(["daily", "weekly"]),
+  /** Hour of the day, UTC. */
+  hour: z.number().int().min(0).max(23),
+  /** Day of a weekly cleanup, 0 = Sunday. */
+  weekday: z.number().int().min(0).max(6)
+});
+var retentionRunSchema = z.object({
+  started_at: dateTimeSchema,
+  finished_at: dateTimeSchema.nullable(),
+  status: z.enum(["running", "ok", "error"]),
+  removed: cleanupCountsSchema.nullable(),
+  error: z.string().nullable()
+});
+var retentionSchema = z.object({
+  settings: retentionSettingsSchema,
+  /** Null while everything is kept forever, and for up to a minute after the settings change. */
+  next_run_at: dateTimeSchema.nullable(),
+  last_run: retentionRunSchema.nullable()
+});
 var cleanupOptionsSchema = z.object({
   older_than_days: z.number().int().min(1),
   project_id: z.number().int().optional(),
@@ -1657,6 +1895,109 @@ var EventsResource = class extends BaseResource {
     );
   }
 };
+
+// src/resources/github.ts
+var GitHubResource = class extends BaseResource {
+  /** The app, its installations and the webhook address (admin only). */
+  async status() {
+    return this.request(() => this.http.get("api/github"), gitHubStatusSchema);
+  }
+  /** The form to post to GitHub to create the app, under an org if given. */
+  async manifest(organization) {
+    return this.request(
+      () => this.http.post("api/github/manifest", { json: { organization } }),
+      gitHubManifestSchema
+    );
+  }
+  async disconnect() {
+    return this.requestVoid(() => this.http.delete("api/github"));
+  }
+  /** Repositories the installations reach, for a project's settings. */
+  async repositories(projectId) {
+    return this.request(
+      () => this.http.get("api/github/repositories", {
+        searchParams: { project_id: projectId }
+      }),
+      gitHubRepositorySchema.array()
+    );
+  }
+  async projectRepository(projectId) {
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/github`),
+      projectRepositorySchema.nullable()
+    );
+  }
+  async setProjectRepository(projectId, input) {
+    const validated = this.validateInput(input, updateProjectRepositorySchema);
+    if (!validated.success) {
+      return validated;
+    }
+    return this.request(
+      () => this.http.put(`api/projects/${projectId}/github`, {
+        json: validated.data
+      }),
+      projectRepositorySchema
+    );
+  }
+  async removeProjectRepository(projectId) {
+    return this.requestVoid(
+      () => this.http.delete(`api/projects/${projectId}/github`)
+    );
+  }
+  /** Copies the repository's CODEOWNERS into Rustrak. */
+  async syncCodeowners(projectId) {
+    return this.request(
+      () => this.http.post(`api/projects/${projectId}/github/codeowners`),
+      projectRepositorySchema
+    );
+  }
+  /** Links, suspect commits and owners for one issue. */
+  async issue(projectId, issueId) {
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/issues/${issueId}/github`),
+      issueGitHubSchema
+    );
+  }
+  async createIssue(projectId, issueId, input = {}) {
+    return this.request(
+      () => this.http.post(
+        `api/projects/${projectId}/issues/${issueId}/github/issues`,
+        { json: input }
+      ),
+      issueLinkSchema
+    );
+  }
+  /** `reference` is a GitHub URL, `owner/repo#12` or `#12`. */
+  async linkIssue(projectId, issueId, reference) {
+    return this.request(
+      () => this.http.post(
+        `api/projects/${projectId}/issues/${issueId}/github/links`,
+        { json: { reference } }
+      ),
+      issueLinkSchema
+    );
+  }
+  async unlinkIssue(projectId, issueId, linkId) {
+    return this.requestVoid(
+      () => this.http.delete(
+        `api/projects/${projectId}/issues/${issueId}/github/links/${linkId}`
+      )
+    );
+  }
+  /** The signed-in person's GitHub username, used to sync assignees. */
+  async myLogin() {
+    return this.request(
+      () => this.http.get("api/github/me"),
+      gitHubLoginSchema
+    );
+  }
+  async setMyLogin(login) {
+    return this.request(
+      () => this.http.put("api/github/me", { json: { login } }),
+      gitHubLoginSchema
+    );
+  }
+};
 var serverVersionSchema = z.object({
   version: z.string()
 });
@@ -2003,6 +2344,77 @@ var MembersResource = class extends BaseResource {
     );
   }
 };
+var MonitorsResource = class extends BaseResource {
+  /** Every monitor of a project, with its environments and recent check-ins. */
+  async list(projectId) {
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/monitors`),
+      z.array(monitorSchema)
+    );
+  }
+  async get(projectId, slug) {
+    return this.request(
+      () => this.http.get(
+        `api/projects/${projectId}/monitors/${encodeURIComponent(slug)}`
+      ),
+      monitorSchema
+    );
+  }
+  async create(projectId, input) {
+    const validated = this.validateInput(input, createMonitorSchema);
+    if (!validated.success) {
+      return validated;
+    }
+    return this.request(
+      () => this.http.post(`api/projects/${projectId}/monitors`, {
+        json: validated.data
+      }),
+      monitorSchema
+    );
+  }
+  /** Fields left out keep their value, including each field of `config`. */
+  async update(projectId, slug, input) {
+    const validated = this.validateInput(input, updateMonitorSchema);
+    if (!validated.success) {
+      return validated;
+    }
+    return this.request(
+      () => this.http.put(
+        `api/projects/${projectId}/monitors/${encodeURIComponent(slug)}`,
+        { json: validated.data }
+      ),
+      monitorSchema
+    );
+  }
+  /** Deletes the monitor and its check-ins. Its issues stay. */
+  async delete(projectId, slug) {
+    return this.requestVoid(
+      () => this.http.delete(
+        `api/projects/${projectId}/monitors/${encodeURIComponent(slug)}`
+      )
+    );
+  }
+  /** Check-ins of one monitor, newest first. */
+  async listCheckIns(projectId, slug, options) {
+    const searchParams = {};
+    if (options?.page) {
+      searchParams.page = String(options.page);
+    }
+    if (options?.per_page) {
+      searchParams.per_page = String(options.per_page);
+    }
+    if (options?.environment) {
+      searchParams.environment = options.environment;
+    }
+    return this.request(
+      () => this.http.get(
+        `api/projects/${projectId}/monitors/${encodeURIComponent(slug)}/checkins`,
+        { searchParams }
+      ),
+      offsetPaginatedResponseSchema(checkInSchema)
+    );
+  }
+};
 
 // src/resources/projects.ts
 var ProjectsResource = class extends BaseResource {
@@ -2104,6 +2516,21 @@ var ReleasesResource = class extends BaseResource {
   }
 };
 
+// src/resources/schedules.ts
+var SchedulesResource = class extends BaseResource {
+  /** Validates a schedule and lists its next five runs. */
+  async preview(input) {
+    const validated = this.validateInput(input, previewScheduleSchema);
+    if (!validated.success) {
+      return validated;
+    }
+    return this.request(
+      () => this.http.post("api/schedules/preview", { json: validated.data }),
+      schedulePreviewSchema
+    );
+  }
+};
+
 // src/resources/sessions.ts
 var SessionsResource = class extends BaseResource {
   /**
@@ -2436,6 +2863,66 @@ var StorageResource = class extends BaseResource {
       sourceMapGcResultSchema
     );
   }
+  /**
+   * Retention: how long each kind of data is kept, by default and per
+   * project, when its cleanup runs next and how the last one went.
+   */
+  async getRetention() {
+    return this.request(
+      () => this.http.get("api/storage/retention"),
+      retentionSchema
+    );
+  }
+  /** Replaces the retention settings. A new schedule applies within a minute. */
+  async updateRetention(settings) {
+    const validated = this.validateInput(settings, retentionSettingsSchema);
+    if (!validated.success) {
+      return validated;
+    }
+    return this.request(
+      () => this.http.put("api/storage/retention", { json: validated.data }),
+      retentionSchema
+    );
+  }
+  /**
+   * Enforces the saved retention now, without waiting for the schedule, and
+   * deletes unused source maps. Returns the started job; follow it with
+   * {@link getCleanupStatus}. A `validation` error while everything is kept
+   * forever, `conflict` while a cleanup runs.
+   */
+  async runRetention() {
+    return this.request(
+      () => this.http.post("api/storage/retention/run", {
+        // No retry, as for `executeCleanup`: a lost response after the
+        // cleanup started would be retried into a refused second run.
+        retry: 0
+      }),
+      cleanupStatusSchema
+    );
+  }
+  /** How long ago each project's data arrived, per kind, in age buckets. */
+  async getAge() {
+    return this.request(
+      () => this.http.get("api/storage/age"),
+      storageAgeSchema
+    );
+  }
+  /**
+   * Dry-run: what enforcing these retention settings now would delete, each
+   * project against its own windows. Saves and deletes nothing.
+   */
+  async previewRetention(settings) {
+    const validated = this.validateInput(settings, retentionSettingsSchema);
+    if (!validated.success) {
+      return validated;
+    }
+    return this.request(
+      () => this.http.post("api/storage/retention/preview", {
+        json: validated.data
+      }),
+      cleanupCountsSchema
+    );
+  }
 };
 
 // src/resources/team.ts
@@ -2675,6 +3162,14 @@ var RustrakClient = class {
    * Logs API resource (standalone logs)
    */
   logs;
+  /**
+   * Cron monitors API resource (Sentry Crons)
+   */
+  monitors;
+  /**
+   * Schedules API resource (previews for crontab/interval schedules)
+   */
+  schedules;
   /**
    * Spans API resource (standalone + transaction-embedded spans, shared table)
    */
@@ -2695,6 +3190,10 @@ var RustrakClient = class {
    * Health API resource (version info)
    */
   health;
+  /**
+   * GitHub integration resource
+   */
+  github;
   /**
    * Create a new Rustrak API client
    *
@@ -2707,6 +3206,7 @@ var RustrakClient = class {
     this.issues = new IssuesResource(this.http);
     this.events = new EventsResource(this.http);
     this.tokens = new TokensResource(this.http);
+    this.github = new GitHubResource(this.http);
     this.alertIntegrations = new AlertIntegrationsResource(this.http);
     this.alertRules = new AlertRulesResource(this.http);
     this.sourceMaps = new SourceMapsResource(this.http);
@@ -2717,6 +3217,8 @@ var RustrakClient = class {
     this.releases = new ReleasesResource(this.http);
     this.transactions = new TransactionsResource(this.http);
     this.logs = new LogsResource(this.http);
+    this.monitors = new MonitorsResource(this.http);
+    this.schedules = new SchedulesResource(this.http);
     this.spans = new SpansResource(this.http);
     this.agents = new AgentsResource(this.http);
     this.stats = new StatsResource(this.http);