@rooguys/js 0.1.0 → 1.0.0

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

@@ -1,5 +1,5 @@
-import Rooguys from '../../index';
-import { mockSuccessResponse, mockErrorResponse } from '../utils/mockClient';
+import Rooguys, { ValidationError } from '../../index';
+import { mockStandardizedSuccess, mockErrorResponse } from '../utils/mockClient';
 import { mockResponses, mockErrors } from '../fixtures/responses';
 
 describe('Users Resource', () => {
@@ -11,17 +11,171 @@ describe('Users Resource', () => {
     global.fetch.mockClear();
   });
 
+  describe('create', () => {
+    it('should create a new user', async () => {
+      const userData = {
+        userId: 'new_user_123',
+        displayName: 'Test User',
+        email: 'test@example.com',
+      };
+      global.fetch.mockResolvedValue(mockStandardizedSuccess({
+        user_id: 'new_user_123',
+        display_name: 'Test User',
+        email: 'test@example.com',
+        points: 0,
+      }));
+
+      const result = await client.users.create(userData);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.stringContaining('/users'),
+        expect.objectContaining({
+          method: 'POST',
+          body: expect.stringContaining('new_user_123'),
+        })
+      );
+      expect(result.user_id).toBe('new_user_123');
+    });
+
+    it('should throw ValidationError when userId is missing', async () => {
+      await expect(client.users.create({})).rejects.toThrow(ValidationError);
+      await expect(client.users.create({})).rejects.toThrow('User ID is required');
+    });
+
+    it('should throw ValidationError for invalid email format', async () => {
+      await expect(client.users.create({
+        userId: 'user_123',
+        email: 'invalid-email',
+      })).rejects.toThrow(ValidationError);
+      await expect(client.users.create({
+        userId: 'user_123',
+        email: 'invalid-email',
+      })).rejects.toThrow('Invalid email format');
+    });
+
+    it('should allow creation without email', async () => {
+      global.fetch.mockResolvedValue(mockStandardizedSuccess({
+        user_id: 'user_123',
+        points: 0,
+      }));
+
+      const result = await client.users.create({ userId: 'user_123' });
+      expect(result.user_id).toBe('user_123');
+    });
+  });
+
+  describe('update', () => {
+    it('should update an existing user', async () => {
+      global.fetch.mockResolvedValue(mockStandardizedSuccess({
+        user_id: 'user_123',
+        display_name: 'Updated Name',
+        points: 100,
+      }));
+
+      const result = await client.users.update('user_123', { displayName: 'Updated Name' });
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.stringContaining('/users/user_123'),
+        expect.objectContaining({
+          method: 'PATCH',
+        })
+      );
+      expect(result.display_name).toBe('Updated Name');
+    });
+
+    it('should throw ValidationError when userId is missing', async () => {
+      await expect(client.users.update('', { displayName: 'Test' })).rejects.toThrow(ValidationError);
+    });
+
+    it('should throw ValidationError for invalid email format', async () => {
+      await expect(client.users.update('user_123', {
+        email: 'not-an-email',
+      })).rejects.toThrow(ValidationError);
+    });
+
+    it('should only send provided fields (partial update)', async () => {
+      global.fetch.mockResolvedValue(mockStandardizedSuccess({
+        user_id: 'user_123',
+        display_name: 'New Name',
+      }));
+
+      await client.users.update('user_123', { displayName: 'New Name' });
+
+      const callBody = JSON.parse(global.fetch.mock.calls[0][1].body);
+      expect(callBody).toEqual({ display_name: 'New Name' });
+      expect(callBody.email).toBeUndefined();
+    });
+  });
+
+  describe('createBatch', () => {
+    it('should create multiple users', async () => {
+      global.fetch.mockResolvedValue(mockStandardizedSuccess({
+        results: [
+          { index: 0, status: 'created', user_id: 'user_1' },
+          { index: 1, status: 'created', user_id: 'user_2' },
+        ],
+      }));
+
+      const users = [
+        { userId: 'user_1', displayName: 'User 1' },
+        { userId: 'user_2', displayName: 'User 2' },
+      ];
+
+      const result = await client.users.createBatch(users);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.stringContaining('/users/batch'),
+        expect.objectContaining({ method: 'POST' })
+      );
+      expect(result.results).toHaveLength(2);
+    });
+
+    it('should throw ValidationError for non-array input', async () => {
+      await expect(client.users.createBatch('not-an-array')).rejects.toThrow(ValidationError);
+      await expect(client.users.createBatch('not-an-array')).rejects.toThrow('Users must be an array');
+    });
+
+    it('should throw ValidationError for empty array', async () => {
+      await expect(client.users.createBatch([])).rejects.toThrow(ValidationError);
+      await expect(client.users.createBatch([])).rejects.toThrow('Users array cannot be empty');
+    });
+
+    it('should throw ValidationError for batch exceeding 100 users', async () => {
+      const users = Array.from({ length: 101 }, (_, i) => ({ userId: `user_${i}` }));
+      await expect(client.users.createBatch(users)).rejects.toThrow(ValidationError);
+      await expect(client.users.createBatch(users)).rejects.toThrow('Batch size exceeds maximum of 100 users');
+    });
+
+    it('should throw ValidationError when a user is missing userId', async () => {
+      const users = [
+        { userId: 'user_1' },
+        { displayName: 'Missing ID' },
+      ];
+      await expect(client.users.createBatch(users)).rejects.toThrow(ValidationError);
+      await expect(client.users.createBatch(users)).rejects.toThrow('User at index 1: User ID is required');
+    });
+
+    it('should throw ValidationError for invalid email in batch', async () => {
+      const users = [
+        { userId: 'user_1', email: 'valid@example.com' },
+        { userId: 'user_2', email: 'invalid-email' },
+      ];
+      await expect(client.users.createBatch(users)).rejects.toThrow(ValidationError);
+      await expect(client.users.createBatch(users)).rejects.toThrow('User at index 1: Invalid email format');
+    });
+  });
+
   describe('get', () => {
     it('should get a user profile', async () => {
-      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.userProfile));
+      global.fetch.mockResolvedValue(mockStandardizedSuccess(mockResponses.userProfile));
 
       const result = await client.users.get('user_123');
 
       expect(global.fetch).toHaveBeenCalledWith(
-        expect.stringContaining('/user/user_123'),
+        expect.stringContaining('/users/user_123'),
         expect.any(Object)
       );
-      expect(result).toEqual(mockResponses.userProfile);
+      expect(result.user_id).toBe('user123');
     });
 
     it('should throw 404 error when user not found', async () => {
@@ -31,20 +185,129 @@ describe('Users Resource', () => {
 
       await expect(client.users.get('nonexistent_user')).rejects.toThrow("User 'user123' does not exist in this project");
     });
+
+    it('should support field selection', async () => {
+      global.fetch.mockResolvedValue(mockStandardizedSuccess({
+        user_id: 'user_123',
+        points: 100,
+      }));
+
+      await client.users.get('user_123', { fields: ['user_id', 'points'] });
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('fields=user_id%2Cpoints');
+    });
+
+    it('should parse activity summary in profile', async () => {
+      global.fetch.mockResolvedValue(mockStandardizedSuccess({
+        user_id: 'user_123',
+        activity_summary: {
+          last_event_at: '2024-01-15T10:30:00Z',
+          event_count: 150,
+          days_active: 30,
+        },
+      }));
+
+      const result = await client.users.get('user_123');
+
+      expect(result.activitySummary).toBeDefined();
+      expect(result.activitySummary.eventCount).toBe(150);
+      expect(result.activitySummary.daysActive).toBe(30);
+      expect(result.activitySummary.lastEventAt).toBeInstanceOf(Date);
+    });
+
+    it('should parse streak info in profile', async () => {
+      global.fetch.mockResolvedValue(mockStandardizedSuccess({
+        user_id: 'user_123',
+        streak: {
+          current_streak: 5,
+          longest_streak: 10,
+          last_activity_at: '2024-01-15T10:30:00Z',
+        },
+      }));
+
+      const result = await client.users.get('user_123');
+
+      expect(result.streak).toBeDefined();
+      expect(result.streak.currentStreak).toBe(5);
+      expect(result.streak.longestStreak).toBe(10);
+    });
+
+    it('should parse inventory summary in profile', async () => {
+      global.fetch.mockResolvedValue(mockStandardizedSuccess({
+        user_id: 'user_123',
+        inventory: {
+          item_count: 5,
+          active_effects: ['double_points', 'shield'],
+        },
+      }));
+
+      const result = await client.users.get('user_123');
+
+      expect(result.inventory).toBeDefined();
+      expect(result.inventory.itemCount).toBe(5);
+      expect(result.inventory.activeEffects).toEqual(['double_points', 'shield']);
+    });
+  });
+
+  describe('search', () => {
+    it('should search users with query', async () => {
+      global.fetch.mockResolvedValue(mockStandardizedSuccess({
+        users: [
+          { user_id: 'user_1', display_name: 'John' },
+          { user_id: 'user_2', display_name: 'Johnny' },
+        ],
+        pagination: { page: 1, limit: 50, total: 2, totalPages: 1 },
+      }));
+
+      const result = await client.users.search('john');
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.stringContaining('/users/search'),
+        expect.any(Object)
+      );
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('q=john');
+      expect(result.users).toHaveLength(2);
+    });
+
+    it('should support pagination options', async () => {
+      global.fetch.mockResolvedValue(mockStandardizedSuccess({
+        users: [],
+        pagination: { page: 2, limit: 10, total: 0, totalPages: 0 },
+      }));
+
+      await client.users.search('test', { page: 2, limit: 10 });
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('page=2');
+      expect(callUrl).toContain('limit=10');
+    });
+
+    it('should support field selection in search', async () => {
+      global.fetch.mockResolvedValue(mockStandardizedSuccess({
+        users: [],
+        pagination: { page: 1, limit: 50, total: 0, totalPages: 0 },
+      }));
+
+      await client.users.search('test', { fields: ['user_id', 'points'] });
+
+      const callUrl = global.fetch.mock.calls[0][0];
+      expect(callUrl).toContain('fields=user_id%2Cpoints');
+    });
   });
 
   describe('getBulk', () => {
     it('should get multiple user profiles', async () => {
-      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.bulkUsersResponse));
+      global.fetch.mockResolvedValue(mockStandardizedSuccess(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: [] }));
+      global.fetch.mockResolvedValue(mockStandardizedSuccess({ users: [] }));
 
       const result = await client.users.getBulk(['nonexistent1']);
 
@@ -55,7 +318,7 @@ describe('Users Resource', () => {
   describe('getBadges', () => {
     it('should get user badges', async () => {
       global.fetch.mockResolvedValue(
-        mockSuccessResponse({ badges: mockResponses.userProfile.badges })
+        mockStandardizedSuccess({ badges: mockResponses.userProfile.badges })
       );
 
       const result = await client.users.getBadges('user_123');
@@ -66,7 +329,7 @@ describe('Users Resource', () => {
 
   describe('getRank', () => {
     it('should get user rank with default timeframe', async () => {
-      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.userRankResponse));
+      global.fetch.mockResolvedValue(mockStandardizedSuccess(mockResponses.userRankResponse));
 
       const result = await client.users.getRank('user_123');
 
@@ -76,7 +339,7 @@ describe('Users Resource', () => {
     });
 
     it('should get user rank with weekly timeframe', async () => {
-      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.userRankResponse));
+      global.fetch.mockResolvedValue(mockStandardizedSuccess(mockResponses.userRankResponse));
 
       await client.users.getRank('user_123', 'weekly');
 
@@ -87,7 +350,7 @@ describe('Users Resource', () => {
 
   describe('submitAnswers', () => {
     it('should submit questionnaire answers', async () => {
-      global.fetch.mockResolvedValue(mockSuccessResponse(mockResponses.answerSubmissionResponse));
+      global.fetch.mockResolvedValue(mockStandardizedSuccess(mockResponses.answerSubmissionResponse));
 
       const answers = [
         { question_id: 'q1', answer_option_id: 'a1' },

package/src/__tests__/utils/generators.js

@@ -77,4 +77,91 @@ export const arbitraries = {
     }),
     { minLength: 1, maxLength: 20 }
   ),
+
+  // Request ID
+  requestId: () => fc.string({ minLength: 10, maxLength: 50 }).map(s => `req_${s}`),
+
+  // HTTP status codes
+  httpStatusCode: () => fc.constantFrom(200, 201, 400, 401, 403, 404, 409, 429, 500, 502, 503),
+  
+  // Error status codes only
+  errorStatusCode: () => fc.constantFrom(400, 401, 403, 404, 409, 429, 500, 502, 503),
+
+  // Rate limit info
+  rateLimitInfo: () => fc.record({
+    limit: fc.integer({ min: 100, max: 10000 }),
+    remaining: fc.integer({ min: 0, max: 10000 }),
+    reset: fc.integer({ min: 1700000000, max: 1800000000 }),
+  }).filter(r => r.remaining <= r.limit),
+
+  // Standardized success response
+  successResponse: () => fc.record({
+    success: fc.constant(true),
+    data: fc.dictionary(
+      fc.string({ minLength: 1, maxLength: 20 }),
+      fc.oneof(
+        fc.string(),
+        fc.integer(),
+        fc.boolean(),
+        fc.constant(null),
+        fc.array(fc.string(), { maxLength: 5 })
+      )
+    ),
+    request_id: arbitraries.requestId(),
+  }),
+
+  // Standardized error response
+  errorResponse: () => fc.record({
+    success: fc.constant(false),
+    error: fc.record({
+      code: fc.constantFrom(
+        'VALIDATION_ERROR',
+        'INVALID_API_KEY',
+        'NOT_FOUND',
+        'CONFLICT',
+        'RATE_LIMIT_EXCEEDED',
+        'INTERNAL_ERROR'
+      ),
+      message: fc.string({ minLength: 5, maxLength: 100 }),
+      details: fc.option(
+        fc.array(
+          fc.record({
+            field: fc.string({ minLength: 1, maxLength: 30 }),
+            message: fc.string({ minLength: 5, maxLength: 100 }),
+          }),
+          { minLength: 1, maxLength: 5 }
+        ),
+        { nil: null }
+      ),
+    }),
+    request_id: arbitraries.requestId(),
+  }),
+
+  // Pagination info
+  paginationInfo: () => fc.record({
+    page: fc.integer({ min: 1, max: 100 }),
+    limit: fc.integer({ min: 1, max: 100 }),
+    total: fc.integer({ min: 0, max: 10000 }),
+    totalPages: fc.integer({ min: 0, max: 100 }),
+  }),
+
+  // Valid API response (either success or error)
+  validApiResponse: () => fc.oneof(
+    arbitraries.successResponse(),
+    arbitraries.errorResponse()
+  ),
+
+  // Error code to status mapping
+  errorCodeStatusPair: () => fc.constantFrom(
+    { code: 'VALIDATION_ERROR', status: 400 },
+    { code: 'INVALID_API_KEY', status: 401 },
+    { code: 'FORBIDDEN', status: 403 },
+    { code: 'NOT_FOUND', status: 404 },
+    { code: 'USER_NOT_FOUND', status: 404 },
+    { code: 'CONFLICT', status: 409 },
+    { code: 'USER_EXISTS', status: 409 },
+    { code: 'RATE_LIMIT_EXCEEDED', status: 429 },
+    { code: 'INTERNAL_ERROR', status: 500 },
+    { code: 'SERVER_ERROR', status: 500 }
+  ),
 };

package/src/__tests__/utils/mockClient.js

@@ -7,30 +7,70 @@ export function createMockFetch() {
   return jest.fn();
 }
 
-export function mockSuccessResponse(data, status = 200) {
+export function mockSuccessResponse(data, status = 200, headers = {}) {
+  const defaultHeaders = {
+    'X-RateLimit-Limit': '1000',
+    'X-RateLimit-Remaining': '950',
+    'X-RateLimit-Reset': '1704067200',
+    'X-Request-Id': 'req_test123',
+    ...headers,
+  };
+
   return Promise.resolve({
     ok: true,
     status,
+    headers: createMockHeaders(defaultHeaders),
     json: () => Promise.resolve(data),
     text: () => Promise.resolve(JSON.stringify(data)),
   });
 }
 
-export function mockErrorResponse(status, message, details) {
+export function mockStandardizedSuccess(data, requestId = 'req_test123', headers = {}) {
+  const responseBody = {
+    success: true,
+    data,
+    request_id: requestId,
+  };
+  return mockSuccessResponse(responseBody, 200, { 'X-Request-Id': requestId, ...headers });
+}
+
+export function mockErrorResponse(status, message, details = null, headers = {}) {
   const errorData = {
-    error: message,
-    ...(details && { details }),
+    success: false,
+    error: {
+      code: getErrorCodeForStatus(status),
+      message,
+      ...(details && { details }),
+    },
+    request_id: headers['X-Request-Id'] || 'req_error123',
   };
-  
+
+  const defaultHeaders = {
+    'X-RateLimit-Limit': '1000',
+    'X-RateLimit-Remaining': '950',
+    'X-RateLimit-Reset': '1704067200',
+    ...headers,
+  };
+
   return Promise.resolve({
     ok: false,
     status,
     statusText: message,
+    headers: createMockHeaders(defaultHeaders),
     json: () => Promise.resolve(errorData),
     text: () => Promise.resolve(JSON.stringify(errorData)),
   });
 }
 
+export function mockRateLimitResponse(retryAfter = 60) {
+  return mockErrorResponse(429, 'Rate limit exceeded', null, {
+    'Retry-After': String(retryAfter),
+    'X-RateLimit-Limit': '1000',
+    'X-RateLimit-Remaining': '0',
+    'X-RateLimit-Reset': String(Math.floor(Date.now() / 1000) + retryAfter),
+  });
+}
+
 export function mockNetworkError(message = 'Network error') {
   return new Error(message);
 }
@@ -40,3 +80,29 @@ export function mockTimeoutError() {
   error.name = 'AbortError';
   return error;
 }
+
+function getErrorCodeForStatus(status) {
+  const codeMap = {
+    400: 'VALIDATION_ERROR',
+    401: 'INVALID_API_KEY',
+    403: 'FORBIDDEN',
+    404: 'NOT_FOUND',
+    409: 'CONFLICT',
+    429: 'RATE_LIMIT_EXCEEDED',
+    500: 'INTERNAL_ERROR',
+    502: 'BAD_GATEWAY',
+    503: 'SERVICE_UNAVAILABLE',
+  };
+  return codeMap[status] || 'UNKNOWN_ERROR';
+}
+
+/**
+ * Create mock headers object that mimics the Headers API
+ */
+export function createMockHeaders(headersObj = {}) {
+  return {
+    get: (name) => headersObj[name] || headersObj[name.toLowerCase()] || null,
+    has: (name) => name in headersObj || name.toLowerCase() in headersObj,
+    entries: () => Object.entries(headersObj),
+  };
+}

package/src/errors.js

@@ -0,0 +1,156 @@
+/**
+ * Rooguys SDK Error Classes
+ * Typed error classes for different API error scenarios
+ */
+
+/**
+ * Base error class for all Rooguys SDK errors
+ */
+export class RooguysError extends Error {
+  constructor(message, { code = 'UNKNOWN_ERROR', requestId = null, statusCode = 500 } = {}) {
+    super(message);
+    this.name = 'RooguysError';
+    this.code = code;
+    this.requestId = requestId;
+    this.statusCode = statusCode;
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      requestId: this.requestId,
+      statusCode: this.statusCode,
+    };
+  }
+}
+
+/**
+ * Validation error (HTTP 400)
+ * Thrown when request validation fails
+ */
+export class ValidationError extends RooguysError {
+  constructor(message, { code = 'VALIDATION_ERROR', requestId = null, fieldErrors = null } = {}) {
+    super(message, { code, requestId, statusCode: 400 });
+    this.name = 'ValidationError';
+    this.fieldErrors = fieldErrors;
+  }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      fieldErrors: this.fieldErrors,
+    };
+  }
+}
+
+/**
+ * Authentication error (HTTP 401)
+ * Thrown when API key is invalid or missing
+ */
+export class AuthenticationError extends RooguysError {
+  constructor(message, { code = 'AUTHENTICATION_ERROR', requestId = null } = {}) {
+    super(message, { code, requestId, statusCode: 401 });
+    this.name = 'AuthenticationError';
+  }
+}
+
+/**
+ * Forbidden error (HTTP 403)
+ * Thrown when access is denied
+ */
+export class ForbiddenError extends RooguysError {
+  constructor(message, { code = 'FORBIDDEN', requestId = null } = {}) {
+    super(message, { code, requestId, statusCode: 403 });
+    this.name = 'ForbiddenError';
+  }
+}
+
+/**
+ * Not found error (HTTP 404)
+ * Thrown when requested resource doesn't exist
+ */
+export class NotFoundError extends RooguysError {
+  constructor(message, { code = 'NOT_FOUND', requestId = null } = {}) {
+    super(message, { code, requestId, statusCode: 404 });
+    this.name = 'NotFoundError';
+  }
+}
+
+/**
+ * Conflict error (HTTP 409)
+ * Thrown when resource already exists or state conflict
+ */
+export class ConflictError extends RooguysError {
+  constructor(message, { code = 'CONFLICT', requestId = null } = {}) {
+    super(message, { code, requestId, statusCode: 409 });
+    this.name = 'ConflictError';
+  }
+}
+
+/**
+ * Rate limit error (HTTP 429)
+ * Thrown when rate limit is exceeded
+ */
+export class RateLimitError extends RooguysError {
+  constructor(message, { code = 'RATE_LIMIT_EXCEEDED', requestId = null, retryAfter = 60 } = {}) {
+    super(message, { code, requestId, statusCode: 429 });
+    this.name = 'RateLimitError';
+    this.retryAfter = retryAfter;
+  }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      retryAfter: this.retryAfter,
+    };
+  }
+}
+
+/**
+ * Server error (HTTP 500+)
+ * Thrown when server encounters an error
+ */
+export class ServerError extends RooguysError {
+  constructor(message, { code = 'SERVER_ERROR', requestId = null, statusCode = 500 } = {}) {
+    super(message, { code, requestId, statusCode });
+    this.name = 'ServerError';
+  }
+}
+
+/**
+ * Map HTTP status code to appropriate error class
+ * @param {number} status - HTTP status code
+ * @param {object} errorBody - Error response body
+ * @param {string} requestId - Request ID from response
+ * @param {object} headers - Response headers
+ * @returns {RooguysError} Appropriate error instance
+ */
+export function mapStatusToError(status, errorBody, requestId, headers = {}) {
+  const message = errorBody?.error?.message || errorBody?.error || errorBody?.message || 'An error occurred';
+  const code = errorBody?.error?.code || errorBody?.code || 'UNKNOWN_ERROR';
+  const fieldErrors = errorBody?.error?.details || errorBody?.details || null;
+
+  switch (status) {
+    case 400:
+      return new ValidationError(message, { code, requestId, fieldErrors });
+    case 401:
+      return new AuthenticationError(message, { code, requestId });
+    case 403:
+      return new ForbiddenError(message, { code, requestId });
+    case 404:
+      return new NotFoundError(message, { code, requestId });
+    case 409:
+      return new ConflictError(message, { code, requestId });
+    case 429: {
+      const retryAfter = parseInt(headers['retry-after'] || headers['Retry-After'] || '60', 10);
+      return new RateLimitError(message, { code, requestId, retryAfter });
+    }
+    default:
+      if (status >= 500) {
+        return new ServerError(message, { code, requestId, statusCode: status });
+      }
+      return new RooguysError(message, { code, requestId, statusCode: status });
+  }
+}