@withvlibe/base-sdk 1.0.1 → 1.1.0

package/dist/index.mjs

@@ -681,8 +681,525 @@ var VlibeBasePayments = class {
     return this.baseUrl;
   }
 };
+
+// src/VlibeBaseEcommerce.ts
+var VlibeBaseEcommerce = class {
+  constructor(db) {
+    this.db = db;
+  }
+  // ===========================
+  // PRODUCTS & INVENTORY
+  // ===========================
+  /**
+   * Create a new product
+   * Auto-generates SKU if not provided
+   */
+  async createProduct(input) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const sku = input.sku || this.generateSKU();
+    const product = {
+      id: crypto.randomUUID(),
+      name: input.name,
+      description: input.description,
+      sku,
+      price: input.price,
+      currency: input.currency,
+      images: input.images || [],
+      stock: input.stock,
+      isActive: input.isActive ?? true,
+      category: input.category,
+      metadata: input.metadata,
+      created_at: now,
+      updated_at: now
+    };
+    await this.db.insert("products", product);
+    return product;
+  }
+  /**
+   * Update an existing product
+   */
+  async updateProduct(productId, updates) {
+    const existing = await this.getProduct(productId);
+    if (!existing) {
+      throw new Error(`Product not found: ${productId}`);
+    }
+    const updated = {
+      ...existing,
+      ...updates,
+      id: productId,
+      // Ensure ID doesn't change
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.db.update("products", productId, updated);
+    return updated;
+  }
+  /**
+   * Get a single product by ID
+   */
+  async getProduct(productId) {
+    return await this.db.get("products", productId);
+  }
+  /**
+   * List products with filtering and pagination
+   */
+  async listProducts(options) {
+    const where = {};
+    if (options?.category) {
+      where.category = options.category;
+    }
+    if (options?.isActive !== void 0) {
+      where.isActive = options.isActive;
+    }
+    const products = await this.db.query("products", {
+      where,
+      orderBy: options?.sortBy,
+      orderDirection: "asc",
+      limit: options?.limit,
+      offset: options?.offset
+    });
+    const total = await this.db.count("products", where);
+    return { products, total };
+  }
+  /**
+   * Soft delete a product (sets isActive = false)
+   */
+  async deleteProduct(productId) {
+    await this.updateProduct(productId, { isActive: false });
+  }
+  /**
+   * Update product inventory with atomic operations
+   */
+  async updateInventory(productId, quantity, operation) {
+    const product = await this.getProduct(productId);
+    if (!product) {
+      throw new Error(`Product not found: ${productId}`);
+    }
+    let newStock;
+    switch (operation) {
+      case "set":
+        newStock = quantity;
+        break;
+      case "increment":
+        newStock = product.stock + quantity;
+        break;
+      case "decrement":
+        newStock = product.stock - quantity;
+        if (newStock < 0) {
+          throw new Error(`Insufficient stock for product ${productId}. Available: ${product.stock}, requested: ${quantity}`);
+        }
+        break;
+    }
+    return await this.updateProduct(productId, { stock: newStock });
+  }
+  /**
+   * Get products below stock threshold
+   */
+  async getLowStockProducts(threshold = 10) {
+    const products = await this.db.query("products", {
+      where: { isActive: true }
+    });
+    return products.filter((p) => p.stock <= threshold);
+  }
+  /**
+   * Bulk update inventory for multiple products
+   */
+  async bulkUpdateInventory(updates) {
+    const results = [];
+    for (const update of updates) {
+      const product = await this.updateInventory(update.productId, update.quantity, update.operation);
+      results.push(product);
+    }
+    return results;
+  }
+  // ===========================
+  // ORDERS & CHECKOUT
+  // ===========================
+  /**
+   * Calculate order totals from cart items
+   */
+  async calculateOrderTotal(items) {
+    const calculatedItems = [];
+    let subtotal = 0;
+    for (const item of items) {
+      const product = await this.getProduct(item.productId);
+      if (!product) {
+        throw new Error(`Product not found: ${item.productId}`);
+      }
+      const lineTotal = product.price * item.quantity;
+      const inStock = product.stock >= item.quantity;
+      calculatedItems.push({
+        productId: item.productId,
+        name: product.name,
+        price: product.price,
+        quantity: item.quantity,
+        lineTotal,
+        inStock
+      });
+      subtotal += lineTotal;
+    }
+    const allInStock = calculatedItems.every((item) => item.inStock);
+    if (!allInStock) {
+      const outOfStock = calculatedItems.filter((item) => !item.inStock);
+      throw new Error(`Items out of stock: ${outOfStock.map((i) => i.name).join(", ")}`);
+    }
+    const tax = Math.round(subtotal * 0.08);
+    const shipping = subtotal > 5e3 ? 0 : 500;
+    const total = subtotal + tax + shipping;
+    return {
+      subtotal,
+      tax,
+      shipping,
+      total,
+      items: calculatedItems
+    };
+  }
+  /**
+   * Create an order from cart items
+   * Reduces inventory atomically
+   */
+  async createOrder(input) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const calculation = await this.calculateOrderTotal(
+      input.items.map((item) => ({ productId: item.productId, quantity: item.quantity }))
+    );
+    const orderItems = calculation.items.map((item) => ({
+      productId: item.productId,
+      name: item.name,
+      quantity: item.quantity,
+      price: item.price
+    }));
+    const order = {
+      id: crypto.randomUUID(),
+      userId: input.userId,
+      status: "pending",
+      items: orderItems,
+      subtotal: calculation.subtotal,
+      tax: calculation.tax,
+      shipping: calculation.shipping,
+      total: calculation.total,
+      shippingAddress: input.shippingAddress,
+      billingAddress: input.billingAddress,
+      paymentMethodId: input.paymentMethodId,
+      notes: input.notes,
+      created_at: now,
+      updated_at: now
+    };
+    await this.db.insert("orders", order);
+    for (const item of orderItems) {
+      await this.db.insert("order_items", {
+        id: crypto.randomUUID(),
+        orderId: order.id,
+        ...item,
+        lineTotal: item.price * item.quantity,
+        created_at: now
+      });
+    }
+    await this.bulkUpdateInventory(
+      input.items.map((item) => ({
+        productId: item.productId,
+        quantity: item.quantity,
+        operation: "decrement"
+      }))
+    );
+    return order;
+  }
+  /**
+   * Get an order by ID
+   */
+  async getOrder(orderId) {
+    const order = await this.db.get("orders", orderId);
+    if (!order) return null;
+    const items = await this.db.query("order_items", {
+      where: { orderId }
+    });
+    order.items = items.map((item) => ({
+      productId: item.productId,
+      name: item.name,
+      quantity: item.quantity,
+      price: item.price
+    }));
+    return order;
+  }
+  /**
+   * List orders with filtering
+   */
+  async listOrders(options) {
+    const where = {};
+    if (options?.userId) {
+      where.userId = options.userId;
+    }
+    if (options?.status) {
+      where.status = options.status;
+    }
+    const orders = await this.db.query("orders", {
+      where,
+      orderBy: options?.sortBy || "created_at",
+      orderDirection: "desc",
+      limit: options?.limit,
+      offset: options?.offset
+    });
+    for (const order of orders) {
+      const items = await this.db.query("order_items", {
+        where: { orderId: order.id }
+      });
+      order.items = items.map((item) => ({
+        productId: item.productId,
+        name: item.name,
+        quantity: item.quantity,
+        price: item.price
+      }));
+    }
+    const total = await this.db.count("orders", where);
+    return { orders, total };
+  }
+  /**
+   * Update order status
+   */
+  async updateOrderStatus(orderId, status) {
+    const order = await this.getOrder(orderId);
+    if (!order) {
+      throw new Error(`Order not found: ${orderId}`);
+    }
+    const updated = {
+      ...order,
+      status,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.db.update("orders", orderId, updated);
+    return updated;
+  }
+  /**
+   * Cancel an order and optionally restore inventory
+   */
+  async cancelOrder(orderId, restoreInventory = true) {
+    const order = await this.getOrder(orderId);
+    if (!order) {
+      throw new Error(`Order not found: ${orderId}`);
+    }
+    if (order.status === "cancelled") {
+      return order;
+    }
+    if (restoreInventory && order.items) {
+      await this.bulkUpdateInventory(
+        order.items.map((item) => ({
+          productId: item.productId,
+          quantity: item.quantity,
+          operation: "increment"
+        }))
+      );
+    }
+    return await this.updateOrderStatus(orderId, "cancelled");
+  }
+  // ===========================
+  // CART OPERATIONS
+  // ===========================
+  /**
+   * Add item to user's cart
+   */
+  async addToCart(userId, item) {
+    const existingCart = await this.db.query("carts", {
+      where: { userId, productId: item.productId }
+    });
+    if (existingCart.length > 0) {
+      const existing = existingCart[0];
+      await this.db.update("carts", existing.id, {
+        ...existing,
+        quantity: existing.quantity + item.quantity,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } else {
+      await this.db.insert("carts", {
+        id: crypto.randomUUID(),
+        userId,
+        productId: item.productId,
+        quantity: item.quantity,
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    return await this.getCart(userId);
+  }
+  /**
+   * Update cart item quantity or remove if quantity = 0
+   */
+  async updateCartItem(userId, productId, quantity) {
+    const items = await this.db.query("carts", {
+      where: { userId, productId }
+    });
+    if (items.length === 0) {
+      throw new Error(`Cart item not found for product: ${productId}`);
+    }
+    const item = items[0];
+    if (quantity === 0) {
+      await this.db.delete("carts", item.id);
+    } else {
+      await this.db.update("carts", item.id, {
+        ...item,
+        quantity,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    return await this.getCart(userId);
+  }
+  /**
+   * Get user's cart
+   */
+  async getCart(userId) {
+    const items = await this.db.query("carts", {
+      where: { userId }
+    });
+    return items.map((item) => ({
+      productId: item.productId,
+      quantity: item.quantity
+    }));
+  }
+  /**
+   * Clear user's cart
+   */
+  async clearCart(userId) {
+    const items = await this.db.query("carts", {
+      where: { userId }
+    });
+    for (const item of items) {
+      await this.db.delete("carts", item.id);
+    }
+  }
+  /**
+   * Checkout - convert cart to order and clear cart
+   */
+  async checkout(userId, shippingAddress, paymentMethodId) {
+    const cart = await this.getCart(userId);
+    if (cart.length === 0) {
+      throw new Error("Cart is empty");
+    }
+    const order = await this.createOrder({
+      userId,
+      items: cart.map((item) => ({ productId: item.productId, quantity: item.quantity })),
+      shippingAddress,
+      paymentMethodId
+    });
+    await this.clearCart(userId);
+    return order;
+  }
+  // ===========================
+  // ANALYTICS
+  // ===========================
+  /**
+   * Get revenue statistics for a time period
+   */
+  async getRevenueStats(period) {
+    const now = /* @__PURE__ */ new Date();
+    const periodStart = this.getPeriodStart(now, period);
+    const previousPeriodStart = this.getPeriodStart(new Date(periodStart), period);
+    const orders = await this.db.query("orders", {});
+    const currentOrders = orders.filter((o) => new Date(o.created_at) >= periodStart);
+    const previousOrders = orders.filter(
+      (o) => new Date(o.created_at) >= previousPeriodStart && new Date(o.created_at) < periodStart
+    );
+    const totalRevenue = currentOrders.reduce((sum, o) => sum + o.total, 0);
+    const previousRevenue = previousOrders.reduce((sum, o) => sum + o.total, 0);
+    const totalOrders = currentOrders.length;
+    const previousOrderCount = previousOrders.length;
+    const averageOrderValue = totalOrders > 0 ? totalRevenue / totalOrders : 0;
+    const revenueTrend = previousRevenue > 0 ? (totalRevenue - previousRevenue) / previousRevenue * 100 : 0;
+    const ordersTrend = previousOrderCount > 0 ? (totalOrders - previousOrderCount) / previousOrderCount * 100 : 0;
+    return {
+      totalRevenue,
+      totalOrders,
+      averageOrderValue,
+      period: {
+        start: periodStart.toISOString(),
+        end: now.toISOString()
+      },
+      trend: {
+        revenue: Math.round(revenueTrend * 100) / 100,
+        orders: Math.round(ordersTrend * 100) / 100
+      }
+    };
+  }
+  /**
+   * Get top selling products
+   */
+  async getTopProducts(limit = 10, period) {
+    const orders = await this.db.query("orders", {});
+    let filteredOrders = orders;
+    if (period) {
+      const periodStart = this.getPeriodStart(/* @__PURE__ */ new Date(), period);
+      filteredOrders = orders.filter((o) => new Date(o.created_at) >= periodStart);
+    }
+    const productMap = /* @__PURE__ */ new Map();
+    for (const order of filteredOrders) {
+      if (!order.items) continue;
+      for (const item of order.items) {
+        const existing = productMap.get(item.productId) || { name: item.name, totalSold: 0, revenue: 0 };
+        existing.totalSold += item.quantity;
+        existing.revenue += item.price * item.quantity;
+        productMap.set(item.productId, existing);
+      }
+    }
+    const stats = Array.from(productMap.entries()).map(([productId, data]) => ({
+      productId,
+      name: data.name,
+      totalSold: data.totalSold,
+      revenue: data.revenue
+    }));
+    stats.sort((a, b) => b.revenue - a.revenue);
+    return stats.slice(0, limit);
+  }
+  /**
+   * Get order statistics by status
+   */
+  async getOrderStats() {
+    const orders = await this.db.query("orders", {});
+    const stats = {
+      pending: 0,
+      processing: 0,
+      shipped: 0,
+      delivered: 0,
+      cancelled: 0,
+      averageOrderValue: 0
+    };
+    let totalValue = 0;
+    for (const order of orders) {
+      stats[order.status]++;
+      totalValue += order.total;
+    }
+    stats.averageOrderValue = orders.length > 0 ? totalValue / orders.length : 0;
+    return stats;
+  }
+  // ===========================
+  // HELPER METHODS
+  // ===========================
+  generateSKU() {
+    const timestamp = Date.now().toString(36).toUpperCase();
+    const random = Math.random().toString(36).substring(2, 6).toUpperCase();
+    return `${timestamp}-${random}`;
+  }
+  getPeriodStart(date, period) {
+    const d = new Date(date);
+    switch (period) {
+      case "day":
+        d.setHours(0, 0, 0, 0);
+        break;
+      case "week":
+        d.setDate(d.getDate() - d.getDay());
+        d.setHours(0, 0, 0, 0);
+        break;
+      case "month":
+        d.setDate(1);
+        d.setHours(0, 0, 0, 0);
+        break;
+      case "year":
+        d.setMonth(0, 1);
+        d.setHours(0, 0, 0, 0);
+        break;
+    }
+    return d;
+  }
+};
 export {
   VlibeBaseAuth,
   VlibeBaseDatabase,
+  VlibeBaseEcommerce,
   VlibeBasePayments
 };

package/dist/react.d.mts

@@ -1,5 +1,5 @@
-import { j as BaseRecord, V as VlibeBaseDatabase, w as UseCollectionOptions, v as UseCollectionReturn, x as UseKVReturn, c as VlibeBaseAuth, y as UseAuthReturn } from './VlibeBaseAuth-BxS9T0vB.mjs';
-export { z as UsePaymentsReturn, l as VlibeUser } from './VlibeBaseAuth-BxS9T0vB.mjs';
+import { k as BaseRecord, V as VlibeBaseDatabase, I as UseCollectionOptions, H as UseCollectionReturn, J as UseKVReturn, c as VlibeBaseAuth, K as UseAuthReturn, d as VlibeBaseEcommerce, q as Product, u as CreateProductInput, t as CartItem, s as Address, O as Order } from './VlibeBaseEcommerce-B6l17uup.mjs';
+export { v as CreateOrderInput, L as UsePaymentsReturn, m as VlibeUser } from './VlibeBaseEcommerce-B6l17uup.mjs';
 
 /**
  * React hook for working with a database collection
@@ -93,4 +93,108 @@ declare function useKV<T = unknown>(db: VlibeBaseDatabase, key: string): UseKVRe
  */
 declare function useAuth(auth: VlibeBaseAuth, initialToken?: string | null): UseAuthReturn;
 
-export { BaseRecord, UseAuthReturn, UseCollectionOptions, UseCollectionReturn, UseKVReturn, useAuth, useCollection, useKV };
+interface UseProductsOptions {
+    category?: string;
+    isActive?: boolean;
+    autoLoad?: boolean;
+}
+interface UseProductsReturn {
+    products: Product[];
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+    createProduct: (input: CreateProductInput) => Promise<Product>;
+    updateProduct: (productId: string, updates: Partial<Product>) => Promise<Product>;
+    deleteProduct: (productId: string) => Promise<void>;
+    updateInventory: (productId: string, quantity: number, operation: 'set' | 'increment' | 'decrement') => Promise<Product>;
+}
+/**
+ * React hook for managing products
+ *
+ * @param ecommerce - VlibeBaseEcommerce instance
+ * @param options - Optional filtering and configuration
+ * @returns Product list with CRUD operations
+ *
+ * @example
+ * ```tsx
+ * const { products, loading, createProduct } = useProducts(ecommerce, { isActive: true });
+ *
+ * const handleCreate = async () => {
+ *   await createProduct({
+ *     name: 'T-Shirt',
+ *     price: 2999,
+ *     stock: 50,
+ *     currency: 'usd'
+ *   });
+ * };
+ * ```
+ */
+declare function useProducts(ecommerce: VlibeBaseEcommerce, options?: UseProductsOptions): UseProductsReturn;
+
+interface UseCartReturn {
+    cart: CartItem[];
+    itemCount: number;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+    addItem: (item: CartItem) => Promise<CartItem[]>;
+    updateItem: (productId: string, quantity: number) => Promise<CartItem[]>;
+    removeItem: (productId: string) => Promise<CartItem[]>;
+    clear: () => Promise<void>;
+    checkout: (shippingAddress: Address, paymentMethodId?: string) => Promise<Order>;
+    calculateTotal: () => Promise<any>;
+}
+/**
+ * React hook for managing shopping cart
+ *
+ * @param ecommerce - VlibeBaseEcommerce instance
+ * @param userId - User ID for cart ownership
+ * @returns Shopping cart with add/update/remove/checkout operations
+ *
+ * @example
+ * ```tsx
+ * const { cart, itemCount, addItem, checkout } = useCart(ecommerce, userId);
+ *
+ * const handleAddToCart = async (productId: string) => {
+ *   await addItem({ productId, quantity: 1 });
+ * };
+ *
+ * const handleCheckout = async () => {
+ *   const order = await checkout(shippingAddress, paymentMethodId);
+ * };
+ * ```
+ */
+declare function useCart(ecommerce: VlibeBaseEcommerce, userId: string): UseCartReturn;
+
+interface UseOrdersOptions {
+    userId?: string;
+    status?: Order['status'];
+    autoLoad?: boolean;
+}
+interface UseOrdersReturn {
+    orders: Order[];
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+    updateStatus: (orderId: string, status: Order['status']) => Promise<Order>;
+    cancelOrder: (orderId: string, restoreInventory?: boolean) => Promise<Order>;
+}
+/**
+ * React hook for managing orders
+ *
+ * @param ecommerce - VlibeBaseEcommerce instance
+ * @param options - Optional filtering and configuration
+ * @returns Order list with status management operations
+ *
+ * @example
+ * ```tsx
+ * const { orders, loading, updateStatus } = useOrders(ecommerce, { userId: 'user123' });
+ *
+ * const handleShip = async (orderId: string) => {
+ *   await updateStatus(orderId, 'shipped');
+ * };
+ * ```
+ */
+declare function useOrders(ecommerce: VlibeBaseEcommerce, options?: UseOrdersOptions): UseOrdersReturn;
+
+export { BaseRecord, CartItem, CreateProductInput, Order, Product, UseAuthReturn, type UseCartReturn, UseCollectionOptions, UseCollectionReturn, UseKVReturn, type UseOrdersOptions, type UseOrdersReturn, type UseProductsOptions, type UseProductsReturn, useAuth, useCart, useCollection, useKV, useOrders, useProducts };