@turtleclub/hooks 0.5.0-beta.2 → 0.5.0-beta.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@turtleclub/hooks",
   "type": "module",
-  "version": "0.5.0-beta.2",
+  "version": "0.5.0-beta.4",
   "license": "MIT",
   "exports": {
     ".": {
@@ -54,5 +54,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "09d5d186b6253d8315b6e69aae3921d6850cddb2"
+  "gitHead": "eb8863ed74fbff69137de45e4670779a4a4f11e6"
 }

package/src/v2/incentives/api.ts

@@ -11,12 +11,12 @@ import {
   uploadIncentiveIconResponseSchema,
 } from "./schema";
 
-// GET /admin/incentives
+// GET /turtle/incentives
 export async function getIncentives(): Promise<IncentivesResponse> {
   const params = new URLSearchParams();
 
   const queryString = params.toString();
-  const endpoint = `/admin/incentives${queryString ? `?${queryString}` : ""}`;
+  const endpoint = `/turtle/incentives${queryString ? `?${queryString}` : ""}`;
 
   const data = await apiClient.fetch(endpoint, {
     method: "GET",

package/src/v2/index.ts

@@ -9,6 +9,7 @@ import { ensoBalancesQueries } from "./enso-balances/queries";
 import { widgetQueries } from "./widget/queries";
 import { supportedChainsQueries } from "./supported-chains/queries";
 import { supportedTokensQueries } from "./supported-tokens/queries";
+import { usersQueries } from "./users/queries";
 
 // Merged query keys for cache invalidation
 export const queries = mergeQueryKeys(
@@ -21,7 +22,8 @@ export const queries = mergeQueryKeys(
   ensoBalancesQueries,
   widgetQueries,
   supportedChainsQueries,
-  supportedTokensQueries
+  supportedTokensQueries,
+  usersQueries
 );
 
 // Features - Earn API
@@ -40,12 +42,13 @@ export * from "./supported-chains";
 export * from "./supported-tokens";
 export * from "./geocheck";
 export * from "./swap";
+export * from "./users";
 
 // Shared schemas
 export * from "./schemas/shared";
 
 // Provider & Client
-export { TurtleProvider } from "./lib/turtle-provider";
-export type { TurtleProviderProps } from "./lib/turtle-provider";
+export { TurtleHooksProvider } from "./lib/turtle-provider";
+export type { TurtleHooksProviderProps } from "./lib/turtle-provider";
 export { apiClient, ApiError } from "./lib/api-client";
 export type { ApiClientConfig, ApiClientOptions, ApiDomain } from "./lib/api-client";

package/src/v2/lib/turtle-provider.tsx

@@ -3,7 +3,7 @@
 import React, { useEffect, useMemo } from "react";
 import { apiClient, type ApiClientConfig } from "./api-client";
 
-export interface TurtleProviderProps extends ApiClientConfig {
+export interface TurtleHooksProviderProps extends ApiClientConfig {
   children: React.ReactNode;
 }
 
@@ -28,13 +28,13 @@ export interface TurtleProviderProps extends ApiClientConfig {
  * }
  * ```
  */
-export function TurtleProvider({
+export function TurtleHooksProvider({
   children,
   apiUrl,
   earnUrl,
   getToken,
   debug,
-}: TurtleProviderProps) {
+}: TurtleHooksProviderProps) {
   const config = useMemo(
     () => ({ apiUrl, earnUrl, getToken, debug }),
     [apiUrl, earnUrl, getToken, debug]

package/src/v2/products/api.ts

@@ -16,16 +16,14 @@ import {
   UploadProductLogoResponseSchema,
 } from "./schema";
 
-// GET /admin/products
-export async function getProducts(
-  filters?: ProductFilters
-): Promise<ProductsResponse> {
+// GET /turtle/products
+export async function getProducts(filters?: ProductFilters): Promise<ProductsResponse> {
   const params = new URLSearchParams();
 
   if (filters?.organizationId) params.append("organizationId", filters.organizationId);
 
   const queryString = params.toString();
-  const endpoint = `/admin/products${queryString ? `?${queryString}` : ""}`;
+  const endpoint = `/turtle/products${queryString ? `?${queryString}` : ""}`;
 
   const data = await apiClient.fetch(endpoint, {
     method: "GET",
@@ -41,9 +39,9 @@ export async function getProducts(
   return result.data;
 }
 
-// GET /admin/products/:id
+// GET /turtle/products/:id
 export async function getProduct(id: string): Promise<ProductResponse> {
-  const endpoint = `/admin/products/${id}`;
+  const endpoint = `/turtle/products/${id}`;
 
   const data = await apiClient.fetch(endpoint, {
     method: "GET",
@@ -60,9 +58,7 @@ export async function getProduct(id: string): Promise<ProductResponse> {
 }
 
 // POST /admin/products
-export async function createProduct(
-  input: CreateProductInput
-): Promise<CreateProductResponse> {
+export async function createProduct(input: CreateProductInput): Promise<CreateProductResponse> {
   const endpoint = `/admin/products`;
 
   const data = await apiClient.fetch(endpoint, {
@@ -81,9 +77,7 @@ export async function createProduct(
 }
 
 // PUT /admin/products/:id
-export async function updateProduct(
-  input: UpdateProductInput
-): Promise<UpdateProductResponse> {
+export async function updateProduct(input: UpdateProductInput): Promise<UpdateProductResponse> {
   const endpoint = `/admin/products/${input.product.id}`;
 
   const data = await apiClient.fetch(endpoint, {

package/src/v2/users/api.ts

@@ -0,0 +1,48 @@
+import { apiClient } from "../lib/api-client";
+import {
+  GetUserByIdInput,
+  GetUserByIdOutput,
+  getUserByIdOutputSchema,
+  GetUserTurtlePortfolioInput,
+  GetUserTurtlePortfolioOutput,
+  getUserTurtlePortfolioOutputSchema,
+} from "./schemas";
+
+// GET /admin/users/:userId
+export async function getUserById(input: GetUserByIdInput): Promise<GetUserByIdOutput> {
+  console.log("input", input);
+  const endpoint = `/admin/users/${input.userId}`;
+
+  const data = await apiClient.fetch(endpoint, {
+    method: "GET",
+  });
+
+  // Validate response with Zod
+  const result = getUserByIdOutputSchema.safeParse(data);
+
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to parse user: ${result.error.message}`);
+  }
+  return result.data;
+}
+
+// GET /admin/users/:userId/portfolio
+export async function getUserPortfolio(
+  input: GetUserTurtlePortfolioInput
+): Promise<GetUserTurtlePortfolioOutput> {
+  const endpoint = `/admin/users/${input.userId}/portfolio`;
+
+  const data = await apiClient.fetch(endpoint, {
+    method: "GET",
+  });
+
+  // Validate response with Zod
+  const result = getUserTurtlePortfolioOutputSchema.safeParse(data);
+
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to parse user portfolio: ${result.error.message}`);
+  }
+  return result.data;
+}

package/src/v2/users/hooks.ts

@@ -0,0 +1,32 @@
+import { useQuery } from "@tanstack/react-query";
+import { queryDefaults } from "../lib/query-config";
+import type { GetUserByIdInput, GetUserTurtlePortfolioInput } from "./schemas";
+import { usersQueries } from "./queries";
+
+export interface UseUserByIdOptions {
+  userId: string;
+  enabled?: boolean;
+}
+
+export function useUserById({ userId, enabled = true }: UseUserByIdOptions) {
+  return useQuery({
+    ...usersQueries.byId({ userId }),
+    ...queryDefaults,
+    enabled,
+  });
+}
+
+export interface UseUserPortfolioOptions {
+  userId: string;
+  enabled?: boolean;
+}
+
+export function useUserPortfolio({ userId, enabled = true }: UseUserPortfolioOptions) {
+  const input: GetUserTurtlePortfolioInput = { userId };
+
+  return useQuery({
+    ...usersQueries.portfolio(input),
+    ...queryDefaults,
+    enabled,
+  });
+}

package/src/v2/users/index.ts

@@ -0,0 +1,13 @@
+// Hooks
+export { useUserById, useUserPortfolio } from "./hooks";
+
+export type { UseUserByIdOptions, UseUserPortfolioOptions } from "./hooks";
+
+// Query keys
+export { usersQueries } from "./queries";
+
+// API functions
+export { getUserById, getUserPortfolio } from "./api";
+
+// Schemas and types
+export * from "./schemas";

package/src/v2/users/queries.ts

@@ -0,0 +1,14 @@
+import { createQueryKeys } from "@lukemorales/query-key-factory";
+import { getUserById, getUserPortfolio } from "./api";
+import type { GetUserByIdInput, GetUserTurtlePortfolioInput } from "./schemas";
+
+export const usersQueries = createQueryKeys("users", {
+  byId: (input: GetUserByIdInput) => ({
+    queryKey: [input.userId],
+    queryFn: () => getUserById(input),
+  }),
+  portfolio: (input: GetUserTurtlePortfolioInput) => ({
+    queryKey: ["portfolio", input.userId],
+    queryFn: () => getUserPortfolio(input),
+  }),
+});

package/src/v2/users/schemas.ts

@@ -0,0 +1,109 @@
+import { z } from "zod";
+import { chainSchema, tokenSchema } from "../schemas/shared";
+
+// Wallet Data Schema
+const walletDataSchema = z.object({
+  address: z.string(),
+  totalAmountInUSD: z.string(),
+  tokens: z.array(tokenSchema),
+});
+
+// Holdings Data Schema
+const holdingsDataSchema = z.object({
+  totalAmountInUSD: z.string(),
+  chains: z.array(chainSchema).nullish(),
+  wallets: z.array(walletDataSchema).nullish(),
+});
+
+// User Earnings Schema
+const userEarningsSchema = z.object({
+  productId: z.string().uuid(),
+  value: z.number(),
+  referralsEarnings: z.number().nullish(),
+  rewardName: z.string().nullish(),
+  rewardType: z.string().nullish(),
+});
+
+// Portfolio Schema
+const portfolioSchema = z.object({
+  productsEarnings: z.array(userEarningsSchema),
+  holdings: holdingsDataSchema.nullish(),
+});
+
+// Holding Info Schema
+const holdingInfoSchema = z.object({
+  amount: z.number(),
+  usdValue: z.number(),
+  token: tokenSchema.nullish(),
+});
+
+// Wallet Info Schema
+const walletInfoSchema = z.object({
+  address: z.string().nullish(),
+  ecosystem: z.string().nullish(),
+  isMain: z.boolean().nullish(),
+  holdings: z.array(holdingInfoSchema).nullish(),
+});
+
+// User With Details Schema
+const userWithDetailsSchema = z.object({
+  id: z.string(),
+  email: z.string().nullable(),
+  username: z.string().nullish(),
+  firstName: z.string().nullish(),
+  lastName: z.string().nullish(),
+  avatarUrl: z.string().nullish(),
+  telegramHandle: z.string().nullish(),
+  xUsername: z.string().nullish(),
+  role: z.string(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  tags: z.array(z.string()).nullish(),
+  wallets: z.array(walletInfoSchema).nullish(),
+});
+
+// GetUserTurtlePortfolioHandler Input Schema
+export const getUserTurtlePortfolioInputSchema = z.object({
+  userId: z.string().uuid(),
+});
+
+// GetUserTurtlePortfolioHandler Output Schema
+export const getUserTurtlePortfolioOutputSchema = z.object({
+  portfolio: portfolioSchema,
+});
+
+// Path Parameters Schema (for URL params)
+export const getUserTurtlePortfolioPathSchema = z.object({
+  userId: z.string().uuid(),
+});
+
+// GetUserByIDHandler Input Schema
+export const getUserByIdInputSchema = z.object({
+  userId: z.string().uuid(),
+});
+
+// GetUserByIDHandler Output Schema
+export const getUserByIdOutputSchema = z.object({
+  user: userWithDetailsSchema.nullable(),
+  error: z.string().optional(),
+});
+
+// Type exports
+export type GetUserByIdInput = z.infer<typeof getUserByIdInputSchema>;
+export type GetUserByIdOutput = z.infer<typeof getUserByIdOutputSchema>;
+export type GetUserTurtlePortfolioInput = z.infer<typeof getUserTurtlePortfolioInputSchema>;
+export type GetUserTurtlePortfolioOutput = z.infer<typeof getUserTurtlePortfolioOutputSchema>;
+export type UserWithDetails = z.infer<typeof userWithDetailsSchema>;
+export type WalletData = z.infer<typeof walletDataSchema>;
+export type HoldingsData = z.infer<typeof holdingsDataSchema>;
+export type Portfolio = z.infer<typeof portfolioSchema>;
+export type UserEarnings = z.infer<typeof userEarningsSchema>;
+
+// Export individual schemas if needed
+export {
+  walletDataSchema,
+  holdingsDataSchema,
+  userEarningsSchema,
+  portfolioSchema,
+  userWithDetailsSchema,
+};