@rustrak/client 0.17.0 → 0.18.0

package/README.md

@@ -1,9 +1,9 @@
 <div align="center">
-  <a href="https://rustrak.github.io/rustrak">
+  <a href="https://rustrak.dev">
     <img src="https://raw.githubusercontent.com/rustrak/rustrak/main/apps/docs/public/logo.svg" alt="Rustrak" width="64" height="64" />
   </a>
   <h1>@rustrak/client</h1>
-  <p>Official TypeScript client for the <a href="https://rustrak.github.io/rustrak">Rustrak</a> self-hosted error tracking API</p>
+  <p>Official TypeScript client for the <a href="https://rustrak.dev">Rustrak</a> self-hosted error tracking API</p>
 
   <p>
     <a href="https://www.npmjs.com/package/@rustrak/client">
@@ -24,7 +24,7 @@
   </p>
 
   <p>
-    <a href="https://rustrak.github.io/rustrak/sdks/client">Documentation</a>
+    <a href="https://rustrak.dev/sdks/client">Documentation</a>
     ·
     <a href="https://github.com/rustrak/rustrak">GitHub</a>
     ·
@@ -34,7 +34,7 @@
 
 ---
 
-`@rustrak/client` is the official TypeScript client for [Rustrak](https://rustrak.github.io/rustrak) — an ultra-lightweight, self-hosted error tracking system compatible with any Sentry SDK. This package wraps the Rustrak REST API with full type safety, runtime validation via Zod, built-in retry logic, and structured error handling. Total bundle size: ~28 KB.
+`@rustrak/client` is the official TypeScript client for [Rustrak](https://rustrak.dev) — an ultra-lightweight, self-hosted error tracking system compatible with any Sentry SDK. This package wraps the Rustrak REST API with full type safety, runtime validation via Zod, built-in retry logic, and structured error handling. Total bundle size: ~28 KB.
 
 ## Installation
 
@@ -78,7 +78,7 @@ const resolved = await client.issues.updateState(1, 'issue-id', {
 });
 ```
 
-**[Full documentation →](https://rustrak.github.io/rustrak/sdks/client)**
+**[Full documentation →](https://rustrak.dev/sdks/client)**
 
 ## Features
 
@@ -319,11 +319,11 @@ import type {
 
 ## What is Rustrak?
 
-[Rustrak](https://rustrak.github.io/rustrak) is a self-hosted error tracking server written in Rust that accepts events from any Sentry SDK: point the SDK's DSN at it and nothing else changes. One container serves the API and the dashboard.
+[Rustrak](https://rustrak.dev) is a self-hosted error tracking server written in Rust that accepts events from any Sentry SDK: point the SDK's DSN at it and nothing else changes. One container serves the API and the dashboard.
 
-- [Getting Started](https://rustrak.github.io/rustrak/getting-started/overview)
-- [Self-Hosting Guide](https://rustrak.github.io/rustrak/configuration/production)
-- [API Reference](https://rustrak.github.io/rustrak/api-reference)
+- [Getting Started](https://rustrak.dev/getting-started/overview)
+- [Self-Hosting Guide](https://rustrak.dev/configuration/production)
+- [API Reference](https://rustrak.dev/api-reference)
 - [GitHub](https://github.com/rustrak/rustrak)
 
 ## License

package/dist/index.cjs

@@ -508,6 +508,96 @@ var upsertProjectMemberSchema = zod.z.object({
   user_id: zod.z.number().int(),
   role: projectRoleSchema
 });
+var intervalUnitSchema = zod.z.enum([
+  "minute",
+  "hour",
+  "day",
+  "week",
+  "month",
+  "year"
+]);
+var scheduleSchema = zod.z.discriminatedUnion("type", [
+  zod.z.object({ type: zod.z.literal("crontab"), value: zod.z.string() }),
+  zod.z.object({
+    type: zod.z.literal("interval"),
+    value: zod.z.number().int().min(1),
+    unit: intervalUnitSchema
+  })
+]);
+var previewScheduleSchema = zod.z.object({
+  schedule: scheduleSchema,
+  /** IANA zone the schedule is read in. Defaults to UTC. */
+  timezone: zod.z.string().optional()
+});
+var schedulePreviewSchema = zod.z.object({
+  next_runs: zod.z.array(dateTimeSchema)
+});
+
+// src/schemas/monitor.ts
+var monitorConfigSchema = zod.z.object({
+  schedule: scheduleSchema,
+  checkin_margin: zod.z.number().int(),
+  max_runtime: zod.z.number().int(),
+  timezone: zod.z.string(),
+  failure_issue_threshold: zod.z.number().int(),
+  recovery_threshold: zod.z.number().int()
+});
+var monitorConfigInputSchema = zod.z.object({
+  schedule: scheduleSchema.optional(),
+  checkin_margin: zod.z.number().int().min(1).optional(),
+  max_runtime: zod.z.number().int().min(1).optional(),
+  timezone: zod.z.string().optional(),
+  failure_issue_threshold: zod.z.number().int().min(1).max(720).optional(),
+  recovery_threshold: zod.z.number().int().min(1).max(720).optional()
+});
+var checkInStatusSchema = zod.z.enum([
+  "ok",
+  "error",
+  "in_progress",
+  "missed",
+  "timeout",
+  "unknown"
+]);
+var monitorEnvironmentStatusSchema = zod.z.enum(["active", "ok", "error"]);
+var checkInSchema = zod.z.object({
+  id: uuidSchema,
+  environment: zod.z.string(),
+  status: checkInStatusSchema,
+  duration_ms: zod.z.number().int().nullable(),
+  date_added: dateTimeSchema,
+  date_updated: dateTimeSchema,
+  expected_time: dateTimeSchema.nullable()
+});
+var monitorEnvironmentSchema = zod.z.object({
+  id: uuidSchema,
+  environment: zod.z.string(),
+  status: monitorEnvironmentStatusSchema,
+  next_checkin: dateTimeSchema.nullable(),
+  next_checkin_latest: dateTimeSchema.nullable(),
+  last_checkin: dateTimeSchema.nullable(),
+  /** Newest first. */
+  recent_checkins: zod.z.array(checkInSchema)
+});
+var monitorSchema = zod.z.object({
+  id: uuidSchema,
+  slug: zod.z.string(),
+  name: zod.z.string(),
+  config: monitorConfigSchema,
+  is_muted: zod.z.boolean(),
+  created_at: dateTimeSchema,
+  environments: zod.z.array(monitorEnvironmentSchema)
+});
+var createMonitorSchema = zod.z.object({
+  name: zod.z.string().trim().min(1).max(128),
+  /** Derived from `name` when left out. */
+  slug: zod.z.string().min(1).max(50).optional(),
+  config: monitorConfigInputSchema
+});
+var updateMonitorSchema = zod.z.object({
+  name: zod.z.string().trim().min(1).max(128).optional(),
+  config: monitorConfigInputSchema.optional(),
+  is_muted: zod.z.boolean().optional()
+});
 var metricDeltaSchema = zod.z.object({
   current: zod.z.number().int(),
   /**
@@ -680,14 +770,21 @@ var projectStorageSchema = zod.z.object({
   spans_count: zod.z.number(),
   logs_count: zod.z.number(),
   source_maps_count: zod.z.number(),
-  estimated_bytes: zod.z.number()
+  /** `events_bytes + transactions_bytes + logs_bytes`. */
+  estimated_bytes: zod.z.number(),
+  events_bytes: zod.z.number(),
+  /** Transactions with their spans. */
+  transactions_bytes: zod.z.number(),
+  logs_bytes: zod.z.number()
 });
 var cleanupCountsSchema = zod.z.object({
   events: zod.z.number(),
   transactions: zod.z.number(),
   spans: zod.z.number(),
   logs: zod.z.number(),
-  issues_removed: zod.z.number()
+  issues_removed: zod.z.number(),
+  /** Unused source maps deleted; only a retention cleanup removes them. */
+  source_maps: zod.z.number().default(0)
 });
 var cleanupStatusSchema = zod.z.object({
   state: zod.z.enum(["idle", "running", "completed", "failed"]),
@@ -700,6 +797,53 @@ var sourceMapGcResultSchema = zod.z.object({
   files_removed: zod.z.number(),
   bytes_freed: zod.z.number()
 });
+var kindAgeSchema = zod.z.object({
+  counts: zod.z.array(zod.z.number()),
+  oldest: dateTimeSchema.nullable()
+});
+var storageAgeSchema = zod.z.object({
+  bucket_days: zod.z.array(zod.z.number()),
+  projects: zod.z.array(
+    zod.z.object({
+      project_id: zod.z.number(),
+      events: kindAgeSchema,
+      transactions: kindAgeSchema,
+      logs: kindAgeSchema
+    })
+  )
+});
+var retentionDaysSchema = zod.z.number().int().min(1).max(36500).nullable();
+var retentionWindowsSchema = zod.z.object({
+  events_days: retentionDaysSchema,
+  /** Transactions with their spans. */
+  transactions_days: retentionDaysSchema,
+  logs_days: retentionDaysSchema
+});
+var projectRetentionSchema = retentionWindowsSchema.extend({
+  project_id: zod.z.number().int()
+});
+var retentionSettingsSchema = zod.z.object({
+  defaults: retentionWindowsSchema,
+  overrides: zod.z.array(projectRetentionSchema),
+  frequency: zod.z.enum(["daily", "weekly"]),
+  /** Hour of the day, UTC. */
+  hour: zod.z.number().int().min(0).max(23),
+  /** Day of a weekly cleanup, 0 = Sunday. */
+  weekday: zod.z.number().int().min(0).max(6)
+});
+var retentionRunSchema = zod.z.object({
+  started_at: dateTimeSchema,
+  finished_at: dateTimeSchema.nullable(),
+  status: zod.z.enum(["running", "ok", "error"]),
+  removed: cleanupCountsSchema.nullable(),
+  error: zod.z.string().nullable()
+});
+var retentionSchema = zod.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 = zod.z.object({
   older_than_days: zod.z.number().int().min(1),
   project_id: zod.z.number().int().optional(),
@@ -2206,6 +2350,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`),
+      zod.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 {
@@ -2307,6 +2522,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 {
   /**
@@ -2639,6 +2869,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
@@ -2878,6 +3168,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)
    */
@@ -2925,6 +3223,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);