@oxy.so/core 1.18.0 → 3.0.0

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

@@ -1,60 +0,0 @@
-/**
- * Shape of an Expo push token: `ExponentPushToken[…]` (what
- * `getExpoPushTokenAsync()` returns today) or the equivalent `ExpoPushToken[…]`
- * spelling. Deliberately plain ASCII — `@oxy.so/core` ships to Hermes, where
- * Unicode property escapes throw at runtime.
- */
-const EXPO_PUSH_TOKEN_PATTERN = /^Expo(nent)?PushToken\[[^[\]\s]+\]$/;
-export function OxyServicesNotificationsMixin(Base) {
-    return class extends Base {
-        /**
-         * Register this installation's **Expo** push token for the authenticated
-         * identity (`POST /notifications/push-token`, bearer required).
-         *
-         * Idempotent server-side: re-registering the same token for the same
-         * identity refreshes the existing row rather than creating a duplicate, so
-         * callers can safely re-register on every cold boot.
-         *
-         * @throws When `expoPushToken` is not an Expo push token — a raw APNs/FCM
-         *   device token fails here rather than becoming a silently undeliverable
-         *   registration.
-         */
-        async registerPushToken(input) {
-            try {
-                if (!EXPO_PUSH_TOKEN_PATTERN.test(input.expoPushToken)) {
-                    throw new Error('registerPushToken expects an Expo push token ("ExponentPushToken[...]", from getExpoPushTokenAsync). ' +
-                        'A raw APNs/FCM device token from getDevicePushTokenAsync cannot be delivered to.');
-                }
-                await this.makeRequest('POST', '/notifications/push-token', {
-                    token: input.expoPushToken,
-                    platform: input.platform,
-                    // Omitted entirely when absent so the body stays exactly what the
-                    // endpoint has always received (the server reads presence).
-                    ...(input.deviceId ? { deviceId: input.deviceId } : {}),
-                    ...(input.clientId ? { clientId: input.clientId } : {}),
-                }, { cache: false });
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Retire an **Expo** push token for the authenticated identity
-         * (`DELETE /notifications/push-token`, bearer required).
-         *
-         * Call it when the user turns notifications off, when the vault identity is
-         * replaced, and on sign-out — otherwise the installation keeps receiving
-         * approval requests for an identity it no longer holds.
-         *
-         * @param expoPushToken - The exact token previously registered.
-         */
-        async unregisterPushToken(expoPushToken) {
-            try {
-                await this.makeRequest('DELETE', '/notifications/push-token', { token: expoPushToken }, { cache: false });
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-    };
-}

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

@@ -1,155 +0,0 @@
-import { CACHE_TIMES } from './mixinHelpers.js';
-export function OxyServicesPaymentMixin(Base) {
-    return class extends Base {
-        constructor(...args) {
-            super(...args);
-        }
-        /**
-         * Create a payment
-         * @param data - Payment data
-         * @returns Created payment object
-         */
-        async createPayment(data) {
-            try {
-                return await this.makeRequest('POST', '/payments', data, { cache: false });
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Get payment by ID
-         * @param paymentId - The payment ID
-         * @returns Payment object
-         */
-        async getPayment(paymentId) {
-            try {
-                return await this.makeRequest('GET', `/payments/${paymentId}`, undefined, {
-                    cache: true,
-                    cacheTTL: CACHE_TIMES.LONG,
-                });
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Get user payments
-         * @returns Array of user payments
-         */
-        async getUserPayments() {
-            try {
-                return await this.makeRequest('GET', '/payments/user', undefined, {
-                    cache: false, // Don't cache user payments - always get fresh data
-                });
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Get user subscription
-         * @param userId - The user ID
-         * @returns Subscription object
-         */
-        async getSubscription(userId) {
-            try {
-                return await this.makeRequest('GET', `/subscription/${userId}`, undefined, {
-                    cache: true,
-                    cacheTTL: CACHE_TIMES.MEDIUM,
-                });
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Get current user's subscription
-         * @returns Subscription object
-         */
-        async getCurrentUserSubscription() {
-            try {
-                const userId = this.getCurrentUserId();
-                if (!userId) {
-                    throw new Error('User not authenticated');
-                }
-                return await this.getSubscription(userId);
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Get user wallet
-         * @param userId - The user ID
-         * @returns Wallet object with balance
-         */
-        async getWallet(userId) {
-            try {
-                return await this.makeRequest('GET', `/wallet/${userId}`, undefined, {
-                    cache: true,
-                    cacheTTL: CACHE_TIMES.SHORT, // Cache wallet for short time as balance changes frequently
-                });
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Get current user's wallet
-         * @returns Wallet object with balance
-         */
-        async getCurrentUserWallet() {
-            try {
-                const userId = this.getCurrentUserId();
-                if (!userId) {
-                    throw new Error('User not authenticated');
-                }
-                return await this.getWallet(userId);
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Get wallet transaction history
-         * @param userId - The user ID
-         * @param options - Pagination options
-         * @returns Transaction history
-         */
-        async getWalletTransactions(userId, options) {
-            try {
-                const params = new URLSearchParams();
-                if (options?.limit)
-                    params.append('limit', options.limit.toString());
-                if (options?.offset)
-                    params.append('offset', options.offset.toString());
-                const queryString = params.toString();
-                const url = `/wallet/transactions/${userId}${queryString ? `?${queryString}` : ''}`;
-                return await this.makeRequest('GET', url, undefined, {
-                    cache: false, // Don't cache transactions - always get fresh data
-                });
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Get current user's wallet transaction history
-         * @param options - Pagination options
-         * @returns Transaction history
-         */
-        async getCurrentUserWalletTransactions(options) {
-            try {
-                const userId = this.getCurrentUserId();
-                if (!userId) {
-                    throw new Error('User not authenticated');
-                }
-                return await this.getWalletTransactions(userId, options);
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-    };
-}

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

@@ -1,196 +0,0 @@
-import { logger } from '../logger/index.js';
-export function OxyServicesPrivacyMixin(Base) {
-    return class extends Base {
-        constructor(...args) {
-            super(...args);
-        }
-        /**
-         * Extract user ID from blocked/restricted user object
-         */
-        extractUserId(userIdField) {
-            return typeof userIdField === 'string' ? userIdField : userIdField._id;
-        }
-        /**
-         * Check if a user is in a list (blocked or restricted)
-         */
-        async isUserInList(userId, getUserList, getIdField) {
-            try {
-                if (!userId) {
-                    return false;
-                }
-                const users = await getUserList();
-                return users.some(item => {
-                    const itemId = this.extractUserId(getIdField(item));
-                    return itemId === userId;
-                });
-            }
-            catch (error) {
-                // If there's an error, assume not in list to avoid breaking functionality
-                logger.warn('Error checking user list', { component: 'OxyServices.privacy' }, error);
-                return false;
-            }
-        }
-        // ============================================================================
-        // BLOCKED USERS METHODS
-        // ============================================================================
-        /**
-         * Get list of blocked users
-         * @returns Array of blocked users
-         */
-        async getBlockedUsers() {
-            try {
-                return await this.makeRequest('GET', '/privacy/blocked', undefined, {
-                    cache: true,
-                    cacheTTL: 1 * 60 * 1000, // 1 minute cache
-                });
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Block a user.
-         *
-         * Invalidates the cached `GET /privacy/blocked` response after the write.
-         * `getBlockedUsers` caches for ~1 minute (identity-scoped); without busting
-         * that entry, a consumer that re-reads the blocked list within the TTL
-         * window would not see the user it just blocked. `clearCacheEntry` deletes
-         * every identity-scoped variant of the key.
-         * @param userId - The user ID to block
-         * @returns Success message
-         */
-        async blockUser(userId) {
-            try {
-                if (!userId) {
-                    throw new Error('User ID is required');
-                }
-                const result = await this.makeRequest('POST', `/privacy/blocked/${userId}`, undefined, {
-                    cache: false,
-                });
-                this.clearCacheEntry('GET:/privacy/blocked');
-                // The block changed the viewer's graph (`blockedIds`) — bust the cached
-                // consolidated `GET /users/me/graph` so the next read reflects it.
-                this.clearCacheEntry('GET:/users/me/graph');
-                return result;
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Unblock a user.
-         *
-         * Busts the cached `GET /privacy/blocked` response so a remount reads the
-         * fresh list without the just-unblocked user (see `blockUser`).
-         * @param userId - The user ID to unblock
-         * @returns Success message
-         */
-        async unblockUser(userId) {
-            try {
-                if (!userId) {
-                    throw new Error('User ID is required');
-                }
-                const result = await this.makeRequest('DELETE', `/privacy/blocked/${userId}`, undefined, {
-                    cache: false,
-                });
-                this.clearCacheEntry('GET:/privacy/blocked');
-                // Symmetric to blockUser: the unblock changed the viewer's `blockedIds`,
-                // so bust the consolidated `GET /users/me/graph` cache.
-                this.clearCacheEntry('GET:/users/me/graph');
-                return result;
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Check if a user is blocked
-         * @param userId - The user ID to check
-         * @returns True if the user is blocked, false otherwise
-         */
-        async isUserBlocked(userId) {
-            return this.isUserInList(userId, () => this.getBlockedUsers(), (block) => block.blockedId);
-        }
-        // ============================================================================
-        // RESTRICTED USERS METHODS
-        // ============================================================================
-        /**
-         * Get list of restricted users
-         * @returns Array of restricted users
-         */
-        async getRestrictedUsers() {
-            try {
-                return await this.makeRequest('GET', '/privacy/restricted', undefined, {
-                    cache: true,
-                    cacheTTL: 1 * 60 * 1000, // 1 minute cache
-                });
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Restrict a user (limit their interactions without fully blocking).
-         *
-         * Invalidates the cached `GET /privacy/restricted` response after the write.
-         * `getRestrictedUsers` caches for ~1 minute (identity-scoped); without
-         * busting that entry, a consumer that re-reads the restricted list within
-         * the TTL window would not see the user it just restricted.
-         * `clearCacheEntry` deletes every identity-scoped variant of the key.
-         * @param userId - The user ID to restrict
-         * @returns Success message
-         */
-        async restrictUser(userId) {
-            try {
-                if (!userId) {
-                    throw new Error('User ID is required');
-                }
-                const result = await this.makeRequest('POST', `/privacy/restricted/${userId}`, undefined, {
-                    cache: false,
-                });
-                this.clearCacheEntry('GET:/privacy/restricted');
-                // The restriction changed the viewer's graph (`restrictedIds`) — bust the
-                // cached consolidated `GET /users/me/graph` so the next read reflects it.
-                this.clearCacheEntry('GET:/users/me/graph');
-                return result;
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Unrestrict a user.
-         *
-         * Busts the cached `GET /privacy/restricted` response so a remount reads the
-         * fresh list without the just-unrestricted user (see `restrictUser`).
-         * @param userId - The user ID to unrestrict
-         * @returns Success message
-         */
-        async unrestrictUser(userId) {
-            try {
-                if (!userId) {
-                    throw new Error('User ID is required');
-                }
-                const result = await this.makeRequest('DELETE', `/privacy/restricted/${userId}`, undefined, {
-                    cache: false,
-                });
-                this.clearCacheEntry('GET:/privacy/restricted');
-                // Symmetric to restrictUser: the unrestrict changed the viewer's
-                // `restrictedIds`, so bust the consolidated `GET /users/me/graph` cache.
-                this.clearCacheEntry('GET:/users/me/graph');
-                return result;
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Check if a user is restricted
-         * @param userId - The user ID to check
-         * @returns True if the user is restricted, false otherwise
-         */
-        async isUserRestricted(userId) {
-            return this.isUserInList(userId, () => this.getRestrictedUsers(), (restrict) => restrict.restrictedId);
-        }
-    };
-}