@oxyhq/services 5.17.18 → 5.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxyhq/services",
-  "version": "5.17.18",
+  "version": "5.18.0",
   "description": "Reusable OxyHQ module to handle authentication, user management, karma system, device-based session management and more 🚀",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",

package/src/core/mixins/OxyServices.features.ts

@@ -0,0 +1,428 @@
+/**
+ * Features Methods Mixin
+ *
+ * Provides methods for various features:
+ * - Feedback submission
+ * - Subscription plans
+ * - Saves/Collections
+ * - User history
+ * - FAQ
+ * - User stats
+ * - Achievements
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+import { CACHE_TIMES } from './mixinHelpers';
+
+// Types
+export interface FeedbackPayload {
+    type: 'bug' | 'feature' | 'general' | 'support';
+    title: string;
+    description: string;
+    priority: 'low' | 'medium' | 'high' | 'critical';
+    category: string;
+    contactEmail?: string;
+    systemInfo?: {
+        platform: string;
+        version: string;
+        appVersion: string;
+        userId?: string;
+        username?: string;
+        timestamp: string;
+    };
+}
+
+export interface FeedbackResult {
+    id: string;
+    status: string;
+    createdAt: string;
+}
+
+export interface SubscriptionPlan {
+    id: string;
+    name: string;
+    description: string;
+    price: number;
+    currency: string;
+    interval: 'month' | 'year';
+    features: string[];
+}
+
+export interface SubscriptionResult {
+    subscriptionId: string;
+    status: string;
+    currentPeriodEnd: string;
+}
+
+export interface SavedItem {
+    id: string;
+    itemId: string;
+    itemType: string;
+    title: string;
+    createdAt: string;
+}
+
+export interface Collection {
+    id: string;
+    name: string;
+    description?: string;
+    itemCount: number;
+    createdAt: string;
+}
+
+export interface UserStats {
+    postCount: number;
+    commentCount: number;
+    followerCount: number;
+    followingCount: number;
+    karmaScore?: number;
+}
+
+export interface HistoryItem {
+    id: string;
+    type: string;
+    title: string;
+    timestamp: string;
+    metadata?: Record<string, any>;
+}
+
+export interface FAQ {
+    id: string;
+    question: string;
+    answer: string;
+    category: string;
+}
+
+export interface Achievement {
+    id: string;
+    name: string;
+    description: string;
+    icon: string;
+    unlockedAt?: string;
+}
+
+export function OxyServicesFeaturesMixin<T extends typeof OxyServicesBase>(Base: T) {
+    return class extends Base {
+        constructor(...args: any[]) {
+            super(...(args as [any]));
+        }
+
+        // ==================
+        // FEEDBACK METHODS
+        // ==================
+
+        /**
+         * Submit user feedback
+         */
+        async submitFeedback(payload: FeedbackPayload): Promise<FeedbackResult> {
+            try {
+                return await this.makeRequest<FeedbackResult>('POST', '/api/feedback', payload, {
+                    cache: false,
+                });
+            } catch (error) {
+                throw this.handleError(error);
+            }
+        }
+
+        // ==================
+        // SUBSCRIPTION METHODS
+        // ==================
+
+        /**
+         * Get available subscription plans
+         */
+        async getSubscriptionPlans(): Promise<SubscriptionPlan[]> {
+            try {
+                return await this.makeRequest<SubscriptionPlan[]>('GET', '/api/subscriptions/plans', undefined, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.LONG,
+                });
+            } catch (error) {
+                throw this.handleError(error);
+            }
+        }
+
+        /**
+         * Get individual purchasable features
+         */
+        async getIndividualFeatures(): Promise<any[]> {
+            try {
+                return await this.makeRequest<any[]>('GET', '/api/subscriptions/features', undefined, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.LONG,
+                });
+            } catch (error) {
+                throw this.handleError(error);
+            }
+        }
+
+        /**
+         * Subscribe to a plan
+         */
+        async subscribe(planId: string, paymentMethodId?: string): Promise<SubscriptionResult> {
+            return this.withAuthRetry(async () => {
+                return await this.makeRequest<SubscriptionResult>('POST', '/api/subscriptions/subscribe', {
+                    planId,
+                    paymentMethodId,
+                }, { cache: false });
+            }, 'subscribe');
+        }
+
+        /**
+         * Subscribe to an individual feature
+         */
+        async subscribeToFeature(featureId: string, paymentMethodId?: string): Promise<SubscriptionResult> {
+            return this.withAuthRetry(async () => {
+                return await this.makeRequest<SubscriptionResult>('POST', '/api/subscriptions/features/subscribe', {
+                    featureId,
+                    paymentMethodId,
+                }, { cache: false });
+            }, 'subscribeToFeature');
+        }
+
+        /**
+         * Cancel subscription
+         */
+        async cancelSubscription(subscriptionId: string): Promise<void> {
+            return this.withAuthRetry(async () => {
+                await this.makeRequest('POST', `/api/subscriptions/${subscriptionId}/cancel`, undefined, {
+                    cache: false,
+                });
+            }, 'cancelSubscription');
+        }
+
+        /**
+         * Reactivate subscription
+         */
+        async reactivateSubscription(subscriptionId: string): Promise<void> {
+            return this.withAuthRetry(async () => {
+                await this.makeRequest('POST', `/api/subscriptions/${subscriptionId}/reactivate`, undefined, {
+                    cache: false,
+                });
+            }, 'reactivateSubscription');
+        }
+
+        /**
+         * Get current user's subscription
+         */
+        async getCurrentSubscription(): Promise<SubscriptionResult | null> {
+            return this.withAuthRetry(async () => {
+                try {
+                    return await this.makeRequest<SubscriptionResult>('GET', '/api/subscriptions/current', undefined, {
+                        cache: true,
+                        cacheTTL: CACHE_TIMES.SHORT,
+                    });
+                } catch (error: any) {
+                    if (error.status === 404) return null;
+                    throw error;
+                }
+            }, 'getCurrentSubscription');
+        }
+
+        // ==================
+        // SAVES/COLLECTIONS
+        // ==================
+
+        /**
+         * Get user's saved items
+         */
+        async getSavedItems(userId?: string): Promise<SavedItem[]> {
+            return this.withAuthRetry(async () => {
+                const endpoint = userId ? `/api/users/${userId}/saves` : '/api/saves';
+                return await this.makeRequest<SavedItem[]>('GET', endpoint, undefined, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.SHORT,
+                });
+            }, 'getSavedItems');
+        }
+
+        /**
+         * Get user's collections
+         */
+        async getCollections(userId?: string): Promise<Collection[]> {
+            return this.withAuthRetry(async () => {
+                const endpoint = userId ? `/api/users/${userId}/collections` : '/api/collections';
+                return await this.makeRequest<Collection[]>('GET', endpoint, undefined, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.SHORT,
+                });
+            }, 'getCollections');
+        }
+
+        /**
+         * Save an item
+         */
+        async saveItem(itemId: string, itemType: string, collectionId?: string): Promise<SavedItem> {
+            return this.withAuthRetry(async () => {
+                return await this.makeRequest<SavedItem>('POST', '/api/saves', {
+                    itemId,
+                    itemType,
+                    collectionId,
+                }, { cache: false });
+            }, 'saveItem');
+        }
+
+        /**
+         * Remove an item from saves
+         */
+        async removeSavedItem(saveId: string): Promise<void> {
+            return this.withAuthRetry(async () => {
+                await this.makeRequest('DELETE', `/api/saves/${saveId}`, undefined, { cache: false });
+            }, 'removeSavedItem');
+        }
+
+        /**
+         * Create a collection
+         */
+        async createCollection(name: string, description?: string): Promise<Collection> {
+            return this.withAuthRetry(async () => {
+                return await this.makeRequest<Collection>('POST', '/api/collections', {
+                    name,
+                    description,
+                }, { cache: false });
+            }, 'createCollection');
+        }
+
+        /**
+         * Delete a collection
+         */
+        async deleteCollection(collectionId: string): Promise<void> {
+            return this.withAuthRetry(async () => {
+                await this.makeRequest('DELETE', `/api/collections/${collectionId}`, undefined, { cache: false });
+            }, 'deleteCollection');
+        }
+
+        // ==================
+        // USER STATS
+        // ==================
+
+        /**
+         * Get user statistics
+         */
+        async getUserStats(userId: string): Promise<UserStats> {
+            try {
+                return await this.makeRequest<UserStats>('GET', `/api/users/${userId}/stats`, undefined, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.MEDIUM,
+                });
+            } catch (error) {
+                throw this.handleError(error);
+            }
+        }
+
+        // ==================
+        // HISTORY
+        // ==================
+
+        /**
+         * Get user history
+         */
+        async getUserHistory(userId?: string, limit?: number, offset?: number): Promise<HistoryItem[]> {
+            return this.withAuthRetry(async () => {
+                const params: any = {};
+                if (limit) params.limit = limit;
+                if (offset) params.offset = offset;
+
+                const endpoint = userId ? `/api/users/${userId}/history` : '/api/history';
+                return await this.makeRequest<HistoryItem[]>('GET', endpoint, params, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.SHORT,
+                });
+            }, 'getUserHistory');
+        }
+
+        /**
+         * Clear user history
+         */
+        async clearUserHistory(): Promise<void> {
+            return this.withAuthRetry(async () => {
+                await this.makeRequest('DELETE', '/api/history', undefined, { cache: false });
+            }, 'clearUserHistory');
+        }
+
+        /**
+         * Delete a history item
+         */
+        async deleteHistoryItem(itemId: string): Promise<void> {
+            return this.withAuthRetry(async () => {
+                await this.makeRequest('DELETE', `/api/history/${itemId}`, undefined, { cache: false });
+            }, 'deleteHistoryItem');
+        }
+
+        // ==================
+        // FAQ
+        // ==================
+
+        /**
+         * Get FAQs
+         */
+        async getFAQs(category?: string): Promise<FAQ[]> {
+            try {
+                const params = category ? { category } : undefined;
+                return await this.makeRequest<FAQ[]>('GET', '/api/faqs', params, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.LONG,
+                });
+            } catch (error) {
+                throw this.handleError(error);
+            }
+        }
+
+        /**
+         * Search FAQs
+         */
+        async searchFAQs(query: string): Promise<FAQ[]> {
+            try {
+                return await this.makeRequest<FAQ[]>('GET', '/api/faqs/search', { query }, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.MEDIUM,
+                });
+            } catch (error) {
+                throw this.handleError(error);
+            }
+        }
+
+        // ==================
+        // ACHIEVEMENTS
+        // ==================
+
+        /**
+         * Get user achievements
+         */
+        async getUserAchievements(userId?: string): Promise<Achievement[]> {
+            return this.withAuthRetry(async () => {
+                const endpoint = userId ? `/api/users/${userId}/achievements` : '/api/achievements';
+                return await this.makeRequest<Achievement[]>('GET', endpoint, undefined, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.MEDIUM,
+                });
+            }, 'getUserAchievements');
+        }
+
+        /**
+         * Get all available achievements
+         */
+        async getAllAchievements(): Promise<Achievement[]> {
+            try {
+                return await this.makeRequest<Achievement[]>('GET', '/api/achievements/all', undefined, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.LONG,
+                });
+            } catch (error) {
+                throw this.handleError(error);
+            }
+        }
+
+        // ==================
+        // ACCOUNT
+        // ==================
+
+        /**
+         * Delete user account (requires password confirmation)
+         */
+        async deleteAccount(password: string): Promise<void> {
+            return this.withAuthRetry(async () => {
+                await this.makeRequest('DELETE', '/api/account', { password }, { cache: false });
+            }, 'deleteAccount');
+        }
+    };
+}

package/src/core/mixins/index.ts

@@ -22,6 +22,7 @@ import { OxyServicesAnalyticsMixin } from './OxyServices.analytics';
 import { OxyServicesDevicesMixin } from './OxyServices.devices';
 import { OxyServicesSecurityMixin } from './OxyServices.security';
 import { OxyServicesUtilityMixin } from './OxyServices.utility';
+import { OxyServicesFeaturesMixin } from './OxyServices.features';
 
 /**
  * Composes all OxyServices mixins in the correct order
@@ -38,23 +39,25 @@ import { OxyServicesUtilityMixin } from './OxyServices.utility';
  */
 export function composeOxyServices() {
   return OxyServicesUtilityMixin(
-    OxyServicesSecurityMixin(
-      OxyServicesDevicesMixin(
-        OxyServicesAnalyticsMixin(
-          OxyServicesLocationMixin(
-            OxyServicesDeveloperMixin(
-              OxyServicesAssetsMixin(
-                OxyServicesKarmaMixin(
-                  OxyServicesPaymentMixin(
-                    OxyServicesLanguageMixin(
-                      OxyServicesPrivacyMixin(
-                        OxyServicesUserMixin(
-                          // Cross-domain authentication mixins (web-only)
-                          OxyServicesRedirectAuthMixin(
-                            OxyServicesPopupAuthMixin(
-                              OxyServicesFedCMMixin(
-                                // Base authentication mixin
-                                OxyServicesAuthMixin(OxyServicesBase)
+    OxyServicesFeaturesMixin(
+      OxyServicesSecurityMixin(
+        OxyServicesDevicesMixin(
+          OxyServicesAnalyticsMixin(
+            OxyServicesLocationMixin(
+              OxyServicesDeveloperMixin(
+                OxyServicesAssetsMixin(
+                  OxyServicesKarmaMixin(
+                    OxyServicesPaymentMixin(
+                      OxyServicesLanguageMixin(
+                        OxyServicesPrivacyMixin(
+                          OxyServicesUserMixin(
+                            // Cross-domain authentication mixins (web-only)
+                            OxyServicesRedirectAuthMixin(
+                              OxyServicesPopupAuthMixin(
+                                OxyServicesFedCMMixin(
+                                  // Base authentication mixin
+                                  OxyServicesAuthMixin(OxyServicesBase)
+                                )
                               )
                             )
                           )

package/src/ui/components/GroupedItem.tsx

@@ -22,6 +22,10 @@ interface GroupedItemProps {
     disabled?: boolean;
     customContent?: React.ReactNode;
     customIcon?: React.ReactNode;
+    /** Accessibility label (defaults to title) */
+    accessibilityLabel?: string;
+    /** Accessibility hint for what happens on press */
+    accessibilityHint?: string;
 }
 
 const GroupedItemComponent = ({
@@ -36,6 +40,8 @@ const GroupedItemComponent = ({
     disabled = false,
     customContent,
     customIcon,
+    accessibilityLabel,
+    accessibilityHint,
 }: GroupedItemProps) => {
     const hookColorScheme = useColorScheme();
     const colorScheme = normalizeColorScheme(hookColorScheme);
@@ -90,13 +96,25 @@ const GroupedItemComponent = ({
                 onPressIn={disabled ? undefined : handlePressIn}
                 onPress={onPress}
                 activeOpacity={0.7}
+                accessibilityRole="button"
+                accessibilityLabel={accessibilityLabel || title}
+                accessibilityHint={accessibilityHint || subtitle}
+                accessibilityState={{ disabled }}
             >
                 {content}
             </TouchableOpacity>
         );
     }
 
-    return <View style={itemStyles}>{content}</View>;
+    return (
+        <View
+            style={itemStyles}
+            accessibilityRole="text"
+            accessibilityLabel={accessibilityLabel || title}
+        >
+            {content}
+        </View>
+    );
 };
 
 GroupedItemComponent.displayName = 'GroupedItem';

package/src/ui/components/SettingRow.tsx

@@ -10,6 +10,12 @@ export interface SettingRowProps {
     textColor?: string;
     mutedTextColor?: string;
     borderColor?: string;
+    /** Active color for the switch track (default: #d169e5) */
+    activeColor?: string;
+    /** Inactive color for the switch track (default: #767577) */
+    inactiveColor?: string;
+    /** Accessibility label for the switch */
+    accessibilityLabel?: string;
 }
 
 /**
@@ -25,15 +31,27 @@ const SettingRow: React.FC<SettingRowProps> = ({
     textColor,
     mutedTextColor,
     borderColor,
+    activeColor = '#d169e5',
+    inactiveColor = '#767577',
+    accessibilityLabel,
 }) => {
     return (
-        <View style={[styles.settingRow, borderColor ? { borderBottomColor: borderColor } : undefined]}>
+        <View
+            style={[styles.settingRow, borderColor ? { borderBottomColor: borderColor } : undefined]}
+            accessibilityRole="none"
+        >
             <View style={styles.settingInfo}>
-                <Text style={[styles.settingTitle, textColor ? { color: textColor } : undefined]}>
+                <Text
+                    style={[styles.settingTitle, textColor ? { color: textColor } : undefined]}
+                    accessibilityRole="text"
+                >
                     {title}
                 </Text>
                 {description && (
-                    <Text style={[styles.settingDescription, mutedTextColor ? { color: mutedTextColor } : undefined]}>
+                    <Text
+                        style={[styles.settingDescription, mutedTextColor ? { color: mutedTextColor } : undefined]}
+                        accessibilityRole="text"
+                    >
                         {description}
                     </Text>
                 )}
@@ -42,8 +60,12 @@ const SettingRow: React.FC<SettingRowProps> = ({
                 value={value}
                 onValueChange={onValueChange}
                 disabled={disabled}
-                trackColor={{ false: '#767577', true: '#d169e5' }}
+                trackColor={{ false: inactiveColor, true: activeColor }}
                 thumbColor={value ? '#fff' : '#f4f3f4'}
+                accessibilityRole="switch"
+                accessibilityLabel={accessibilityLabel || title}
+                accessibilityState={{ checked: value, disabled }}
+                accessibilityHint={description}
             />
         </View>
     );

package/src/ui/components/feedback/FormInput.tsx

@@ -0,0 +1,84 @@
+import React from 'react';
+import { View, Text, TextInput } from 'react-native';
+import { Ionicons } from '@expo/vector-icons';
+import type { FeedbackColors } from './types';
+
+interface FormInputProps {
+    icon: string;
+    label: string;
+    value: string;
+    onChangeText: (text: string) => void;
+    placeholder?: string;
+    multiline?: boolean;
+    numberOfLines?: number;
+    testID?: string;
+    colors: FeedbackColors;
+    styles: any;
+    borderColor?: string;
+    accessibilityLabel?: string;
+    accessibilityHint?: string;
+}
+
+const FormInput: React.FC<FormInputProps> = React.memo(({
+    icon,
+    label,
+    value,
+    onChangeText,
+    placeholder,
+    multiline = false,
+    numberOfLines = 1,
+    testID,
+    colors,
+    styles,
+    borderColor,
+    accessibilityLabel,
+    accessibilityHint,
+}) => (
+    <View style={styles.inputContainer}>
+        <View style={[
+            multiline ? styles.textAreaWrapper : styles.premiumInputWrapper,
+            {
+                borderColor: borderColor || colors.border,
+                backgroundColor: colors.inputBackground,
+                shadowColor: colors.primary,
+                shadowOffset: { width: 0, height: 4 },
+                shadowOpacity: 0.1,
+                shadowRadius: 12,
+                elevation: 3,
+            }
+        ]}>
+            {!multiline && (
+                <Ionicons
+                    name={icon as any}
+                    size={22}
+                    color={colors.secondaryText}
+                    style={styles.inputIcon}
+                />
+            )}
+            <View style={styles.inputContent}>
+                <Text style={[styles.modernLabel, { color: colors.secondaryText }]}>
+                    {label}
+                </Text>
+                <TextInput
+                    style={[
+                        multiline ? styles.textArea : styles.modernInput,
+                        { color: colors.text }
+                    ]}
+                    value={value}
+                    onChangeText={onChangeText}
+                    placeholder={placeholder}
+                    placeholderTextColor={colors.secondaryText + '60'}
+                    multiline={multiline}
+                    numberOfLines={multiline ? numberOfLines : undefined}
+                    testID={testID}
+                    accessibilityLabel={accessibilityLabel || label}
+                    accessibilityHint={accessibilityHint}
+                />
+            </View>
+        </View>
+    </View>
+));
+
+FormInput.displayName = 'FormInput';
+
+export default FormInput;