@oxyhq/services 0.0.85 → 0.1.1

package/README.md

@@ -1,114 +1,198 @@
-# Oxy Services Module 🚀
+# Oxy Services Module
 
-The Oxy Services Module is a comprehensive package designed to provide reusable services and components for building front-end applications with Oxy. It includes hooks and components for session management, user handling, and more, making it easier to integrate Oxy-based functionalities into your React applications.
+A comprehensive authentication, user management, and karma system module for Oxy applications.
 
-## Features ✨
-- **Session Management**: Easily manage user sessions with hooks like `useOxySession`.
-- **User Handling**: Fetch and display user information using functions like `getUserById`.
-- **Components**: Ready-to-use components such as `SignInButton`, `AccountSwitcherModal`, and `SessionOwnerButton`.
+## Features
 
-## Usage Instructions
+- Authentication system with JWT support
+- User profile management
+- Karma/reputation system
+- Wallet and transaction management
 
-To use the OxyServicesModule, follow these steps:
+## Installation
 
-1. Install the package:
-   ```bash
-   npm install @oxyhq/services
-   ```
+```bash
+npm install @oxyhq/services
+```
 
-2. Import the necessary components and hooks in your project:
-   ```javascript
-   import { useOxySession, getUserById, SignInButton, AccountSwitcherModal, SessionOwnerButton } from '@oxyhq/services';
-   ```
+## Usage
 
-3. Use the components and hooks in your application. For example, to use the `SignInButton` component:
-   ```javascript
-   import React from 'react';
-   import { SignInButton } from '@oxyhq/services';
+### Backend Usage
 
-   const App = () => {
-     return (
-       <div>
-         <SignInButton />
-       </div>
-     );
-   };
+```typescript
+import { OxyBackend } from '@oxyhq/services';
 
-   export default App;
-   ```
+// Initialize the backend services
+const oxyBackend = new OxyBackend('https://api.oxy.example.com');
 
-## Examples
+// Use authentication service
+const login = async (username, password) => {
+  const response = await oxyBackend.auth.login({ username, password });
+  if (response.success) {
+    // Handle successful login
+    console.log('Tokens:', response.data);
+  } else {
+    // Handle login failure
+    console.error('Login failed:', response.error);
+  }
+};
 
-### Example 1: Using `useOxySession` Hook
+// Use user service
+const getUserProfile = async (userId) => {
+  const response = await oxyBackend.users.getUserById(userId);
+  if (response.success) {
+    console.log('User profile:', response.data);
+  }
+};
 
-The `useOxySession` hook fetches session data and provides error handling and status management.
+// Use karma service
+const getUserKarma = async (userId) => {
+  const response = await oxyBackend.karma.getUserKarma(userId);
+  if (response.success) {
+    console.log('User karma:', response.data.karma);
+  }
+};
 
-```javascript
-import React from 'react';
-import { useOxySession } from '@oxyhq/services';
+// Use wallet service
+const getWallet = async (userId) => {
+  const response = await oxyBackend.wallet.getWallet(userId);
+  if (response.success) {
+    console.log('Wallet balance:', response.data.balance);
+  }
+};
+```
 
-const SessionComponent = () => {
-  const { session, status, error } = useOxySession();
+### Frontend Usage (React)
 
-  if (status === 'loading') {
-    return <div>Loading...</div>;
-  }
+#### Using OxyProvider (Recommended)
 
-  if (status === 'error') {
-    return <div>Error: {error}</div>;
-  }
+```typescript
+import React from 'react';
+import { OxyProvider, useAuth, useUser, useKarma, useWallet } from '@oxyhq/services';
+
+// Wrap your app with OxyProvider
+function App() {
+  return (
+    <OxyProvider apiUrl="https://api.oxy.example.com" storage="local">
+      <AuthenticatedApp />
+    </OxyProvider>
+  );
+}
+
+// Then in your components, you don't need to specify apiUrl
+function AuthenticatedApp() {
+  // Use hooks without needing to specify apiUrl each time
+  const auth = useAuth();
+  const user = useUser();
+  const karma = useKarma();
+  const wallet = useWallet();
+  
+  const handleLogin = async () => {
+    const result = await auth.login({
+      username: 'user123',
+      password: 'secure-password'
+    });
+    
+    if (result.success) {
+      console.log('Logged in successfully');
+    }
+  };
 
   return (
     <div>
-      <h1>Welcome, {session.user.name}!</h1>
-      <p>Email: {session.user.email}</p>
+      {auth.isAuthenticated ? (
+        <div>
+          <h2>Welcome, {auth.user?.username}</h2>
+          <button onClick={auth.logout}>Logout</button>
+        </div>
+      ) : (
+        <button onClick={handleLogin}>Login</button>
+      )}
     </div>
   );
-};
+}
 
-export default SessionComponent;
+export default App;
 ```
 
-### Example 2: Using `getUserById` Function
+#### Direct Usage (Without Provider)
 
-The `getUserById` function fetches user data by ID and handles possible errors.
+```typescript
+import React from 'react';
+import { useAuth, useUser, useKarma, useWallet } from '@oxyhq/services';
+
+function App() {
+  // Use authentication hook
+  const auth = useAuth({
+    apiUrl: 'https://api.oxy.example.com',
+    storage: 'local',
+    tokenRefreshInterval: 1000 * 60 * 15 // 15 minutes
+  });
+
+  // Use user management hook
+  const user = useUser({
+    apiUrl: 'https://api.oxy.example.com',
+    getToken: auth.getToken
+  });
+
+  // Use karma hook
+  const karma = useKarma({
+    apiUrl: 'https://api.oxy.example.com',
+    getToken: auth.getToken
+  });
+
+  // Use wallet hook
+  const wallet = useWallet({
+    apiUrl: 'https://api.oxy.example.com',
+    getToken: auth.getToken
+  });
+
+  const handleLogin = async () => {
+    const result = await auth.login({
+      username: 'user123',
+      password: 'secure-password'
+    });
+    
+    if (result.success) {
+      console.log('Logged in successfully');
+    }
+  };
 
-```javascript
-import React, { useEffect, useState } from 'react';
-import { getUserById } from '@oxyhq/services';
+  return (
+    <div>
+      {auth.isAuthenticated ? (
+        <div>
+          <h2>Welcome, {auth.user?.username}</h2>
+          <button onClick={auth.logout}>Logout</button>
+        </div>
+      ) : (
+        <button onClick={handleLogin}>Login</button>
+      )}
+    </div>
+  );
+}
 
-const UserComponent = ({ userId }) => {
-  const [user, setUser] = useState(null);
-  const [error, setError] = useState(null);
+export default App;
+```
 
-  useEffect(() => {
-    const fetchUser = async () => {
-      try {
-        const fetchedUser = await getUserById(userId);
-        setUser(fetchedUser);
-      } catch (err) {
-        setError(err.message);
-      }
-    };
+## API Reference
 
-    fetchUser();
-  }, [userId]);
+### Backend Services
 
-  if (error) {
-    return <div>Error: {error}</div>;
-  }
+- `OxyAuthBackend` - Authentication services
+- `OxyUsersBackend` - User management services
+- `OxyKarmaBackend` - Karma/reputation services
+- `OxyWalletBackend` - Wallet and transaction services
 
-  if (!user) {
-    return <div>Loading...</div>;
-  }
+### Frontend Hooks & Context
 
-  return (
-    <div>
-      <h1>{user.name}</h1>
-      <p>Email: {user.email}</p>
-    </div>
-  );
-};
+- `OxyProvider` - Context provider for API URL and authentication
+- `useOxyContext` - Hook to access the Oxy context
+- `useAuth()` - Authentication hooks
+- `useUser()` - User management hooks
+- `useKarma()` - Karma/reputation hooks
+- `useWallet()` - Wallet and transaction hooks
 
-export default UserComponent;
-```
+## License
+
+MIT 

package/dist/backend/auth.d.ts

@@ -0,0 +1,37 @@
+import { ApiResponse, AuthTokens, UserCredentials, UserProfile, UserRegistration } from '../shared/types';
+export declare class OxyAuthBackend {
+    private apiClient;
+    constructor(apiUrl: string);
+    /**
+     * Authenticate a user with username/email and password
+     */
+    login(credentials: UserCredentials): Promise<ApiResponse<AuthTokens>>;
+    /**
+     * Register a new user
+     */
+    register(userData: UserRegistration): Promise<ApiResponse<AuthTokens>>;
+    /**
+     * Refresh the authentication token
+     */
+    refreshToken(refreshToken: string): Promise<ApiResponse<AuthTokens>>;
+    /**
+     * Logout the current user
+     */
+    logout(refreshToken: string): Promise<ApiResponse<void>>;
+    /**
+     * Validate if a token is valid
+     */
+    validateToken(token: string): Promise<ApiResponse<{
+        valid: boolean;
+    }>>;
+    /**
+     * Get the current user's profile
+     */
+    getCurrentUser(token: string): Promise<ApiResponse<UserProfile>>;
+    /**
+     * Check if a username is available
+     */
+    checkUsernameAvailability(username: string): Promise<ApiResponse<{
+        available: boolean;
+    }>>;
+}

package/dist/backend/auth.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OxyAuthBackend = void 0;
+const api_client_1 = require("../shared/api-client");
+class OxyAuthBackend {
+    constructor(apiUrl) {
+        this.apiClient = new api_client_1.ApiClient({ apiUrl });
+    }
+    /**
+     * Authenticate a user with username/email and password
+     */
+    async login(credentials) {
+        return this.apiClient.request({
+            method: 'POST',
+            url: '/auth/login',
+            data: credentials
+        });
+    }
+    /**
+     * Register a new user
+     */
+    async register(userData) {
+        return this.apiClient.request({
+            method: 'POST',
+            url: '/auth/signup',
+            data: userData
+        });
+    }
+    /**
+     * Refresh the authentication token
+     */
+    async refreshToken(refreshToken) {
+        return this.apiClient.request({
+            method: 'POST',
+            url: '/auth/refresh-token',
+            data: { refreshToken }
+        });
+    }
+    /**
+     * Logout the current user
+     */
+    async logout(refreshToken) {
+        return this.apiClient.request({
+            method: 'POST',
+            url: '/auth/logout',
+            data: { refreshToken }
+        });
+    }
+    /**
+     * Validate if a token is valid
+     */
+    async validateToken(token) {
+        return this.apiClient.request({
+            method: 'POST',
+            url: '/auth/validate-token',
+            data: { token }
+        });
+    }
+    /**
+     * Get the current user's profile
+     */
+    async getCurrentUser(token) {
+        return this.apiClient.request({
+            method: 'GET',
+            url: '/auth/me',
+            headers: {
+                Authorization: `Bearer ${token}`
+            }
+        });
+    }
+    /**
+     * Check if a username is available
+     */
+    async checkUsernameAvailability(username) {
+        return this.apiClient.request({
+            method: 'GET',
+            url: `/auth/check-username/${username}`
+        });
+    }
+}
+exports.OxyAuthBackend = OxyAuthBackend;

package/dist/backend/index.d.ts

@@ -0,0 +1,12 @@
+import { OxyAuthBackend } from './auth';
+import { OxyUsersBackend } from './users';
+import { OxyKarmaBackend } from './karma';
+import { OxyWalletBackend } from './wallet';
+export { OxyAuthBackend, OxyUsersBackend, OxyKarmaBackend, OxyWalletBackend };
+export declare class OxyBackend {
+    auth: OxyAuthBackend;
+    users: OxyUsersBackend;
+    karma: OxyKarmaBackend;
+    wallet: OxyWalletBackend;
+    constructor(apiUrl: string);
+}

package/dist/backend/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OxyBackend = exports.OxyWalletBackend = exports.OxyKarmaBackend = exports.OxyUsersBackend = exports.OxyAuthBackend = void 0;
+const auth_1 = require("./auth");
+Object.defineProperty(exports, "OxyAuthBackend", { enumerable: true, get: function () { return auth_1.OxyAuthBackend; } });
+const users_1 = require("./users");
+Object.defineProperty(exports, "OxyUsersBackend", { enumerable: true, get: function () { return users_1.OxyUsersBackend; } });
+const karma_1 = require("./karma");
+Object.defineProperty(exports, "OxyKarmaBackend", { enumerable: true, get: function () { return karma_1.OxyKarmaBackend; } });
+const wallet_1 = require("./wallet");
+Object.defineProperty(exports, "OxyWalletBackend", { enumerable: true, get: function () { return wallet_1.OxyWalletBackend; } });
+class OxyBackend {
+    constructor(apiUrl) {
+        this.auth = new auth_1.OxyAuthBackend(apiUrl);
+        this.users = new users_1.OxyUsersBackend(apiUrl);
+        this.karma = new karma_1.OxyKarmaBackend(apiUrl);
+        this.wallet = new wallet_1.OxyWalletBackend(apiUrl);
+    }
+}
+exports.OxyBackend = OxyBackend;

package/dist/backend/karma.d.ts

@@ -0,0 +1,45 @@
+import { ApiResponse, KarmaAction, KarmaHistory, KarmaRule } from '../shared/types';
+export declare class OxyKarmaBackend {
+    private apiClient;
+    constructor(apiUrl: string);
+    /**
+     * Get a user's karma total
+     */
+    getUserKarma(userId: string): Promise<ApiResponse<{
+        karma: number;
+    }>>;
+    /**
+     * Get a user's karma history (actions that affected karma)
+     */
+    getUserKarmaHistory(userId: string, limit?: number, offset?: number): Promise<ApiResponse<KarmaHistory>>;
+    /**
+     * Award karma points to a user for a specific action
+     */
+    awardKarma(karmaAction: KarmaAction): Promise<ApiResponse<{
+        success: boolean;
+        newTotal: number;
+    }>>;
+    /**
+     * Deduct karma points from a user for a specific action
+     */
+    deductKarma(karmaAction: KarmaAction): Promise<ApiResponse<{
+        success: boolean;
+        newTotal: number;
+    }>>;
+    /**
+     * Get the karma leaderboard (top users by karma)
+     */
+    getKarmaLeaderboard(limit?: number, offset?: number): Promise<ApiResponse<Array<{
+        userId: string;
+        username: string;
+        karma: number;
+    }>>>;
+    /**
+     * Get karma rules configuration
+     */
+    getKarmaRules(): Promise<ApiResponse<KarmaRule[]>>;
+    /**
+     * Admin only: Create or update a karma rule
+     */
+    createOrUpdateKarmaRule(rule: KarmaRule): Promise<ApiResponse<KarmaRule>>;
+}

package/dist/backend/karma.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OxyKarmaBackend = void 0;
+const api_client_1 = require("../shared/api-client");
+class OxyKarmaBackend {
+    constructor(apiUrl) {
+        this.apiClient = new api_client_1.ApiClient({ apiUrl });
+    }
+    /**
+     * Get a user's karma total
+     */
+    async getUserKarma(userId) {
+        return this.apiClient.request({
+            method: 'GET',
+            url: `/karma/${userId}/total`
+        });
+    }
+    /**
+     * Get a user's karma history (actions that affected karma)
+     */
+    async getUserKarmaHistory(userId, limit, offset) {
+        const params = {};
+        if (limit !== undefined)
+            params.limit = limit.toString();
+        if (offset !== undefined)
+            params.offset = offset.toString();
+        return this.apiClient.request({
+            method: 'GET',
+            url: `/karma/${userId}/history`,
+            params
+        });
+    }
+    /**
+     * Award karma points to a user for a specific action
+     */
+    async awardKarma(karmaAction) {
+        return this.apiClient.request({
+            method: 'POST',
+            url: '/karma/award',
+            data: karmaAction
+        });
+    }
+    /**
+     * Deduct karma points from a user for a specific action
+     */
+    async deductKarma(karmaAction) {
+        return this.apiClient.request({
+            method: 'POST',
+            url: '/karma/deduct',
+            data: karmaAction
+        });
+    }
+    /**
+     * Get the karma leaderboard (top users by karma)
+     */
+    async getKarmaLeaderboard(limit = 10, offset = 0) {
+        return this.apiClient.request({
+            method: 'GET',
+            url: '/karma/leaderboard',
+            params: { limit, offset }
+        });
+    }
+    /**
+     * Get karma rules configuration
+     */
+    async getKarmaRules() {
+        return this.apiClient.request({
+            method: 'GET',
+            url: '/karma/rules'
+        });
+    }
+    /**
+     * Admin only: Create or update a karma rule
+     */
+    async createOrUpdateKarmaRule(rule) {
+        return this.apiClient.request({
+            method: 'POST',
+            url: '/karma/rules',
+            data: rule
+        });
+    }
+}
+exports.OxyKarmaBackend = OxyKarmaBackend;

package/dist/backend/users.d.ts

@@ -0,0 +1,39 @@
+import { ApiResponse, UserProfile, PrivacySettings } from '../shared/types';
+export declare class OxyUsersBackend {
+    private apiClient;
+    constructor(apiUrl: string);
+    /**
+     * Get a user by ID
+     */
+    getUserById(userId: string): Promise<ApiResponse<UserProfile>>;
+    /**
+     * Get a user by username
+     */
+    getUserByUsername(username: string): Promise<ApiResponse<UserProfile>>;
+    /**
+     * Update a user's profile
+     */
+    updateUserProfile(userId: string, profileData: Partial<UserProfile>): Promise<ApiResponse<UserProfile>>;
+    /**
+     * Update a user's privacy settings
+     */
+    updatePrivacySettings(userId: string, settings: Partial<PrivacySettings>): Promise<ApiResponse<PrivacySettings>>;
+    /**
+     * Get a user's privacy settings
+     */
+    getPrivacySettings(userId: string): Promise<ApiResponse<PrivacySettings>>;
+    /**
+     * Convert username to user ID
+     */
+    getUserIdFromUsername(username: string): Promise<ApiResponse<{
+        userId: string;
+    }>>;
+    /**
+     * Follow a user
+     */
+    followUser(userId: string, targetUserId: string): Promise<ApiResponse<void>>;
+    /**
+     * Unfollow a user
+     */
+    unfollowUser(userId: string, targetUserId: string): Promise<ApiResponse<void>>;
+}

package/dist/backend/users.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OxyUsersBackend = void 0;
+const api_client_1 = require("../shared/api-client");
+class OxyUsersBackend {
+    constructor(apiUrl) {
+        this.apiClient = new api_client_1.ApiClient({ apiUrl });
+    }
+    /**
+     * Get a user by ID
+     */
+    async getUserById(userId) {
+        return this.apiClient.request({
+            method: 'GET',
+            url: `/users/${userId}`
+        });
+    }
+    /**
+     * Get a user by username
+     */
+    async getUserByUsername(username) {
+        return this.apiClient.request({
+            method: 'GET',
+            url: `/users/username/${username}`
+        });
+    }
+    /**
+     * Update a user's profile
+     */
+    async updateUserProfile(userId, profileData) {
+        return this.apiClient.request({
+            method: 'PUT',
+            url: `/users/${userId}`,
+            data: profileData
+        });
+    }
+    /**
+     * Update a user's privacy settings
+     */
+    async updatePrivacySettings(userId, settings) {
+        return this.apiClient.request({
+            method: 'PUT',
+            url: `/users/${userId}/privacy`,
+            data: settings
+        });
+    }
+    /**
+     * Get a user's privacy settings
+     */
+    async getPrivacySettings(userId) {
+        return this.apiClient.request({
+            method: 'GET',
+            url: `/users/${userId}/privacy`
+        });
+    }
+    /**
+     * Convert username to user ID
+     */
+    async getUserIdFromUsername(username) {
+        // This assumes the API has this endpoint, if not, we would use the getUserByUsername and extract the ID
+        return this.apiClient.request({
+            method: 'GET',
+            url: `/users/resolve/${username}`
+        });
+    }
+    /**
+     * Follow a user
+     */
+    async followUser(userId, targetUserId) {
+        return this.apiClient.request({
+            method: 'POST',
+            url: `/users/${userId}/follow`,
+            data: { targetUserId }
+        });
+    }
+    /**
+     * Unfollow a user
+     */
+    async unfollowUser(userId, targetUserId) {
+        return this.apiClient.request({
+            method: 'POST',
+            url: `/users/${userId}/unfollow`,
+            data: { targetUserId }
+        });
+    }
+}
+exports.OxyUsersBackend = OxyUsersBackend;