@classytic/commerce-sdk 0.1.0

package/dist/chunk-X6PV5MHG.js

@@ -0,0 +1,582 @@
+import { BaseApi } from './chunk-I5TIKUIQ.js';
+import { createCrudHooks } from './chunk-B6MPVOV7.js';
+import { getToastHandler } from './chunk-U3XT35GZ.js';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+
+// src/catalog/api/product.ts
+var ProductApi = class extends BaseApi {
+  constructor(config = {}) {
+    super("products", config);
+  }
+  /**
+   * Get product by slug
+   * GET /products/slug/:slug
+   * (Public endpoint)
+   *
+   * @param token - Auth token (optional, public endpoint)
+   * @param slug - Product slug
+   * @param options - Additional fetch options
+   * @returns Product object
+   */
+  async getBySlug({
+    token = null,
+    slug,
+    options = {}
+  }) {
+    if (!slug) {
+      throw new Error("Product slug is required");
+    }
+    return this.request("GET", `${this.baseUrl}/slug/${slug}`, {
+      token: token || void 0,
+      options: {
+        cache: this.config.cache,
+        ...options
+      }
+    });
+  }
+  /**
+   * Get product recommendations
+   * GET /products/:id/recommendations
+   * (Public endpoint)
+   *
+   * @param token - Auth token (optional)
+   * @param productId - Product ID to get recommendations for
+   * @param options - Additional fetch options
+   * @returns List of recommended products
+   */
+  async getRecommendations({
+    token = null,
+    productId,
+    options = {}
+  }) {
+    if (!productId) {
+      throw new Error("Product ID is required");
+    }
+    return this.request("GET", `${this.baseUrl}/${productId}/recommendations`, {
+      token: token || void 0,
+      options: {
+        cache: this.config.cache,
+        ...options
+      }
+    });
+  }
+  /**
+   * Get soft-deleted products (Recycle Bin)
+   * GET /products/deleted
+   * (Admin only)
+   *
+   * @param token - Auth token (required)
+   * @param params - Query parameters for pagination/filtering
+   * @param options - Additional fetch options
+   * @returns Paginated list of deleted products
+   */
+  async getDeleted({
+    token,
+    params = {},
+    options = {}
+  }) {
+    return this.request("GET", `${this.baseUrl}/deleted`, {
+      token,
+      params,
+      options: {
+        cache: this.config.cache,
+        ...options
+      }
+    });
+  }
+  /**
+   * Restore a soft-deleted product
+   * POST /products/:id/restore
+   * (Admin only)
+   *
+   * @param token - Auth token (required)
+   * @param id - Product ID to restore
+   * @param options - Additional fetch options
+   * @returns Restored product
+   */
+  async restore({
+    token,
+    id,
+    options = {}
+  }) {
+    if (!id) {
+      throw new Error("Product ID is required");
+    }
+    return this.request("POST", `${this.baseUrl}/${id}/restore`, {
+      token,
+      options
+    });
+  }
+  /**
+   * Permanently delete a product (Hard delete)
+   * DELETE /products/:id?hard=true
+   * (Admin only - use with caution)
+   *
+   * @param token - Auth token (required)
+   * @param id - Product ID to permanently delete
+   * @param options - Additional fetch options
+   * @returns Delete confirmation
+   */
+  async hardDelete({
+    token,
+    id,
+    options = {}
+  }) {
+    if (!id) {
+      throw new Error("Product ID is required");
+    }
+    return this.delete({
+      token,
+      id,
+      options: {
+        ...options,
+        // @ts-ignore - params is handled internally
+        params: { hard: "true" }
+      }
+    });
+  }
+  /**
+   * Sync product stock quantity
+   * POST /products/:id/sync-stock
+   *
+   * Recomputes product.quantity by summing all StockEntry quantities across branches.
+   * (Requires: admin, warehouse-admin, warehouse-staff, or store-manager role)
+   *
+   * @param token - Auth token (required)
+   * @param id - Product ID to sync stock for
+   * @param options - Additional fetch options
+   * @returns Sync result with new quantity
+   */
+  async syncStock({
+    token,
+    id,
+    options = {}
+  }) {
+    if (!id) {
+      throw new Error("Product ID is required");
+    }
+    return this.request("POST", `${this.baseUrl}/${id}/sync-stock`, {
+      token,
+      options
+    });
+  }
+};
+var productApi = new ProductApi();
+
+// src/catalog/api/category.ts
+var CategoryApi = class extends BaseApi {
+  constructor(config = {}) {
+    super("categories", config);
+  }
+  /**
+   * Get category tree (nested structure)
+   * GET /categories/tree
+   *
+   * **This is the main endpoint - FE should cache this and derive everything else from it.**
+   *
+   * Returns nested tree structure with children. Use helper functions to flatten, search, or extract children.
+   *
+   * @param token - Auth token (optional, public endpoint)
+   * @param options - Additional fetch options
+   * @returns Nested category tree
+   *
+   * @example
+   * ```typescript
+   * const { data } = await categoryApi.getTree({ token: null });
+   * // data = [{ slug: "clothing", name: "Clothing", children: [...] }]
+   * ```
+   */
+  async getTree({
+    token = null,
+    options = {}
+  } = {}) {
+    return this.request("GET", `${this.baseUrl}/tree`, {
+      token: token || void 0,
+      options: {
+        cache: this.config.cache,
+        ...options
+      }
+    });
+  }
+  /**
+   * Get category by slug
+   * GET /categories/slug/:slug
+   *
+   * For URL resolution when you need full category details.
+   *
+   * @param token - Auth token (optional, public endpoint)
+   * @param slug - Category slug (e.g., "electronics", "t-shirts")
+   * @param options - Additional fetch options
+   * @returns Category object
+   *
+   * @example
+   * ```typescript
+   * const { data } = await categoryApi.getBySlug({
+   *   token: null,
+   *   slug: 'electronics'
+   * });
+   * ```
+   */
+  async getBySlug({
+    token = null,
+    slug,
+    options = {}
+  }) {
+    if (!slug) {
+      throw new Error("Category slug is required");
+    }
+    return this.request("GET", `${this.baseUrl}/slug/${slug}`, {
+      token: token || void 0,
+      options: {
+        cache: this.config.cache,
+        ...options
+      }
+    });
+  }
+  /**
+   * Sync product counts for all categories
+   * POST /categories/sync-product-count
+   *
+   * Recalculates `productCount` for all categories based on current products.
+   * Use when manual data fixes or migrations may have desynced counts.
+   *
+   * @param token - Auth token (admin or inventory staff required)
+   * @param options - Additional fetch options
+   * @returns Number of categories updated
+   *
+   * @example
+   * ```typescript
+   * const { data } = await categoryApi.syncProductCount({ token });
+   * // data = { updated: 42 }
+   * ```
+   */
+  async syncProductCount({
+    token,
+    options = {}
+  }) {
+    return this.request("POST", `${this.baseUrl}/sync-product-count`, {
+      token,
+      options
+    });
+  }
+};
+var categoryApi = new CategoryApi();
+
+// src/catalog/api/size-guide.ts
+var SizeGuideApi = class extends BaseApi {
+  constructor(config = {}) {
+    super("size-guides", config);
+  }
+  /**
+   * Get size guide by slug
+   * GET /size-guides/slug/:slug
+   *
+   * For product detail pages to fetch the appropriate size guide.
+   *
+   * @param token - Auth token (optional, public endpoint)
+   * @param slug - Size guide slug (e.g., "t-shirts-tops")
+   * @param options - Additional fetch options
+   * @returns Size guide object
+   *
+   * @example
+   * ```typescript
+   * const { data } = await sizeGuideApi.getBySlug({
+   *   token: null,
+   *   slug: 't-shirts-tops'
+   * });
+   * ```
+   */
+  async getBySlug({
+    token = null,
+    slug,
+    options = {}
+  }) {
+    if (!slug) {
+      throw new Error("Size guide slug is required");
+    }
+    return this.request("GET", `${this.baseUrl}/slug/${slug}`, {
+      token: token || void 0,
+      options: {
+        cache: this.config.cache,
+        ...options
+      }
+    });
+  }
+};
+var sizeGuideApi = new SizeGuideApi();
+var productHooks = createCrudHooks({
+  api: productApi,
+  entityKey: "products",
+  singular: "Product",
+  plural: "Products",
+  defaults: {
+    staleTime: 5 * 60 * 1e3
+    // 5 minutes
+  }
+});
+var {
+  KEYS: PRODUCT_KEYS,
+  useList: useProducts,
+  useDetail: useProductDetail,
+  useActions: useProductActions,
+  useNavigation: useProductNavigation
+} = productHooks;
+function useProductBySlug(token, slug, options = {}) {
+  return useQuery({
+    queryKey: [...PRODUCT_KEYS.all, "slug", slug],
+    queryFn: () => productApi.getBySlug({ token, slug }),
+    enabled: !!slug,
+    staleTime: 5 * 60 * 1e3,
+    // 5 minutes
+    ...options
+  });
+}
+function useProductRecommendations(productId, options = {}) {
+  const { data, isLoading, error } = useQuery({
+    queryKey: [...PRODUCT_KEYS.all, "recommendations", productId],
+    queryFn: () => productApi.getRecommendations({ token: null, productId }),
+    enabled: !!productId,
+    staleTime: 10 * 60 * 1e3,
+    // 10 minutes
+    ...options
+  });
+  return {
+    recommendations: data?.data ?? [],
+    isLoading,
+    error
+  };
+}
+function useDeletedProducts(token, params = {}, options = {}) {
+  return useQuery({
+    queryKey: [...PRODUCT_KEYS.all, "deleted", params],
+    queryFn: () => productApi.getDeleted({ token, params }),
+    enabled: !!token,
+    staleTime: 2 * 60 * 1e3,
+    // 2 minutes
+    ...options
+  });
+}
+function useRestoreProduct(token) {
+  const queryClient = useQueryClient();
+  const toast = getToastHandler();
+  return useMutation({
+    mutationFn: (id) => productApi.restore({ token, id }),
+    onSuccess: () => {
+      toast.success("Product restored successfully");
+      queryClient.invalidateQueries({ queryKey: [...PRODUCT_KEYS.all, "deleted"] });
+      queryClient.invalidateQueries({ queryKey: PRODUCT_KEYS.lists() });
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to restore product");
+    }
+  });
+}
+function useHardDeleteProduct(token) {
+  const queryClient = useQueryClient();
+  const toast = getToastHandler();
+  return useMutation({
+    mutationFn: (id) => productApi.hardDelete({ token, id }),
+    onSuccess: () => {
+      toast.success("Product permanently deleted");
+      queryClient.invalidateQueries({ queryKey: [...PRODUCT_KEYS.all, "deleted"] });
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to permanently delete product");
+    }
+  });
+}
+function useSyncProductStock(token) {
+  const queryClient = useQueryClient();
+  const toast = getToastHandler();
+  return useMutation({
+    mutationFn: (id) => productApi.syncStock({ token, id }),
+    onSuccess: (result, id) => {
+      toast.success(`Stock synced: ${result.totalQuantity} units`);
+      queryClient.invalidateQueries({ queryKey: PRODUCT_KEYS.detail(id) });
+      queryClient.invalidateQueries({ queryKey: PRODUCT_KEYS.lists() });
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to sync stock");
+    }
+  });
+}
+var categoryHooks = createCrudHooks({
+  api: categoryApi,
+  entityKey: "categories",
+  singular: "Category",
+  plural: "Categories",
+  defaults: {
+    staleTime: 10 * 60 * 1e3
+    // 10 minutes
+  }
+});
+var {
+  KEYS: CATEGORY_KEYS,
+  useList: useCategories,
+  useDetail: useCategoryDetail,
+  useActions: useCategoryActions,
+  useNavigation: useCategoryNavigation
+} = categoryHooks;
+function useCategoryTree(token, options = {}) {
+  return useQuery({
+    queryKey: [...CATEGORY_KEYS.all, "tree"],
+    queryFn: () => categoryApi.getTree({ token }),
+    staleTime: 30 * 60 * 1e3,
+    // 30 minutes (categories rarely change)
+    gcTime: 60 * 60 * 1e3,
+    // 60 minutes
+    ...options
+  });
+}
+function useCategoryBySlug(token, slug, options = {}) {
+  return useQuery({
+    queryKey: [...CATEGORY_KEYS.all, "slug", slug],
+    queryFn: () => categoryApi.getBySlug({ token, slug }),
+    enabled: !!slug,
+    staleTime: 30 * 60 * 1e3,
+    // 30 minutes
+    ...options
+  });
+}
+function useCategorySyncProductCount(token) {
+  const queryClient = useQueryClient();
+  const toast = getToastHandler();
+  return useMutation({
+    mutationFn: () => categoryApi.syncProductCount({ token }),
+    onSuccess: (result) => {
+      const count = result?.data?.updated ?? 0;
+      toast.success(`Synced product counts for ${count} categories`);
+      queryClient.invalidateQueries({ queryKey: CATEGORY_KEYS.all });
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to sync product counts");
+    }
+  });
+}
+function flattenCategoryTree(nodes, depth = 0, result = []) {
+  for (const node of nodes || []) {
+    result.push({
+      ...node,
+      depth,
+      displayName: "\xA0\xA0".repeat(depth) + node.name
+    });
+    if (node.children?.length) {
+      flattenCategoryTree(node.children, depth + 1, result);
+    }
+  }
+  return result;
+}
+function getParentCategoryOptions(tree) {
+  return (tree || []).map((node) => ({
+    value: node.slug,
+    label: node.name
+  }));
+}
+function getAllCategoryOptions(tree) {
+  return flattenCategoryTree(tree).map((node) => ({
+    value: node.slug,
+    label: node.displayName
+  }));
+}
+function findCategoryBySlug(tree, slug) {
+  if (!tree || !slug) return void 0;
+  for (const node of tree) {
+    if (node.slug === slug) return node;
+    if (node.children?.length) {
+      const found = findCategoryBySlug(node.children, slug);
+      if (found) return found;
+    }
+  }
+  return void 0;
+}
+function getCategoryBreadcrumb(tree, slug) {
+  if (!tree || !slug) return [];
+  function findPath(nodes, target, path = []) {
+    for (const node of nodes) {
+      const currentPath = [...path, node];
+      if (node.slug === target) return currentPath;
+      if (node.children?.length) {
+        const found = findPath(node.children, target, currentPath);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+  return findPath(tree, slug) || [];
+}
+function getChildCategorySlugs(tree, parentSlug) {
+  const parent = findCategoryBySlug(tree, parentSlug);
+  if (!parent?.children?.length) return [];
+  const slugs = [];
+  function collectSlugs(nodes) {
+    for (const node of nodes) {
+      slugs.push(node.slug);
+      if (node.children?.length) {
+        collectSlugs(node.children);
+      }
+    }
+  }
+  collectSlugs(parent.children);
+  return slugs;
+}
+function getRootCategories(tree) {
+  return tree || [];
+}
+var sizeGuideHooks = createCrudHooks({
+  api: sizeGuideApi,
+  entityKey: "size-guides",
+  singular: "Size Guide",
+  plural: "Size Guides",
+  defaults: {
+    staleTime: 30 * 60 * 1e3
+    // 30 minutes (size guides change rarely)
+  }
+});
+var {
+  KEYS: SIZE_GUIDE_KEYS,
+  useList: useSizeGuides,
+  useDetail: useSizeGuideDetail,
+  useActions: useSizeGuideActions,
+  useNavigation: useSizeGuideNavigation
+} = sizeGuideHooks;
+function useSizeGuideBySlug(token, slug, options = {}) {
+  return useQuery({
+    queryKey: [...SIZE_GUIDE_KEYS.all, "slug", slug],
+    queryFn: () => sizeGuideApi.getBySlug({ token, slug }),
+    enabled: !!slug,
+    staleTime: 30 * 60 * 1e3,
+    // 30 minutes
+    ...options
+  });
+}
+function getSizeGuideOptions(sizeGuides) {
+  return (sizeGuides || []).map((guide) => ({
+    value: guide._id,
+    label: guide.name
+  }));
+}
+function findSizeGuideById(sizeGuides, id) {
+  return sizeGuides?.find((guide) => guide._id === id);
+}
+function findSizeGuideBySlug(sizeGuides, slug) {
+  return sizeGuides?.find((guide) => guide.slug === slug);
+}
+function formatMeasurement(value, unit) {
+  const unitLabel = unit === "inches" ? "in" : "cm";
+  return `${value} ${unitLabel}`;
+}
+function getSizeTableHeaders(guide) {
+  if (!guide?.measurementLabels) return ["Size"];
+  return ["Size", ...guide.measurementLabels];
+}
+function getSizeTableRows(guide) {
+  if (!guide?.sizes) return [];
+  return guide.sizes.map((size) => ({
+    name: size.name,
+    measurements: size.measurements
+  }));
+}
+
+export { CATEGORY_KEYS, CategoryApi, PRODUCT_KEYS, ProductApi, SIZE_GUIDE_KEYS, SizeGuideApi, categoryApi, categoryHooks, findCategoryBySlug, findSizeGuideById, findSizeGuideBySlug, flattenCategoryTree, formatMeasurement, getAllCategoryOptions, getCategoryBreadcrumb, getChildCategorySlugs, getParentCategoryOptions, getRootCategories, getSizeGuideOptions, getSizeTableHeaders, getSizeTableRows, productApi, productHooks, sizeGuideApi, sizeGuideHooks, useCategories, useCategoryActions, useCategoryBySlug, useCategoryDetail, useCategoryNavigation, useCategorySyncProductCount, useCategoryTree, useDeletedProducts, useHardDeleteProduct, useProductActions, useProductBySlug, useProductDetail, useProductNavigation, useProductRecommendations, useProducts, useRestoreProduct, useSizeGuideActions, useSizeGuideBySlug, useSizeGuideDetail, useSizeGuideNavigation, useSizeGuides, useSyncProductStock };
+//# sourceMappingURL=chunk-X6PV5MHG.js.map
+//# sourceMappingURL=chunk-X6PV5MHG.js.map