@oxyhq/auth 1.0.0

package/dist/esm/stores/accountStore.js

@@ -0,0 +1,219 @@
+import { create } from 'zustand';
+const initialState = {
+    accounts: {},
+    accountOrder: [],
+    accountsArray: [],
+    loading: false,
+    loadingSessionIds: new Set(),
+    error: null,
+};
+// Helper: Build accounts array from accounts map and order
+const buildAccountsArray = (accounts, order) => {
+    const result = [];
+    for (const id of order) {
+        const account = accounts[id];
+        if (account)
+            result.push(account);
+    }
+    return result;
+};
+// Helper: Create QuickAccount from user data
+const createQuickAccount = (sessionId, userData, existingAccount, oxyServices) => {
+    const displayName = userData.name?.full || userData.name?.first || userData.username || 'Account';
+    const userId = userData.id || userData._id?.toString();
+    // Preserve existing avatarUrl if avatar hasn't changed (prevents image reload)
+    let avatarUrl;
+    if (existingAccount && existingAccount.avatar === userData.avatar && existingAccount.avatarUrl) {
+        avatarUrl = existingAccount.avatarUrl; // Reuse existing URL
+    }
+    else if (userData.avatar && oxyServices) {
+        avatarUrl = oxyServices.getFileDownloadUrl(userData.avatar, 'thumb');
+    }
+    return {
+        sessionId,
+        userId,
+        username: userData.username || '',
+        displayName,
+        avatar: userData.avatar,
+        avatarUrl,
+    };
+};
+export const useAccountStore = create((set, get) => ({
+    ...initialState,
+    setAccounts: (accounts) => set((state) => {
+        const accountMap = {};
+        const order = [];
+        const seenSessionIds = new Set();
+        for (const account of accounts) {
+            if (seenSessionIds.has(account.sessionId))
+                continue;
+            seenSessionIds.add(account.sessionId);
+            accountMap[account.sessionId] = account;
+            order.push(account.sessionId);
+        }
+        const accountsArray = buildAccountsArray(accountMap, order);
+        const sameOrder = order.length === state.accountOrder.length &&
+            order.every((id, i) => id === state.accountOrder[i]);
+        const sameAccounts = sameOrder &&
+            order.every(id => {
+                const existing = state.accounts[id];
+                const newAccount = accountMap[id];
+                return existing &&
+                    existing.sessionId === newAccount.sessionId &&
+                    existing.userId === newAccount.userId &&
+                    existing.avatar === newAccount.avatar &&
+                    existing.avatarUrl === newAccount.avatarUrl;
+            });
+        if (sameAccounts)
+            return {};
+        return { accounts: accountMap, accountOrder: order, accountsArray };
+    }),
+    addAccount: (account) => set((state) => {
+        // Check if account with same sessionId exists
+        if (state.accounts[account.sessionId]) {
+            // Update existing
+            const existing = state.accounts[account.sessionId];
+            if (existing.avatar === account.avatar && existing.avatarUrl === account.avatarUrl) {
+                return {}; // No change
+            }
+            const newAccounts = { ...state.accounts, [account.sessionId]: account };
+            return {
+                accounts: newAccounts,
+                accountsArray: buildAccountsArray(newAccounts, state.accountOrder),
+            };
+        }
+        const newAccounts = { ...state.accounts, [account.sessionId]: account };
+        const newOrder = [account.sessionId, ...state.accountOrder];
+        return {
+            accounts: newAccounts,
+            accountOrder: newOrder,
+            accountsArray: buildAccountsArray(newAccounts, newOrder),
+        };
+    }),
+    updateAccount: (sessionId, updates) => set((state) => {
+        const existing = state.accounts[sessionId];
+        if (!existing)
+            return {};
+        const updated = { ...existing, ...updates };
+        if (existing.avatar === updated.avatar && existing.avatarUrl === updated.avatarUrl) {
+            return {}; // No change
+        }
+        const newAccounts = { ...state.accounts, [sessionId]: updated };
+        return {
+            accounts: newAccounts,
+            accountsArray: buildAccountsArray(newAccounts, state.accountOrder),
+        };
+    }),
+    removeAccount: (sessionId) => set((state) => {
+        if (!state.accounts[sessionId])
+            return {};
+        const { [sessionId]: _removed, ...rest } = state.accounts;
+        const newOrder = state.accountOrder.filter(id => id !== sessionId);
+        return {
+            accounts: rest,
+            accountOrder: newOrder,
+            accountsArray: buildAccountsArray(rest, newOrder),
+        };
+    }),
+    moveAccountToTop: (sessionId) => set((state) => {
+        if (!state.accounts[sessionId])
+            return {};
+        const filtered = state.accountOrder.filter(id => id !== sessionId);
+        const newOrder = [sessionId, ...filtered];
+        return {
+            accountOrder: newOrder,
+            accountsArray: buildAccountsArray(state.accounts, newOrder),
+        };
+    }),
+    setLoading: (loading) => set({ loading }),
+    setLoadingSession: (sessionId, loading) => set((state) => {
+        const newSet = new Set(state.loadingSessionIds);
+        if (loading) {
+            newSet.add(sessionId);
+        }
+        else {
+            newSet.delete(sessionId);
+        }
+        return { loadingSessionIds: newSet };
+    }),
+    setError: (error) => set({ error }),
+    loadAccounts: async (sessionIds, oxyServices, existingAccounts = [], preserveOrder = true) => {
+        const state = get();
+        const uniqueSessionIds = Array.from(new Set(sessionIds));
+        if (uniqueSessionIds.length === 0) {
+            get().setAccounts([]);
+            return;
+        }
+        // Try to get data from TanStack Query cache first
+        try {
+            // This will be called from a component, so we need to access queryClient differently
+            // For now, we'll keep the API call but optimize it
+            const existingMap = new Map(existingAccounts.map(a => [a.sessionId, a]));
+            for (const account of Object.values(state.accounts)) {
+                existingMap.set(account.sessionId, account);
+            }
+            const missingSessionIds = uniqueSessionIds.filter(id => !existingMap.has(id));
+            if (missingSessionIds.length === 0) {
+                const ordered = uniqueSessionIds
+                    .map(id => existingMap.get(id))
+                    .filter((acc) => acc !== undefined);
+                get().setAccounts(ordered);
+                return;
+            }
+            if (state.loading) {
+                return;
+            }
+            set({ loading: true, error: null });
+            try {
+                const batchResults = await oxyServices.getUsersBySessions(missingSessionIds);
+                const accountMap = new Map();
+                for (const { sessionId, user: userData } of batchResults) {
+                    if (userData && !accountMap.has(sessionId)) {
+                        const existing = existingMap.get(sessionId);
+                        accountMap.set(sessionId, createQuickAccount(sessionId, userData, existing, oxyServices));
+                    }
+                }
+                for (const [sessionId, account] of accountMap) {
+                    existingMap.set(sessionId, account);
+                }
+                const orderToUse = preserveOrder ? uniqueSessionIds : [...uniqueSessionIds, ...state.accountOrder];
+                const seen = new Set();
+                const ordered = [];
+                for (const sessionId of orderToUse) {
+                    if (seen.has(sessionId))
+                        continue;
+                    seen.add(sessionId);
+                    const account = existingMap.get(sessionId);
+                    if (account)
+                        ordered.push(account);
+                }
+                get().setAccounts(ordered);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to load accounts';
+                if (__DEV__) {
+                    console.error('AccountStore: Failed to load accounts:', error);
+                }
+                set({ error: errorMessage });
+            }
+            finally {
+                set({ loading: false });
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to load accounts';
+            if (__DEV__) {
+                console.error('AccountStore: Failed to load accounts:', error);
+            }
+            set({ error: errorMessage, loading: false });
+        }
+    },
+    reset: () => set(initialState),
+}));
+// Selectors for performance - return cached array to prevent infinite loops
+export const useAccounts = () => {
+    return useAccountStore(state => state.accountsArray);
+};
+export const useAccountLoading = () => useAccountStore(s => s.loading);
+export const useAccountError = () => useAccountStore(s => s.error);
+export const useAccountLoadingSession = (sessionId) => useAccountStore(s => s.loadingSessionIds.has(sessionId));

package/dist/esm/stores/assetStore.js

@@ -0,0 +1,180 @@
+import { create } from 'zustand';
+const initialState = {
+    assets: {},
+    uploadProgress: {},
+    loading: {
+        uploading: false,
+        linking: false,
+        deleting: false,
+    },
+    errors: {},
+};
+export const useAssetStore = create((set, get) => ({
+    ...initialState,
+    // Asset management
+    setAsset: (asset) => {
+        set((state) => ({
+            assets: {
+                ...state.assets,
+                [asset.id]: asset,
+            },
+        }));
+    },
+    setAssets: (assets) => {
+        set((state) => {
+            const assetMap = assets.reduce((acc, asset) => {
+                acc[asset.id] = asset;
+                return acc;
+            }, {});
+            return {
+                assets: {
+                    ...state.assets,
+                    ...assetMap,
+                },
+            };
+        });
+    },
+    removeAsset: (assetId) => {
+        set((state) => {
+            const { [assetId]: removed, ...rest } = state.assets;
+            return { assets: rest };
+        });
+    },
+    // Upload progress
+    setUploadProgress: (fileId, progress) => {
+        set((state) => ({
+            uploadProgress: {
+                ...state.uploadProgress,
+                [fileId]: progress,
+            },
+        }));
+    },
+    removeUploadProgress: (fileId) => {
+        set((state) => {
+            const { [fileId]: removed, ...rest } = state.uploadProgress;
+            return { uploadProgress: rest };
+        });
+    },
+    // Link management
+    addLink: (assetId, link) => {
+        set((state) => {
+            const asset = state.assets[assetId];
+            if (!asset)
+                return state;
+            // Check if link already exists
+            const existingLink = asset.links.find((l) => l.app === link.app &&
+                l.entityType === link.entityType &&
+                l.entityId === link.entityId);
+            if (existingLink)
+                return state;
+            const updatedAsset = {
+                ...asset,
+                links: [...asset.links, link],
+                usageCount: asset.links.length + 1,
+            };
+            return {
+                assets: {
+                    ...state.assets,
+                    [assetId]: updatedAsset,
+                },
+            };
+        });
+    },
+    removeLink: (assetId, app, entityType, entityId) => {
+        set((state) => {
+            const asset = state.assets[assetId];
+            if (!asset)
+                return state;
+            const filteredLinks = asset.links.filter((link) => !(link.app === app &&
+                link.entityType === entityType &&
+                link.entityId === entityId));
+            const updatedAsset = {
+                ...asset,
+                links: filteredLinks,
+                usageCount: filteredLinks.length,
+                status: filteredLinks.length === 0 ? 'trash' : asset.status,
+            };
+            return {
+                assets: {
+                    ...state.assets,
+                    [assetId]: updatedAsset,
+                },
+            };
+        });
+    },
+    // Loading states
+    setUploading: (uploading) => {
+        set((state) => ({
+            loading: { ...state.loading, uploading },
+        }));
+    },
+    setLinking: (linking) => {
+        set((state) => ({
+            loading: { ...state.loading, linking },
+        }));
+    },
+    setDeleting: (deleting) => {
+        set((state) => ({
+            loading: { ...state.loading, deleting },
+        }));
+    },
+    // Error management
+    setUploadError: (error) => {
+        set((state) => ({
+            errors: { ...state.errors, upload: error },
+        }));
+    },
+    setLinkError: (error) => {
+        set((state) => ({
+            errors: { ...state.errors, link: error },
+        }));
+    },
+    setDeleteError: (error) => {
+        set((state) => ({
+            errors: { ...state.errors, delete: error },
+        }));
+    },
+    clearErrors: () => {
+        set({ errors: {} });
+    },
+    // Utility methods
+    getAssetsByApp: (app) => {
+        const { assets } = get();
+        return Object.values(assets).filter((asset) => asset.links.some((link) => link.app === app));
+    },
+    getAssetsByEntity: (app, entityType, entityId) => {
+        const { assets } = get();
+        return Object.values(assets).filter((asset) => asset.links.some((link) => link.app === app &&
+            link.entityType === entityType &&
+            link.entityId === entityId));
+    },
+    getAssetUsageCount: (assetId) => {
+        const { assets } = get();
+        const asset = assets[assetId];
+        return asset ? asset.usageCount : 0;
+    },
+    isAssetLinked: (assetId, app, entityType, entityId) => {
+        const { assets } = get();
+        const asset = assets[assetId];
+        if (!asset)
+            return false;
+        return asset.links.some((link) => link.app === app &&
+            link.entityType === entityType &&
+            link.entityId === entityId);
+    },
+    // Reset store
+    reset: () => {
+        set(initialState);
+    },
+}));
+// Selector hooks for convenience
+export const useAssets = () => useAssetStore((state) => Object.values(state.assets));
+export const useAsset = (assetId) => useAssetStore((state) => state.assets[assetId]);
+export const useUploadProgress = () => useAssetStore((state) => state.uploadProgress);
+export const useAssetLoading = () => useAssetStore((state) => state.loading);
+export const useAssetErrors = () => useAssetStore((state) => state.errors);
+// Typed selectors for specific use cases
+export const useAssetsByApp = (app) => useAssetStore((state) => state.getAssetsByApp(app));
+export const useAssetsByEntity = (app, entityType, entityId) => useAssetStore((state) => state.getAssetsByEntity(app, entityType, entityId));
+export const useAssetUsageCount = (assetId) => useAssetStore((state) => state.getAssetUsageCount(assetId));
+export const useIsAssetLinked = (assetId, app, entityType, entityId) => useAssetStore((state) => state.isAssetLinked(assetId, app, entityType, entityId));

package/dist/esm/stores/authStore.js

@@ -0,0 +1,44 @@
+import { create } from 'zustand';
+import { createDebugLogger } from '@oxyhq/core';
+const debug = createDebugLogger('AuthStore');
+export const useAuthStore = create((set, get) => ({
+    user: null,
+    isAuthenticated: false,
+    isLoading: false,
+    error: null,
+    lastUserFetch: null,
+    loginSuccess: (user) => set({
+        isLoading: false,
+        isAuthenticated: true,
+        user,
+        lastUserFetch: Date.now(),
+    }),
+    loginFailure: (error) => set({ isLoading: false, error }),
+    logout: () => set({
+        user: null,
+        isAuthenticated: false,
+        lastUserFetch: null,
+    }),
+    setUser: (user) => set({ user, lastUserFetch: Date.now() }),
+    fetchUser: async (oxyServices, forceRefresh = false) => {
+        const state = get();
+        const now = Date.now();
+        const cacheAge = state.lastUserFetch ? now - state.lastUserFetch : Number.POSITIVE_INFINITY;
+        const cacheValid = cacheAge < 5 * 60 * 1000; // 5 minutes cache
+        // Use cached data if available and not forcing refresh
+        if (!forceRefresh && state.user && cacheValid) {
+            debug.log('Using cached user data (age:', cacheAge, 'ms)');
+            return;
+        }
+        set({ isLoading: true, error: null });
+        try {
+            const user = await oxyServices.getCurrentUser();
+            set({ user, isLoading: false, isAuthenticated: true, lastUserFetch: now });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to fetch user';
+            debug.error('Error fetching user:', error);
+            set({ error: errorMessage, isLoading: false });
+        }
+    },
+}));

package/dist/esm/stores/followStore.js

@@ -0,0 +1,151 @@
+import { create } from 'zustand';
+export const useFollowStore = create((set, get) => ({
+    followingUsers: {},
+    loadingUsers: {},
+    fetchingUsers: {},
+    errors: {},
+    followerCounts: {},
+    followingCounts: {},
+    loadingCounts: {},
+    setFollowingStatus: (userId, isFollowing) => set((state) => ({
+        followingUsers: { ...state.followingUsers, [userId]: isFollowing },
+        errors: { ...state.errors, [userId]: null },
+    })),
+    clearFollowError: (userId) => set((state) => ({
+        errors: { ...state.errors, [userId]: null },
+    })),
+    resetFollowState: () => set({
+        followingUsers: {},
+        loadingUsers: {},
+        fetchingUsers: {},
+        errors: {},
+        followerCounts: {},
+        followingCounts: {},
+        loadingCounts: {},
+    }),
+    fetchFollowStatus: async (userId, oxyServices) => {
+        set((state) => ({
+            fetchingUsers: { ...state.fetchingUsers, [userId]: true },
+            errors: { ...state.errors, [userId]: null },
+        }));
+        try {
+            const response = await oxyServices.getFollowStatus(userId);
+            set((state) => ({
+                followingUsers: { ...state.followingUsers, [userId]: response.isFollowing },
+                fetchingUsers: { ...state.fetchingUsers, [userId]: false },
+                errors: { ...state.errors, [userId]: null },
+            }));
+        }
+        catch (error) {
+            set((state) => ({
+                fetchingUsers: { ...state.fetchingUsers, [userId]: false },
+                errors: { ...state.errors, [userId]: error?.message || 'Failed to fetch follow status' },
+            }));
+        }
+    },
+    toggleFollowUser: async (userId, oxyServices, isCurrentlyFollowing) => {
+        set((state) => ({
+            loadingUsers: { ...state.loadingUsers, [userId]: true },
+            errors: { ...state.errors, [userId]: null },
+        }));
+        try {
+            let response;
+            let newFollowState;
+            if (isCurrentlyFollowing) {
+                response = await oxyServices.unfollowUser(userId);
+                newFollowState = false;
+            }
+            else {
+                response = await oxyServices.followUser(userId);
+                newFollowState = true;
+            }
+            // Update follow status
+            set((state) => ({
+                followingUsers: { ...state.followingUsers, [userId]: newFollowState },
+                loadingUsers: { ...state.loadingUsers, [userId]: false },
+                errors: { ...state.errors, [userId]: null },
+            }));
+            // Update counts if the response includes them
+            // The API returns counts for both users:
+            // - followers: target user's follower count (the user being followed)
+            // - following: current user's following count (the user doing the following)
+            if (response && response.counts) {
+                const { counts } = response;
+                // Get current user ID from oxyServices
+                const currentUserId = oxyServices.getCurrentUserId();
+                set((state) => {
+                    const updates = {};
+                    // Update target user's follower count (the user being followed)
+                    updates.followerCounts = {
+                        ...state.followerCounts,
+                        [userId]: counts.followers
+                    };
+                    // Update current user's following count (the user doing the following)
+                    if (currentUserId) {
+                        updates.followingCounts = {
+                            ...state.followingCounts,
+                            [currentUserId]: counts.following
+                        };
+                    }
+                    return updates;
+                });
+            }
+        }
+        catch (error) {
+            set((state) => ({
+                loadingUsers: { ...state.loadingUsers, [userId]: false },
+                errors: { ...state.errors, [userId]: error?.message || 'Failed to update follow status' },
+            }));
+        }
+    },
+    setFollowerCount: (userId, count) => set((state) => ({
+        followerCounts: { ...state.followerCounts, [userId]: count },
+    })),
+    setFollowingCount: (userId, count) => set((state) => ({
+        followingCounts: { ...state.followingCounts, [userId]: count },
+    })),
+    updateCountsFromFollowAction: (targetUserId, action, counts, currentUserId) => {
+        set((state) => {
+            const updates = {};
+            // Update target user's follower count (the user being followed)
+            updates.followerCounts = {
+                ...state.followerCounts,
+                [targetUserId]: counts.followers
+            };
+            // Update current user's following count (the user doing the following)
+            if (currentUserId) {
+                updates.followingCounts = {
+                    ...state.followingCounts,
+                    [currentUserId]: counts.following
+                };
+            }
+            return updates;
+        });
+    },
+    fetchUserCounts: async (userId, oxyServices) => {
+        set((state) => ({
+            loadingCounts: { ...state.loadingCounts, [userId]: true },
+        }));
+        try {
+            const user = await oxyServices.getUserById(userId);
+            if (user && user._count) {
+                set((state) => ({
+                    followerCounts: {
+                        ...state.followerCounts,
+                        [userId]: user._count?.followers || 0
+                    },
+                    followingCounts: {
+                        ...state.followingCounts,
+                        [userId]: user._count?.following || 0
+                    },
+                    loadingCounts: { ...state.loadingCounts, [userId]: false },
+                }));
+            }
+        }
+        catch (error) {
+            set((state) => ({
+                loadingCounts: { ...state.loadingCounts, [userId]: false },
+            }));
+        }
+    },
+}));