E-commerce Application

e-commerce-app/
├── src/
│   ├── models/
│   │   ├── User.ts
│   │   ├── Product.ts
│   │   ├── Category.ts
│   │   ├── Order.ts
│   │   ├── Cart.ts
│   │   └── Payment.ts
│   ├── services/
│   │   ├── ProductService.ts
│   │   ├── OrderService.ts
│   │   ├── PaymentService.ts
│   │   └── NotificationService.ts
│   ├── controllers/
│   │   ├── ProductController.ts
│   │   ├── OrderController.ts
│   │   └── UserController.ts
│   ├── config/
│   │   └── query-2jz.config.ts
│   └── index.ts
├── package.json
├── tsconfig.json
└── README.md

// src/models/Product.ts
export interface Product {
  id: string;
  name: string;
  description: string;
  price: number;
  comparePrice?: number;
  sku: string;
  barcode?: string;
  categoryId: string;
  brand?: string;
  weight?: number;
  dimensions?: {
    length: number;
    width: number;
    height: number;
  };
  images: string[];
  tags: string[];
  isActive: boolean;
  isDigital: boolean;
  inventory: {
    quantity: number;
    reserved: number;
    available: number;
  };
  seo: {
    title?: string;
    description?: string;
    keywords?: string[];
  };
  createdAt: Date;
  updatedAt: Date;
  category?: Category;
  variants?: ProductVariant[];
  reviews?: Review[];
}

export interface ProductVariant {
  id: string;
  productId: string;
  name: string;
  sku: string;
  price: number;
  comparePrice?: number;
  inventory: {
    quantity: number;
    reserved: number;
    available: number;
  };
  attributes: Record<string, string>;
  isActive: boolean;
  createdAt: Date;
  updatedAt: Date;
  product?: Product;
}

export interface Review {
  id: string;
  productId: string;
  userId: string;
  rating: number;
  title: string;
  content: string;
  isVerified: boolean;
  helpful: number;
  createdAt: Date;
  updatedAt: Date;
  product?: Product;
  user?: User;
}

// src/models/Order.ts
export interface Order {
  id: string;
  orderNumber: string;
  userId: string;
  status: 'pending' | 'confirmed' | 'processing' | 'shipped' | 'delivered' | 'cancelled' | 'refunded';
  items: OrderItem[];
  shipping: {
    address: Address;
    method: string;
    cost: number;
    trackingNumber?: string;
    estimatedDelivery?: Date;
  };
  billing: {
    address: Address;
    method: string;
  };
  payment: {
    method: string;
    status: 'pending' | 'paid' | 'failed' | 'refunded';
    transactionId?: string;
    amount: number;
    currency: string;
  };
  totals: {
    subtotal: number;
    tax: number;
    shipping: number;
    discount: number;
    total: number;
  };
  notes?: string;
  createdAt: Date;
  updatedAt: Date;
  user?: User;
  items?: OrderItem[];
}

export interface OrderItem {
  id: string;
  orderId: string;
  productId: string;
  variantId?: string;
  quantity: number;
  price: number;
  total: number;
  createdAt: Date;
  updatedAt: Date;
  order?: Order;
  product?: Product;
  variant?: ProductVariant;
}

export interface Address {
  firstName: string;
  lastName: string;
  company?: string;
  address1: string;
  address2?: string;
  city: string;
  state: string;
  zipCode: string;
  country: string;
  phone?: string;
}

// src/services/ProductService.ts
import { Query-2jz } from 'query-2jz';
import { Product, ProductVariant } from '../models/Product';

export class ProductService {
  constructor(private query-2jz: Query-2jz) {}

  async getProducts(filters: {
    categoryId?: string;
    search?: string;
    minPrice?: number;
    maxPrice?: number;
    inStock?: boolean;
    limit?: number;
    offset?: number;
  }) {
    const where: any = { isActive: true };
    
    if (filters.categoryId) {
      where.categoryId = filters.categoryId;
    }
    
    if (filters.search) {
      where.$or = [
        { name: { $like: `%${filters.search}%` } },
        { description: { $like: `%${filters.search}%` } },
        { tags: { $contains: filters.search } }
      ];
    }
    
    if (filters.minPrice || filters.maxPrice) {
      where.price = {};
      if (filters.minPrice) where.price.$gte = filters.minPrice;
      if (filters.maxPrice) where.price.$lte = filters.maxPrice;
    }
    
    if (filters.inStock) {
      where['inventory.available'] = { $gt: 0 };
    }

    return this.query-2jz.query({
      model: 'Product',
      where,
      include: ['category', 'variants'],
      orderBy: 'createdAt:desc',
      limit: filters.limit || 20,
      offset: filters.offset || 0
    });
  }

  async getProduct(slug: string) {
    return this.query-2jz.query({
      model: 'Product',
      where: { slug, isActive: true },
      include: ['category', 'variants', 'reviews']
    });
  }

  async updateInventory(productId: string, quantity: number, operation: 'add' | 'subtract' | 'set') {
    const product = await this.query-2jz.query({
      model: 'Product',
      where: { id: productId }
    });

    if (product.data.length === 0) {
      throw new Error('Product not found');
    }

    const currentInventory = product.data[0].inventory;
    let newQuantity: number;

    switch (operation) {
      case 'add':
        newQuantity = currentInventory.quantity + quantity;
        break;
      case 'subtract':
        newQuantity = Math.max(0, currentInventory.quantity - quantity);
        break;
      case 'set':
        newQuantity = quantity;
        break;
    }

    const available = Math.max(0, newQuantity - currentInventory.reserved);

    return this.query-2jz.update({
      model: 'Product',
      id: productId,
      data: {
        inventory: {
          quantity: newQuantity,
          reserved: currentInventory.reserved,
          available
        }
      }
    });
  }

  async reserveInventory(productId: string, quantity: number) {
    const product = await this.query-2jz.query({
      model: 'Product',
      where: { id: productId }
    });

    if (product.data.length === 0) {
      throw new Error('Product not found');
    }

    const currentInventory = product.data[0].inventory;
    
    if (currentInventory.available < quantity) {
      throw new Error('Insufficient inventory');
    }

    const newReserved = currentInventory.reserved + quantity;
    const newAvailable = currentInventory.quantity - newReserved;

    return this.query-2jz.update({
      model: 'Product',
      id: productId,
      data: {
        inventory: {
          quantity: currentInventory.quantity,
          reserved: newReserved,
          available: newAvailable
        }
      }
    });
  }
}

// src/services/OrderService.ts
import { Query-2jz } from 'query-2jz';
import { Order, OrderItem } from '../models/Order';
import { ProductService } from './ProductService';

export class OrderService {
  constructor(
    private query-2jz: Query-2jz,
    private productService: ProductService
  ) {}

  async createOrder(userId: string, items: Array<{
    productId: string;
    variantId?: string;
    quantity: number;
  }>) {
    // Calculate totals
    let subtotal = 0;
    const orderItems = [];

    for (const item of items) {
      const product = await this.query-2jz.query({
        model: 'Product',
        where: { id: item.productId }
      });

      if (product.data.length === 0) {
        throw new Error(`Product ${item.productId} not found`);
      }

      const productData = product.data[0];
      const price = productData.price;
      const total = price * item.quantity;
      
      subtotal += total;

      orderItems.push({
        productId: item.productId,
        variantId: item.variantId,
        quantity: item.quantity,
        price,
        total
      });

      // Reserve inventory
      await this.productService.reserveInventory(item.productId, item.quantity);
    }

    // Calculate taxes and shipping (simplified)
    const tax = subtotal * 0.08; // 8% tax
    const shipping = subtotal > 100 ? 0 : 10; // Free shipping over $100
    const total = subtotal + tax + shipping;

    // Generate order number
    const orderNumber = `ORD-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;

    // Create order
    const order = await this.query-2jz.create({
      model: 'Order',
      data: {
        orderNumber,
        userId,
        status: 'pending',
        shipping: {
          address: {}, // Get from user profile
          method: 'standard',
          cost: shipping
        },
        billing: {
          address: {}, // Get from user profile
          method: 'credit_card'
        },
        payment: {
          method: 'credit_card',
          status: 'pending',
          amount: total,
          currency: 'USD'
        },
        totals: {
          subtotal,
          tax,
          shipping,
          discount: 0,
          total
        }
      }
    });

    // Create order items
    for (const item of orderItems) {
      await this.query-2jz.create({
        model: 'OrderItem',
        data: {
          orderId: order.id,
          ...item
        }
      });
    }

    return order;
  }

  async updateOrderStatus(orderId: string, status: string) {
    const order = await this.query-2jz.query({
      model: 'Order',
      where: { id: orderId }
    });

    if (order.data.length === 0) {
      throw new Error('Order not found');
    }

    const updatedOrder = await this.query-2jz.update({
      model: 'Order',
      id: orderId,
      data: { status }
    });

    // If order is cancelled or refunded, release reserved inventory
    if (status === 'cancelled' || status === 'refunded') {
      const items = await this.query-2jz.query({
        model: 'OrderItem',
        where: { orderId }
      });

      for (const item of items.data) {
        await this.productService.updateInventory(
          item.productId,
          item.quantity,
          'add'
        );
      }
    }

    return updatedOrder;
  }

  async getOrderHistory(userId: string, limit = 20, offset = 0) {
    return this.query-2jz.query({
      model: 'Order',
      where: { userId },
      include: ['items', 'items.product'],
      orderBy: 'createdAt:desc',
      limit,
      offset
    });
  }
}

// src/controllers/ProductController.ts
import { Request, Response } from 'express';
import { ProductService } from '../services/ProductService';

export class ProductController {
  constructor(private productService: ProductService) {}

  async getProducts(req: Request, res: Response) {
    try {
      const {
        categoryId,
        search,
        minPrice,
        maxPrice,
        inStock,
        limit = 20,
        offset = 0
      } = req.query;

      const products = await this.productService.getProducts({
        categoryId: categoryId as string,
        search: search as string,
        minPrice: minPrice ? parseFloat(minPrice as string) : undefined,
        maxPrice: maxPrice ? parseFloat(maxPrice as string) : undefined,
        inStock: inStock === 'true',
        limit: parseInt(limit as string),
        offset: parseInt(offset as string)
      });

      res.json(products);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }

  async getProduct(req: Request, res: Response) {
    try {
      const { slug } = req.params;
      const product = await this.productService.getProduct(slug);
      
      if (product.data.length === 0) {
        return res.status(404).json({ error: 'Product not found' });
      }

      res.json(product.data[0]);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }

  async getCategories(req: Request, res: Response) {
    try {
      const categories = await this.query-2jz.query({
        model: 'Category',
        where: { isActive: true },
        orderBy: 'sortOrder:asc'
      });

      res.json(categories.data);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }
}

// src/controllers/OrderController.ts
import { Request, Response } from 'express';
import { OrderService } from '../services/OrderService';

export class OrderController {
  constructor(private orderService: OrderService) {}

  async createOrder(req: Request, res: Response) {
    try {
      const userId = req.user.id;
      const { items } = req.body;

      if (!items || !Array.isArray(items) || items.length === 0) {
        return res.status(400).json({ error: 'Items are required' });
      }

      const order = await this.orderService.createOrder(userId, items);
      res.status(201).json(order);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }

  async getOrderHistory(req: Request, res: Response) {
    try {
      const userId = req.user.id;
      const { limit = 20, offset = 0 } = req.query;

      const orders = await this.orderService.getOrderHistory(
        userId,
        parseInt(limit as string),
        parseInt(offset as string)
      );

      res.json(orders);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }

  async getOrder(req: Request, res: Response) {
    try {
      const { id } = req.params;
      const userId = req.user.id;

      const order = await this.query-2jz.query({
        model: 'Order',
        where: { id, userId },
        include: ['items', 'items.product']
      });

      if (order.data.length === 0) {
        return res.status(404).json({ error: 'Order not found' });
      }

      res.json(order.data[0]);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }

  async updateOrderStatus(req: Request, res: Response) {
    try {
      const { id } = req.params;
      const { status } = req.body;

      const order = await this.orderService.updateOrderStatus(id, status);
      res.json(order);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  }
}