@turtleclub/hooks 0.4.0-beta.6 → 0.4.0-beta.7

package/dist/index.cjs

@@ -103,6 +103,7 @@ __export(index_exports, {
   useSignup: () => useSignup,
   useTokenBalance: () => useTokenBalance,
   useUpdateProduct: () => useUpdateProduct,
+  useUploadProductLogo: () => useUploadProductLogo,
   useWidgetOpportunities: () => useWidgetOpportunities,
   vaultConfigSchema: () => vaultConfigSchema,
   walletBalanceSchema: () => walletBalanceSchema,
@@ -1073,110 +1074,219 @@ var earnDepositsQueries = (0, import_query_key_factory5.createQueryKeys)("earnDe
 // src/v2/products/queries.ts
 var import_query_key_factory6 = require("@lukemorales/query-key-factory");
 
+// src/v2/lib/authenticated-api-client.ts
+async function authenticatedApiClient(endpoint, options, token = null) {
+  return apiClient(endpoint, {
+    ...options,
+    headers: {
+      ...token && { Authorization: `Bearer ${token}` },
+      ...options?.headers
+    }
+  });
+}
+
 // src/v2/products/schema.ts
 var import_zod7 = require("zod");
-var productsResponseSchema = import_zod7.z.object({
-  products: import_zod7.z.array(productSchema),
-  total: import_zod7.z.number().optional()
+var ProductTypeSchema = import_zod7.z.enum(["deal", "campaign"]);
+var ProductStatusSchema = import_zod7.z.enum(["active", "paused", "ended"]);
+var TurtleOrganizationSchema = import_zod7.z.object({
+  id: import_zod7.z.string().uuid(),
+  name: import_zod7.z.string(),
+  iconUrl: import_zod7.z.string(),
+  landingUrl: import_zod7.z.string()
 });
-var productCreateInputSchema = import_zod7.z.object({
+var ProductSchema = import_zod7.z.object({
+  id: import_zod7.z.string().uuid(),
   name: import_zod7.z.string(),
-  title: import_zod7.z.string().optional().nullable(),
-  subtitle: import_zod7.z.string().optional().nullable(),
-  description: import_zod7.z.string().optional().nullable(),
-  logoUrl: import_zod7.z.string().optional().nullable(),
-  productUrl: import_zod7.z.string().optional().nullable(),
+  title: import_zod7.z.string(),
+  subtitle: import_zod7.z.string(),
+  description: import_zod7.z.string(),
+  logoUrl: import_zod7.z.string(),
+  productUrl: import_zod7.z.string(),
   startedAt: import_zod7.z.string().optional().nullable(),
-  status: import_zod7.z.string().optional().nullable(),
-  productType: import_zod7.z.string().optional().nullable(),
-  // Relations
+  endedAt: import_zod7.z.string().optional().nullable(),
+  status: ProductStatusSchema,
+  productType: ProductTypeSchema,
+  organization: TurtleOrganizationSchema.nullable(),
+  createdAt: import_zod7.z.string()
+});
+var CreateProductInputSchema = import_zod7.z.object({
+  product: ProductSchema.omit({
+    id: true,
+    createdAt: true,
+    organization: true
+  }),
   organizationId: import_zod7.z.string().uuid()
 });
-var productUpdateInputSchema = productCreateInputSchema.extend({
+var UpdateProductInputSchema = import_zod7.z.object({
+  product: ProductSchema.partial().omit({
+    organization: true
+  })
+  // organizationId: z.string().uuid(),
+});
+var ProductsResponseSchema = import_zod7.z.object({
+  products: import_zod7.z.array(ProductSchema),
+  total: import_zod7.z.number().optional()
+});
+var ProductResponseSchema = import_zod7.z.object({
+  product: ProductSchema
+});
+var CreateProductResponseSchema = import_zod7.z.object({
   id: import_zod7.z.string().uuid()
 });
+var UpdateProductResponseSchema = import_zod7.z.object({
+  success: import_zod7.z.boolean()
+});
+var fileSchema = import_zod7.z.any().refine((value) => {
+  if (!value) return false;
+  if (!(value instanceof File)) return false;
+  if (value.size > 10 * 1024 * 1024) return false;
+  return true;
+}, "Invalid file");
+var UploadProductLogoRequestSchema = import_zod7.z.object({
+  // Form data - file upload (required)
+  file: fileSchema,
+  // Form data - optional filename override
+  filename: import_zod7.z.string().optional()
+});
+var UploadProductLogoResponseSchema = import_zod7.z.object({
+  url: import_zod7.z.string().url(),
+  error: import_zod7.z.string().optional()
+});
+var ProductFiltersSchema = import_zod7.z.object({
+  organizationId: import_zod7.z.string().uuid().optional()
+});
 
 // src/v2/products/api.ts
-async function getProducts(options) {
+async function getProducts(filters, token) {
   const params = new URLSearchParams();
+  if (filters?.organizationId) params.append("organizationId", filters.organizationId);
   const queryString = params.toString();
   const endpoint = `/admin/products${queryString ? `?${queryString}` : ""}`;
-  const data = await apiClient(endpoint, {
-    method: "GET",
-    debug: options?.debug
-  });
-  const result = productsResponseSchema.safeParse(data);
+  console.log("endpoint", endpoint, filters);
+  const data = await authenticatedApiClient(
+    endpoint,
+    {
+      method: "GET"
+    },
+    token
+  );
+  const result = ProductsResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
     throw new Error(`Failed to parse products: ${result.error.message}`);
   }
   return result.data;
 }
-async function createProduct(input, options) {
+async function getProduct(id, token) {
+  const endpoint = `/admin/products/${id}`;
+  const data = await authenticatedApiClient(
+    endpoint,
+    {
+      method: "GET"
+    },
+    token
+  );
+  console.log(data);
+  const result = ProductResponseSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to parse product: ${result.error.message}`);
+  }
+  return result.data;
+}
+async function createProduct(input, token) {
   const endpoint = `/admin/products`;
-  const data = await apiClient(endpoint, {
-    method: "POST",
-    body: JSON.stringify(input),
-    headers: {
-      "Content-Type": "application/json"
+  const data = await authenticatedApiClient(
+    endpoint,
+    {
+      method: "POST",
+      body: JSON.stringify(input),
+      headers: {
+        "Content-Type": "application/json"
+      }
     },
-    debug: options?.debug
-  });
-  const result = productSchema.safeParse(data);
+    token
+  );
+  const result = CreateProductResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
     throw new Error(`Failed to create product: ${result.error.message}`);
   }
   return result.data;
 }
-async function updateProduct(input, options) {
-  const endpoint = `/admin/products/${input.id}`;
-  const data = await apiClient(endpoint, {
-    method: "PUT",
-    body: JSON.stringify(input),
-    headers: {
-      "Content-Type": "application/json"
+async function updateProduct(input, token) {
+  const endpoint = `/admin/products/${input.product.id}`;
+  const data = await authenticatedApiClient(
+    endpoint,
+    {
+      method: "PUT",
+      body: JSON.stringify(input),
+      headers: {
+        "Content-Type": "application/json"
+      }
     },
-    debug: options?.debug
-  });
-  const result = productSchema.safeParse(data);
+    token
+  );
+  const result = UpdateProductResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
     throw new Error(`Failed to update product: ${result.error.message}`);
   }
   return result.data;
 }
-async function deleteProduct(id, options) {
+async function deleteProduct(id, token) {
   const endpoint = `/admin/products/${id}`;
-  const data = await apiClient(endpoint, {
-    method: "DELETE",
-    headers: {
-      "Content-Type": "application/json"
+  const data = await authenticatedApiClient(
+    endpoint,
+    {
+      method: "DELETE",
+      headers: {
+        "Content-Type": "application/json"
+      }
     },
-    debug: options?.debug
-  });
-  const result = productSchema.safeParse(data);
+    token
+  );
+  const result = ProductResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
     throw new Error(`Failed to delete product: ${result.error.message}`);
   }
 }
+async function uploadProductLogo({ file, filename }, token) {
+  const endpoint = `/admin/products/upload-logo`;
+  const formData = new FormData();
+  formData.append("file", file, filename || file.name);
+  const data = await authenticatedApiClient(
+    endpoint,
+    {
+      method: "POST",
+      body: formData
+    },
+    token
+  );
+  const result = UploadProductLogoResponseSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to upload product logo: ${result.error.message}`);
+  }
+  return result.data;
+}
 
 // src/v2/products/queries.ts
 var productsQueries = (0, import_query_key_factory6.createQueryKeys)("products", {
   // Get all products (no filters)
-  all: {
-    queryKey: null,
-    queryFn: () => getProducts()
-  },
-  // Get single product by ID
-  byId: (id) => ({
+  all: (token) => ({
+    queryKey: ["all"],
+    queryFn: () => getProducts(void 0, token)
+  }),
+  list: (filters, token) => ({
+    queryKey: [{ filters }],
+    queryFn: () => getProducts(filters, token)
+  }),
+  byId: (id, token) => ({
     queryKey: [id],
-    // Replace by true query then
-    queryFn: async () => {
-      const products = await getProducts();
-      return products.products.find((product) => product.id === id);
-    }
+    queryFn: () => getProduct(id, token)
   })
 });
 
@@ -1415,38 +1525,84 @@ function useOpportunity({ id, ...options }) {
 
 // src/v2/products/hooks.ts
 var import_react_query23 = require("@tanstack/react-query");
-function useProducts(options) {
-  return (0, import_react_query23.useQuery)({ ...productsQueries.all, ...queryDefaults });
+
+// src/v2/lib/auth-provider.tsx
+var import_react2 = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var AuthContext = (0, import_react2.createContext)(null);
+function AuthProvider({ getToken, children }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AuthContext.Provider, { value: { getToken }, children });
+}
+function useAuthToken() {
+  const context = (0, import_react2.useContext)(AuthContext);
+  if (!context) {
+    throw new Error("useAuthToken must be used within AuthProvider");
+  }
+  return context;
 }
-function useProduct({ id, ...options }) {
-  return (0, import_react_query23.useQuery)({ ...productsQueries.byId(id), ...queryDefaults });
+
+// src/v2/products/hooks.ts
+function useProducts({ filters, enabled = true }) {
+  const { getToken } = useAuthToken();
+  return (0, import_react_query23.useQuery)({
+    ...productsQueries.list(filters, getToken()),
+    ...queryDefaults,
+    enabled
+  });
 }
-function useCreateProduct({ ...options }) {
-  return (0, import_react_query23.useMutation)({ mutationFn: createProduct });
+function useProduct({ id, enabled = true }) {
+  const { getToken } = useAuthToken();
+  return (0, import_react_query23.useQuery)({
+    ...productsQueries.byId(id, getToken()),
+    ...queryDefaults,
+    enabled
+  });
 }
-function useUpdateProduct({ ...options }) {
-  return (0, import_react_query23.useMutation)({ mutationFn: updateProduct });
+function useCreateProduct(options) {
+  const { getToken } = useAuthToken();
+  return (0, import_react_query23.useMutation)({
+    mutationFn: (input) => createProduct(input, getToken()),
+    ...options
+  });
+}
+function useUpdateProduct(options) {
+  const { getToken } = useAuthToken();
+  return (0, import_react_query23.useMutation)({
+    mutationFn: (input) => updateProduct(input, getToken()),
+    ...options
+  });
 }
-function useDeleteProduct({ ...options }) {
-  return (0, import_react_query23.useMutation)({ mutationFn: deleteProduct });
+function useDeleteProduct(options) {
+  const { getToken } = useAuthToken();
+  return (0, import_react_query23.useMutation)({
+    mutationFn: (id) => deleteProduct(id, getToken()),
+    ...options
+  });
+}
+function useUploadProductLogo(options) {
+  const { getToken } = useAuthToken();
+  return (0, import_react_query23.useMutation)({
+    mutationFn: (request) => uploadProductLogo(request, getToken()),
+    ...options
+  });
 }
 
 // src/v2/balance/useTokenBalance.ts
-var import_react2 = require("react");
+var import_react3 = require("react");
 var import_viem = require("viem");
 var import_utils2 = require("@turtleclub/utils");
 function useTokenBalance({ token, amount, setAmount }) {
-  const usdValue = (0, import_react2.useMemo)(() => (0, import_utils2.calculateUsdValue)(amount, token?.price), [amount, token?.price]);
-  const hasInsufficientBalance = (0, import_react2.useMemo)(
+  const usdValue = (0, import_react3.useMemo)(() => (0, import_utils2.calculateUsdValue)(amount, token?.price), [amount, token?.price]);
+  const hasInsufficientBalance = (0, import_react3.useMemo)(
     () => (0, import_utils2.checkInsufficientBalance)(token, amount),
     [token, amount]
   );
-  const handleMaxClick = (0, import_react2.useCallback)(() => {
+  const handleMaxClick = (0, import_react3.useCallback)(() => {
     if (!token) return;
     const maxAmount = (0, import_utils2.calculateMaxAmount)(token.balance, token.decimals);
     setAmount(maxAmount);
   }, [token, setAmount]);
-  const amountBigInt = (0, import_react2.useMemo)(() => {
+  const amountBigInt = (0, import_react3.useMemo)(() => {
     if (!token || !amount) return void 0;
     try {
       return (0, import_viem.parseUnits)(amount, token.decimals);
@@ -1481,21 +1637,6 @@ function useWidgetOpportunities(distributorId) {
   });
 }
 
-// src/v2/lib/auth-provider.tsx
-var import_react3 = require("react");
-var import_jsx_runtime = require("react/jsx-runtime");
-var AuthContext = (0, import_react3.createContext)(null);
-function AuthProvider({ getToken, children }) {
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AuthContext.Provider, { value: { getToken }, children });
-}
-function useAuthToken() {
-  const context = (0, import_react3.useContext)(AuthContext);
-  if (!context) {
-    throw new Error("useAuthToken must be used within AuthProvider");
-  }
-  return context;
-}
-
 // src/v2/index.ts
 var queries = (0, import_query_key_factory9.mergeQueryKeys)(
   opportunitiesQueries,
@@ -1592,6 +1733,7 @@ var queries = (0, import_query_key_factory9.mergeQueryKeys)(
   useSignup,
   useTokenBalance,
   useUpdateProduct,
+  useUploadProductLogo,
   useWidgetOpportunities,
   vaultConfigSchema,
   walletBalanceSchema,