@rustrak/client 0.16.3 → 0.17.0

package/dist/index.js

@@ -128,13 +128,24 @@ var alertRuleChannelInputSchema = z.object({
   integration_id: z.number().int(),
   routing_override: z.record(z.string(), z.unknown()).default({})
 });
+var alertRuleConditionsSchema = z.object({
+  /** The quietest level that still fires. The server takes `null` as absent. */
+  min_level: z.enum(["debug", "info", "warning", "error", "fatal"]).nullish(),
+  /** When non-empty, the only environments that fire. */
+  environments: z.array(z.string()).optional(),
+  /** A new issue fires when it reaches this many events, not on its first. */
+  min_events: z.number().int().min(1).nullish()
+});
 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()),
+  // A rule stored before the filters existed may hold any object. The server
+  // evaluates one it cannot read as no filters; one bad row must not fail the
+  // whole list either.
+  conditions: alertRuleConditionsSchema.catch({}),
   cooldown_minutes: z.number().int(),
   last_triggered_at: dateTimeSchema.nullable(),
   created_at: dateTimeSchema,
@@ -147,13 +158,13 @@ var createAlertRuleSchema = z.object({
   alert_type: alertTypeSchema,
   channels: z.array(alertRuleChannelInputSchema).default([]),
   is_enabled: z.boolean().optional(),
-  conditions: z.record(z.string(), z.unknown()).optional(),
+  conditions: alertRuleConditionsSchema.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(),
+  conditions: alertRuleConditionsSchema.optional(),
   cooldown_minutes: z.number().int().min(0).optional(),
   channels: z.array(alertRuleChannelInputSchema).optional()
 });
@@ -225,6 +236,89 @@ var eventDetailSchema = z.object({
   data: z.record(z.string(), z.any())
   // Full Sentry event JSON
 });
+var gitHubAppSchema = z.object({
+  app_id: z.number().int(),
+  slug: z.string(),
+  html_url: z.string(),
+  owner_login: z.string(),
+  install_url: z.string(),
+  last_webhook_at: dateTimeSchema.nullable(),
+  created_at: dateTimeSchema
+});
+var gitHubInstallationSchema = z.object({
+  id: z.number().int(),
+  account_login: z.string(),
+  account_type: z.string(),
+  suspended: z.boolean(),
+  created_at: dateTimeSchema
+});
+var gitHubStatusSchema = z.object({
+  app: gitHubAppSchema.nullable(),
+  installations: z.array(gitHubInstallationSchema),
+  webhook_url: z.string()
+});
+var gitHubManifestSchema = z.object({
+  action_url: z.string(),
+  manifest: z.string()
+});
+var gitHubRepositorySchema = z.object({
+  installation_id: z.number().int(),
+  full_name: z.string(),
+  default_branch: z.string(),
+  private: z.boolean(),
+  html_url: z.string()
+});
+var codeMappingSchema = z.object({
+  stack_root: z.string(),
+  source_root: z.string()
+});
+var projectRepositorySchema = z.object({
+  project_id: z.number().int(),
+  installation_id: z.number().int(),
+  repo_full_name: z.string(),
+  default_branch: z.string(),
+  html_url: z.string(),
+  code_mappings: z.array(codeMappingSchema),
+  /** Open a GitHub issue for new issues that pass `auto_create_conditions`. */
+  auto_create_issues: z.boolean(),
+  auto_create_conditions: alertRuleConditionsSchema,
+  codeowners_rules: z.number().int().nullable(),
+  codeowners_synced_at: dateTimeSchema.nullable()
+});
+var updateProjectRepositorySchema = z.object({
+  installation_id: z.number().int(),
+  repo_full_name: z.string().min(1),
+  code_mappings: z.array(codeMappingSchema).optional(),
+  auto_create_issues: z.boolean().optional(),
+  auto_create_conditions: alertRuleConditionsSchema.optional()
+});
+var issueLinkSchema = z.object({
+  id: z.number().int(),
+  issue_id: z.string(),
+  repo_full_name: z.string(),
+  number: z.number().int(),
+  title: z.string(),
+  url: z.string(),
+  state: z.string(),
+  created_at: dateTimeSchema
+});
+var repoCommitSchema = z.object({
+  repo_full_name: z.string(),
+  sha: z.string(),
+  message: z.string(),
+  author_name: z.string(),
+  author_login: z.string().nullable(),
+  url: z.string(),
+  committed_at: dateTimeSchema
+});
+var issueGitHubSchema = z.object({
+  links: z.array(issueLinkSchema),
+  suspect_commits: z.array(repoCommitSchema),
+  owners: z.array(z.string())
+});
+var gitHubLoginSchema = z.object({
+  login: z.string().nullable()
+});
 var globalRoleSchema = z.enum(["admin", "member"]);
 var teamMemberSchema = z.object({
   id: z.number().int(),
@@ -1657,6 +1751,109 @@ var EventsResource = class extends BaseResource {
     );
   }
 };
+
+// src/resources/github.ts
+var GitHubResource = class extends BaseResource {
+  /** The app, its installations and the webhook address (admin only). */
+  async status() {
+    return this.request(() => this.http.get("api/github"), gitHubStatusSchema);
+  }
+  /** The form to post to GitHub to create the app, under an org if given. */
+  async manifest(organization) {
+    return this.request(
+      () => this.http.post("api/github/manifest", { json: { organization } }),
+      gitHubManifestSchema
+    );
+  }
+  async disconnect() {
+    return this.requestVoid(() => this.http.delete("api/github"));
+  }
+  /** Repositories the installations reach, for a project's settings. */
+  async repositories(projectId) {
+    return this.request(
+      () => this.http.get("api/github/repositories", {
+        searchParams: { project_id: projectId }
+      }),
+      gitHubRepositorySchema.array()
+    );
+  }
+  async projectRepository(projectId) {
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/github`),
+      projectRepositorySchema.nullable()
+    );
+  }
+  async setProjectRepository(projectId, input) {
+    const validated = this.validateInput(input, updateProjectRepositorySchema);
+    if (!validated.success) {
+      return validated;
+    }
+    return this.request(
+      () => this.http.put(`api/projects/${projectId}/github`, {
+        json: validated.data
+      }),
+      projectRepositorySchema
+    );
+  }
+  async removeProjectRepository(projectId) {
+    return this.requestVoid(
+      () => this.http.delete(`api/projects/${projectId}/github`)
+    );
+  }
+  /** Copies the repository's CODEOWNERS into Rustrak. */
+  async syncCodeowners(projectId) {
+    return this.request(
+      () => this.http.post(`api/projects/${projectId}/github/codeowners`),
+      projectRepositorySchema
+    );
+  }
+  /** Links, suspect commits and owners for one issue. */
+  async issue(projectId, issueId) {
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/issues/${issueId}/github`),
+      issueGitHubSchema
+    );
+  }
+  async createIssue(projectId, issueId, input = {}) {
+    return this.request(
+      () => this.http.post(
+        `api/projects/${projectId}/issues/${issueId}/github/issues`,
+        { json: input }
+      ),
+      issueLinkSchema
+    );
+  }
+  /** `reference` is a GitHub URL, `owner/repo#12` or `#12`. */
+  async linkIssue(projectId, issueId, reference) {
+    return this.request(
+      () => this.http.post(
+        `api/projects/${projectId}/issues/${issueId}/github/links`,
+        { json: { reference } }
+      ),
+      issueLinkSchema
+    );
+  }
+  async unlinkIssue(projectId, issueId, linkId) {
+    return this.requestVoid(
+      () => this.http.delete(
+        `api/projects/${projectId}/issues/${issueId}/github/links/${linkId}`
+      )
+    );
+  }
+  /** The signed-in person's GitHub username, used to sync assignees. */
+  async myLogin() {
+    return this.request(
+      () => this.http.get("api/github/me"),
+      gitHubLoginSchema
+    );
+  }
+  async setMyLogin(login) {
+    return this.request(
+      () => this.http.put("api/github/me", { json: { login } }),
+      gitHubLoginSchema
+    );
+  }
+};
 var serverVersionSchema = z.object({
   version: z.string()
 });
@@ -2695,6 +2892,10 @@ var RustrakClient = class {
    * Health API resource (version info)
    */
   health;
+  /**
+   * GitHub integration resource
+   */
+  github;
   /**
    * Create a new Rustrak API client
    *
@@ -2707,6 +2908,7 @@ var RustrakClient = class {
     this.issues = new IssuesResource(this.http);
     this.events = new EventsResource(this.http);
     this.tokens = new TokensResource(this.http);
+    this.github = new GitHubResource(this.http);
     this.alertIntegrations = new AlertIntegrationsResource(this.http);
     this.alertRules = new AlertRulesResource(this.http);
     this.sourceMaps = new SourceMapsResource(this.http);