@mohasinac/appkit 2.1.3 → 2.3.0

package/src/features/products/hooks/useProductDetail.ts

@@ -1,44 +0,0 @@
-"use client";
-
-import { useQuery } from "@tanstack/react-query";
-import { apiClient, ApiClientError } from "../../../http";
-import type { ProductItem } from "../types";
-
-interface UseProductDetailOptions<TProduct = ProductItem> {
-  initialData?: TProduct;
-  enabled?: boolean;
-  endpoint?: string;
-  queryKeyPrefix?: string;
-  transform?: (item: ProductItem) => TProduct;
-}
-
-export function useProductDetail<TProduct = ProductItem>(
-  slug: string,
-  options?: UseProductDetailOptions<TProduct>,
-) {
-  const endpoint = options?.endpoint ?? `/api/products/${slug}`;
-  const queryKeyPrefix = options?.queryKeyPrefix ?? "product";
-
-  const { data, isLoading, error, refetch } = useQuery<ProductItem | null>({
-    queryKey: [queryKeyPrefix, slug],
-    queryFn: async () => {
-      try {
-        return await apiClient.get<ProductItem>(endpoint);
-      } catch (e) {
-        if (e instanceof ApiClientError && e.status === 404) return null;
-        throw e;
-      }
-    },
-    enabled: (options?.enabled ?? true) && Boolean(slug),
-    initialData:
-      (options?.initialData as ProductItem | null | undefined) ?? undefined,
-  });
-
-  const product = data
-    ? options?.transform
-      ? options.transform(data as ProductItem)
-      : (data as TProduct)
-    : null;
-
-  return { product, isLoading, error, refetch };
-}

package/src/features/products/hooks/useProducts.ts

@@ -1,112 +0,0 @@
-"use client";
-import { useQuery } from "@tanstack/react-query";
-import { apiClient } from "../../../http";
-import type {
-  ProductItem,
-  ProductListResponse,
-  ProductListParams,
-} from "../types";
-
-// ─── useProducts ──────────────────────────────────────────────────────────────
-
-interface UseProductsOptions<T extends ProductItem = ProductItem> {
-  initialData?: ProductListResponse;
-  enabled?: boolean;
-  /**
-   * Map each API item to a richer app-level type.
-   * The API always returns `ProductItem`; use this to project it to your own
-   * extended type (e.g. `ProductDocument`) without forking the package.
-   *
-   * @example
-   * const { products } = useProducts<ProductDocument>(params, {
-   *   transform: (raw) => ({ ...raw, brand: raw.attributes?.brand ?? "" }),
-   * });
-   */
-  transform?: (item: ProductItem) => T;
-}
-
-export function useProducts<T extends ProductItem = ProductItem>(
-  params: ProductListParams = {},
-  opts?: UseProductsOptions<T>,
-) {
-  const sp = new URLSearchParams();
-  if (params.q) sp.set("q", params.q);
-  if (params.category) sp.set("category", params.category);
-  if (params.status) sp.set("status", params.status);
-  if (params.condition) sp.set("condition", params.condition);
-  if (params.minPrice !== undefined)
-    sp.set("minPrice", String(params.minPrice));
-  if (params.maxPrice !== undefined)
-    sp.set("maxPrice", String(params.maxPrice));
-  if (params.inStock !== undefined) sp.set("inStock", String(params.inStock));
-  if (params.isAuction !== undefined)
-    sp.set("isAuction", String(params.isAuction));
-  if (params.sellerId) sp.set("sellerId", params.sellerId);
-  if (params.sort) sp.set("sorts", params.sort);
-  if (params.page) sp.set("page", String(params.page));
-  if (params.perPage) sp.set("pageSize", String(params.perPage));
-  if (params.featured !== undefined)
-    sp.set("featured", String(params.featured));
-  const qs = sp.toString();
-
-  const query = useQuery<ProductListResponse>({
-    queryKey: ["products", qs],
-    queryFn: () =>
-      apiClient.get<ProductListResponse>(`/api/products${qs ? `?${qs}` : ""}`),
-    initialData: opts?.initialData,
-    enabled: opts?.enabled,
-  });
-
-  const rawItems = query.data?.items ?? [];
-  const products = (
-    opts?.transform ? rawItems.map(opts.transform) : rawItems
-  ) as T[];
-
-  return {
-    products,
-    total: query.data?.total ?? 0,
-    totalPages: query.data?.totalPages ?? 1,
-    page: query.data?.page ?? 1,
-    hasMore: query.data?.hasMore ?? false,
-    isLoading: query.isLoading,
-    error: query.error,
-  };
-}
-
-// ─── useProduct ───────────────────────────────────────────────────────────────
-
-interface UseProductOptions<T extends ProductItem = ProductItem> {
-  initialData?: ProductItem;
-  enabled?: boolean;
-  /**
-   * Map the API item to a richer app-level type.
-   * @example
-   * const { product } = useProduct<ProductDocument>(slug, {
-   *   transform: (raw) => ({ ...raw, brand: raw.attributes?.brand ?? "" }),
-   * });
-   */
-  transform?: (item: ProductItem) => T;
-}
-
-export function useProduct<T extends ProductItem = ProductItem>(
-  slug: string,
-  opts?: UseProductOptions<T>,
-) {
-  const query = useQuery<ProductItem>({
-    queryKey: ["products", slug],
-    queryFn: () => apiClient.get<ProductItem>(`/api/products/${slug}`),
-    initialData: opts?.initialData,
-    enabled: opts?.enabled !== false && !!slug,
-  });
-
-  const product =
-    query.data && opts?.transform
-      ? opts.transform(query.data)
-      : (query.data as T | undefined);
-
-  return {
-    product,
-    isLoading: query.isLoading,
-    error: query.error,
-  };
-}

package/src/features/products/index.ts

@@ -1,9 +0,0 @@
-export * from "./types";
-export * from "./hooks/useProducts";
-export * from "./hooks/useProductDetail";
-export * from "./components";
-export * from "./schemas";
-export * from "./columns";
-export { ProductsRepository } from "./repository/products.repository";
-export { manifest } from "./manifest";
-export { normalizeListingType } from "./utils/listing-type";

package/src/features/products/manifest.ts

@@ -1,18 +0,0 @@
-import type { FeatureManifest } from "../../contracts";
-
-export const manifest: FeatureManifest = {
-  name: "products",
-  i18nNamespace: "products",
-  envKeys: [],
-  routes: [
-    { segment: "[locale]/products", exports: { default: "ProductsListView" } },
-    {
-      segment: "[locale]/products/[slug]",
-      exports: { default: "ProductDetailView" },
-    },
-  ],
-  apiRoutes: [
-    { segment: "api/products", methods: ["GET", "POST"] },
-    { segment: "api/products/[slug]", methods: ["GET", "PATCH", "DELETE"] },
-  ],
-};

package/src/features/products/messages/en.json

@@ -1,11 +0,0 @@
-{
-  "title": "Products",
-  "noProducts": "No products found",
-  "addToWishlist": "Add to Wishlist",
-  "removeFromWishlist": "Remove from Wishlist",
-  "auction": "Auction",
-  "sortNewest": "Newest",
-  "sortPriceLow": "Price: Low to High",
-  "sortPriceHigh": "Price: High to Low",
-  "sortPopular": "Most Popular"
-}

package/src/features/products/repository/products.repository.ts

@@ -1,83 +0,0 @@
-import type {
-  IRepository,
-  PagedResult,
-  SieveQuery,
-} from "../../../contracts";
-import type { ProductItem } from "../types";
-
-export class ProductsRepository {
-  constructor(private readonly repo: IRepository<ProductItem>) {}
-
-  async findAll(query?: SieveQuery): Promise<PagedResult<ProductItem>> {
-    return this.repo.findAll(query ?? {});
-  }
-
-  async findBySlug(slug: string): Promise<ProductItem | null> {
-    const result = await this.repo.findAll({
-      filters: `slug==${slug},status==published`,
-      perPage: 1,
-    });
-    return result.data[0] ?? null;
-  }
-
-  async findBySeller(
-    sellerId: string,
-    page = 1,
-    perPage = 20,
-  ): Promise<PagedResult<ProductItem>> {
-    return this.repo.findAll({
-      filters: `sellerId==${sellerId},status==published`,
-      sort: "-createdAt",
-      page,
-      perPage,
-    });
-  }
-
-  async findByCategory(
-    categoryId: string,
-    page = 1,
-    perPage = 20,
-  ): Promise<PagedResult<ProductItem>> {
-    return this.repo.findAll({
-      filters: `category==${categoryId},status==published`,
-      sort: "-publishedAt",
-      page,
-      perPage,
-    });
-  }
-
-  async findFeatured(limit = 8): Promise<ProductItem[]> {
-    const result = await this.repo.findAll({
-      filters: "status==published",
-      sort: "-publishedAt",
-      perPage: limit,
-    });
-    return result.data;
-  }
-
-  async findById(id: string): Promise<ProductItem | null> {
-    return this.repo.findById(id);
-  }
-
-  /**
-   * Find a product by its Firestore document ID or its URL slug.
-   * Tries ID lookup first (O(1)); falls back to a Sieve slug query.
-   */
-  async findByIdOrSlug(idOrSlug: string): Promise<ProductItem | null> {
-    const byId = await this.repo.findById(idOrSlug);
-    if (byId) return byId;
-    return this.findBySlug(idOrSlug);
-  }
-
-  async create(data: Omit<ProductItem, "id">): Promise<ProductItem> {
-    return this.repo.create(data);
-  }
-
-  async update(id: string, data: Partial<ProductItem>): Promise<ProductItem> {
-    return this.repo.update(id, data);
-  }
-
-  async delete(id: string): Promise<void> {
-    return this.repo.delete(id);
-  }
-}

package/src/features/products/schemas/index.ts

@@ -1,185 +0,0 @@
-import { z } from "zod";
-import { mediaFieldSchema } from "../../media/types/index";
-
-// ─── Sub-schemas ──────────────────────────────────────────────────────────────
-
-export const productImageSchema = z.object({
-  url: z.string(),
-  thumbnailUrl: z.string().optional(),
-  alt: z.string().optional(),
-  order: z.number().optional(),
-});
-
-export const productSeoSchema = z.object({
-  title: z.string().optional(),
-  description: z.string().optional(),
-  keywords: z.array(z.string()).optional(),
-});
-
-// ─── Base item schema ─────────────────────────────────────────────────────────
-
-/**
- * Base Zod schema for a product item.
- * Apps can extend this to add their own fields:
- *
- * @example
- * import { productItemSchema } from "@mohasinac/feat-products";
- *
- * const myProductSchema = productItemSchema.extend({
- *   brand: z.string(),
- *   auctionEndDate: z.string().optional(),
- * });
- * type MyProduct = z.infer<typeof myProductSchema>;
- */
-export const productItemSchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  slug: z.string().optional(),
-  description: z.string().optional(),
-  price: z.number(),
-  originalPrice: z.number().optional(),
-  currency: z.string().optional(),
-  mainImage: z.string().optional(),
-  images: z.array(z.string()).optional(),
-  media: z.array(mediaFieldSchema).optional(),
-  video: z
-    .object({ url: z.string(), thumbnailUrl: z.string().optional() })
-    .optional(),
-  featured: z.boolean().optional(),
-  isPromoted: z.boolean().optional(),
-  currentBid: z.number().optional(),
-  availableQuantity: z.number().optional(),
-  category: z.string().optional(),
-  categorySlug: z.string().optional(),
-  sellerId: z.string().optional(),
-  sellerName: z.string().optional(),
-  sellerAvatar: z.string().optional(),
-  status: z.enum([
-    "draft",
-    "published",
-    "archived",
-    "sold",
-    "out_of_stock",
-    "discontinued",
-  ]),
-  condition: z
-    .enum([
-      "new",
-      "like_new",
-      "good",
-      "fair",
-      "poor",
-      "used",
-      "refurbished",
-      "broken",
-    ])
-    .optional(),
-  listingType: z.enum(["fixed", "standard", "auction", "pre-order"]).optional(),
-  isAuction: z.boolean().optional(),
-  isPreOrder: z.boolean().optional(),
-  inStock: z.boolean().optional(),
-  stockCount: z.number().optional(),
-  rating: z.number().optional(),
-  reviewCount: z.number().optional(),
-  tags: z.array(z.string()).optional(),
-  attributes: z.record(z.string()).optional(),
-  seo: productSeoSchema.optional(),
-  createdAt: z.string().optional(),
-  updatedAt: z.string().optional(),
-  publishedAt: z.string().optional(),
-
-  // Detail fields
-  stockQuantity: z.number().optional(),
-  subcategory: z.string().optional(),
-  brand: z.string().optional(),
-  storeId: z.string().optional(),
-  sellerEmail: z.string().optional(),
-  specifications: z
-    .array(
-      z.object({
-        name: z.string(),
-        value: z.string(),
-        unit: z.string().optional(),
-      }),
-    )
-    .optional(),
-  features: z.array(z.string()).optional(),
-  shippingInfo: z.string().optional(),
-  returnPolicy: z.string().optional(),
-  ingredients: z.array(z.string()).optional(),
-  howToUse: z.array(z.string()).optional(),
-  allowOffers: z.boolean().optional(),
-  minOfferPercent: z.number().optional(),
-  bulkDiscounts: z
-    .array(z.object({ quantity: z.number(), discountPercent: z.number() }))
-    .optional(),
-
-  // Auction detail fields
-  startingBid: z.number().optional(),
-  bidCount: z.number().optional(),
-  auctionEndDate: z.union([z.string(), z.date()]).optional(),
-  reservePrice: z.number().optional(),
-  buyNowPrice: z.number().optional(),
-  minBidIncrement: z.number().optional(),
-  autoExtendable: z.boolean().optional(),
-  auctionExtensionMinutes: z.number().optional(),
-  auctionShippingPaidBy: z.enum(["seller", "winner"]).optional(),
-
-  // Pre-order detail fields
-  preOrderDeliveryDate: z.union([z.string(), z.date()]).optional(),
-  preOrderDepositPercent: z.number().optional(),
-  preOrderDepositAmount: z.number().optional(),
-  preOrderMaxQuantity: z.number().optional(),
-  preOrderCurrentCount: z.number().optional(),
-  preOrderProductionStatus: z
-    .enum(["upcoming", "in_production", "ready_to_ship"])
-    .optional(),
-  preOrderCancellable: z.boolean().optional(),
-
-  // Analytics
-  viewCount: z.number().optional(),
-  avgRating: z.number().optional(),
-
-  // Shipping
-  shippingPaidBy: z.enum(["seller", "buyer"]).optional(),
-  pickupAddressId: z.string().optional(),
-  insurance: z.boolean().optional(),
-  insuranceCost: z.number().optional(),
-});
-
-/** Base Zod schema for list-query parameters. */
-export const productListParamsSchema = z.object({
-  q: z.string().optional(),
-  category: z.string().optional(),
-  status: z
-    .enum([
-      "draft",
-      "published",
-      "archived",
-      "sold",
-      "out_of_stock",
-      "discontinued",
-    ])
-    .optional(),
-  condition: z
-    .enum([
-      "new",
-      "like_new",
-      "good",
-      "fair",
-      "poor",
-      "used",
-      "refurbished",
-      "broken",
-    ])
-    .optional(),
-  minPrice: z.coerce.number().optional(),
-  maxPrice: z.coerce.number().optional(),
-  inStock: z.coerce.boolean().optional(),
-  isAuction: z.coerce.boolean().optional(),
-  sellerId: z.string().optional(),
-  sort: z.string().optional(),
-  page: z.coerce.number().optional(),
-  perPage: z.coerce.number().optional(),
-  featured: z.coerce.boolean().optional(),
-});

package/src/features/products/server.ts

@@ -1,12 +0,0 @@
-/**
- * @mohasinac/appkit/features/products/server
- *
- * Server-only entry point — exports only the API route handlers.
- */
-
-export { GET, POST } from "./api/route";
-export {
-  GET as productItemGET,
-  PATCH as productItemPATCH,
-  DELETE as productItemDELETE,
-} from "./api/[id]/route";

package/src/features/products/types/index.ts

@@ -1,142 +0,0 @@
-import type { MediaField } from "../../media/types/index";
-
-export type ProductStatus =
-  | "draft"
-  | "published"
-  | "archived"
-  | "sold"
-  | "out_of_stock"
-  | "discontinued";
-export type ProductCondition =
-  | "new"
-  | "like_new"
-  | "good"
-  | "fair"
-  | "poor"
-  | "used"
-  | "refurbished"
-  | "broken";
-export type ListingType = "fixed" | "standard" | "auction" | "pre-order";
-
-export interface ProductImage {
-  url: string;
-  thumbnailUrl?: string;
-  alt?: string;
-  order?: number;
-}
-
-export interface ProductSeo {
-  title?: string;
-  description?: string;
-  keywords?: string[];
-}
-
-export interface ProductItem {
-  id: string;
-  title: string;
-  slug?: string;
-  description?: string;
-  price: number;
-  originalPrice?: number;
-  currency?: string;
-  mainImage?: string;
-  images?: string[];
-  media?: MediaField[];
-  video?: { url: string; thumbnailUrl?: string };
-  featured?: boolean;
-  isPromoted?: boolean;
-  currentBid?: number;
-  availableQuantity?: number;
-  category?: string;
-  categoryName?: string;
-  categorySlug?: string;
-  sellerId?: string;
-  sellerName?: string;
-  sellerAvatar?: string;
-  status: ProductStatus;
-  condition?: ProductCondition;
-  listingType?: ListingType;
-  isAuction?: boolean;
-  isPreOrder?: boolean;
-  inStock?: boolean;
-  stockCount?: number;
-  rating?: number;
-  reviewCount?: number;
-  tags?: string[];
-  attributes?: Record<string, string>;
-  seo?: ProductSeo;
-  createdAt?: string;
-  updatedAt?: string;
-  publishedAt?: string;
-
-  // Detail fields
-  stockQuantity?: number;
-  subcategory?: string;
-  brand?: string;
-  storeId?: string;
-  sellerEmail?: string;
-  specifications?: { name: string; value: string; unit?: string }[];
-  features?: string[];
-  shippingInfo?: string;
-  returnPolicy?: string;
-  ingredients?: string[];
-  howToUse?: string[];
-  allowOffers?: boolean;
-  minOfferPercent?: number;
-  bulkDiscounts?: { quantity: number; discountPercent: number }[];
-
-  // Auction detail fields
-  startingBid?: number;
-  bidCount?: number;
-  auctionEndDate?: string | Date;
-  reservePrice?: number;
-  buyNowPrice?: number;
-  minBidIncrement?: number;
-  autoExtendable?: boolean;
-  auctionExtensionMinutes?: number;
-  auctionShippingPaidBy?: "seller" | "winner";
-
-  // Pre-order detail fields
-  preOrderDeliveryDate?: string | Date;
-  preOrderDepositPercent?: number;
-  preOrderDepositAmount?: number;
-  preOrderMaxQuantity?: number;
-  preOrderCurrentCount?: number;
-  preOrderProductionStatus?: "upcoming" | "in_production" | "ready_to_ship";
-  preOrderCancellable?: boolean;
-
-  // Analytics
-  viewCount?: number;
-  avgRating?: number;
-
-  // Shipping
-  shippingPaidBy?: "seller" | "buyer";
-  pickupAddressId?: string;
-  insurance?: boolean;
-  insuranceCost?: number;
-}
-
-export interface ProductListResponse {
-  items: ProductItem[];
-  total: number;
-  page: number;
-  pageSize: number;
-  totalPages: number;
-  hasMore: boolean;
-}
-
-export interface ProductListParams {
-  q?: string;
-  category?: string;
-  status?: ProductStatus;
-  condition?: ProductCondition;
-  minPrice?: number;
-  maxPrice?: number;
-  inStock?: boolean;
-  isAuction?: boolean;
-  sellerId?: string;
-  sort?: string;
-  page?: number;
-  perPage?: number;
-  featured?: boolean;
-}

package/src/features/products/utils/listing-type.ts

@@ -1,12 +0,0 @@
-import type { ListingType, ProductItem } from "../types/index";
-
-export function normalizeListingType(
-  input?: Partial<
-    Pick<ProductItem, "listingType" | "isAuction" | "isPreOrder">
-  >,
-): ListingType {
-  if (input?.listingType) return input.listingType;
-  if (input?.isAuction) return "auction";
-  if (input?.isPreOrder) return "pre-order";
-  return "standard";
-}