@rustrak/client 0.2.1 → 0.3.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import ky, { isHTTPError } from 'ky';
 
-// src/resources/alert-channels.ts
+// src/resources/alert-integrations.ts
 var paginatedResponseSchema = (itemSchema) => z.object({
   items: z.array(itemSchema),
   next_cursor: z.string().optional(),
@@ -25,7 +25,7 @@ z.object({
 });
 
 // src/schemas/alert.ts
-var channelTypeSchema = z.enum(["webhook", "email", "slack"]);
+var providerTypeSchema = z.enum(["webhook", "email", "slack"]);
 var alertTypeSchema = z.enum(["new_issue", "regression", "unmute"]);
 var alertStatusSchema = z.enum([
   "pending",
@@ -33,11 +33,11 @@ var alertStatusSchema = z.enum([
   "failed",
   "skipped"
 ]);
-var notificationChannelSchema = z.object({
+var alertIntegrationSchema = z.object({
   id: z.number().int(),
   name: z.string(),
-  channel_type: channelTypeSchema,
-  config: z.record(z.string(), z.unknown()),
+  provider_type: providerTypeSchema,
+  credentials: z.record(z.string(), z.unknown()),
   is_enabled: z.boolean(),
   failure_count: z.number().int(),
   last_failure_at: dateTimeSchema.nullable(),
@@ -46,17 +46,21 @@ var notificationChannelSchema = z.object({
   created_at: dateTimeSchema,
   updated_at: dateTimeSchema
 });
-var createNotificationChannelSchema = z.object({
+var createAlertIntegrationSchema = z.object({
   name: z.string().min(1),
-  channel_type: channelTypeSchema,
-  config: z.record(z.string(), z.unknown()),
+  provider_type: providerTypeSchema,
+  credentials: z.record(z.string(), z.unknown()),
   is_enabled: z.boolean().optional()
 });
-var updateNotificationChannelSchema = z.object({
+var updateAlertIntegrationSchema = z.object({
   name: z.string().min(1).optional(),
-  config: z.record(z.string(), z.unknown()).optional(),
+  credentials: z.record(z.string(), z.unknown()).optional(),
   is_enabled: z.boolean().optional()
 });
+var alertRuleChannelInputSchema = z.object({
+  integration_id: z.number().int(),
+  routing_override: z.record(z.string(), z.unknown()).default({})
+});
 var alertRuleSchema = z.object({
   id: z.number().int(),
   project_id: z.number().int(),
@@ -68,12 +72,13 @@ var alertRuleSchema = z.object({
   last_triggered_at: dateTimeSchema.nullable(),
   created_at: dateTimeSchema,
   updated_at: dateTimeSchema,
-  channel_ids: z.array(z.number().int())
+  channels: z.array(alertRuleChannelInputSchema).default([]),
+  integration_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),
+  channels: z.array(alertRuleChannelInputSchema).default([]),
   is_enabled: z.boolean().optional(),
   conditions: z.record(z.string(), z.unknown()).optional(),
   cooldown_minutes: z.number().int().min(0).optional()
@@ -83,12 +88,12 @@ var updateAlertRuleSchema = z.object({
   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()
+  channels: z.array(alertRuleChannelInputSchema).optional()
 });
 var alertHistorySchema = z.object({
   id: z.number().int(),
   alert_rule_id: z.number().int().nullable(),
-  channel_id: z.number().int().nullable(),
+  integration_id: z.number().int().nullable(),
   issue_id: z.string().uuid().nullable(),
   project_id: z.number().int().nullable(),
   alert_type: z.string(),
@@ -107,6 +112,9 @@ var testChannelResponseSchema = z.object({
   success: z.boolean(),
   message: z.string()
 });
+var testIntegrationBodySchema = z.object({
+  routing_override: z.record(z.string(), z.unknown()).optional()
+});
 
 // src/errors/base.ts
 var RustrakError = class extends Error {
@@ -222,55 +230,57 @@ var BaseResource = class {
   }
 };
 
-// src/resources/alert-channels.ts
-var AlertChannelsResource = class extends BaseResource {
+// src/resources/alert-integrations.ts
+var AlertIntegrationsResource = class extends BaseResource {
   /**
-   * List all notification channels
+   * List all alert integrations
    */
   async list() {
-    const data = await this.http.get("api/alert-channels").json();
-    return this.validate(data, z.array(notificationChannelSchema));
+    const data = await this.http.get("api/integrations").json();
+    return this.validate(data, z.array(alertIntegrationSchema));
   }
   /**
-   * Get a single notification channel by ID
+   * Get a single alert integration by ID
    */
   async get(id) {
-    const data = await this.http.get(`api/alert-channels/${id}`).json();
-    return this.validate(data, notificationChannelSchema);
+    const data = await this.http.get(`api/integrations/${id}`).json();
+    return this.validate(data, alertIntegrationSchema);
   }
   /**
-   * Create a new notification channel
+   * Create a new alert integration
    */
   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);
+    const validatedInput = this.validate(input, createAlertIntegrationSchema);
+    const data = await this.http.post("api/integrations", { json: validatedInput }).json();
+    return this.validate(data, alertIntegrationSchema);
   }
   /**
-   * Update an existing notification channel
+   * Update an existing alert integration
    */
   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);
+    const validatedInput = this.validate(input, updateAlertIntegrationSchema);
+    const data = await this.http.patch(`api/integrations/${id}`, { json: validatedInput }).json();
+    return this.validate(data, alertIntegrationSchema);
   }
   /**
-   * Delete a notification channel
+   * Delete an alert integration
    */
   async delete(id) {
-    await this.http.delete(`api/alert-channels/${id}`);
+    await this.http.delete(`api/integrations/${id}`);
   }
   /**
-   * Send a test notification to verify channel configuration
+   * Send a test notification to verify integration configuration.
+   * For Slack bot_token integrations, routingOverride must include `channel`.
    */
-  async test(id) {
-    const data = await this.http.post(`api/alert-channels/${id}/test`).json();
+  async test(id, routingOverride) {
+    const body = routingOverride !== void 0 ? this.validate(
+      { routing_override: routingOverride },
+      testIntegrationBodySchema
+    ) : void 0;
+    const data = await this.http.post(
+      `api/integrations/${id}/test`,
+      body !== void 0 ? { json: body } : void 0
+    ).json();
     return this.validate(data, testChannelResponseSchema);
   }
 };
@@ -327,9 +337,49 @@ var AlertRulesResource = class extends BaseResource {
     return this.validate(data, z.array(alertHistorySchema));
   }
 };
+var globalRoleSchema = z.enum(["admin", "member"]);
+var teamMemberSchema = z.object({
+  id: z.number().int(),
+  email: z.string().email(),
+  role: globalRoleSchema,
+  is_active: z.boolean(),
+  /** True for the first-registered account, which cannot be demoted or deleted. */
+  is_primary: z.boolean().optional(),
+  created_at: dateTimeSchema,
+  last_login: dateTimeSchema.nullable().optional()
+});
+var updateUserRoleSchema = z.object({
+  role: globalRoleSchema
+});
+
+// src/schemas/invitation.ts
+var invitationStatusSchema = z.string();
+var invitationSchema = z.object({
+  token: z.string(),
+  email: z.string().email(),
+  role: globalRoleSchema,
+  status: invitationStatusSchema,
+  expires_at: dateTimeSchema,
+  created_at: dateTimeSchema
+});
+var invitationInfoSchema = z.object({
+  email: z.string().email(),
+  role: globalRoleSchema,
+  status: invitationStatusSchema,
+  expires_at: dateTimeSchema
+});
+var createInvitationSchema = z.object({
+  email: z.string().email(),
+  role: globalRoleSchema
+});
+var acceptInvitationSchema = z.object({
+  token: z.string().min(1),
+  password: z.string().min(1)
+});
 var userSchema = z.object({
   id: z.number().int().positive(),
   email: z.string().email(),
+  role: globalRoleSchema,
   is_admin: z.boolean()
 });
 var authResponseSchema = z.object({
@@ -341,11 +391,11 @@ z.object({
 });
 var loginRequestSchema = z.object({
   email: z.string().email(),
-  password: z.string().min(8)
+  password: z.string().min(1)
 });
 var registerRequestSchema = z.object({
   email: z.string().email(),
-  password: z.string().min(8)
+  password: z.string().min(1)
 });
 
 // src/resources/auth.ts
@@ -406,6 +456,34 @@ var AuthResource = class extends BaseResource {
     const data = await this.http.get("auth/me").json();
     return this.validate(data, userSchema);
   }
+  /**
+   * Get the details of a pending invitation by its token (public endpoint)
+   * Used by the accept-invitation page before the user has an account
+   * @param token - Invitation token
+   * @returns Invitation info (email, role, status, expiry)
+   */
+  async getInvitation(token) {
+    const data = await this.http.get(`auth/invitation/${token}`).json();
+    return this.validate(data, invitationInfoSchema);
+  }
+  /**
+   * Accept a pending invitation, creating the user account and logging in
+   * @param input - Invitation token and the new account's password
+   * @returns LoginResult with user information and session cookies
+   */
+  async acceptInvitation(input) {
+    const validatedInput = this.validate(input, acceptInvitationSchema);
+    const response = await this.http.post("auth/accept-invitation", {
+      json: validatedInput
+    });
+    const cookies = response.headers.getSetCookie();
+    const data = await response.json();
+    const authResponse = this.validate(data, authResponseSchema);
+    return {
+      user: authResponse.user,
+      cookies
+    };
+  }
 };
 var eventSchema = z.object({
   id: uuidSchema,
@@ -453,6 +531,17 @@ var updateIssueStateSchema = z.object({
   is_resolved: z.boolean().optional(),
   is_muted: z.boolean().optional()
 });
+var projectRoleSchema = z.enum(["viewer", "editor", "admin"]);
+var projectMemberSchema = z.object({
+  user_id: z.number().int(),
+  email: z.string().email(),
+  role: projectRoleSchema,
+  created_at: dateTimeSchema
+});
+var upsertProjectMemberSchema = z.object({
+  user_id: z.number().int(),
+  role: projectRoleSchema
+});
 var projectSchema = z.object({
   id: z.number().int(),
   name: z.string(),
@@ -539,6 +628,33 @@ var EventsResource = class extends BaseResource {
   }
 };
 
+// src/resources/invitations.ts
+var InvitationsResource = class extends BaseResource {
+  /**
+   * Create a new invitation
+   * @param input - Email and global role for the invited user
+   */
+  async create(input) {
+    const validatedInput = this.validate(input, createInvitationSchema);
+    const data = await this.http.post("api/invitations", { json: validatedInput }).json();
+    return this.validate(data, invitationSchema);
+  }
+  /**
+   * List all invitations
+   */
+  async list() {
+    const data = await this.http.get("api/invitations").json();
+    return this.validate(data, invitationSchema.array());
+  }
+  /**
+   * Revoke a pending invitation
+   * @param token - Invitation token to revoke
+   */
+  async revoke(token) {
+    await this.http.delete(`api/invitations/${token}`);
+  }
+};
+
 // src/resources/issues.ts
 var IssuesResource = class extends BaseResource {
   /**
@@ -589,6 +705,37 @@ var IssuesResource = class extends BaseResource {
   }
 };
 
+// src/resources/members.ts
+var MembersResource = class extends BaseResource {
+  /**
+   * List members of a project
+   * @param projectId - ID of the project
+   */
+  async list(projectId) {
+    const data = await this.http.get(`api/projects/${projectId}/members`).json();
+    return this.validate(data, projectMemberSchema.array());
+  }
+  /**
+   * Add or update a project member
+   * @param projectId - ID of the project
+   * @param input - User ID and per-project role
+   */
+  async upsert(projectId, input) {
+    const validatedInput = this.validate(input, upsertProjectMemberSchema);
+    await this.http.put(`api/projects/${projectId}/members`, {
+      json: validatedInput
+    });
+  }
+  /**
+   * Remove a member from a project
+   * @param projectId - ID of the project
+   * @param userId - ID of the user to remove
+   */
+  async remove(projectId, userId) {
+    await this.http.delete(`api/projects/${projectId}/members/${userId}`);
+  }
+};
+
 // src/resources/projects.ts
 var ProjectsResource = class extends BaseResource {
   /**
@@ -693,6 +840,33 @@ var SourceMapsResource = class extends BaseResource {
   }
 };
 
+// src/resources/team.ts
+var TeamResource = class extends BaseResource {
+  /**
+   * List all team members (users)
+   */
+  async list() {
+    const data = await this.http.get("api/team").json();
+    return this.validate(data, teamMemberSchema.array());
+  }
+  /**
+   * Change a user's global role
+   * @param userId - ID of the user to update
+   * @param role - New global role to assign
+   */
+  async updateRole(userId, role) {
+    const body = this.validate({ role }, updateUserRoleSchema);
+    await this.http.patch(`api/team/${userId}/role`, { json: body });
+  }
+  /**
+   * Permanently remove a user from the instance.
+   * @param userId - ID of the user to delete
+   */
+  async remove(userId) {
+    await this.http.delete(`api/team/${userId}`);
+  }
+};
+
 // src/resources/tokens.ts
 var TokensResource = class extends BaseResource {
   /**
@@ -813,9 +987,9 @@ var RustrakClient = class {
    */
   tokens;
   /**
-   * Alert Channels API resource (global notification destinations)
+   * Alert Integrations API resource (global credential destinations)
    */
-  alertChannels;
+  alertIntegrations;
   /**
    * Alert Rules API resource (per-project alert configuration)
    */
@@ -824,6 +998,18 @@ var RustrakClient = class {
    * Source Maps API resource (sentry-cli artifact bundle upload protocol)
    */
   sourceMaps;
+  /**
+   * Team API resource (global user roster and roles)
+   */
+  team;
+  /**
+   * Invitations API resource (pending user invitations)
+   */
+  invitations;
+  /**
+   * Project Members API resource (per-project membership and roles)
+   */
+  members;
   /**
    * Create a new Rustrak API client
    *
@@ -836,9 +1022,12 @@ var RustrakClient = class {
     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.alertIntegrations = new AlertIntegrationsResource(this.http);
     this.alertRules = new AlertRulesResource(this.http);
     this.sourceMaps = new SourceMapsResource(this.http);
+    this.team = new TeamResource(this.http);
+    this.invitations = new InvitationsResource(this.http);
+    this.members = new MembersResource(this.http);
   }
 };