@bbearai/core 0.1.6 → 0.2.1

package/dist/index.js

@@ -86,7 +86,16 @@ var BugBearClient = class {
    */
   async submitReport(report) {
     try {
+      const validationError = this.validateReport(report);
+      if (validationError) {
+        return { success: false, error: validationError };
+      }
       const userInfo = await this.getCurrentUserInfo();
+      const rateLimitId = userInfo?.email || this.config.projectId;
+      const rateLimit = await this.checkRateLimit(rateLimitId, "report_submit");
+      if (!rateLimit.allowed) {
+        return { success: false, error: rateLimit.error };
+      }
       if (!userInfo) {
         console.error("BugBear: No user info available, cannot submit report");
         return { success: false, error: "User not authenticated" };
@@ -137,6 +146,7 @@ var BugBearClient = class {
       const { data, error } = await this.supabase.from("test_assignments").select(`
           id,
           status,
+          started_at,
           test_case:test_cases(
             id,
             title,
@@ -164,6 +174,7 @@ var BugBearClient = class {
       return (data || []).map((item) => ({
         id: item.id,
         status: item.status,
+        startedAt: item.started_at,
         testCase: {
           id: item.test_case.id,
           title: item.test_case.title,
@@ -189,47 +200,430 @@ var BugBearClient = class {
       return [];
     }
   }
+  /**
+   * Get assignment by ID with time tracking fields
+   */
+  async getAssignment(assignmentId) {
+    try {
+      const { data, error } = await this.supabase.from("test_assignments").select(`
+          id,
+          status,
+          started_at,
+          completed_at,
+          duration_seconds,
+          test_case:test_cases(
+            id,
+            title,
+            test_key,
+            description,
+            steps,
+            expected_result,
+            priority,
+            target_route,
+            track:qa_tracks(
+              id,
+              name,
+              icon,
+              color,
+              test_template,
+              rubric_mode,
+              description
+            )
+          )
+        `).eq("id", assignmentId).single();
+      if (error || !data) return null;
+      const testCase = data.test_case;
+      if (!testCase) {
+        console.error("BugBear: Assignment returned without test_case");
+        return null;
+      }
+      const track = testCase.track;
+      return {
+        id: data.id,
+        status: data.status,
+        startedAt: data.started_at,
+        durationSeconds: data.duration_seconds,
+        testCase: {
+          id: testCase.id,
+          title: testCase.title,
+          testKey: testCase.test_key,
+          description: testCase.description,
+          steps: testCase.steps,
+          expectedResult: testCase.expected_result,
+          priority: testCase.priority,
+          targetRoute: testCase.target_route,
+          track: track ? {
+            id: track.id,
+            name: track.name,
+            icon: track.icon,
+            color: track.color,
+            testTemplate: track.test_template,
+            rubricMode: track.rubric_mode || "pass_fail",
+            description: track.description
+          } : void 0
+        }
+      };
+    } catch (err) {
+      console.error("BugBear: Error fetching assignment", err);
+      return null;
+    }
+  }
+  /**
+   * Update assignment status with automatic time tracking
+   * - Sets started_at when status changes to 'in_progress'
+   * - Calculates duration_seconds when status changes to 'passed'/'failed'/'blocked'
+   * - Optionally include feedback when completing a test
+   */
+  async updateAssignmentStatus(assignmentId, status, options) {
+    try {
+      const { data: currentAssignment, error: fetchError } = await this.supabase.from("test_assignments").select("status, started_at").eq("id", assignmentId).single();
+      if (fetchError || !currentAssignment) {
+        return { success: false, error: "Assignment not found" };
+      }
+      const updateData = { status };
+      let durationSeconds;
+      if (status === "in_progress" && currentAssignment.status !== "in_progress") {
+        updateData.started_at = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      if (["passed", "failed", "blocked"].includes(status)) {
+        updateData.completed_at = (/* @__PURE__ */ new Date()).toISOString();
+        if (currentAssignment.started_at) {
+          const startedAt = new Date(currentAssignment.started_at);
+          const completedAt = /* @__PURE__ */ new Date();
+          durationSeconds = Math.round((completedAt.getTime() - startedAt.getTime()) / 1e3);
+          updateData.duration_seconds = durationSeconds;
+        }
+      }
+      if (options?.notes) {
+        updateData.notes = options.notes;
+      }
+      if (options?.testResult) {
+        updateData.test_result = options.testResult;
+      }
+      const { error } = await this.supabase.from("test_assignments").update(updateData).eq("id", assignmentId);
+      if (error) {
+        console.error("BugBear: Failed to update assignment status", error);
+        return { success: false, error: error.message };
+      }
+      if (options?.feedback && ["passed", "failed", "blocked"].includes(status)) {
+        const { data: assignmentData, error: fetchError2 } = await this.supabase.from("test_assignments").select("test_case_id").eq("id", assignmentId).single();
+        if (fetchError2) {
+          console.error("BugBear: Failed to fetch assignment for feedback", fetchError2);
+        } else if (assignmentData?.test_case_id) {
+          const feedbackResult = await this.submitTestFeedback({
+            testCaseId: assignmentData.test_case_id,
+            assignmentId,
+            feedback: options.feedback,
+            timeToCompleteSeconds: durationSeconds
+          });
+          if (!feedbackResult.success) {
+            console.error("BugBear: Failed to submit feedback", feedbackResult.error);
+          }
+        }
+      }
+      return { success: true, durationSeconds };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      console.error("BugBear: Error updating assignment status", err);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Submit feedback on a test case to help improve test quality
+   * This empowers testers to shape better tests over time
+   */
+  async submitTestFeedback(options) {
+    try {
+      const testerInfo = await this.getTesterInfo();
+      if (!testerInfo) {
+        return { success: false, error: "Not authenticated as tester" };
+      }
+      const { testCaseId, assignmentId, feedback, timeToCompleteSeconds } = options;
+      if (feedback.rating < 1 || feedback.rating > 5) {
+        return { success: false, error: "Rating must be between 1 and 5" };
+      }
+      const { error: feedbackError } = await this.supabase.from("test_feedback").insert({
+        project_id: this.config.projectId,
+        test_case_id: testCaseId,
+        assignment_id: assignmentId || null,
+        tester_id: testerInfo.id,
+        rating: feedback.rating,
+        clarity_rating: feedback.clarityRating || null,
+        steps_rating: feedback.stepsRating || null,
+        relevance_rating: feedback.relevanceRating || null,
+        feedback_note: feedback.feedbackNote?.trim() || null,
+        suggested_improvement: feedback.suggestedImprovement?.trim() || null,
+        is_outdated: feedback.isOutdated || false,
+        needs_more_detail: feedback.needsMoreDetail || false,
+        steps_unclear: feedback.stepsUnclear || false,
+        expected_result_unclear: feedback.expectedResultUnclear || false,
+        platform: this.getDeviceInfo().platform,
+        time_to_complete_seconds: timeToCompleteSeconds || null
+      });
+      if (feedbackError) {
+        console.error("BugBear: Failed to submit feedback", feedbackError);
+        return { success: false, error: feedbackError.message };
+      }
+      if (assignmentId) {
+        const { error: assignmentError } = await this.supabase.from("test_assignments").update({
+          feedback_rating: feedback.rating,
+          feedback_note: feedback.feedbackNote?.trim() || null,
+          feedback_submitted_at: (/* @__PURE__ */ new Date()).toISOString()
+        }).eq("id", assignmentId);
+        if (assignmentError) {
+          console.error("BugBear: Failed to update assignment feedback fields", assignmentError);
+        }
+      }
+      return { success: true };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      console.error("BugBear: Error submitting feedback", err);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Get the currently active (in_progress) assignment for the tester
+   */
+  async getActiveAssignment() {
+    try {
+      const testerInfo = await this.getTesterInfo();
+      if (!testerInfo) return null;
+      const { data, error } = await this.supabase.from("test_assignments").select(`
+          id,
+          status,
+          started_at,
+          test_case:test_cases(
+            id,
+            title,
+            test_key,
+            description,
+            steps,
+            expected_result,
+            priority,
+            target_route,
+            track:qa_tracks(
+              id,
+              name,
+              icon,
+              color,
+              test_template,
+              rubric_mode,
+              description
+            )
+          )
+        `).eq("project_id", this.config.projectId).eq("tester_id", testerInfo.id).eq("status", "in_progress").order("started_at", { ascending: false }).limit(1).maybeSingle();
+      if (error || !data) return null;
+      const testCase = data.test_case;
+      if (!testCase) {
+        console.error("BugBear: Active assignment returned without test_case");
+        return null;
+      }
+      const track = testCase.track;
+      return {
+        id: data.id,
+        status: data.status,
+        startedAt: data.started_at,
+        testCase: {
+          id: testCase.id,
+          title: testCase.title,
+          testKey: testCase.test_key,
+          description: testCase.description,
+          steps: testCase.steps,
+          expectedResult: testCase.expected_result,
+          priority: testCase.priority,
+          targetRoute: testCase.target_route,
+          track: track ? {
+            id: track.id,
+            name: track.name,
+            icon: track.icon,
+            color: track.color,
+            testTemplate: track.test_template,
+            rubricMode: track.rubric_mode || "pass_fail",
+            description: track.description
+          } : void 0
+        }
+      };
+    } catch (err) {
+      console.error("BugBear: Error fetching active assignment", err);
+      return null;
+    }
+  }
   /**
    * Get current tester info
    * Looks up tester by email from the host app's authenticated user
+   * Checks both primary email AND additional_emails array
+   * Uses parameterized RPC function to prevent SQL injection
    */
   async getTesterInfo() {
     try {
       const userInfo = await this.getCurrentUserInfo();
-      if (!userInfo) return null;
-      const { data, error } = await this.supabase.from("testers").select("*").eq("project_id", this.config.projectId).eq("email", userInfo.email).eq("status", "active").single();
+      if (!userInfo?.email) return null;
+      if (!this.isValidEmail(userInfo.email)) {
+        console.warn("BugBear: Invalid email format");
+        return null;
+      }
+      const { data, error } = await this.supabase.rpc("lookup_tester_by_email", {
+        p_project_id: this.config.projectId,
+        p_email: userInfo.email
+      }).maybeSingle();
       if (error || !data) return null;
+      const tester = data;
       return {
-        id: data.id,
-        name: data.name,
-        email: data.email,
-        additionalEmails: data.additional_emails || [],
-        avatarUrl: data.avatar_url || void 0,
-        platforms: data.platforms || [],
-        assignedTests: data.assigned_count || 0,
-        completedTests: data.completed_count || 0
+        id: tester.id,
+        name: tester.name,
+        email: tester.email,
+        additionalEmails: tester.additional_emails || [],
+        avatarUrl: tester.avatar_url || void 0,
+        platforms: tester.platforms || [],
+        assignedTests: tester.assigned_count || 0,
+        completedTests: tester.completed_count || 0
       };
     } catch (err) {
       console.error("BugBear: getTesterInfo error", err);
       return null;
     }
   }
+  /**
+   * Basic email format validation (defense in depth)
+   */
+  isValidEmail(email) {
+    if (!email || email.length > 254) return false;
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+  }
+  /**
+   * Validate report input before submission
+   * Returns error message if invalid, null if valid
+   */
+  validateReport(report) {
+    const validTypes = ["bug", "feedback", "suggestion", "test_pass", "test_fail"];
+    if (report.type && !validTypes.includes(report.type)) {
+      return `Invalid report type: ${report.type}. Must be one of: ${validTypes.join(", ")}`;
+    }
+    const validSeverities = ["critical", "high", "medium", "low"];
+    if (report.severity && !validSeverities.includes(report.severity)) {
+      return `Invalid severity: ${report.severity}. Must be one of: ${validSeverities.join(", ")}`;
+    }
+    if (report.title && report.title.length > 500) {
+      return "Title must be 500 characters or less";
+    }
+    if (report.description && report.description.length > 1e4) {
+      return "Description must be 10,000 characters or less";
+    }
+    if (report.screenshots && Array.isArray(report.screenshots)) {
+      if (report.screenshots.length > 10) {
+        return "Maximum 10 screenshots allowed";
+      }
+      for (const url of report.screenshots) {
+        if (typeof url !== "string" || url.length > 2e3) {
+          return "Invalid screenshot URL";
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Validate profile update input
+   * Returns error message if invalid, null if valid
+   */
+  validateProfileUpdate(updates) {
+    if (updates.name !== void 0) {
+      if (typeof updates.name !== "string" || updates.name.length > 100) {
+        return "Name must be 100 characters or less";
+      }
+    }
+    if (updates.additionalEmails !== void 0) {
+      if (!Array.isArray(updates.additionalEmails)) {
+        return "Additional emails must be an array";
+      }
+      if (updates.additionalEmails.length > 5) {
+        return "Maximum 5 additional emails allowed";
+      }
+      for (const email of updates.additionalEmails) {
+        if (!this.isValidEmail(email)) {
+          return `Invalid email format: ${email}`;
+        }
+      }
+    }
+    if (updates.avatarUrl !== void 0 && updates.avatarUrl !== null) {
+      if (typeof updates.avatarUrl !== "string" || updates.avatarUrl.length > 2e3) {
+        return "Invalid avatar URL";
+      }
+    }
+    if (updates.platforms !== void 0) {
+      if (!Array.isArray(updates.platforms)) {
+        return "Platforms must be an array";
+      }
+      const validPlatforms = ["ios", "android", "web", "desktop", "other"];
+      for (const platform of updates.platforms) {
+        if (!validPlatforms.includes(platform)) {
+          return `Invalid platform: ${platform}. Must be one of: ${validPlatforms.join(", ")}`;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Check rate limit for an action
+   * Returns { allowed: boolean, error?: string, remaining?: number }
+   */
+  async checkRateLimit(identifier, action) {
+    try {
+      const { data, error } = await this.supabase.rpc("check_rate_limit", {
+        p_identifier: identifier,
+        p_action: action,
+        p_project_id: this.config.projectId
+      });
+      if (error) {
+        console.warn("BugBear: Rate limit check failed, allowing request", error.message);
+        return { allowed: true };
+      }
+      if (!data.allowed) {
+        return {
+          allowed: false,
+          error: `Rate limit exceeded. Try again in ${Math.ceil((new Date(data.reset_at).getTime() - Date.now()) / 1e3)} seconds.`,
+          remaining: 0,
+          resetAt: data.reset_at
+        };
+      }
+      return {
+        allowed: true,
+        remaining: data.remaining,
+        resetAt: data.reset_at
+      };
+    } catch (err) {
+      console.warn("BugBear: Rate limit check error", err);
+      return { allowed: true };
+    }
+  }
   /**
    * Update tester profile
    * Allows testers to update their name, additional emails, avatar, and platforms
    */
   async updateTesterProfile(updates) {
     try {
+      const validationError = this.validateProfileUpdate(updates);
+      if (validationError) {
+        return { success: false, error: validationError };
+      }
       const userInfo = await this.getCurrentUserInfo();
       if (!userInfo) {
         return { success: false, error: "Not authenticated" };
       }
+      const rateLimit = await this.checkRateLimit(userInfo.email, "profile_update");
+      if (!rateLimit.allowed) {
+        return { success: false, error: rateLimit.error };
+      }
+      const testerInfo = await this.getTesterInfo();
+      if (!testerInfo) {
+        return { success: false, error: "Not a registered tester" };
+      }
       const updateData = {};
       if (updates.name !== void 0) updateData.name = updates.name;
       if (updates.additionalEmails !== void 0) updateData.additional_emails = updates.additionalEmails;
       if (updates.avatarUrl !== void 0) updateData.avatar_url = updates.avatarUrl;
       if (updates.platforms !== void 0) updateData.platforms = updates.platforms;
-      const { error } = await this.supabase.from("testers").update(updateData).eq("project_id", this.config.projectId).eq("email", userInfo.email);
+      const { error } = await this.supabase.from("testers").update(updateData).eq("id", testerInfo.id);
       if (error) {
         console.error("BugBear: updateTesterProfile error", error);
         return { success: false, error: error.message };
@@ -505,6 +899,11 @@ var BugBearClient = class {
         console.error("BugBear: No tester info, cannot send message");
         return false;
       }
+      const rateLimit = await this.checkRateLimit(testerInfo.email, "message_send");
+      if (!rateLimit.allowed) {
+        console.error("BugBear: Rate limit exceeded for messages");
+        return false;
+      }
       const { error } = await this.supabase.from("discussion_messages").insert({
         thread_id: threadId,
         sender_type: "tester",
@@ -599,6 +998,248 @@ var BugBearClient = class {
       return { success: false, error: message };
     }
   }
+  // ============================================
+  // QA Sessions (Sprint 1)
+  // ============================================
+  /**
+   * Start a new QA session for exploratory testing
+   */
+  async startSession(options = {}) {
+    try {
+      const testerInfo = await this.getTesterInfo();
+      if (!testerInfo) {
+        return { success: false, error: "Not authenticated as a tester" };
+      }
+      const activeSession = await this.getActiveSession();
+      if (activeSession) {
+        return { success: false, error: "You already have an active session. End it before starting a new one." };
+      }
+      const { data, error } = await this.supabase.rpc("start_qa_session", {
+        p_project_id: this.config.projectId,
+        p_tester_id: testerInfo.id,
+        p_focus_area: options.focusArea || null,
+        p_track: options.track || null,
+        p_platform: options.platform || null
+      });
+      if (error) {
+        console.error("BugBear: Failed to start session", error);
+        return { success: false, error: error.message };
+      }
+      const session = await this.getSession(data);
+      if (!session) {
+        return { success: false, error: "Session created but could not be fetched" };
+      }
+      return { success: true, session };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      console.error("BugBear: Error starting session", err);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * End the current QA session
+   */
+  async endSession(sessionId, options = {}) {
+    try {
+      const { data, error } = await this.supabase.rpc("end_qa_session", {
+        p_session_id: sessionId,
+        p_notes: options.notes || null,
+        p_routes_covered: options.routesCovered || null
+      });
+      if (error) {
+        console.error("BugBear: Failed to end session", error);
+        return { success: false, error: error.message };
+      }
+      const session = this.transformSession(data);
+      return { success: true, session };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      console.error("BugBear: Error ending session", err);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Get the current active session for the tester
+   */
+  async getActiveSession() {
+    try {
+      const testerInfo = await this.getTesterInfo();
+      if (!testerInfo) return null;
+      const { data, error } = await this.supabase.from("qa_sessions").select("*").eq("project_id", this.config.projectId).eq("tester_id", testerInfo.id).eq("status", "active").order("started_at", { ascending: false }).limit(1).maybeSingle();
+      if (error || !data) return null;
+      return this.transformSession(data);
+    } catch (err) {
+      console.error("BugBear: Error fetching active session", err);
+      return null;
+    }
+  }
+  /**
+   * Get a session by ID
+   */
+  async getSession(sessionId) {
+    try {
+      const { data, error } = await this.supabase.from("qa_sessions").select("*").eq("id", sessionId).single();
+      if (error || !data) return null;
+      return this.transformSession(data);
+    } catch (err) {
+      console.error("BugBear: Error fetching session", err);
+      return null;
+    }
+  }
+  /**
+   * Get session history for the tester
+   */
+  async getSessionHistory(limit = 10) {
+    try {
+      const testerInfo = await this.getTesterInfo();
+      if (!testerInfo) return [];
+      const { data, error } = await this.supabase.from("qa_sessions").select("*").eq("project_id", this.config.projectId).eq("tester_id", testerInfo.id).order("started_at", { ascending: false }).limit(limit);
+      if (error) {
+        console.error("BugBear: Failed to fetch session history", error);
+        return [];
+      }
+      return (data || []).map((s) => this.transformSession(s));
+    } catch (err) {
+      console.error("BugBear: Error fetching session history", err);
+      return [];
+    }
+  }
+  /**
+   * Add a finding during a session
+   */
+  async addFinding(sessionId, options) {
+    try {
+      const { data, error } = await this.supabase.rpc("add_session_finding", {
+        p_session_id: sessionId,
+        p_type: options.type,
+        p_title: options.title,
+        p_description: options.description || null,
+        p_severity: options.severity || "observation",
+        p_route: options.route || null,
+        p_screenshot_url: options.screenshotUrl || null,
+        p_console_logs: options.consoleLogs || null,
+        p_network_snapshot: options.networkSnapshot || null,
+        p_device_info: options.deviceInfo || null,
+        p_app_context: options.appContext || null
+      });
+      if (error) {
+        console.error("BugBear: Failed to add finding", error);
+        return { success: false, error: error.message };
+      }
+      const finding = this.transformFinding(data);
+      return { success: true, finding };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      console.error("BugBear: Error adding finding", err);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Get findings for a session
+   */
+  async getSessionFindings(sessionId) {
+    try {
+      const { data, error } = await this.supabase.from("qa_findings").select("*").eq("session_id", sessionId).order("created_at", { ascending: true });
+      if (error) {
+        console.error("BugBear: Failed to fetch findings", error);
+        return [];
+      }
+      return (data || []).map((f) => this.transformFinding(f));
+    } catch (err) {
+      console.error("BugBear: Error fetching findings", err);
+      return [];
+    }
+  }
+  /**
+   * Convert a finding to a bug report
+   */
+  async convertFindingToBug(findingId) {
+    try {
+      const { data, error } = await this.supabase.rpc("convert_finding_to_bug", {
+        p_finding_id: findingId
+      });
+      if (error) {
+        console.error("BugBear: Failed to convert finding", error);
+        return { success: false, error: error.message };
+      }
+      return { success: true, bugId: data };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      console.error("BugBear: Error converting finding", err);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Dismiss a finding
+   */
+  async dismissFinding(findingId, reason) {
+    try {
+      const { error } = await this.supabase.from("qa_findings").update({
+        dismissed: true,
+        dismissed_reason: reason || null,
+        dismissed_at: (/* @__PURE__ */ new Date()).toISOString()
+      }).eq("id", findingId);
+      if (error) {
+        console.error("BugBear: Failed to dismiss finding", error);
+        return { success: false, error: error.message };
+      }
+      return { success: true };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      console.error("BugBear: Error dismissing finding", err);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Transform database session to QASession type
+   */
+  transformSession(data) {
+    return {
+      id: data.id,
+      projectId: data.project_id,
+      testerId: data.tester_id,
+      focusArea: data.focus_area,
+      track: data.track,
+      platform: data.platform,
+      startedAt: data.started_at,
+      endedAt: data.ended_at,
+      notes: data.notes,
+      routesCovered: data.routes_covered || [],
+      status: data.status,
+      durationMinutes: data.duration_minutes,
+      findingsCount: data.findings_count || 0,
+      bugsFiled: data.bugs_filed || 0,
+      createdAt: data.created_at,
+      updatedAt: data.updated_at
+    };
+  }
+  /**
+   * Transform database finding to QAFinding type
+   */
+  transformFinding(data) {
+    return {
+      id: data.id,
+      sessionId: data.session_id,
+      projectId: data.project_id,
+      type: data.type,
+      severity: data.severity,
+      title: data.title,
+      description: data.description,
+      route: data.route,
+      screenshotUrl: data.screenshot_url,
+      consoleLogs: data.console_logs,
+      networkSnapshot: data.network_snapshot,
+      deviceInfo: data.device_info,
+      appContext: data.app_context,
+      convertedToBugId: data.converted_to_bug_id,
+      convertedToTestId: data.converted_to_test_id,
+      dismissed: data.dismissed || false,
+      dismissedReason: data.dismissed_reason,
+      dismissedAt: data.dismissed_at,
+      createdAt: data.created_at,
+      updatedAt: data.updated_at
+    };
+  }
 };
 function createBugBear(config) {
   return new BugBearClient(config);