@rustrak/client 0.15.0 → 0.15.2

package/README.md

@@ -135,6 +135,8 @@ await client.issues.delete(projectId, issueId);
 ```typescript
 const { items } = await client.events.list(projectId, issueId, { order: 'desc' });
 const event     = await client.events.get(projectId, issueId, eventId);
+// Resolve the ID returned by a Sentry SDK without knowing its issue first.
+const captured  = await client.events.getBySentryId(projectId, sentryEventId);
 console.log(event.data); // Full Sentry event payload
 ```
 
@@ -264,7 +266,7 @@ export default async function ProjectsPage() {
     // `kind` is what decides: only 'unauthenticated' means "send to login".
     // Redirecting on 'network' or 'server_error' turns a flaky connection
     // into a login loop.
-    if (projects.error.kind === 'unauthenticated') redirect('/auth/login');
+    if (projects.error.kind === 'unauthenticated') redirect('/login');
     return <LoadFailed error={projects.error} />;
   }
 
@@ -317,7 +319,7 @@ import type {
 
 ## What is Rustrak?
 
-[Rustrak](https://rustrak.github.io/rustrak) is a self-hosted error tracking server written in Rust that is fully compatible with any Sentry SDK. Drop-in replacement for Sentry — no code changes needed. Runs on ~50 MB of memory as a single binary or Docker image.
+[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.
 
 - [Getting Started](https://rustrak.github.io/rustrak/getting-started/overview)
 - [Self-Hosting Guide](https://rustrak.github.io/rustrak/configuration/production)

package/dist/index.cjs

@@ -443,6 +443,14 @@ var projectSchema = zod.z.object({
   dsn: zod.z.string(),
   stored_event_count: zod.z.number().int(),
   digested_event_count: zod.z.number().int(),
+  /** Accepted events the quota dropped instead of storing. */
+  rate_limited_event_count: zod.z.number().int(),
+  /**
+   * The project's own limits, or null where it follows the server's. They can
+   * only tighten `MAX_EVENTS_PER_PROJECT_*`, never raise it.
+   */
+  rate_limit_per_minute: zod.z.number().int().nullable(),
+  rate_limit_per_hour: zod.z.number().int().nullable(),
   created_at: dateTimeSchema,
   updated_at: dateTimeSchema,
   platform: zod.z.string().nullable(),
@@ -469,7 +477,14 @@ var updateProjectSchema = zod.z.object({
    * Slugified server-side. Unlike on create, a taken slug is a 409 rather than
    * being silently de-duplicated.
    */
-  slug: zod.z.string().min(1).optional()
+  slug: zod.z.string().min(1).optional(),
+  /** A number sets the project's own limit; null removes it. */
+  rate_limit_per_minute: zod.z.number().int().min(1).nullable().optional(),
+  rate_limit_per_hour: zod.z.number().int().min(1).nullable().optional()
+});
+var rateLimitsSchema = zod.z.object({
+  project_per_minute: zod.z.number().int(),
+  project_per_hour: zod.z.number().int()
 });
 var releaseHealthRowSchema = zod.z.object({
   release: zod.z.string(),
@@ -712,6 +727,24 @@ var registerRequestSchema = zod.z.object({
   email: zod.z.string().email(),
   password: zod.z.string().min(1)
 });
+var ssoConfigSchema = zod.z.object({
+  enabled: zod.z.boolean(),
+  provider_name: zod.z.string().nullable()
+});
+var ssoStartSchema = zod.z.object({
+  authorization_url: zod.z.string().url()
+});
+var ssoLinkSchema = zod.z.object({
+  email: zod.z.string(),
+  provider_name: zod.z.string()
+});
+var confirmSsoLinkRequestSchema = zod.z.object({
+  password: zod.z.string().min(1)
+});
+var changePasswordRequestSchema = zod.z.object({
+  current_password: zod.z.string().min(1),
+  new_password: zod.z.string().min(1)
+});
 
 // src/errors.ts
 var FIELD_ERROR_CODES = [
@@ -1384,6 +1417,59 @@ function readSetCookie(response) {
   return folded === null ? [] : [folded];
 }
 var AuthResource = class extends BaseResource {
+  /** Return the public SSO login configuration. */
+  async getSsoConfig() {
+    return this.request(
+      () => this.http.get("auth/sso/config"),
+      ssoConfigSchema
+    );
+  }
+  /** Begin SSO and return the provider URL plus the encrypted state cookie. */
+  async startSso() {
+    return this.requestResponse(
+      () => this.http.post("auth/sso/start"),
+      async (response) => {
+        const cookies = readSetCookie(response);
+        const body = await this.readJson(response);
+        if (!body.success) return body;
+        const data = this.validate(body.data, ssoStartSchema);
+        if (!data.success) return data;
+        return Ok({
+          authorizationUrl: data.data.authorization_url,
+          cookies
+        });
+      }
+    );
+  }
+  /** The account an SSO login is waiting to link, if any. */
+  async getSsoLink() {
+    return this.request(() => this.http.get("auth/sso/link"), ssoLinkSchema);
+  }
+  /** Link the pending SSO identity with the account's password and sign in. */
+  async confirmSsoLink(password) {
+    const validatedInput = this.validateInput(
+      { password },
+      confirmSsoLinkRequestSchema
+    );
+    if (!validatedInput.success) {
+      return validatedInput;
+    }
+    return this.requestResponse(
+      () => this.http.post("auth/sso/link", { json: validatedInput.data }),
+      (response) => this.readLoginResult(response)
+    );
+  }
+  /** Complete an OIDC callback and return the normal Rustrak session cookie. */
+  async completeSso(callback) {
+    const searchParams = new URLSearchParams();
+    if (callback.code) searchParams.set("code", callback.code);
+    if (callback.state) searchParams.set("state", callback.state);
+    if (callback.error) searchParams.set("error", callback.error);
+    return this.requestResponse(
+      () => this.http.get("auth/sso/callback", { searchParams }),
+      (response) => this.readLoginResult(response)
+    );
+  }
   /**
    * Register a new user account
    * Creates a new user and automatically logs them in (sets session cookie)
@@ -1466,6 +1552,20 @@ var AuthResource = class extends BaseResource {
       userSchema
     );
   }
+  /** Replaces the signed-in user's password, given the current one. */
+  async changePassword(request) {
+    const validatedInput = this.validateInput(
+      request,
+      changePasswordRequestSchema
+    );
+    if (!validatedInput.success) return validatedInput;
+    return this.requestVoid(
+      () => this.http.post("auth/me/password", {
+        json: validatedInput.data,
+        retry: 0
+      })
+    );
+  }
   /**
    * Get the details of a pending invitation by its token (public endpoint)
    * Used by the accept-invitation page before the user has an account
@@ -1545,6 +1645,15 @@ var EventsResource = class extends BaseResource {
       eventDetailSchema
     );
   }
+  /** Resolve the client-supplied Sentry event ID, including its owning issue. */
+  async getBySentryId(projectId, eventId) {
+    return this.request(
+      () => this.http.get(
+        `api/projects/${projectId}/events/sentry/${encodeURIComponent(eventId)}`
+      ),
+      eventDetailSchema
+    );
+  }
 };
 var serverVersionSchema = zod.z.object({
   version: zod.z.string()
@@ -1919,6 +2028,15 @@ var ProjectsResource = class extends BaseResource {
       offsetPaginatedResponseSchema(projectSchema)
     );
   }
+  /**
+   * The server's per-project limits, which a project without its own follows
+   */
+  async rateLimits() {
+    return this.request(
+      () => this.http.get("api/rate-limits"),
+      rateLimitsSchema
+    );
+  }
   /**
    * Get a single project by ID
    */