@rustrak/client 0.1.2

package/dist/index.js

@@ -0,0 +1,766 @@
+import { z } from 'zod';
+import ky, { isHTTPError } from 'ky';
+
+// src/resources/alert-channels.ts
+var paginatedResponseSchema = (itemSchema) => z.object({
+  items: z.array(itemSchema),
+  next_cursor: z.string().optional(),
+  has_more: z.boolean()
+});
+var offsetPaginatedResponseSchema = (itemSchema) => z.object({
+  items: z.array(itemSchema),
+  total_count: z.number().int(),
+  page: z.number().int(),
+  per_page: z.number().int(),
+  total_pages: z.number().int()
+});
+z.enum(["asc", "desc"]);
+z.enum(["digest_order", "last_seen"]);
+z.enum(["open", "resolved", "muted", "all"]);
+var dateTimeSchema = z.string().datetime();
+var uuidSchema = z.string().uuid();
+z.object({
+  error: z.string(),
+  message: z.string().optional()
+});
+
+// src/schemas/alert.ts
+var channelTypeSchema = z.enum(["webhook", "email", "slack"]);
+var alertTypeSchema = z.enum(["new_issue", "regression", "unmute"]);
+var alertStatusSchema = z.enum([
+  "pending",
+  "sent",
+  "failed",
+  "skipped"
+]);
+var notificationChannelSchema = z.object({
+  id: z.number().int(),
+  name: z.string(),
+  channel_type: channelTypeSchema,
+  config: z.record(z.string(), z.unknown()),
+  is_enabled: z.boolean(),
+  failure_count: z.number().int(),
+  last_failure_at: dateTimeSchema.nullable(),
+  last_failure_message: z.string().nullable(),
+  last_success_at: dateTimeSchema.nullable(),
+  created_at: dateTimeSchema,
+  updated_at: dateTimeSchema
+});
+var createNotificationChannelSchema = z.object({
+  name: z.string().min(1),
+  channel_type: channelTypeSchema,
+  config: z.record(z.string(), z.unknown()),
+  is_enabled: z.boolean().optional()
+});
+var updateNotificationChannelSchema = z.object({
+  name: z.string().min(1).optional(),
+  config: z.record(z.string(), z.unknown()).optional(),
+  is_enabled: z.boolean().optional()
+});
+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()),
+  cooldown_minutes: z.number().int(),
+  last_triggered_at: dateTimeSchema.nullable(),
+  created_at: dateTimeSchema,
+  updated_at: dateTimeSchema,
+  channel_ids: z.array(z.number().int())
+});
+var createAlertRuleSchema = z.object({
+  name: z.string().min(1),
+  alert_type: alertTypeSchema,
+  channel_ids: z.array(z.number().int()).min(1),
+  is_enabled: z.boolean().optional(),
+  conditions: z.record(z.string(), z.unknown()).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(),
+  cooldown_minutes: z.number().int().min(0).optional(),
+  channel_ids: z.array(z.number().int()).optional()
+});
+var alertHistorySchema = z.object({
+  id: z.number().int(),
+  alert_rule_id: z.number().int().nullable(),
+  channel_id: z.number().int().nullable(),
+  issue_id: z.string().uuid().nullable(),
+  project_id: z.number().int().nullable(),
+  alert_type: z.string(),
+  channel_type: z.string(),
+  channel_name: z.string(),
+  status: alertStatusSchema,
+  attempt_count: z.number().int(),
+  next_retry_at: dateTimeSchema.nullable(),
+  error_message: z.string().nullable(),
+  http_status_code: z.number().int().nullable(),
+  idempotency_key: z.string(),
+  created_at: dateTimeSchema,
+  sent_at: dateTimeSchema.nullable()
+});
+var testChannelResponseSchema = z.object({
+  success: z.boolean(),
+  message: z.string()
+});
+
+// src/errors/base.ts
+var RustrakError = class extends Error {
+  /**
+   * Whether this error is safe to retry
+   */
+  retryable;
+  /**
+   * HTTP status code if applicable
+   */
+  statusCode;
+  /**
+   * Original error cause
+   */
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.name = this.constructor.name;
+    this.retryable = options?.retryable ?? false;
+    this.statusCode = options?.statusCode;
+    this.cause = options?.cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+
+// src/errors/http.ts
+var NetworkError = class extends RustrakError {
+  constructor(message, cause) {
+    super(message, { retryable: true, cause });
+  }
+};
+var AuthenticationError = class extends RustrakError {
+  constructor(message = "Authentication failed") {
+    super(message, { retryable: false, statusCode: 401 });
+  }
+};
+var AuthorizationError = class extends RustrakError {
+  constructor(message = "Insufficient permissions") {
+    super(message, { retryable: false, statusCode: 403 });
+  }
+};
+var NotFoundError = class extends RustrakError {
+  constructor(resource) {
+    super(`Resource not found: ${resource}`, {
+      retryable: false,
+      statusCode: 404
+    });
+  }
+};
+var RateLimitError = class extends RustrakError {
+  /**
+   * Number of seconds to wait before retrying (from Retry-After header)
+   */
+  retryAfter;
+  constructor(message = "Rate limit exceeded", retryAfter) {
+    super(message, { retryable: true, statusCode: 429 });
+    if (retryAfter !== void 0) {
+      this.retryAfter = typeof retryAfter === "string" ? parseInt(retryAfter, 10) : retryAfter;
+    }
+  }
+};
+var ServerError = class extends RustrakError {
+  constructor(message, statusCode = 500) {
+    super(message, { retryable: true, statusCode });
+  }
+};
+var BadRequestError = class extends RustrakError {
+  constructor(message) {
+    super(message, { retryable: false, statusCode: 400 });
+  }
+};
+
+// src/errors/validation.ts
+var ValidationError = class extends RustrakError {
+  /**
+   * Zod validation errors
+   */
+  validationErrors;
+  constructor(message, validationErrors) {
+    super(message, { retryable: false });
+    this.validationErrors = validationErrors;
+  }
+  /**
+   * Get a formatted string of validation errors
+   */
+  getValidationDetails() {
+    if (!this.validationErrors) {
+      return this.message;
+    }
+    const errors = this.validationErrors.issues.map((err) => `${err.path.map(String).join(".")}: ${err.message}`).join(", ");
+    return `${this.message} - ${errors}`;
+  }
+};
+
+// src/resources/base.ts
+var BaseResource = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Validate API response against Zod schema
+   * @throws {ValidationError} if validation fails
+   */
+  validate(data, schema) {
+    const result = schema.safeParse(data);
+    if (!result.success) {
+      throw new ValidationError("API response validation failed", result.error);
+    }
+    return result.data;
+  }
+};
+
+// src/resources/alert-channels.ts
+var AlertChannelsResource = class extends BaseResource {
+  /**
+   * List all notification channels
+   */
+  async list() {
+    const data = await this.http.get("api/alert-channels").json();
+    return this.validate(data, z.array(notificationChannelSchema));
+  }
+  /**
+   * Get a single notification channel by ID
+   */
+  async get(id) {
+    const data = await this.http.get(`api/alert-channels/${id}`).json();
+    return this.validate(data, notificationChannelSchema);
+  }
+  /**
+   * Create a new notification channel
+   */
+  async create(input) {
+    const validatedInput = this.validate(
+      input,
+      createNotificationChannelSchema
+    );
+    const data = await this.http.post("api/alert-channels", { json: validatedInput }).json();
+    return this.validate(data, notificationChannelSchema);
+  }
+  /**
+   * Update an existing notification channel
+   */
+  async update(id, input) {
+    const validatedInput = this.validate(
+      input,
+      updateNotificationChannelSchema
+    );
+    const data = await this.http.patch(`api/alert-channels/${id}`, { json: validatedInput }).json();
+    return this.validate(data, notificationChannelSchema);
+  }
+  /**
+   * Delete a notification channel
+   */
+  async delete(id) {
+    await this.http.delete(`api/alert-channels/${id}`);
+  }
+  /**
+   * Send a test notification to verify channel configuration
+   */
+  async test(id) {
+    const data = await this.http.post(`api/alert-channels/${id}/test`).json();
+    return this.validate(data, testChannelResponseSchema);
+  }
+};
+var AlertRulesResource = class extends BaseResource {
+  /**
+   * List all alert rules for a project
+   */
+  async list(projectId) {
+    const data = await this.http.get(`api/projects/${projectId}/alert-rules`).json();
+    return this.validate(data, z.array(alertRuleSchema));
+  }
+  /**
+   * Get a single alert rule by ID
+   */
+  async get(projectId, ruleId) {
+    const data = await this.http.get(`api/projects/${projectId}/alert-rules/${ruleId}`).json();
+    return this.validate(data, alertRuleSchema);
+  }
+  /**
+   * Create a new alert rule for a project
+   */
+  async create(projectId, input) {
+    const validatedInput = this.validate(input, createAlertRuleSchema);
+    const data = await this.http.post(`api/projects/${projectId}/alert-rules`, { json: validatedInput }).json();
+    return this.validate(data, alertRuleSchema);
+  }
+  /**
+   * Update an existing alert rule
+   */
+  async update(projectId, ruleId, input) {
+    const validatedInput = this.validate(input, updateAlertRuleSchema);
+    const data = await this.http.patch(`api/projects/${projectId}/alert-rules/${ruleId}`, {
+      json: validatedInput
+    }).json();
+    return this.validate(data, alertRuleSchema);
+  }
+  /**
+   * Delete an alert rule
+   */
+  async delete(projectId, ruleId) {
+    await this.http.delete(`api/projects/${projectId}/alert-rules/${ruleId}`);
+  }
+  /**
+   * List alert history for a project
+   */
+  async listHistory(projectId, options) {
+    const searchParams = new URLSearchParams();
+    if (options?.limit !== void 0) {
+      searchParams.set("limit", options.limit.toString());
+    }
+    const query = searchParams.toString();
+    const url = query ? `api/projects/${projectId}/alert-history?${query}` : `api/projects/${projectId}/alert-history`;
+    const data = await this.http.get(url).json();
+    return this.validate(data, z.array(alertHistorySchema));
+  }
+};
+var userSchema = z.object({
+  id: z.number().int().positive(),
+  email: z.string().email(),
+  is_admin: z.boolean()
+});
+var authResponseSchema = z.object({
+  user: userSchema
+});
+z.object({
+  user: userSchema,
+  cookies: z.array(z.string())
+});
+var loginRequestSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(8)
+});
+var registerRequestSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(8)
+});
+
+// src/resources/auth.ts
+var AuthResource = class extends BaseResource {
+  /**
+   * Register a new user account
+   * Creates a new user and automatically logs them in (sets session cookie)
+   * @param credentials - Email and password for the new account
+   * @returns LoginResult with user information and session cookies
+   */
+  async register(credentials) {
+    const validatedInput = this.validate(credentials, registerRequestSchema);
+    const response = await this.http.post("auth/register", {
+      json: validatedInput
+    });
+    const cookies = response.headers.getSetCookie();
+    const data = await response.json();
+    const authResponse = this.validate(data, authResponseSchema);
+    return {
+      user: authResponse.user,
+      cookies
+    };
+  }
+  /**
+   * Login with email and password
+   * Authenticates the user and sets a session cookie
+   * @param credentials - Email and password
+   * @returns LoginResult with user information and session cookies
+   */
+  async login(credentials) {
+    const validatedInput = this.validate(credentials, loginRequestSchema);
+    const response = await this.http.post("auth/login", {
+      json: validatedInput
+    });
+    const cookies = response.headers.getSetCookie();
+    const data = await response.json();
+    const authResponse = this.validate(data, authResponseSchema);
+    return {
+      user: authResponse.user,
+      cookies
+    };
+  }
+  /**
+   * Logout the current user
+   * Clears the session cookie
+   * @returns Array of Set-Cookie headers (typically clearing cookies)
+   */
+  async logout() {
+    const response = await this.http.post("auth/logout");
+    return response.headers.getSetCookie();
+  }
+  /**
+   * Get current authenticated user
+   * Requires a valid session cookie
+   * @returns User information
+   */
+  async getCurrentUser() {
+    const data = await this.http.get("auth/me").json();
+    return this.validate(data, userSchema);
+  }
+};
+var eventSchema = z.object({
+  id: uuidSchema,
+  event_id: uuidSchema,
+  issue_id: uuidSchema,
+  title: z.string(),
+  timestamp: dateTimeSchema,
+  level: z.string(),
+  platform: z.string(),
+  release: z.string(),
+  environment: z.string()
+});
+var eventDetailSchema = z.object({
+  id: uuidSchema,
+  event_id: uuidSchema,
+  issue_id: uuidSchema,
+  title: z.string(),
+  timestamp: dateTimeSchema,
+  ingested_at: dateTimeSchema,
+  level: z.string(),
+  platform: z.string(),
+  release: z.string(),
+  environment: z.string(),
+  server_name: z.string(),
+  sdk_name: z.string(),
+  sdk_version: z.string(),
+  data: z.record(z.string(), z.any())
+  // Full Sentry event JSON
+});
+var issueSchema = z.object({
+  id: uuidSchema,
+  project_id: z.number().int(),
+  short_id: z.string(),
+  title: z.string(),
+  value: z.string(),
+  first_seen: dateTimeSchema,
+  last_seen: dateTimeSchema,
+  event_count: z.number().int(),
+  level: z.string().nullable(),
+  platform: z.string().nullable(),
+  is_resolved: z.boolean(),
+  is_muted: z.boolean()
+});
+var updateIssueStateSchema = z.object({
+  is_resolved: z.boolean().optional(),
+  is_muted: z.boolean().optional()
+});
+var projectSchema = z.object({
+  id: z.number().int(),
+  name: z.string(),
+  slug: z.string(),
+  sentry_key: uuidSchema,
+  dsn: z.string(),
+  stored_event_count: z.number().int(),
+  digested_event_count: z.number().int(),
+  created_at: dateTimeSchema,
+  updated_at: dateTimeSchema
+});
+var createProjectSchema = z.object({
+  name: z.string().min(1),
+  slug: z.string().optional()
+});
+var updateProjectSchema = z.object({
+  name: z.string().min(1).optional()
+});
+var authTokenSchema = z.object({
+  id: z.number().int(),
+  token_prefix: z.string(),
+  description: z.string().nullable(),
+  created_at: dateTimeSchema,
+  last_used_at: dateTimeSchema.nullable()
+});
+var authTokenCreatedSchema = z.object({
+  id: z.number().int(),
+  token: z.string(),
+  description: z.string().nullable(),
+  created_at: dateTimeSchema
+});
+var createAuthTokenSchema = z.object({
+  description: z.string().optional()
+});
+
+// src/resources/events.ts
+var EventsResource = class extends BaseResource {
+  /**
+   * List events for an issue with pagination
+   */
+  async list(projectId, issueId, options) {
+    const searchParams = {};
+    if (options?.order) {
+      searchParams.order = options.order;
+    }
+    if (options?.cursor) {
+      searchParams.cursor = options.cursor;
+    }
+    const data = await this.http.get(`api/projects/${projectId}/issues/${issueId}/events`, {
+      searchParams
+    }).json();
+    return this.validate(data, paginatedResponseSchema(eventSchema));
+  }
+  /**
+   * Get a single event by ID with full details
+   */
+  async get(projectId, issueId, eventId) {
+    const data = await this.http.get(`api/projects/${projectId}/issues/${issueId}/events/${eventId}`).json();
+    return this.validate(data, eventDetailSchema);
+  }
+};
+
+// src/resources/issues.ts
+var IssuesResource = class extends BaseResource {
+  /**
+   * List issues for a project with offset-based pagination
+   */
+  async list(projectId, options) {
+    const searchParams = {};
+    if (options?.page !== void 0) {
+      searchParams.page = options.page.toString();
+    }
+    if (options?.per_page !== void 0) {
+      searchParams.per_page = options.per_page.toString();
+    }
+    if (options?.sort) {
+      searchParams.sort = options.sort;
+    }
+    if (options?.order) {
+      searchParams.order = options.order;
+    }
+    if (options?.filter) {
+      searchParams.filter = options.filter;
+    }
+    const data = await this.http.get(`api/projects/${projectId}/issues`, { searchParams }).json();
+    return this.validate(data, offsetPaginatedResponseSchema(issueSchema));
+  }
+  /**
+   * Get a single issue by ID
+   */
+  async get(projectId, issueId) {
+    const data = await this.http.get(`api/projects/${projectId}/issues/${issueId}`).json();
+    return this.validate(data, issueSchema);
+  }
+  /**
+   * Update issue state (resolve, mute, etc.)
+   */
+  async updateState(projectId, issueId, input) {
+    const validatedInput = this.validate(input, updateIssueStateSchema);
+    const data = await this.http.patch(`api/projects/${projectId}/issues/${issueId}`, {
+      json: validatedInput
+    }).json();
+    return this.validate(data, issueSchema);
+  }
+  /**
+   * Delete an issue
+   */
+  async delete(projectId, issueId) {
+    await this.http.delete(`api/projects/${projectId}/issues/${issueId}`);
+  }
+};
+
+// src/resources/projects.ts
+var ProjectsResource = class extends BaseResource {
+  /**
+   * List projects with pagination
+   */
+  async list(options) {
+    const searchParams = new URLSearchParams();
+    if (options?.page !== void 0) {
+      searchParams.set("page", options.page.toString());
+    }
+    if (options?.per_page !== void 0) {
+      searchParams.set("per_page", options.per_page.toString());
+    }
+    if (options?.order) {
+      searchParams.set("order", options.order);
+    }
+    const query = searchParams.toString();
+    const url = query ? `api/projects?${query}` : "api/projects";
+    const data = await this.http.get(url).json();
+    return this.validate(data, offsetPaginatedResponseSchema(projectSchema));
+  }
+  /**
+   * Get a single project by ID
+   */
+  async get(id) {
+    const data = await this.http.get(`api/projects/${id}`).json();
+    return this.validate(data, projectSchema);
+  }
+  /**
+   * Create a new project
+   */
+  async create(input) {
+    const validatedInput = this.validate(input, createProjectSchema);
+    const data = await this.http.post("api/projects", { json: validatedInput }).json();
+    return this.validate(data, projectSchema);
+  }
+  /**
+   * Update an existing project
+   */
+  async update(id, input) {
+    const validatedInput = this.validate(input, updateProjectSchema);
+    const data = await this.http.patch(`api/projects/${id}`, { json: validatedInput }).json();
+    return this.validate(data, projectSchema);
+  }
+  /**
+   * Delete a project
+   */
+  async delete(id) {
+    await this.http.delete(`api/projects/${id}`);
+  }
+};
+
+// src/resources/tokens.ts
+var TokensResource = class extends BaseResource {
+  /**
+   * List all auth tokens (masked)
+   */
+  async list() {
+    const data = await this.http.get("api/tokens").json();
+    return this.validate(data, authTokenSchema.array());
+  }
+  /**
+   * Get a single auth token by ID (masked)
+   */
+  async get(id) {
+    const data = await this.http.get(`api/tokens/${id}`).json();
+    return this.validate(data, authTokenSchema);
+  }
+  /**
+   * Create a new auth token
+   * Note: The full token is only returned once during creation
+   */
+  async create(input) {
+    const validatedInput = this.validate(input, createAuthTokenSchema);
+    const data = await this.http.post("api/tokens", { json: validatedInput }).json();
+    return this.validate(data, authTokenCreatedSchema);
+  }
+  /**
+   * Delete an auth token
+   */
+  async delete(id) {
+    await this.http.delete(`api/tokens/${id}`);
+  }
+};
+function transformHttpError(error) {
+  const { response } = error;
+  const status = response.status;
+  let errorMessage = `HTTP ${status} error`;
+  const body = error.data;
+  if (body) {
+    errorMessage = body.error || body.message || errorMessage;
+  }
+  switch (status) {
+    case 400:
+      return new BadRequestError(errorMessage);
+    case 401:
+      return new AuthenticationError(errorMessage);
+    case 403:
+      return new AuthorizationError(errorMessage);
+    case 404:
+      return new NotFoundError(errorMessage);
+    case 429: {
+      const retryAfter = response.headers.get("Retry-After");
+      return new RateLimitError(errorMessage, retryAfter ?? void 0);
+    }
+    case 500:
+    case 502:
+    case 503:
+    case 504:
+      return new ServerError(errorMessage, status);
+    default:
+      return new RustrakError(errorMessage, { statusCode: status });
+  }
+}
+function createKyInstance(config) {
+  const headers = {
+    "Content-Type": "application/json",
+    ...config.headers
+  };
+  if (config.token) {
+    headers.Authorization = `Bearer ${config.token}`;
+  }
+  return ky.create({
+    prefix: config.baseUrl,
+    timeout: config.timeout ?? 3e4,
+    credentials: "include",
+    retry: {
+      limit: config.maxRetries ?? 2,
+      statusCodes: [408, 500, 502, 503, 504],
+      methods: ["get", "post", "put", "patch", "delete"]
+    },
+    headers,
+    hooks: {
+      beforeError: [
+        ({ error }) => {
+          if (error.name === "TimeoutError") {
+            throw new NetworkError("Request timed out", error);
+          }
+          if (isHTTPError(error)) {
+            throw transformHttpError(error);
+          }
+          throw new NetworkError(error.message, error);
+        }
+      ]
+    }
+  });
+}
+
+// src/client.ts
+var RustrakClient = class {
+  http;
+  /**
+   * Authentication API resource
+   */
+  auth;
+  /**
+   * Projects API resource
+   */
+  projects;
+  /**
+   * Issues API resource
+   */
+  issues;
+  /**
+   * Events API resource
+   */
+  events;
+  /**
+   * Auth Tokens API resource
+   */
+  tokens;
+  /**
+   * Alert Channels API resource (global notification destinations)
+   */
+  alertChannels;
+  /**
+   * Alert Rules API resource (per-project alert configuration)
+   */
+  alertRules;
+  /**
+   * Create a new Rustrak API client
+   *
+   * @param config - Client configuration
+   */
+  constructor(config) {
+    this.http = createKyInstance(config);
+    this.auth = new AuthResource(this.http);
+    this.projects = new ProjectsResource(this.http);
+    this.issues = new IssuesResource(this.http);
+    this.events = new EventsResource(this.http);
+    this.tokens = new TokensResource(this.http);
+    this.alertChannels = new AlertChannelsResource(this.http);
+    this.alertRules = new AlertRulesResource(this.http);
+  }
+};
+
+export { AuthenticationError, AuthorizationError, BadRequestError, NetworkError, NotFoundError, RateLimitError, RustrakClient, RustrakError, ServerError, ValidationError };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map