@rustrak/client 0.2.1 → 0.3.0

package/dist/index.cjs

@@ -7,7 +7,7 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var ky__default = /*#__PURE__*/_interopDefault(ky);
 
-// src/resources/alert-channels.ts
+// src/resources/alert-integrations.ts
 var paginatedResponseSchema = (itemSchema) => zod.z.object({
   items: zod.z.array(itemSchema),
   next_cursor: zod.z.string().optional(),
@@ -31,7 +31,7 @@ zod.z.object({
 });
 
 // src/schemas/alert.ts
-var channelTypeSchema = zod.z.enum(["webhook", "email", "slack"]);
+var providerTypeSchema = zod.z.enum(["webhook", "email", "slack"]);
 var alertTypeSchema = zod.z.enum(["new_issue", "regression", "unmute"]);
 var alertStatusSchema = zod.z.enum([
   "pending",
@@ -39,11 +39,11 @@ var alertStatusSchema = zod.z.enum([
   "failed",
   "skipped"
 ]);
-var notificationChannelSchema = zod.z.object({
+var alertIntegrationSchema = zod.z.object({
   id: zod.z.number().int(),
   name: zod.z.string(),
-  channel_type: channelTypeSchema,
-  config: zod.z.record(zod.z.string(), zod.z.unknown()),
+  provider_type: providerTypeSchema,
+  credentials: zod.z.record(zod.z.string(), zod.z.unknown()),
   is_enabled: zod.z.boolean(),
   failure_count: zod.z.number().int(),
   last_failure_at: dateTimeSchema.nullable(),
@@ -52,17 +52,21 @@ var notificationChannelSchema = zod.z.object({
   created_at: dateTimeSchema,
   updated_at: dateTimeSchema
 });
-var createNotificationChannelSchema = zod.z.object({
+var createAlertIntegrationSchema = zod.z.object({
   name: zod.z.string().min(1),
-  channel_type: channelTypeSchema,
-  config: zod.z.record(zod.z.string(), zod.z.unknown()),
+  provider_type: providerTypeSchema,
+  credentials: zod.z.record(zod.z.string(), zod.z.unknown()),
   is_enabled: zod.z.boolean().optional()
 });
-var updateNotificationChannelSchema = zod.z.object({
+var updateAlertIntegrationSchema = zod.z.object({
   name: zod.z.string().min(1).optional(),
-  config: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  credentials: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
   is_enabled: zod.z.boolean().optional()
 });
+var alertRuleChannelInputSchema = zod.z.object({
+  integration_id: zod.z.number().int(),
+  routing_override: zod.z.record(zod.z.string(), zod.z.unknown()).default({})
+});
 var alertRuleSchema = zod.z.object({
   id: zod.z.number().int(),
   project_id: zod.z.number().int(),
@@ -74,12 +78,13 @@ var alertRuleSchema = zod.z.object({
   last_triggered_at: dateTimeSchema.nullable(),
   created_at: dateTimeSchema,
   updated_at: dateTimeSchema,
-  channel_ids: zod.z.array(zod.z.number().int())
+  channels: zod.z.array(alertRuleChannelInputSchema).default([]),
+  integration_ids: zod.z.array(zod.z.number().int())
 });
 var createAlertRuleSchema = zod.z.object({
   name: zod.z.string().min(1),
   alert_type: alertTypeSchema,
-  channel_ids: zod.z.array(zod.z.number().int()).min(1),
+  channels: zod.z.array(alertRuleChannelInputSchema).default([]),
   is_enabled: zod.z.boolean().optional(),
   conditions: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
   cooldown_minutes: zod.z.number().int().min(0).optional()
@@ -89,12 +94,12 @@ var updateAlertRuleSchema = zod.z.object({
   is_enabled: zod.z.boolean().optional(),
   conditions: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
   cooldown_minutes: zod.z.number().int().min(0).optional(),
-  channel_ids: zod.z.array(zod.z.number().int()).optional()
+  channels: zod.z.array(alertRuleChannelInputSchema).optional()
 });
 var alertHistorySchema = zod.z.object({
   id: zod.z.number().int(),
   alert_rule_id: zod.z.number().int().nullable(),
-  channel_id: zod.z.number().int().nullable(),
+  integration_id: zod.z.number().int().nullable(),
   issue_id: zod.z.string().uuid().nullable(),
   project_id: zod.z.number().int().nullable(),
   alert_type: zod.z.string(),
@@ -113,6 +118,9 @@ var testChannelResponseSchema = zod.z.object({
   success: zod.z.boolean(),
   message: zod.z.string()
 });
+var testIntegrationBodySchema = zod.z.object({
+  routing_override: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
 
 // src/errors/base.ts
 var RustrakError = class extends Error {
@@ -228,55 +236,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, zod.z.array(notificationChannelSchema));
+    const data = await this.http.get("api/integrations").json();
+    return this.validate(data, zod.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);
   }
 };
@@ -333,9 +343,49 @@ var AlertRulesResource = class extends BaseResource {
     return this.validate(data, zod.z.array(alertHistorySchema));
   }
 };
+var globalRoleSchema = zod.z.enum(["admin", "member"]);
+var teamMemberSchema = zod.z.object({
+  id: zod.z.number().int(),
+  email: zod.z.string().email(),
+  role: globalRoleSchema,
+  is_active: zod.z.boolean(),
+  /** True for the first-registered account, which cannot be demoted or deleted. */
+  is_primary: zod.z.boolean().optional(),
+  created_at: dateTimeSchema,
+  last_login: dateTimeSchema.nullable().optional()
+});
+var updateUserRoleSchema = zod.z.object({
+  role: globalRoleSchema
+});
+
+// src/schemas/invitation.ts
+var invitationStatusSchema = zod.z.string();
+var invitationSchema = zod.z.object({
+  token: zod.z.string(),
+  email: zod.z.string().email(),
+  role: globalRoleSchema,
+  status: invitationStatusSchema,
+  expires_at: dateTimeSchema,
+  created_at: dateTimeSchema
+});
+var invitationInfoSchema = zod.z.object({
+  email: zod.z.string().email(),
+  role: globalRoleSchema,
+  status: invitationStatusSchema,
+  expires_at: dateTimeSchema
+});
+var createInvitationSchema = zod.z.object({
+  email: zod.z.string().email(),
+  role: globalRoleSchema
+});
+var acceptInvitationSchema = zod.z.object({
+  token: zod.z.string().min(1),
+  password: zod.z.string().min(1)
+});
 var userSchema = zod.z.object({
   id: zod.z.number().int().positive(),
   email: zod.z.string().email(),
+  role: globalRoleSchema,
   is_admin: zod.z.boolean()
 });
 var authResponseSchema = zod.z.object({
@@ -347,11 +397,11 @@ zod.z.object({
 });
 var loginRequestSchema = zod.z.object({
   email: zod.z.string().email(),
-  password: zod.z.string().min(8)
+  password: zod.z.string().min(1)
 });
 var registerRequestSchema = zod.z.object({
   email: zod.z.string().email(),
-  password: zod.z.string().min(8)
+  password: zod.z.string().min(1)
 });
 
 // src/resources/auth.ts
@@ -412,6 +462,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 = zod.z.object({
   id: uuidSchema,
@@ -459,6 +537,17 @@ var updateIssueStateSchema = zod.z.object({
   is_resolved: zod.z.boolean().optional(),
   is_muted: zod.z.boolean().optional()
 });
+var projectRoleSchema = zod.z.enum(["viewer", "editor", "admin"]);
+var projectMemberSchema = zod.z.object({
+  user_id: zod.z.number().int(),
+  email: zod.z.string().email(),
+  role: projectRoleSchema,
+  created_at: dateTimeSchema
+});
+var upsertProjectMemberSchema = zod.z.object({
+  user_id: zod.z.number().int(),
+  role: projectRoleSchema
+});
 var projectSchema = zod.z.object({
   id: zod.z.number().int(),
   name: zod.z.string(),
@@ -545,6 +634,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 {
   /**
@@ -595,6 +711,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 {
   /**
@@ -699,6 +846,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 {
   /**
@@ -819,9 +993,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)
    */
@@ -830,6 +1004,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
    *
@@ -842,9 +1028,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);
   }
 };