@rooguys/js 0.1.0

package/src/__tests__/unit/levels.test.js

@@ -0,0 +1,70 @@
+import Rooguys from '../../index';
+import { mockSuccessResponse, mockErrorResponse } from '../utils/mockClient';
+import { mockResponses, mockErrors } from '../fixtures/responses';
+
+describe('Levels Resource', () => {
+  let client;
+  const apiKey = 'test-api-key';
+
+  beforeEach(() => {
+    client = new Rooguys(apiKey);
+    global.fetch.mockClear();
+  });
+
+  describe('list', () => {
+    it('should list levels with default parameters', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.levelsListResponse));
+
+      const result = await client.levels.list();
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('page=1');
+      expect(callUrl).toContain('limit=50');
+      expect(result.levels).toHaveLength(2);
+    });
+
+    it('should list levels with custom pagination', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.levelsListResponse));
+
+      await client.levels.list(2, 25);
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('page=2');
+      expect(callUrl).toContain('limit=25');
+    });
+
+    it('should handle empty levels list', async () => {
+      const emptyResponse = {
+        levels: [],
+        pagination: { page: 1, limit: 50, total: 0, totalPages: 0 },
+      };
+      global.fetch.mockResolvedValue(mockSuccessResponse(emptyResponse));
+
+      const result = await client.levels.list();
+
+      expect(result.levels).toEqual([]);
+    });
+
+    it('should handle levels with all fields', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.levelsListResponse));
+
+      const result = await client.levels.list();
+
+      const level = result.levels[0];
+      expect(level.id).toBeDefined();
+      expect(level.name).toBeDefined();
+      expect(level.level_number).toBeDefined();
+      expect(level.points_required).toBeDefined();
+    });
+
+    it('should throw error for invalid pagination', async () => {
+      global.fetch.mockResolvedValue(
+        mockErrorResponse(400, mockErrors.invalidPaginationError.message)
+      );
+
+      await expect(client.levels.list(1, 150)).rejects.toThrow(
+        'Limit must be between 1 and 100'
+      );
+    });
+  });
+});

package/src/__tests__/unit/questionnaires.test.js

@@ -0,0 +1,68 @@
+import Rooguys from '../../index';
+import { mockSuccessResponse, mockErrorResponse } from '../utils/mockClient';
+import { mockResponses } from '../fixtures/responses';
+
+describe('Questionnaires Resource', () => {
+  let client;
+  const apiKey = 'test-api-key';
+
+  beforeEach(() => {
+    client = new Rooguys(apiKey);
+    global.fetch.mockClear();
+  });
+
+  describe('get', () => {
+    it('should get questionnaire by slug', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.questionnaireResponse));
+
+      const result = await client.questionnaires.get('user-persona');
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.stringContaining('/questionnaire/user-persona'),
+        expect.any(Object)
+      );
+      expect(result.slug).toBe('user-persona');
+    });
+
+    it('should throw 404 error when questionnaire not found', async () => {
+      global.fetch.mockResolvedValue(mockErrorResponse(404, 'Questionnaire not found'));
+
+      await expect(client.questionnaires.get('nonexistent-slug')).rejects.toThrow(
+        'Questionnaire not found'
+      );
+    });
+
+    it('should handle questionnaire with multiple questions', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.questionnaireResponse));
+
+      const result = await client.questionnaires.get('user-persona');
+
+      expect(result.questions).toBeDefined();
+      expect(result.questions.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('getActive', () => {
+    it('should get active questionnaire', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.questionnaireResponse));
+
+      const result = await client.questionnaires.getActive();
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.stringContaining('/questionnaire/active'),
+        expect.any(Object)
+      );
+      expect(result.is_active).toBe(true);
+    });
+
+    it('should throw 404 error when no active questionnaire', async () => {
+      global.fetch.mockResolvedValue(
+        mockErrorResponse(404, 'No active questionnaire found for this project')
+      );
+
+      await expect(client.questionnaires.getActive()).rejects.toThrow(
+        'No active questionnaire found'
+      );
+    });
+  });
+});

package/src/__tests__/unit/users.test.js

@@ -0,0 +1,102 @@
+import Rooguys from '../../index';
+import { mockSuccessResponse, mockErrorResponse } from '../utils/mockClient';
+import { mockResponses, mockErrors } from '../fixtures/responses';
+
+describe('Users Resource', () => {
+  let client;
+  const apiKey = 'test-api-key';
+
+  beforeEach(() => {
+    client = new Rooguys(apiKey);
+    global.fetch.mockClear();
+  });
+
+  describe('get', () => {
+    it('should get a user profile', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.userProfile));
+
+      const result = await client.users.get('user_123');
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.stringContaining('/user/user_123'),
+        expect.any(Object)
+      );
+      expect(result).toEqual(mockResponses.userProfile);
+    });
+
+    it('should throw 404 error when user not found', async () => {
+      global.fetch.mockResolvedValue(
+        mockErrorResponse(404, mockErrors.notFoundError.message)
+      );
+
+      await expect(client.users.get('nonexistent_user')).rejects.toThrow("User 'user123' does not exist in this project");
+    });
+  });
+
+  describe('getBulk', () => {
+    it('should get multiple user profiles', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.bulkUsersResponse));
+
+      const result = await client.users.getBulk(['user1', 'user2']);
+
+      expect(result).toEqual(mockResponses.bulkUsersResponse);
+      expect(result.users).toHaveLength(2);
+    });
+
+    it('should handle empty results', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse({ users: [] }));
+
+      const result = await client.users.getBulk(['nonexistent1']);
+
+      expect(result.users).toEqual([]);
+    });
+  });
+
+  describe('getBadges', () => {
+    it('should get user badges', async () => {
+      global.fetch.mockResolvedValue(
+        mockSuccessResponse({ badges: mockResponses.userProfile.badges })
+      );
+
+      const result = await client.users.getBadges('user_123');
+
+      expect(result.badges).toHaveLength(1);
+    });
+  });
+
+  describe('getRank', () => {
+    it('should get user rank with default timeframe', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.userRankResponse));
+
+      const result = await client.users.getRank('user_123');
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('timeframe=all-time');
+      expect(result.rank).toBe(42);
+    });
+
+    it('should get user rank with weekly timeframe', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.userRankResponse));
+
+      await client.users.getRank('user_123', 'weekly');
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('timeframe=weekly');
+    });
+  });
+
+  describe('submitAnswers', () => {
+    it('should submit questionnaire answers', async () => {
+      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.answerSubmissionResponse));
+
+      const answers = [
+        { question_id: 'q1', answer_option_id: 'a1' },
+        { question_id: 'q2', answer_option_id: 'a2' },
+      ];
+
+      const result = await client.users.submitAnswers('user_123', 'questionnaire_id', answers);
+
+      expect(result.status).toBe('accepted');
+    });
+  });
+});

package/src/__tests__/utils/generators.js

@@ -0,0 +1,80 @@
+import fc from 'fast-check';
+
+/**
+ * Property-based testing generators for SDK inputs
+ */
+
+export const arbitraries = {
+  // User ID: 1-255 characters, alphanumeric with some special chars
+  userId: () => fc.string({ minLength: 1, maxLength: 255 }).filter(s => s.trim().length > 0),
+  
+  // Event name: 1-100 characters
+  eventName: () => fc.string({ minLength: 1, maxLength: 100 }).filter(s => s.trim().length > 0),
+  
+  // Properties: any JSON-serializable object
+  properties: () => fc.dictionary(
+    fc.string({ minLength: 1, maxLength: 50 }),
+    fc.oneof(
+      fc.string(),
+      fc.integer(),
+      fc.double().filter(n => Number.isFinite(n)), // Exclude Infinity and NaN
+      fc.boolean(),
+      fc.constant(null)
+    )
+  ),
+  
+  // Timeframe: one of the valid values
+  timeframe: () => fc.constantFrom('all-time', 'weekly', 'monthly'),
+  
+  // Pagination parameters
+  pagination: () => fc.record({
+    page: fc.integer({ min: 1, max: 1000 }),
+    limit: fc.integer({ min: 1, max: 100 }),
+  }),
+  
+  // Aha score value: 1-5
+  ahaValue: () => fc.integer({ min: 1, max: 5 }),
+  
+  // Invalid Aha score value: outside 1-5 range
+  invalidAhaValue: () => fc.oneof(
+    fc.integer({ max: 0 }),
+    fc.integer({ min: 6 })
+  ),
+  
+  // UUID for leaderboard IDs
+  uuid: () => fc.uuid(),
+  
+  // Slug for questionnaires
+  slug: () => fc.string({ minLength: 1, maxLength: 100 })
+    .filter(s => /^[a-z0-9-]+$/.test(s)),
+  
+  // Array of user IDs for bulk operations
+  userIds: () => fc.array(
+    fc.string({ minLength: 1, maxLength: 255 }),
+    { minLength: 1, maxLength: 100 }
+  ),
+  
+  // Boolean for active_only filter
+  activeOnly: () => fc.boolean(),
+  
+  // Search query
+  searchQuery: () => fc.option(fc.string({ maxLength: 100 }), { nil: null }),
+  
+  // Base URL
+  baseUrl: () => fc.webUrl(),
+  
+  // Timeout in milliseconds
+  timeout: () => fc.integer({ min: 1000, max: 60000 }),
+  
+  // API key
+  apiKey: () => fc.string({ minLength: 10, maxLength: 100 }),
+  
+  // Questionnaire answers
+  questionnaireAnswers: () => fc.array(
+    fc.record({
+      question_id: fc.uuid(),
+      answer_option_id: fc.uuid(),
+    }),
+    { minLength: 1, maxLength: 20 }
+  ),
+};

package/src/__tests__/utils/mockClient.js

@@ -0,0 +1,42 @@
+/**
+ * Mock fetch for browser SDK testing
+ */
+import { jest } from '@jest/globals';
+
+export function createMockFetch() {
+  return jest.fn();
+}
+
+export function mockSuccessResponse(data, status = 200) {
+  return Promise.resolve({
+    ok: true,
+    status,
+    json: () => Promise.resolve(data),
+    text: () => Promise.resolve(JSON.stringify(data)),
+  });
+}
+
+export function mockErrorResponse(status, message, details) {
+  const errorData = {
+    error: message,
+    ...(details && { details }),
+  };
+  
+  return Promise.resolve({
+    ok: false,
+    status,
+    statusText: message,
+    json: () => Promise.resolve(errorData),
+    text: () => Promise.resolve(JSON.stringify(errorData)),
+  });
+}
+
+export function mockNetworkError(message = 'Network error') {
+  return new Error(message);
+}
+
+export function mockTimeoutError() {
+  const error = new Error('The operation was aborted');
+  error.name = 'AbortError';
+  return error;
+}

package/src/index.js

@@ -0,0 +1,138 @@
+/**
+ * Rooguys Browser SDK
+ */
+class Rooguys {
+  constructor(apiKey, options = {}) {
+    this.apiKey = apiKey;
+    this.baseUrl = options.baseUrl || 'https://api.rooguys.com/v1';
+    this.timeout = options.timeout || 10000;
+  }
+
+  async _request(endpoint, method = 'GET', data = null, params = {}) {
+    const url = new URL(`${this.baseUrl}${endpoint}`);
+    Object.keys(params).forEach(key => {
+      if (params[key] !== undefined) {
+        url.searchParams.append(key, params[key]);
+      }
+    });
+
+    const config = {
+      method,
+      headers: {
+        'x-api-key': this.apiKey,
+        'Content-Type': 'application/json',
+      },
+    };
+
+    if (data) {
+      config.body = JSON.stringify(data);
+    }
+
+    try {
+      const controller = new AbortController();
+      const id = setTimeout(() => controller.abort(), this.timeout);
+      config.signal = controller.signal;
+
+      const response = await fetch(url.toString(), config);
+      clearTimeout(id);
+
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(errorData.message || `API Error: ${response.statusText}`);
+      }
+
+      return await response.json();
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  get events() {
+    return {
+      track: (eventName, userId, properties = {}, options = {}) => {
+        return this._request('/event', 'POST', {
+          event_name: eventName,
+          user_id: userId,
+          properties,
+        }, {
+          include_profile: options.includeProfile,
+        });
+      },
+    };
+  }
+
+  get users() {
+    return {
+      get: (userId) => this._request(`/user/${encodeURIComponent(userId)}`),
+      
+      getBulk: (userIds) => this._request('/users/bulk', 'POST', { user_ids: userIds }),
+      
+      getBadges: (userId) => this._request(`/user/${encodeURIComponent(userId)}/badges`),
+      
+      getRank: (userId, timeframe = 'all-time') => 
+        this._request(`/user/${encodeURIComponent(userId)}/rank`, 'GET', null, { timeframe }),
+        
+      submitAnswers: (userId, questionnaireId, answers) =>
+        this._request(`/user/${encodeURIComponent(userId)}/answers`, 'POST', {
+          questionnaire_id: questionnaireId,
+          answers,
+        }),
+    };
+  }
+
+  get leaderboards() {
+    return {
+      getGlobal: (timeframe = 'all-time', page = 1, limit = 50) =>
+        this._request('/leaderboard', 'GET', null, { timeframe, page, limit }),
+        
+      list: (page = 1, limit = 50, search = null) =>
+        this._request('/leaderboards', 'GET', null, { page, limit, search }),
+        
+      getCustom: (leaderboardId, page = 1, limit = 50, search = null) =>
+        this._request(`/leaderboard/${encodeURIComponent(leaderboardId)}`, 'GET', null, { page, limit, search }),
+        
+      getUserRank: (leaderboardId, userId) =>
+        this._request(`/leaderboard/${encodeURIComponent(leaderboardId)}/user/${encodeURIComponent(userId)}/rank`),
+    };
+  }
+
+  get badges() {
+    return {
+      list: (page = 1, limit = 50, activeOnly = false) =>
+        this._request('/badges', 'GET', null, { page, limit, active_only: activeOnly }),
+    };
+  }
+
+  get levels() {
+    return {
+      list: (page = 1, limit = 50) =>
+        this._request('/levels', 'GET', null, { page, limit }),
+    };
+  }
+
+  get questionnaires() {
+    return {
+      get: (slug) => this._request(`/questionnaire/${slug}`),
+      getActive: () => this._request('/questionnaire/active'),
+    };
+  }
+
+  get aha() {
+    return {
+      declare: (userId, value) => {
+        // Validate value is between 1 and 5
+        if (!Number.isInteger(value) || value < 1 || value > 5) {
+          throw new Error('Aha score value must be an integer between 1 and 5');
+        }
+        return this._request('/aha/declare', 'POST', {
+          user_id: userId,
+          value,
+        });
+      },
+
+      getUserScore: (userId) => this._request(`/users/${encodeURIComponent(userId)}/aha`),
+    };
+  }
+}
+
+export default Rooguys;