@oxyhq/core 1.0.0

package/dist/esm/mixins/OxyServices.developer.js

@@ -0,0 +1,94 @@
+import { CACHE_TIMES } from './mixinHelpers';
+export function OxyServicesDeveloperMixin(Base) {
+    return class extends Base {
+        constructor(...args) {
+            super(...args);
+        }
+        /**
+         * Get developer apps for the current user
+         * @returns Array of developer apps
+         */
+        async getDeveloperApps() {
+            try {
+                const res = await this.makeRequest('GET', '/api/developer/apps', undefined, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.MEDIUM,
+                });
+                return res.apps || [];
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Create a new developer app
+         * @param data - Developer app configuration
+         * @returns Created developer app
+         */
+        async createDeveloperApp(data) {
+            try {
+                const res = await this.makeRequest('POST', '/api/developer/apps', data, { cache: false });
+                return res.app;
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Get a specific developer app
+         */
+        async getDeveloperApp(appId) {
+            try {
+                const res = await this.makeRequest('GET', `/api/developer/apps/${appId}`, undefined, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.LONG,
+                });
+                return res.app;
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Update a developer app
+         * @param appId - The developer app ID
+         * @param data - Updated app configuration
+         * @returns Updated developer app
+         */
+        async updateDeveloperApp(appId, data) {
+            try {
+                const res = await this.makeRequest('PATCH', `/api/developer/apps/${appId}`, data, { cache: false });
+                return res.app;
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Regenerate API secret for a developer app
+         * @param appId - The developer app ID
+         * @returns App with new secret
+         */
+        async regenerateDeveloperAppSecret(appId) {
+            try {
+                return await this.makeRequest('POST', `/api/developer/apps/${appId}/regenerate-secret`, undefined, { cache: false });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Delete a developer app
+         * @param appId - The developer app ID
+         * @returns Deletion result
+         */
+        async deleteDeveloperApp(appId) {
+            try {
+                return await this.makeRequest('DELETE', `/api/developer/apps/${appId}`, undefined, { cache: false });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+    };
+}

package/dist/esm/mixins/OxyServices.devices.js

@@ -0,0 +1,113 @@
+export function OxyServicesDevicesMixin(Base) {
+    return class extends Base {
+        constructor(...args) {
+            super(...args);
+        }
+        /**
+         * Register a new device
+         * @param deviceData - Device information
+         * @returns Registered device object
+         */
+        async registerDevice(deviceData) {
+            try {
+                return await this.makeRequest('POST', '/api/devices', deviceData, { cache: false });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Get all devices for the current user
+         * @returns Array of user devices
+         */
+        async getUserDevices() {
+            try {
+                return await this.makeRequest('GET', '/api/devices', undefined, {
+                    cache: false, // Don't cache device list - always get fresh data
+                });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Remove a device
+         * @param deviceId - The device ID to remove
+         */
+        async removeDevice(deviceId) {
+            try {
+                await this.makeRequest('DELETE', `/api/devices/${deviceId}`, undefined, { cache: false });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Get device sessions for a given session ID
+         * Note: Not cached by default to ensure fresh data
+         * @param sessionId - The session ID
+         * @returns Array of device sessions
+         */
+        async getDeviceSessions(sessionId) {
+            try {
+                // Use makeRequest for consistent error handling and optional caching
+                // Cache disabled by default to ensure fresh session data
+                return await this.makeRequest('GET', `/api/session/device/sessions/${sessionId}`, undefined, {
+                    cache: false, // Don't cache sessions - always get fresh data
+                    deduplicate: true, // Deduplicate concurrent requests for same sessionId
+                });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Logout all device sessions
+         * @param sessionId - The session ID
+         * @param deviceId - Optional device ID to target
+         * @param excludeCurrent - Whether to exclude the current session
+         * @returns Logout result
+         */
+        async logoutAllDeviceSessions(sessionId, deviceId, excludeCurrent) {
+            try {
+                const urlParams = {};
+                if (deviceId)
+                    urlParams.deviceId = deviceId;
+                if (excludeCurrent)
+                    urlParams.excludeCurrent = 'true';
+                return await this.makeRequest('POST', `/api/session/device/logout-all/${sessionId}`, urlParams, { cache: false });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Update device name
+         * @param sessionId - The session ID
+         * @param deviceName - New device name
+         * @returns Updated device object
+         */
+        async updateDeviceName(sessionId, deviceName) {
+            try {
+                return await this.makeRequest('PUT', `/api/session/device/name/${sessionId}`, { deviceName }, { cache: false });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Get security information
+         * @returns Security information object
+         */
+        async getSecurityInfo() {
+            try {
+                return await this.makeRequest('GET', '/api/devices/security', undefined, {
+                    cache: false,
+                });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+    };
+}

package/dist/esm/mixins/OxyServices.features.js

@@ -0,0 +1,306 @@
+import { CACHE_TIMES } from './mixinHelpers';
+export function OxyServicesFeaturesMixin(Base) {
+    return class extends Base {
+        constructor(...args) {
+            super(...args);
+        }
+        // ==================
+        // FEEDBACK METHODS
+        // ==================
+        /**
+         * Submit user feedback
+         */
+        async submitFeedback(payload) {
+            try {
+                return await this.makeRequest('POST', '/api/feedback', payload, {
+                    cache: false,
+                });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        // ==================
+        // SUBSCRIPTION METHODS
+        // ==================
+        /**
+         * Get available subscription plans
+         */
+        async getSubscriptionPlans() {
+            try {
+                return await this.makeRequest('GET', '/api/subscriptions/plans', undefined, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.LONG,
+                });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Get individual purchasable features
+         */
+        async getIndividualFeatures() {
+            try {
+                return await this.makeRequest('GET', '/api/subscriptions/features', undefined, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.LONG,
+                });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Subscribe to a plan
+         */
+        async subscribe(planId, paymentMethodId) {
+            return this.withAuthRetry(async () => {
+                return await this.makeRequest('POST', '/api/subscriptions/subscribe', {
+                    planId,
+                    paymentMethodId,
+                }, { cache: false });
+            }, 'subscribe');
+        }
+        /**
+         * Subscribe to an individual feature
+         */
+        async subscribeToFeature(featureId, paymentMethodId) {
+            return this.withAuthRetry(async () => {
+                return await this.makeRequest('POST', '/api/subscriptions/features/subscribe', {
+                    featureId,
+                    paymentMethodId,
+                }, { cache: false });
+            }, 'subscribeToFeature');
+        }
+        /**
+         * Cancel subscription
+         */
+        async cancelSubscription(subscriptionId) {
+            return this.withAuthRetry(async () => {
+                await this.makeRequest('POST', `/api/subscriptions/${subscriptionId}/cancel`, undefined, {
+                    cache: false,
+                });
+            }, 'cancelSubscription');
+        }
+        /**
+         * Reactivate subscription
+         */
+        async reactivateSubscription(subscriptionId) {
+            return this.withAuthRetry(async () => {
+                await this.makeRequest('POST', `/api/subscriptions/${subscriptionId}/reactivate`, undefined, {
+                    cache: false,
+                });
+            }, 'reactivateSubscription');
+        }
+        /**
+         * Get current user's subscription
+         */
+        async getCurrentSubscription() {
+            return this.withAuthRetry(async () => {
+                try {
+                    return await this.makeRequest('GET', '/api/subscriptions/current', undefined, {
+                        cache: true,
+                        cacheTTL: CACHE_TIMES.SHORT,
+                    });
+                }
+                catch (error) {
+                    if (error.status === 404)
+                        return null;
+                    throw error;
+                }
+            }, 'getCurrentSubscription');
+        }
+        // ==================
+        // SAVES/COLLECTIONS
+        // ==================
+        /**
+         * Get user's saved items
+         */
+        async getSavedItems(userId) {
+            return this.withAuthRetry(async () => {
+                const endpoint = userId ? `/api/users/${userId}/saves` : '/api/saves';
+                return await this.makeRequest('GET', endpoint, undefined, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.SHORT,
+                });
+            }, 'getSavedItems');
+        }
+        /**
+         * Get user's collections
+         */
+        async getCollections(userId) {
+            return this.withAuthRetry(async () => {
+                const endpoint = userId ? `/api/users/${userId}/collections` : '/api/collections';
+                return await this.makeRequest('GET', endpoint, undefined, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.SHORT,
+                });
+            }, 'getCollections');
+        }
+        /**
+         * Save an item
+         */
+        async saveItem(itemId, itemType, collectionId) {
+            return this.withAuthRetry(async () => {
+                return await this.makeRequest('POST', '/api/saves', {
+                    itemId,
+                    itemType,
+                    collectionId,
+                }, { cache: false });
+            }, 'saveItem');
+        }
+        /**
+         * Remove an item from saves
+         */
+        async removeSavedItem(saveId) {
+            return this.withAuthRetry(async () => {
+                await this.makeRequest('DELETE', `/api/saves/${saveId}`, undefined, { cache: false });
+            }, 'removeSavedItem');
+        }
+        /**
+         * Create a collection
+         */
+        async createCollection(name, description) {
+            return this.withAuthRetry(async () => {
+                return await this.makeRequest('POST', '/api/collections', {
+                    name,
+                    description,
+                }, { cache: false });
+            }, 'createCollection');
+        }
+        /**
+         * Delete a collection
+         */
+        async deleteCollection(collectionId) {
+            return this.withAuthRetry(async () => {
+                await this.makeRequest('DELETE', `/api/collections/${collectionId}`, undefined, { cache: false });
+            }, 'deleteCollection');
+        }
+        // ==================
+        // USER STATS
+        // ==================
+        /**
+         * Get user statistics
+         */
+        async getUserStats(userId) {
+            try {
+                return await this.makeRequest('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, limit, offset) {
+            return this.withAuthRetry(async () => {
+                const params = {};
+                if (limit)
+                    params.limit = limit;
+                if (offset)
+                    params.offset = offset;
+                const endpoint = userId ? `/api/users/${userId}/history` : '/api/history';
+                return await this.makeRequest('GET', endpoint, params, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.SHORT,
+                });
+            }, 'getUserHistory');
+        }
+        /**
+         * Clear user history
+         */
+        async clearUserHistory() {
+            return this.withAuthRetry(async () => {
+                await this.makeRequest('DELETE', '/api/history', undefined, { cache: false });
+            }, 'clearUserHistory');
+        }
+        /**
+         * Delete a history item
+         */
+        async deleteHistoryItem(itemId) {
+            return this.withAuthRetry(async () => {
+                await this.makeRequest('DELETE', `/api/history/${itemId}`, undefined, { cache: false });
+            }, 'deleteHistoryItem');
+        }
+        // ==================
+        // FAQ
+        // ==================
+        /**
+         * Get FAQs
+         */
+        async getFAQs(category) {
+            try {
+                const params = category ? { category } : undefined;
+                return await this.makeRequest('GET', '/api/faqs', params, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.LONG,
+                });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        /**
+         * Search FAQs
+         */
+        async searchFAQs(query) {
+            try {
+                return await this.makeRequest('GET', '/api/faqs/search', { query }, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.MEDIUM,
+                });
+            }
+            catch (error) {
+                throw this.handleError(error);
+            }
+        }
+        // ==================
+        // ACHIEVEMENTS
+        // ==================
+        /**
+         * Get user achievements
+         */
+        async getUserAchievements(userId) {
+            return this.withAuthRetry(async () => {
+                const endpoint = userId ? `/api/users/${userId}/achievements` : '/api/achievements';
+                return await this.makeRequest('GET', endpoint, undefined, {
+                    cache: true,
+                    cacheTTL: CACHE_TIMES.MEDIUM,
+                });
+            }, 'getUserAchievements');
+        }
+        /**
+         * Get all available achievements
+         */
+        async getAllAchievements() {
+            try {
+                return await this.makeRequest('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) {
+            return this.withAuthRetry(async () => {
+                await this.makeRequest('DELETE', '/api/account', { password }, { cache: false });
+            }, 'deleteAccount');
+        }
+    };
+}