@rooguys/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,222 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rooguys = void 0;
+const axios_1 = __importDefault(require("axios"));
+class Rooguys {
+    constructor(apiKey, options = {}) {
+        this.apiKey = apiKey;
+        this.events = {
+            track: async (eventName, userId, properties = {}, options = {}) => {
+                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);
+                }
+            },
+        };
+        this.users = {
+            get: async (userId) => {
+                try {
+                    const response = await this.client.get(`/user/${encodeURIComponent(userId)}`);
+                    return response.data;
+                }
+                catch (error) {
+                    throw this.handleError(error);
+                }
+            },
+            getBulk: async (userIds) => {
+                try {
+                    const response = await this.client.post('/users/bulk', { user_ids: userIds });
+                    return response.data;
+                }
+                catch (error) {
+                    throw this.handleError(error);
+                }
+            },
+            getBadges: async (userId) => {
+                try {
+                    const response = await this.client.get(`/user/${encodeURIComponent(userId)}/badges`);
+                    return response.data;
+                }
+                catch (error) {
+                    throw this.handleError(error);
+                }
+            },
+            getRank: async (userId, timeframe = 'all-time') => {
+                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, questionnaireId, answers) => {
+                try {
+                    const response = await this.client.post(`/user/${encodeURIComponent(userId)}/answers`, {
+                        questionnaire_id: questionnaireId,
+                        answers,
+                    });
+                    return response.data;
+                }
+                catch (error) {
+                    throw this.handleError(error);
+                }
+            },
+        };
+        this.leaderboards = {
+            getGlobal: async (timeframe = 'all-time', page = 1, limit = 50) => {
+                try {
+                    const response = await this.client.get('/leaderboard', {
+                        params: { timeframe, page, limit },
+                    });
+                    return response.data;
+                }
+                catch (error) {
+                    throw this.handleError(error);
+                }
+            },
+            list: async (page = 1, limit = 50, search) => {
+                try {
+                    const params = { 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, page = 1, limit = 50, search) => {
+                try {
+                    const params = { 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, userId) => {
+                try {
+                    const response = await this.client.get(`/leaderboard/${encodeURIComponent(leaderboardId)}/user/${encodeURIComponent(userId)}/rank`);
+                    return response.data;
+                }
+                catch (error) {
+                    throw this.handleError(error);
+                }
+            },
+        };
+        this.badges = {
+            list: async (page = 1, limit = 50, activeOnly = false) => {
+                try {
+                    const response = await this.client.get('/badges', {
+                        params: { page, limit, active_only: activeOnly },
+                    });
+                    return response.data;
+                }
+                catch (error) {
+                    throw this.handleError(error);
+                }
+            },
+        };
+        this.levels = {
+            list: async (page = 1, limit = 50) => {
+                try {
+                    const response = await this.client.get('/levels', {
+                        params: { page, limit },
+                    });
+                    return response.data;
+                }
+                catch (error) {
+                    throw this.handleError(error);
+                }
+            },
+        };
+        this.questionnaires = {
+            get: async (slug) => {
+                try {
+                    const response = await this.client.get(`/questionnaire/${slug}`);
+                    return response.data;
+                }
+                catch (error) {
+                    throw this.handleError(error);
+                }
+            },
+            getActive: async () => {
+                try {
+                    const response = await this.client.get('/questionnaire/active');
+                    return response.data;
+                }
+                catch (error) {
+                    throw this.handleError(error);
+                }
+            },
+        };
+        this.aha = {
+            declare: async (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');
+                }
+                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) => {
+                try {
+                    const response = await this.client.get(`/users/${encodeURIComponent(userId)}/aha`);
+                    return response.data;
+                }
+                catch (error) {
+                    throw this.handleError(error);
+                }
+            },
+        };
+        this.client = axios_1.default.create({
+            baseURL: options.baseUrl || 'https://api.rooguys.com/v1',
+            timeout: options.timeout || 10000,
+            headers: {
+                'x-api-key': this.apiKey,
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    handleError(error) {
+        var _a, _b;
+        if (axios_1.default.isAxiosError(error)) {
+            const message = ((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) || error.message;
+            return new Error(message);
+        }
+        return error;
+    }
+}
+exports.Rooguys = Rooguys;
+exports.default = Rooguys;

package/dist/types.d.ts

@@ -0,0 +1,148 @@
+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/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/jest.config.js

@@ -0,0 +1,31 @@
+export default {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/__tests__/**/*.test.ts'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.test.ts',
+    '!src/**/__tests__/**',
+  ],
+  coverageThreshold: {
+    global: {
+      lines: 90,
+      branches: 85,
+      functions: 90,
+      statements: 90,
+    },
+  },
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov', 'html'],
+  moduleNameMapper: {
+    '^@/(.*)$': '<rootDir>/src/$1',
+  },
+  transform: {
+    '^.+\\.ts$': ['ts-jest', {
+      tsconfig: {
+        esModuleInterop: true,
+      },
+    }],
+  },
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "@rooguys/sdk",
+    "version": "0.1.0",
+    "description": "Official Node.js SDK for Rooguys API",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "tsc",
+        "test": "jest",
+        "test:watch": "jest --watch",
+        "test:coverage": "jest --coverage",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "rooguys",
+        "sdk",
+        "api",
+        "gamification"
+    ],
+    "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rooguys/rooguys-nodejs-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Rooguys/rooguys-nodejs-sdk/issues"
+  },
+  "homepage": "https://github.com/Rooguys/rooguys-nodejs-sdk#readme",
+    "author": "mowamed",
+    "license": "MIT",
+    "dependencies": {
+        "axios": "^1.6.0"
+    },
+    "devDependencies": {
+        "@types/jest": "^29.5.0",
+        "@types/node": "^20.0.0",
+        "fast-check": "^3.15.0",
+        "jest": "^29.7.0",
+        "ts-jest": "^29.1.0",
+        "typescript": "^5.0.0"
+    }
+}