@rooguys/sdk 0.1.0

package/src/index.test.ts

@@ -0,0 +1,69 @@
+import axios from 'axios';
+import { Rooguys } from './index';
+
+jest.mock('axios');
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+describe('Rooguys SDK', () => {
+  let client: Rooguys;
+  const apiKey = 'test-api-key';
+  const mockAxiosInstance = {
+    get: jest.fn(),
+    post: jest.fn(),
+    defaults: { headers: { common: {} } },
+    interceptors: { request: { use: jest.fn() }, response: { use: jest.fn() } },
+  };
+
+  beforeEach(() => {
+    mockedAxios.create.mockReturnValue(mockAxiosInstance as any);
+    client = new Rooguys(apiKey);
+    jest.clearAllMocks();
+  });
+
+  describe('Events', () => {
+    it('should track an event', async () => {
+      const mockResponse = { data: { status: 'queued', message: 'ok' } };
+      mockAxiosInstance.post.mockResolvedValue(mockResponse);
+
+      const result = await client.events.track('test_event', 'user_1');
+
+      expect(mockAxiosInstance.post).toHaveBeenCalledWith(
+        '/event',
+        {
+          event_name: 'test_event',
+          user_id: 'user_1',
+          properties: {},
+        },
+        { params: { include_profile: undefined } }
+      );
+      expect(result).toEqual(mockResponse.data);
+    });
+  });
+
+  describe('Users', () => {
+    it('should get a user profile', async () => {
+      const mockResponse = { data: { user_id: 'user_1', points: 100 } };
+      mockAxiosInstance.get.mockResolvedValue(mockResponse);
+
+      const result = await client.users.get('user_1');
+
+      expect(mockAxiosInstance.get).toHaveBeenCalledWith('/user/user_1');
+      expect(result).toEqual(mockResponse.data);
+    });
+  });
+
+  describe('Leaderboards', () => {
+    it('should get global leaderboard', async () => {
+      const mockResponse = { data: { rankings: [] } };
+      mockAxiosInstance.get.mockResolvedValue(mockResponse);
+
+      const result = await client.leaderboards.getGlobal();
+
+      expect(mockAxiosInstance.get).toHaveBeenCalledWith(
+        '/leaderboard',
+        { params: { timeframe: 'all-time', page: 1, limit: 50 } }
+      );
+      expect(result).toEqual(mockResponse.data);
+    });
+  });
+});

package/src/index.ts

@@ -0,0 +1,236 @@
+import axios, { AxiosInstance, AxiosError } from 'axios';
+import { RooguysOptions, TrackEventResponse, UserProfile, UserBadge, UserRank, LeaderboardResult, AnswerSubmission, AhaDeclarationResult, AhaScoreResult, BadgeListResult, LevelListResult, Questionnaire, LeaderboardListResult } from './types';
+
+export class Rooguys {
+  private client: AxiosInstance;
+
+  constructor(private apiKey: string, options: RooguysOptions = {}) {
+    this.client = axios.create({
+      baseURL: options.baseUrl || 'https://api.rooguys.com/v1',
+      timeout: options.timeout || 10000,
+      headers: {
+        'x-api-key': this.apiKey,
+        'Content-Type': 'application/json',
+      },
+    });
+  }
+
+  public events = {
+    track: async (
+      eventName: string,
+      userId: string,
+      properties: Record<string, any> = {},
+      options: { includeProfile?: boolean } = {}
+    ): Promise<TrackEventResponse> => {
+      try {
+        const response = await this.client.post('/event', {
+          event_name: eventName,
+          user_id: userId,
+          properties,
+        }, {
+          params: {
+            include_profile: options.includeProfile,
+          },
+        });
+        return response.data;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    },
+  };
+
+  public users = {
+    get: async (userId: string): Promise<UserProfile> => {
+      try {
+        const response = await this.client.get(`/user/${encodeURIComponent(userId)}`);
+        return response.data;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    },
+
+    getBulk: async (userIds: string[]): Promise<{ users: UserProfile[] }> => {
+      try {
+        const response = await this.client.post('/users/bulk', { user_ids: userIds });
+        return response.data;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    },
+
+    getBadges: async (userId: string): Promise<{ badges: UserBadge[] }> => {
+      try {
+        const response = await this.client.get(`/user/${encodeURIComponent(userId)}/badges`);
+        return response.data;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    },
+
+    getRank: async (userId: string, timeframe: 'all-time' | 'weekly' | 'monthly' = 'all-time'): Promise<UserRank> => {
+      try {
+        const response = await this.client.get(`/user/${encodeURIComponent(userId)}/rank`, {
+          params: { timeframe },
+        });
+        return response.data;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    },
+
+    submitAnswers: async (userId: string, questionnaireId: string, answers: AnswerSubmission[]): Promise<{ status: string; message: string }> => {
+      try {
+        const response = await this.client.post(`/user/${encodeURIComponent(userId)}/answers`, {
+          questionnaire_id: questionnaireId,
+          answers,
+        });
+        return response.data;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    },
+  };
+
+  public leaderboards = {
+    getGlobal: async (
+      timeframe: 'all-time' | 'weekly' | 'monthly' = 'all-time',
+      page: number = 1,
+      limit: number = 50
+    ): Promise<LeaderboardResult> => {
+      try {
+        const response = await this.client.get('/leaderboard', {
+          params: { timeframe, page, limit },
+        });
+        return response.data;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    },
+
+    list: async (page: number = 1, limit: number = 50, search?: string): Promise<LeaderboardListResult> => {
+      try {
+        const params: any = { page, limit };
+        if (search) {
+          params.search = search;
+        }
+        const response = await this.client.get('/leaderboards', { params });
+        return response.data;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    },
+
+    getCustom: async (
+      leaderboardId: string,
+      page: number = 1,
+      limit: number = 50,
+      search?: string
+    ): Promise<LeaderboardResult> => {
+      try {
+        const params: any = { page, limit };
+        if (search) {
+          params.search = search;
+        }
+        const response = await this.client.get(`/leaderboard/${encodeURIComponent(leaderboardId)}`, { params });
+        return response.data;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    },
+
+    getUserRank: async (leaderboardId: string, userId: string): Promise<UserRank> => {
+      try {
+        const response = await this.client.get(
+          `/leaderboard/${encodeURIComponent(leaderboardId)}/user/${encodeURIComponent(userId)}/rank`
+        );
+        return response.data;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    },
+  };
+
+  public badges = {
+    list: async (page: number = 1, limit: number = 50, activeOnly: boolean = false): Promise<BadgeListResult> => {
+      try {
+        const response = await this.client.get('/badges', {
+          params: { page, limit, active_only: activeOnly },
+        });
+        return response.data;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    },
+  };
+
+  public levels = {
+    list: async (page: number = 1, limit: number = 50): Promise<LevelListResult> => {
+      try {
+        const response = await this.client.get('/levels', {
+          params: { page, limit },
+        });
+        return response.data;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    },
+  };
+
+  public questionnaires = {
+    get: async (slug: string): Promise<Questionnaire> => {
+      try {
+        const response = await this.client.get(`/questionnaire/${slug}`);
+        return response.data;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    },
+
+    getActive: async (): Promise<Questionnaire> => {
+      try {
+        const response = await this.client.get('/questionnaire/active');
+        return response.data;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    },
+  };
+
+  public aha = {
+    declare: async (userId: string, value: number): Promise<AhaDeclarationResult> => {
+      // 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');
+      }
+
+      try {
+        const response = await this.client.post('/aha/declare', {
+          user_id: userId,
+          value,
+        });
+        return response.data;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    },
+
+    getUserScore: async (userId: string): Promise<AhaScoreResult> => {
+      try {
+        const response = await this.client.get(`/users/${encodeURIComponent(userId)}/aha`);
+        return response.data;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    },
+  };
+
+  private handleError(error: any): Error {
+    if (axios.isAxiosError(error)) {
+      const message = error.response?.data?.message || error.message;
+      return new Error(message);
+    }
+    return error;
+  }
+}
+
+export default Rooguys;

package/src/types.ts

@@ -0,0 +1,165 @@
+export interface RooguysOptions {
+  baseUrl?: string;
+  timeout?: number;
+}
+
+export interface UserProfile {
+  user_id: string;
+  points: number;
+  persona: string | null;
+  level: {
+    id: string;
+    name: string;
+    level_number: number;
+    points_required: number;
+  } | null;
+  next_level: {
+    id: string;
+    name: string;
+    level_number: number;
+    points_required: number;
+    points_needed: number;
+  } | null;
+  metrics: Record<string, any>;
+  badges: UserBadge[];
+}
+
+export interface UserBadge {
+  id: string;
+  name: string;
+  description: string;
+  icon_url: string;
+  earned_at: string;
+}
+
+export interface UserRank {
+  user_id: string;
+  rank: number;
+  points: number;
+  total_users: number;
+}
+
+export interface LeaderboardEntry {
+  rank: number;
+  user_id: string;
+  points: number;
+  level: {
+    id: string;
+    name: string;
+    level_number: number;
+  } | null;
+}
+
+export interface LeaderboardResult {
+  timeframe: string;
+  page: number;
+  limit: number;
+  total: number;
+  rankings: LeaderboardEntry[];
+}
+
+export interface TrackEventResponse {
+  status: string;
+  message: string;
+  profile?: UserProfile;
+}
+
+export interface AnswerSubmission {
+  question_id: string;
+  answer_option_id: string;
+}
+
+export interface AhaDeclarationResult {
+  success: boolean;
+  message: string;
+}
+
+export interface AhaScoreResult {
+  success: boolean;
+  data: {
+    user_id: string;
+    current_score: number;
+    declarative_score: number | null;
+    inferred_score: number | null;
+    status: 'not_started' | 'progressing' | 'activated';
+    history: {
+      initial: number | null;
+      initial_date: string | null;
+      previous: number | null;
+    };
+  };
+}
+
+export interface Badge {
+  id: string;
+  name: string;
+  description: string;
+  icon_url: string;
+  points_required: number;
+  is_active: boolean;
+  unlock_criteria: string;
+  created_at: string;
+}
+
+export interface BadgeListResult {
+  badges: Badge[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+  };
+}
+
+export interface Level {
+  id: string;
+  name: string;
+  level_number: number;
+  points_required: number;
+  description: string | null;
+  icon_url: string | null;
+  created_at: string;
+}
+
+export interface LevelListResult {
+  levels: Level[];
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+  };
+}
+
+export interface QuestionOption {
+  id: string;
+  text: string;
+  persona_weight: Record<string, number>;
+}
+
+export interface Question {
+  id: string;
+  text: string;
+  order: number;
+  answer_options: QuestionOption[];
+}
+
+export interface Questionnaire {
+  id: string;
+  slug: string;
+  title: string;
+  description: string;
+  is_active: boolean;
+  questions: Question[];
+  created_at: string;
+}
+
+export interface LeaderboardListResult {
+  page: number;
+  limit: number;
+  total: number;
+  leaderboards: Array<{
+    id: string;
+    name: string;
+    description: string;
+    created_at: string;
+  }>;
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "es2018",
+    "module": "commonjs",
+    "lib": ["es2018", "dom"],
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "**/*.test.ts"]
+}