@growsober/sdk 1.0.0

package/dist/api/queries/users.js

@@ -0,0 +1,370 @@
+"use strict";
+/**
+ * Users Query Hooks
+ *
+ * TanStack Query hooks for user-related read operations.
+ * These hooks handle fetching user data, profiles, library items, and subscriptions.
+ *
+ * @module api/queries/users
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userKeys = void 0;
+exports.useCurrentUser = useCurrentUser;
+exports.useUser = useUser;
+exports.usePublicProfile = usePublicProfile;
+exports.useMyBookmarks = useMyBookmarks;
+exports.useMyProgress = useMyProgress;
+exports.useMyRedeemedOffers = useMyRedeemedOffers;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+// ============================================================================
+// QUERY KEYS
+// ============================================================================
+/**
+ * Query key factory for user-related queries
+ * @see https://tkdodo.eu/blog/effective-react-query-keys
+ */
+exports.userKeys = {
+    all: ['users'],
+    me: () => [...exports.userKeys.all, 'me'],
+    detail: (id) => [...exports.userKeys.all, 'detail', id],
+    public: (id) => [...exports.userKeys.all, 'public', id],
+    library: {
+        all: () => [...exports.userKeys.me(), 'library'],
+        bookmarks: () => [...exports.userKeys.library.all(), 'bookmarks'],
+        progress: () => [...exports.userKeys.library.all(), 'progress'],
+    },
+    offers: {
+        all: () => [...exports.userKeys.me(), 'offers'],
+        redeemed: () => [...exports.userKeys.offers.all(), 'redeemed'],
+    },
+    subscription: () => [...exports.userKeys.me(), 'subscription'],
+};
+// ============================================================================
+// QUERY HOOKS
+// ============================================================================
+/**
+ * Get current user's profile
+ *
+ * @description
+ * Retrieves the currently authenticated user's complete profile information.
+ * Requires a valid access token to be set via the SDK configuration.
+ *
+ * @endpoint GET /api/v1/users/me
+ *
+ * @example
+ * ```tsx
+ * import { useCurrentUser } from '@growsober/sdk';
+ *
+ * function ProfileScreen() {
+ *   const { data: user, isLoading, error } = useCurrentUser();
+ *
+ *   if (isLoading) return <Spinner />;
+ *   if (error) return <Error message={error.message} />;
+ *   if (!user) return <NotFound />;
+ *
+ *   return (
+ *     <div>
+ *       <h1>{user.name}</h1>
+ *       <p>{user.email}</p>
+ *       <p>Sober Since: {user.soberDate}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * With custom options:
+ * ```tsx
+ * const { data: user } = useCurrentUser({
+ *   refetchOnMount: false,
+ *   staleTime: 5 * 60 * 1000, // 5 minutes
+ * });
+ * ```
+ *
+ * @param options - TanStack Query options for customizing the query behavior
+ * @returns TanStack Query result with user data
+ */
+function useCurrentUser(options) {
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.userKeys.me(),
+        queryFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.get('/api/v1/users/me');
+            return response.data;
+        },
+        ...options,
+    });
+}
+/**
+ * Get a specific user's full profile by ID
+ *
+ * @description
+ * Retrieves a user's complete profile information by their ID.
+ * This may include private information depending on the requesting user's permissions.
+ *
+ * @endpoint GET /api/v1/users/{id}
+ *
+ * @example
+ * ```tsx
+ * import { useUser } from '@growsober/sdk';
+ *
+ * function UserProfileScreen({ userId }: { userId: string }) {
+ *   const { data: user, isLoading } = useUser(userId);
+ *
+ *   if (isLoading) return <Spinner />;
+ *
+ *   return (
+ *     <div>
+ *       <Avatar src={user.avatar} />
+ *       <h1>{user.name}</h1>
+ *       <p>{user.bio}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * With conditional fetching:
+ * ```tsx
+ * const { data: user } = useUser(userId, {
+ *   enabled: !!userId, // Only fetch when userId is defined
+ * });
+ * ```
+ *
+ * @param id - The user ID to fetch
+ * @param options - TanStack Query options for customizing the query behavior
+ * @returns TanStack Query result with user data
+ */
+function useUser(id, options) {
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.userKeys.detail(id),
+        queryFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.get(`/api/v1/users/${id}`);
+            return response.data;
+        },
+        ...options,
+    });
+}
+/**
+ * Get a user's public profile by ID
+ *
+ * @description
+ * Retrieves a user's public profile information.
+ * This endpoint returns only publicly visible information and doesn't require authentication.
+ *
+ * @endpoint GET /api/v1/users/{id}/public
+ *
+ * @example
+ * ```tsx
+ * import { usePublicProfile } from '@growsober/sdk';
+ *
+ * function PublicProfileCard({ userId }: { userId: string }) {
+ *   const { data: profile, isLoading } = usePublicProfile(userId);
+ *
+ *   if (isLoading) return <Skeleton />;
+ *
+ *   return (
+ *     <div>
+ *       <Avatar src={profile.avatar} />
+ *       <h2>{profile.displayName}</h2>
+ *       <p>{profile.city}</p>
+ *       {profile.soberSince && (
+ *         <p>Sober since: {new Date(profile.soberSince).toLocaleDateString()}</p>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @param id - The user ID to fetch
+ * @param options - TanStack Query options for customizing the query behavior
+ * @returns TanStack Query result with public profile data
+ */
+function usePublicProfile(id, options) {
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.userKeys.public(id),
+        queryFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.get(`/api/v1/users/${id}/public`);
+            return response.data;
+        },
+        ...options,
+    });
+}
+/**
+ * Get current user's bookmarked library content
+ *
+ * @description
+ * Retrieves all library content (articles, videos, podcasts, etc.) that the user has bookmarked.
+ * This allows users to save content for later reading/viewing.
+ *
+ * @endpoint GET /api/v1/users/me/library/bookmarks
+ *
+ * @example
+ * ```tsx
+ * import { useMyBookmarks } from '@growsober/sdk';
+ *
+ * function BookmarksScreen() {
+ *   const { data: bookmarks, isLoading } = useMyBookmarks();
+ *
+ *   if (isLoading) return <Loading />;
+ *
+ *   return (
+ *     <div>
+ *       <h1>My Saved Content</h1>
+ *       {bookmarks?.map(content => (
+ *         <ContentCard key={content.id} content={content} />
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * With auto-refresh:
+ * ```tsx
+ * const { data: bookmarks } = useMyBookmarks({
+ *   refetchInterval: 60000, // Refresh every minute
+ * });
+ * ```
+ *
+ * @param options - TanStack Query options for customizing the query behavior
+ * @returns TanStack Query result with array of bookmarked content
+ */
+function useMyBookmarks(options) {
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.userKeys.library.bookmarks(),
+        queryFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.get('/api/v1/users/me/library/bookmarks');
+            return response.data;
+        },
+        ...options,
+    });
+}
+/**
+ * Get current user's library content progress
+ *
+ * @description
+ * Retrieves the user's progress on library content items.
+ * Tracks which content has been started, completed, or partially viewed/read.
+ *
+ * @endpoint GET /api/v1/users/me/library/progress
+ *
+ * @example
+ * ```tsx
+ * import { useMyProgress } from '@growsober/sdk';
+ *
+ * function LibraryProgressScreen() {
+ *   const { data: progress, isLoading } = useMyProgress();
+ *
+ *   if (isLoading) return <Loading />;
+ *
+ *   const completed = progress?.filter(p => p.completed) || [];
+ *   const inProgress = progress?.filter(p => !p.completed && p.progress > 0) || [];
+ *
+ *   return (
+ *     <div>
+ *       <h2>Completed: {completed.length}</h2>
+ *       <h2>In Progress: {inProgress.length}</h2>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * Check progress for specific content:
+ * ```tsx
+ * function ContentProgress({ contentId }: { contentId: string }) {
+ *   const { data: progress } = useMyProgress();
+ *   const contentProgress = progress?.find(p => p.contentId === contentId);
+ *
+ *   return (
+ *     <ProgressBar
+ *       value={contentProgress?.progress || 0}
+ *       max={100}
+ *     />
+ *   );
+ * }
+ * ```
+ *
+ * @param options - TanStack Query options for customizing the query behavior
+ * @returns TanStack Query result with array of progress records
+ */
+function useMyProgress(options) {
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.userKeys.library.progress(),
+        queryFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.get('/api/v1/users/me/library/progress');
+            return response.data;
+        },
+        ...options,
+    });
+}
+/**
+ * Get current user's redeemed offers
+ *
+ * @description
+ * Retrieves all offers/deals that the user has redeemed.
+ * Shows history of partner offers used by the user.
+ *
+ * @endpoint GET /api/v1/users/me/offers/redeemed
+ *
+ * @example
+ * ```tsx
+ * import { useMyRedeemedOffers } from '@growsober/sdk';
+ *
+ * function RedeemedOffersScreen() {
+ *   const { data: offers, isLoading } = useMyRedeemedOffers();
+ *
+ *   if (isLoading) return <Loading />;
+ *
+ *   return (
+ *     <div>
+ *       <h1>My Redeemed Offers</h1>
+ *       {offers?.map(offer => (
+ *         <div key={offer.id}>
+ *           <h3>{offer.title}</h3>
+ *           <p>Redeemed: {new Date(offer.redeemedAt).toLocaleDateString()}</p>
+ *           <p>Code: {offer.code}</p>
+ *         </div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * Check if specific offer was redeemed:
+ * ```tsx
+ * function OfferCard({ offerId }: { offerId: string }) {
+ *   const { data: redeemedOffers } = useMyRedeemedOffers();
+ *   const isRedeemed = redeemedOffers?.some(o => o.id === offerId);
+ *
+ *   return (
+ *     <button disabled={isRedeemed}>
+ *       {isRedeemed ? 'Already Redeemed' : 'Redeem Offer'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ *
+ * @param options - TanStack Query options for customizing the query behavior
+ * @returns TanStack Query result with array of redeemed offers
+ */
+function useMyRedeemedOffers(options) {
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.userKeys.offers.redeemed(),
+        queryFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.get('/api/v1/users/me/offers/redeemed');
+            return response.data;
+        },
+        ...options,
+    });
+}
+// Note: useMySubscription is available from '@growsober/sdk' via ./subscriptions
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"users.js","sourceRoot":"","sources":["../../../src/api/queries/users.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Users Query Hooks\n *\n * TanStack Query hooks for user-related read operations.\n * These hooks handle fetching user data, profiles, library items, and subscriptions.\n *\n * @module api/queries/users\n */\n\nimport { useQuery, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';\nimport { getApiClient } from '../client';\nimport type {\n  UserResponse,\n  UserPublicResponse,\n  LibraryContentResponse,\n  LibraryProgressResponse,\n  OfferResponse,\n  SubscriptionResponse,\n} from '../types';\n\n// ============================================================================\n// QUERY KEYS\n// ============================================================================\n\n/**\n * Query key factory for user-related queries\n * @see https://tkdodo.eu/blog/effective-react-query-keys\n */\nexport const userKeys = {\n  all: ['users'] as const,\n  me: () => [...userKeys.all, 'me'] as const,\n  detail: (id: string) => [...userKeys.all, 'detail', id] as const,\n  public: (id: string) => [...userKeys.all, 'public', id] as const,\n  library: {\n    all: () => [...userKeys.me(), 'library'] as const,\n    bookmarks: () => [...userKeys.library.all(), 'bookmarks'] as const,\n    progress: () => [...userKeys.library.all(), 'progress'] as const,\n  },\n  offers: {\n    all: () => [...userKeys.me(), 'offers'] as const,\n    redeemed: () => [...userKeys.offers.all(), 'redeemed'] as const,\n  },\n  subscription: () => [...userKeys.me(), 'subscription'] as const,\n};\n\n// ============================================================================\n// QUERY HOOKS\n// ============================================================================\n\n/**\n * Get current user's profile\n *\n * @description\n * Retrieves the currently authenticated user's complete profile information.\n * Requires a valid access token to be set via the SDK configuration.\n *\n * @endpoint GET /api/v1/users/me\n *\n * @example\n * ```tsx\n * import { useCurrentUser } from '@growsober/sdk';\n *\n * function ProfileScreen() {\n *   const { data: user, isLoading, error } = useCurrentUser();\n *\n *   if (isLoading) return <Spinner />;\n *   if (error) return <Error message={error.message} />;\n *   if (!user) return <NotFound />;\n *\n *   return (\n *     <div>\n *       <h1>{user.name}</h1>\n *       <p>{user.email}</p>\n *       <p>Sober Since: {user.soberDate}</p>\n *     </div>\n *   );\n * }\n * ```\n *\n * @example\n * With custom options:\n * ```tsx\n * const { data: user } = useCurrentUser({\n *   refetchOnMount: false,\n *   staleTime: 5 * 60 * 1000, // 5 minutes\n * });\n * ```\n *\n * @param options - TanStack Query options for customizing the query behavior\n * @returns TanStack Query result with user data\n */\nexport function useCurrentUser(\n  options?: Omit<UseQueryOptions<UserResponse>, 'queryKey' | 'queryFn'>\n): UseQueryResult<UserResponse> {\n  return useQuery({\n    queryKey: userKeys.me(),\n    queryFn: async (): Promise<UserResponse> => {\n      const client = getApiClient();\n      const response = await client.get<UserResponse>('/api/v1/users/me');\n      return response.data;\n    },\n    ...options,\n  });\n}\n\n/**\n * Get a specific user's full profile by ID\n *\n * @description\n * Retrieves a user's complete profile information by their ID.\n * This may include private information depending on the requesting user's permissions.\n *\n * @endpoint GET /api/v1/users/{id}\n *\n * @example\n * ```tsx\n * import { useUser } from '@growsober/sdk';\n *\n * function UserProfileScreen({ userId }: { userId: string }) {\n *   const { data: user, isLoading } = useUser(userId);\n *\n *   if (isLoading) return <Spinner />;\n *\n *   return (\n *     <div>\n *       <Avatar src={user.avatar} />\n *       <h1>{user.name}</h1>\n *       <p>{user.bio}</p>\n *     </div>\n *   );\n * }\n * ```\n *\n * @example\n * With conditional fetching:\n * ```tsx\n * const { data: user } = useUser(userId, {\n *   enabled: !!userId, // Only fetch when userId is defined\n * });\n * ```\n *\n * @param id - The user ID to fetch\n * @param options - TanStack Query options for customizing the query behavior\n * @returns TanStack Query result with user data\n */\nexport function useUser(\n  id: string,\n  options?: Omit<UseQueryOptions<UserResponse>, 'queryKey' | 'queryFn'>\n): UseQueryResult<UserResponse> {\n  return useQuery({\n    queryKey: userKeys.detail(id),\n    queryFn: async (): Promise<UserResponse> => {\n      const client = getApiClient();\n      const response = await client.get<UserResponse>(`/api/v1/users/${id}`);\n      return response.data;\n    },\n    ...options,\n  });\n}\n\n/**\n * Get a user's public profile by ID\n *\n * @description\n * Retrieves a user's public profile information.\n * This endpoint returns only publicly visible information and doesn't require authentication.\n *\n * @endpoint GET /api/v1/users/{id}/public\n *\n * @example\n * ```tsx\n * import { usePublicProfile } from '@growsober/sdk';\n *\n * function PublicProfileCard({ userId }: { userId: string }) {\n *   const { data: profile, isLoading } = usePublicProfile(userId);\n *\n *   if (isLoading) return <Skeleton />;\n *\n *   return (\n *     <div>\n *       <Avatar src={profile.avatar} />\n *       <h2>{profile.displayName}</h2>\n *       <p>{profile.city}</p>\n *       {profile.soberSince && (\n *         <p>Sober since: {new Date(profile.soberSince).toLocaleDateString()}</p>\n *       )}\n *     </div>\n *   );\n * }\n * ```\n *\n * @param id - The user ID to fetch\n * @param options - TanStack Query options for customizing the query behavior\n * @returns TanStack Query result with public profile data\n */\nexport function usePublicProfile(\n  id: string,\n  options?: Omit<UseQueryOptions<UserPublicResponse>, 'queryKey' | 'queryFn'>\n): UseQueryResult<UserPublicResponse> {\n  return useQuery({\n    queryKey: userKeys.public(id),\n    queryFn: async (): Promise<UserPublicResponse> => {\n      const client = getApiClient();\n      const response = await client.get<UserPublicResponse>(`/api/v1/users/${id}/public`);\n      return response.data;\n    },\n    ...options,\n  });\n}\n\n/**\n * Get current user's bookmarked library content\n *\n * @description\n * Retrieves all library content (articles, videos, podcasts, etc.) that the user has bookmarked.\n * This allows users to save content for later reading/viewing.\n *\n * @endpoint GET /api/v1/users/me/library/bookmarks\n *\n * @example\n * ```tsx\n * import { useMyBookmarks } from '@growsober/sdk';\n *\n * function BookmarksScreen() {\n *   const { data: bookmarks, isLoading } = useMyBookmarks();\n *\n *   if (isLoading) return <Loading />;\n *\n *   return (\n *     <div>\n *       <h1>My Saved Content</h1>\n *       {bookmarks?.map(content => (\n *         <ContentCard key={content.id} content={content} />\n *       ))}\n *     </div>\n *   );\n * }\n * ```\n *\n * @example\n * With auto-refresh:\n * ```tsx\n * const { data: bookmarks } = useMyBookmarks({\n *   refetchInterval: 60000, // Refresh every minute\n * });\n * ```\n *\n * @param options - TanStack Query options for customizing the query behavior\n * @returns TanStack Query result with array of bookmarked content\n */\nexport function useMyBookmarks(\n  options?: Omit<UseQueryOptions<LibraryContentResponse[]>, 'queryKey' | 'queryFn'>\n): UseQueryResult<LibraryContentResponse[]> {\n  return useQuery({\n    queryKey: userKeys.library.bookmarks(),\n    queryFn: async (): Promise<LibraryContentResponse[]> => {\n      const client = getApiClient();\n      const response = await client.get<LibraryContentResponse[]>('/api/v1/users/me/library/bookmarks');\n      return response.data;\n    },\n    ...options,\n  });\n}\n\n/**\n * Get current user's library content progress\n *\n * @description\n * Retrieves the user's progress on library content items.\n * Tracks which content has been started, completed, or partially viewed/read.\n *\n * @endpoint GET /api/v1/users/me/library/progress\n *\n * @example\n * ```tsx\n * import { useMyProgress } from '@growsober/sdk';\n *\n * function LibraryProgressScreen() {\n *   const { data: progress, isLoading } = useMyProgress();\n *\n *   if (isLoading) return <Loading />;\n *\n *   const completed = progress?.filter(p => p.completed) || [];\n *   const inProgress = progress?.filter(p => !p.completed && p.progress > 0) || [];\n *\n *   return (\n *     <div>\n *       <h2>Completed: {completed.length}</h2>\n *       <h2>In Progress: {inProgress.length}</h2>\n *     </div>\n *   );\n * }\n * ```\n *\n * @example\n * Check progress for specific content:\n * ```tsx\n * function ContentProgress({ contentId }: { contentId: string }) {\n *   const { data: progress } = useMyProgress();\n *   const contentProgress = progress?.find(p => p.contentId === contentId);\n *\n *   return (\n *     <ProgressBar\n *       value={contentProgress?.progress || 0}\n *       max={100}\n *     />\n *   );\n * }\n * ```\n *\n * @param options - TanStack Query options for customizing the query behavior\n * @returns TanStack Query result with array of progress records\n */\nexport function useMyProgress(\n  options?: Omit<UseQueryOptions<LibraryProgressResponse[]>, 'queryKey' | 'queryFn'>\n): UseQueryResult<LibraryProgressResponse[]> {\n  return useQuery({\n    queryKey: userKeys.library.progress(),\n    queryFn: async (): Promise<LibraryProgressResponse[]> => {\n      const client = getApiClient();\n      const response = await client.get<LibraryProgressResponse[]>('/api/v1/users/me/library/progress');\n      return response.data;\n    },\n    ...options,\n  });\n}\n\n/**\n * Get current user's redeemed offers\n *\n * @description\n * Retrieves all offers/deals that the user has redeemed.\n * Shows history of partner offers used by the user.\n *\n * @endpoint GET /api/v1/users/me/offers/redeemed\n *\n * @example\n * ```tsx\n * import { useMyRedeemedOffers } from '@growsober/sdk';\n *\n * function RedeemedOffersScreen() {\n *   const { data: offers, isLoading } = useMyRedeemedOffers();\n *\n *   if (isLoading) return <Loading />;\n *\n *   return (\n *     <div>\n *       <h1>My Redeemed Offers</h1>\n *       {offers?.map(offer => (\n *         <div key={offer.id}>\n *           <h3>{offer.title}</h3>\n *           <p>Redeemed: {new Date(offer.redeemedAt).toLocaleDateString()}</p>\n *           <p>Code: {offer.code}</p>\n *         </div>\n *       ))}\n *     </div>\n *   );\n * }\n * ```\n *\n * @example\n * Check if specific offer was redeemed:\n * ```tsx\n * function OfferCard({ offerId }: { offerId: string }) {\n *   const { data: redeemedOffers } = useMyRedeemedOffers();\n *   const isRedeemed = redeemedOffers?.some(o => o.id === offerId);\n *\n *   return (\n *     <button disabled={isRedeemed}>\n *       {isRedeemed ? 'Already Redeemed' : 'Redeem Offer'}\n *     </button>\n *   );\n * }\n * ```\n *\n * @param options - TanStack Query options for customizing the query behavior\n * @returns TanStack Query result with array of redeemed offers\n */\nexport function useMyRedeemedOffers(\n  options?: Omit<UseQueryOptions<OfferResponse[]>, 'queryKey' | 'queryFn'>\n): UseQueryResult<OfferResponse[]> {\n  return useQuery({\n    queryKey: userKeys.offers.redeemed(),\n    queryFn: async (): Promise<OfferResponse[]> => {\n      const client = getApiClient();\n      const response = await client.get<OfferResponse[]>('/api/v1/users/me/offers/redeemed');\n      return response.data;\n    },\n    ...options,\n  });\n}\n\n// Note: useMySubscription is available from '@growsober/sdk' via ./subscriptions\n"]}