yapi-seller-service 0.0.0-alpha1

package/index.js

@@ -0,0 +1,1621 @@
+// index.js
+/**
+ * @file index.js
+ * @description A simulated service layer for managing seller operations within the Yapi platform.
+ * This package provides functionalities for seller profile management, product listing and management,
+ * order viewing, and basic inventory updates, simulating interactions with a backend API.
+ * All data storage and API interactions are simulated in-memory using standard JavaScript features.
+ * This code is intended to mimic the structure and complexity of a real service package,
+ * including validation, error handling, and asynchronous operations.
+ */
+
+// --- Simulated Data Storage (In-memory) ---
+// These variables simulate a backend database for a specific seller.
+// In a real application, these would be API calls to a server.
+
+/** @type {SellerProfile|null} */
+let _sellerProfile = null;
+
+/** @type {Product[]} */
+let _products = [];
+
+/** @type {Order[]} */
+let _orders = [];
+
+// --- Constants and Configuration (Simulated) ---
+
+const SIMULATED_API_MIN_DELAY_MS = 100;
+const SIMULATED_API_MAX_DELAY_MS = 500;
+const SIMULATED_API_ERROR_CHANCE = 0.1; // 10% chance of simulated network/connection error
+
+const PRODUCT_STATUSES = ['draft', 'active', 'archived'];
+const ORDER_STATUSES = ['pending', 'processing', 'shipped', 'delivered', 'cancelled', 'returned'];
+
+// --- Data Structure Classes (Simulated Models) ---
+
+/**
+ * Represents a Seller Profile on the Yapi platform.
+ * @typedef {object} SellerProfile
+ * @property {string} id - Unique identifier for the seller.
+ * @property {string} name - The seller's name or business name.
+ * @property {string} email - Seller's contact email.
+ * @property {string} phone - Seller's contact phone number.
+ * @property {string} address - Seller's primary address.
+ * @property {string} [description] - Optional description of the seller or business.
+ * @property {Date} createdAt - Timestamp when the profile was created.
+ * @property {Date} updatedAt - Timestamp when the profile was last updated.
+ */
+class SellerProfile {
+    /**
+     * @param {object} data - Initial data for the seller profile.
+     * @param {string} data.id - Unique identifier.
+     * @param {string} data.name - Seller name.
+     * @param {string} data.email - Seller email.
+     * @param {string} data.phone - Seller phone.
+     * @param {string} data.address - Seller address.
+     * @param {string} [data.description] - Optional description.
+     * @param {Date} [data.createdAt=new Date()] - Creation timestamp.
+     * @param {Date} [data.updatedAt=new Date()] - Update timestamp.
+     */
+    constructor({ id, name, email, phone, address, description = '', createdAt = new Date(), updatedAt = new Date() }) {
+        if (!id || !name || !email || !phone || !address) {
+            throw new Error("SellerProfile requires id, name, email, phone, and address.");
+        }
+        this.id = id;
+        this.name = name;
+        this.email = email;
+        this.phone = phone;
+        this.address = address;
+        this.description = description;
+        this.createdAt = new Date(createdAt); // Ensure Date object
+        this.updatedAt = new Date(updatedAt); // Ensure Date object
+    }
+
+    /**
+     * Updates profile data.
+     * @param {object} updateData - Data to update.
+     */
+    update(updateData) {
+        Object.assign(this, updateData);
+        this.updatedAt = new Date();
+    }
+
+    /**
+     * Returns a plain object representation.
+     * @returns {object}
+     */
+    toObject() {
+        return {
+            id: this.id,
+            name: this.name,
+            email: this.email,
+            phone: this.phone,
+            address: this.address,
+            description: this.description,
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt,
+        };
+    }
+}
+
+/**
+ * Represents a Product listed by the seller.
+ * @typedef {object} Product
+ * @property {string} id - Unique identifier for the product.
+ * @property {string} sellerId - The ID of the seller who owns this product.
+ * @property {string} title - Product title.
+ * @property {string} [description] - Optional product description.
+ * @property {number} price - Product price (e.g., in currency units).
+ * @property {number} stock - Current stock quantity.
+ * @property {string} [imageUrl] - URL of the product image.
+ * @property {string} [category] - Product category.
+ * @property {string} status - Product status ('draft', 'active', 'archived').
+ * @property {Date} createdAt - Timestamp when the product was created.
+ * @property {Date} updatedAt - Timestamp when the product was last updated.
+ */
+class Product {
+    /**
+     * @param {object} data - Initial data for the product.
+     * @param {string} data.id - Unique identifier.
+     * @param {string} data.sellerId - Seller ID.
+     * @param {string} data.title - Product title.
+     * @param {number} data.price - Product price.
+     * @param {number} data.stock - Stock quantity.
+     * @param {string} [data.description] - Description.
+     * @param {string} [data.imageUrl] - Image URL.
+     * @param {string} [data.category] - Category.
+     * @param {string} [data.status='draft'] - Product status.
+     * @param {Date} [data.createdAt=new Date()] - Creation timestamp.
+     * @param {Date} [data.updatedAt=new Date()] - Update timestamp.
+     */
+    constructor({
+        id,
+        sellerId,
+        title,
+        description = '',
+        price,
+        stock,
+        imageUrl = '',
+        category = 'uncategorized',
+        status = 'draft',
+        createdAt = new Date(),
+        updatedAt = new Date()
+    }) {
+        if (!id || !sellerId || !title || price === undefined || stock === undefined) {
+            throw new Error("Product requires id, sellerId, title, price, and stock.");
+        }
+        if (!PRODUCT_STATUSES.includes(status)) {
+             throw new Error(`Invalid product status: ${status}. Must be one of ${PRODUCT_STATUSES.join(', ')}.`);
+        }
+
+        this.id = id;
+        this.sellerId = sellerId;
+        this.title = title;
+        this.description = description;
+        this.price = price;
+        this.stock = stock;
+        this.imageUrl = imageUrl;
+        this.category = category;
+        this.status = status;
+        this.createdAt = new Date(createdAt);
+        this.updatedAt = new Date(updatedAt);
+    }
+
+    /**
+     * Updates product data.
+     * @param {object} updateData - Data to update.
+     */
+    update(updateData) {
+        // Basic validation for status update
+        if (updateData.status !== undefined && !PRODUCT_STATUSES.includes(updateData.status)) {
+             throw new Error(`Invalid product status update: ${updateData.status}. Must be one of ${PRODUCT_STATUSES.join(', ')}.`);
+        }
+        Object.assign(this, updateData);
+        this.updatedAt = new Date();
+    }
+
+     /**
+     * Returns a plain object representation.
+     * @returns {object}
+     */
+    toObject() {
+        return {
+            id: this.id,
+            sellerId: this.sellerId,
+            title: this.title,
+            description: this.description,
+            price: this.price,
+            stock: this.stock,
+            imageUrl: this.imageUrl,
+            category: this.category,
+            status: this.status,
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt,
+        };
+    }
+}
+
+
+/**
+ * Represents an Order placed by a buyer for the seller's products.
+ * Note: This simplified model represents an order *item* or a single product order.
+ * A real system would likely have an Order header and multiple OrderItems.
+ * @typedef {object} Order
+ * @property {string} id - Unique identifier for the order item.
+ * @property {string} orderId - Identifier for the overall order (if multiple items).
+ * @property {string} sellerId - The ID of the seller fulfilling this item.
+ * @property {string} productId - The ID of the product ordered.
+ * @property {string} productName - The name of the product ordered (snapshot at time of order).
+ * @property {number} quantity - Quantity of the product ordered.
+ * @property {number} itemPrice - Price of one unit of the product at the time of order.
+ * @property {number} totalPrice - Total price for this item (quantity * itemPrice).
+ * @property {string} buyerId - The ID of the buyer.
+ * @property {object} buyerInfo - Snapshot of buyer's info (e.g., { name, address }).
+ * @property {string} status - Order item status ('pending', 'processing', 'shipped', 'delivered', 'cancelled', 'returned').
+ * @property {Date} orderDate - Timestamp when the order was placed.
+ * @property {Date} [updatedAt] - Timestamp when the order item status was last updated.
+ */
+class Order {
+     /**
+     * @param {object} data - Initial data for the order item.
+     * @param {string} data.id - Unique identifier.
+     * @param {string} data.orderId - Overall order ID.
+     * @param {string} data.sellerId - Seller ID.
+     * @param {string} data.productId - Product ID.
+     * @param {string} data.productName - Product name snapshot.
+     * @param {number} data.quantity - Quantity.
+     * @param {number} data.itemPrice - Price per item at order time.
+     * @param {object} data.buyerInfo - Buyer info snapshot.
+     * @param {string} [data.status='pending'] - Order status.
+     * @param {Date} [data.orderDate=new Date()] - Order placement timestamp.
+     * @param {Date} [data.updatedAt=new Date()] - Update timestamp.
+     */
+    constructor({
+        id,
+        orderId,
+        sellerId,
+        productId,
+        productName,
+        quantity,
+        itemPrice,
+        buyerInfo,
+        status = 'pending',
+        orderDate = new Date(),
+        updatedAt = new Date()
+    }) {
+        if (!id || !orderId || !sellerId || !productId || !productName || quantity === undefined || itemPrice === undefined || !buyerInfo) {
+             throw new Error("Order requires id, orderId, sellerId, productId, productName, quantity, itemPrice, and buyerInfo.");
+        }
+        if (!ORDER_STATUSES.includes(status)) {
+            throw new Error(`Invalid order status: ${status}. Must be one of ${ORDER_STATUSES.join(', ')}.`);
+        }
+
+        this.id = id;
+        this.orderId = orderId;
+        this.sellerId = sellerId;
+        this.productId = productId;
+        this.productName = productName;
+        this.quantity = quantity;
+        this.itemPrice = itemPrice;
+        this.totalPrice = quantity * itemPrice;
+        this.buyerInfo = buyerInfo; // Simple object copy
+        this.status = status;
+        this.orderDate = new Date(orderDate);
+        this.updatedAt = new Date(updatedAt);
+    }
+
+    /**
+     * Updates the order item status.
+     * @param {string} newStatus - The new status for the order item.
+     */
+    updateStatus(newStatus) {
+         if (!ORDER_STATUSES.includes(newStatus)) {
+            throw new Error(`Invalid order status update: ${newStatus}. Must be one of ${ORDER_STATUSES.join(', ')}.`);
+        }
+        this.status = newStatus;
+        this.updatedAt = new Date();
+    }
+
+     /**
+     * Returns a plain object representation.
+     * @returns {object}
+     */
+    toObject() {
+        return {
+            id: this.id,
+            orderId: this.orderId,
+            sellerId: this.sellerId,
+            productId: this.productId,
+            productName: this.productName,
+            quantity: this.quantity,
+            itemPrice: this.itemPrice,
+            totalPrice: this.totalPrice,
+            buyerInfo: { ...this.buyerInfo }, // Return a copy
+            status: this.status,
+            orderDate: this.orderDate,
+            updatedAt: this.updatedAt,
+        };
+    }
+}
+
+
+// --- Utility Functions (Helper Methods) ---
+
+/**
+ * Generates a simple unique ID string.
+ * Not a true UUID, but sufficient for simulation.
+ * @returns {string} A unique identifier string.
+ * @private
+ */
+function _generateUniqueId() {
+    // Simple simulation of ID generation
+    // Combination of random string and timestamp for uniqueness likelihood
+    return 'yapi_' + Math.random().toString(36).substring(2, 15) + Date.now().toString(36);
+}
+
+/**
+ * Basic validation for a non-empty string.
+ * @param {*} value - The value to validate.
+ * @param {string} name - The name of the parameter being validated (for error messages).
+ * @param {boolean} [allowEmptyString=false] - If true, an empty string is considered valid.
+ * @private
+ * @throws {Error} If validation fails.
+ */
+function _validateString(value, name, allowEmptyString = false) {
+    if (value === null || value === undefined) {
+        throw new Error(`${name} cannot be null or undefined.`);
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`${name} must be a string.`);
+    }
+    if (!allowEmptyString && value.trim().length === 0) {
+        throw new Error(`${name} cannot be an empty string.`);
+    }
+}
+
+/**
+ * Basic validation for a non-negative number (integer or float).
+ * @param {*} value - The value to validate.
+ * @param {string} name - The name of the parameter being validated.
+ * @private
+ * @throws {Error} If validation fails.
+ */
+function _validatePositiveNumber(value, name) {
+     if (value === null || value === undefined) {
+        throw new Error(`${name} cannot be null or undefined.`);
+    }
+    if (typeof value !== 'number' || isNaN(value) || !isFinite(value)) {
+        throw new Error(`${name} must be a valid number.`);
+    }
+    if (value < 0) {
+        throw new Error(`${name} cannot be negative.`);
+    }
+}
+
+/**
+ * Basic validation for a non-negative integer.
+ * @param {*} value - The value to validate.
+ * @param {string} name - The name of the parameter being validated.
+ * @private
+ * @throws {Error} If validation fails.
+ */
+function _validateNonNegativeInteger(value, name) {
+    _validatePositiveNumber(value, name); // Must be non-negative number first
+    if (!Number.isInteger(value)) {
+        throw new Error(`${name} must be an integer.`);
+    }
+}
+
+
+/**
+ * Validates that a value is a valid status from a given list.
+ * @param {string} status - The status string to validate.
+ * @param {string[]} validStatuses - An array of valid status strings.
+ * @param {string} name - The name of the status being validated (e.g., 'product status').
+ * @private
+ * @throws {Error} If validation fails.
+ */
+function _validateStatus(status, validStatuses, name) {
+    _validateString(status, name);
+    if (!validStatuses.includes(status)) {
+        throw new Error(`Invalid ${name}: "${status}". Must be one of ${validStatuses.join(', ')}.`);
+    }
+}
+
+/**
+ * Validates data required for creating a new product.
+ * @param {object} productData - The data object for creating a product.
+ * @private
+ * @throws {Error} If validation fails.
+ */
+function _validateNewProductData(productData) {
+    if (!productData || typeof productData !== 'object') {
+        throw new Error('Invalid product data: Must be an object.');
+    }
+    _validateString(productData.title, 'product title');
+    if (productData.title.length < 3 || productData.title.length > 100) {
+         throw new Error('Invalid product title: Must be between 3 and 100 characters.');
+    }
+    // Description is optional but validate if provided
+    if (productData.description !== undefined && productData.description !== null) {
+         _validateString(productData.description, 'product description', true); // Allow empty string
+         if (productData.description.length > 500) {
+             throw new Error('Invalid product description: Cannot exceed 500 characters.');
+         }
+    } else {
+        productData.description = ''; // Default if not provided
+    }
+    _validatePositiveNumber(productData.price, 'product price');
+    if (productData.price > 100000) { // Arbitrary max price
+         throw new Error('Invalid product price: Price exceeds maximum allowed value.');
+    }
+    _validateNonNegativeInteger(productData.stock, 'product stock');
+     if (productData.stock > 1000000) { // Arbitrary max stock
+         throw new Error('Invalid product stock: Stock exceeds maximum allowed value.');
+     }
+    // Image URL is optional but validate if provided
+    if (productData.imageUrl !== undefined && productData.imageUrl !== null) {
+        _validateString(productData.imageUrl, 'product imageUrl', true);
+        if (productData.imageUrl.length > 0 && !productData.imageUrl.startsWith('http')) {
+             throw new Error('Invalid product imageUrl: Must be a valid URL starting with http.');
+        }
+    } else {
+        productData.imageUrl = ''; // Default if not provided
+    }
+    // Category is optional but validate if provided
+    if (productData.category !== undefined && productData.category !== null) {
+        _validateString(productData.category, 'product category', true); // Allow empty string
+         if (productData.category.length > 50) {
+             throw new Error('Invalid product category: Cannot exceed 50 characters.');
+         }
+    } else {
+         productData.category = 'uncategorized'; // Default if not provided
+    }
+     // Status is optional but validate if provided, default to 'draft'
+    if (productData.status !== undefined && productData.status !== null) {
+         _validateStatus(productData.status, PRODUCT_STATUSES, 'product status');
+    } else {
+         productData.status = 'draft'; // Default if not provided
+    }
+}
+
+/**
+ * Validates data provided for updating an existing product.
+ * @param {object} updateData - The data object for updating a product.
+ * @private
+ * @throws {Error} If validation fails.
+ */
+function _validateProductUpdateData(updateData) {
+    if (!updateData || typeof updateData !== 'object') {
+        throw new Error('Invalid product update data: Must be an object.');
+    }
+    // Allow partial updates, but validate fields if they exist
+    let hasUpdateFields = false;
+    if (updateData.title !== undefined) {
+        _validateString(updateData.title, 'title');
+        if (updateData.title.length < 3 || updateData.title.length > 100) {
+             throw new Error('Invalid product title: Must be between 3 and 100 characters.');
+        }
+        hasUpdateFields = true;
+    }
+    if (updateData.description !== undefined) {
+        if (updateData.description !== null) { // Allow null/undefined to potentially clear
+             _validateString(updateData.description, 'description', true);
+             if (updateData.description.length > 500) {
+                 throw new Error('Invalid product description: Cannot exceed 500 characters.');
+             }
+        }
+         hasUpdateFields = true;
+    }
+    if (updateData.price !== undefined) {
+        _validatePositiveNumber(updateData.price, 'price');
+        if (updateData.price > 100000) {
+             throw new Error('Invalid product price: Price exceeds maximum allowed value.');
+        }
+        hasUpdateFields = true;
+    }
+    if (updateData.stock !== undefined) {
+        _validateNonNegativeInteger(updateData.stock, 'stock');
+         if (updateData.stock > 1000000) {
+             throw new Error('Invalid product stock: Stock exceeds maximum allowed value.');
+         }
+        hasUpdateFields = true;
+    }
+    if (updateData.imageUrl !== undefined) {
+         if (updateData.imageUrl !== null) {
+             _validateString(updateData.imageUrl, 'imageUrl', true);
+             if (updateData.imageUrl.length > 0 && !updateData.imageUrl.startsWith('http')) {
+                  throw new Error('Invalid product imageUrl: Must be a valid URL starting with http.');
+             }
+         }
+         hasUpdateFields = true;
+    }
+    if (updateData.category !== undefined) {
+        if (updateData.category !== null) {
+            _validateString(updateData.category, 'category', true);
+             if (updateData.category.length > 50) {
+                 throw new Error('Invalid product category: Cannot exceed 50 characters.');
+             }
+        }
+         hasUpdateFields = true;
+    }
+    if (updateData.status !== undefined) {
+        _validateStatus(updateData.status, PRODUCT_STATUSES, 'status');
+        hasUpdateFields = true;
+    }
+
+    if (!hasUpdateFields) {
+         throw new Error('Invalid product update data: No valid fields provided for update.');
+    }
+}
+
+
+/**
+ * Validates data provided for updating the seller profile.
+ * @param {object} updateData - The data object for updating the profile.
+ * @private
+ * @throws {Error} If validation fails.
+ */
+function _validateSellerProfileUpdateData(updateData) {
+    if (!updateData || typeof updateData !== 'object') {
+        throw new Error('Invalid profile update data: Must be an object.');
+    }
+    let hasUpdateFields = false;
+    if (updateData.name !== undefined) {
+        _validateString(updateData.name, 'name');
+        hasUpdateFields = true;
+    }
+    if (updateData.email !== undefined) {
+        _validateString(updateData.email, 'email');
+        // Basic email format check (can be improved)
+        if (!/\S+@\S+\.\S+/.test(updateData.email)) {
+             throw new Error('Invalid email format.');
+        }
+        hasUpdateFields = true;
+    }
+    if (updateData.phone !== undefined) {
+        _validateString(updateData.phone, 'phone');
+        // Basic phone format check (can be improved, e.g., regex)
+         if (updateData.phone.length < 5) {
+              throw new Error('Invalid phone number format.');
+         }
+        hasUpdateFields = true;
+    }
+     if (updateData.address !== undefined) {
+        _validateString(updateData.address, 'address');
+        hasUpdateFields = true;
+    }
+     if (updateData.description !== undefined) {
+        if (updateData.description !== null) {
+             _validateString(updateData.description, 'description', true);
+             if (updateData.description.length > 1000) {
+                  throw new Error('Invalid description: Cannot exceed 1000 characters.');
+             }
+        }
+        hasUpdateFields = true;
+    }
+
+    if (!hasUpdateFields) {
+         throw new Error('Invalid profile update data: No valid fields provided for update.');
+    }
+}
+
+
+/**
+ * Simulates an asynchronous API call with potential network delay and error chance.
+ * Wraps a given operation function.
+ * @param {function(): any} operation - The synchronous function containing the core logic to simulate.
+ * @param {number} [minDelay=SIMULATED_API_MIN_DELAY_MS] - Minimum delay in milliseconds.
+ * @param {number} [maxDelay=SIMULATED_API_MAX_DELAY_MS] - Maximum delay in milliseconds.
+ * @param {number} [errorChance=SIMULATED_API_ERROR_CHANCE] - Probability of a simulated API network/connection error (0 to 1).
+ * @returns {Promise<any>} A promise that resolves with the result of the operation or rejects with an error.
+ * @private
+ */
+function _simulateApiCall(operation, minDelay = SIMULATED_API_MIN_DELAY_MS, maxDelay = SIMULATED_API_MAX_DELAY_MS, errorChance = SIMULATED_API_ERROR_CHANCE) {
+    const delay = Math.random() * (maxDelay - minDelay) + minDelay;
+    const simulateNetworkError = Math.random() < errorChance;
+
+    return new Promise((resolve, reject) => {
+        setTimeout(() => {
+            if (simulateNetworkError) {
+                console.warn(`[YapiSellerService - Simulation] Simulated API network error after ${delay.toFixed(0)}ms delay.`);
+                // Use a generic network error message
+                reject(new Error(`Network Error: Could not connect to the service.`));
+                return;
+            }
+            try {
+                // Execute the actual operation
+                const result = operation();
+                console.debug(`[YapiSellerService - Simulation] Operation successful after ${delay.toFixed(0)}ms delay.`);
+                resolve(result);
+            } catch (error) {
+                // Catch and propagate errors thrown by the operation itself
+                console.error(`[YapiSellerService - Simulation] Operation failed after ${delay.toFixed(0)}ms delay:`, error.message);
+                // Wrap known errors or propagate them
+                if (error instanceof Error) {
+                   reject(error);
+                } else {
+                   reject(new Error(`An unexpected error occurred during the operation: ${error}`));
+                }
+            }
+        }, delay);
+    });
+}
+
+
+// --- Simulate Initial Data Population (for demonstration) ---
+// In a real scenario, this data would come from a backend API.
+function _populateSimulatedData(sellerId) {
+    if (_sellerProfile === null) {
+        _sellerProfile = new SellerProfile({
+            id: sellerId,
+            name: 'Acme Supplies Inc.',
+            email: 'seller@acmesupplies.com',
+            phone: '+1-555-0101',
+            address: '123 Main St, Anytown, CA 91234',
+            description: 'Your one-stop shop for quality goods.',
+            createdAt: new Date(Date.now() - 86400000 * 365), // 1 year ago
+            updatedAt: new Date(Date.now() - 86400000 * 30) // 30 days ago
+        });
+
+        // Simulate some products
+        const product1Id = _generateUniqueId();
+        const product2Id = _generateUniqueId();
+        const product3Id = _generateUniqueId();
+        const product4Id = _generateUniqueId();
+
+        _products = [
+            new Product({
+                id: product1Id,
+                sellerId: sellerId,
+                title: 'Wireless Mouse',
+                description: 'Ergonomic wireless mouse with long battery life.',
+                price: 25.99,
+                stock: 150,
+                imageUrl: 'https://example.com/images/mouse.jpg',
+                category: 'electronics',
+                status: 'active',
+                createdAt: new Date(Date.now() - 86400000 * 100),
+                updatedAt: new Date(Date.now() - 86400000 * 5)
+            }),
+            new Product({
+                id: product2Id,
+                sellerId: sellerId,
+                title: 'Mechanical Keyboard',
+                description: 'Clicky mechanical keyboard for typing enthusiasts.',
+                price: 75.00,
+                stock: 50,
+                imageUrl: 'https://example.com/images/keyboard.jpg',
+                category: 'electronics',
+                status: 'active',
+                 createdAt: new Date(Date.now() - 86400000 * 90),
+                updatedAt: new Date(Date.now() - 86400000 * 2)
+            }),
+             new Product({
+                id: product3Id,
+                sellerId: sellerId,
+                title: 'Desk Lamp',
+                description: 'Adjustable LED desk lamp with dimmer.',
+                price: 35.50,
+                stock: 10, // Low stock
+                imageUrl: 'https://example.com/images/lamp.jpg',
+                category: 'home goods',
+                status: 'active',
+                 createdAt: new Date(Date.now() - 86400000 * 80),
+                updatedAt: new Date(Date.now() - 86400000 * 1)
+            }),
+             new Product({
+                id: product4Id,
+                sellerId: sellerId,
+                title: 'Archived Item',
+                description: 'This product is no longer available.',
+                price: 9.99,
+                stock: 0,
+                imageUrl: 'https://example.com/images/archived.jpg',
+                category: 'misc',
+                status: 'archived',
+                 createdAt: new Date(Date.now() - 86400000 * 200),
+                updatedAt: new Date(Date.now() - 86400000 * 60)
+            }),
+        ];
+
+        // Simulate some orders for these products
+        const order1Id = _generateUniqueId();
+        const order2Id = _generateUniqueId();
+        const order3Id = _generateUniqueId();
+        const order4Id = _generateUniqueId();
+
+
+        _orders = [
+             new Order({
+                id: _generateUniqueId(),
+                orderId: order1Id,
+                sellerId: sellerId,
+                productId: product1Id,
+                productName: 'Wireless Mouse',
+                quantity: 2,
+                itemPrice: 25.99,
+                buyerInfo: { name: 'Alice Smith', address: '456 Oak Ave' },
+                status: 'delivered',
+                orderDate: new Date(Date.now() - 86400000 * 20),
+                updatedAt: new Date(Date.now() - 86400000 * 15)
+            }),
+            new Order({
+                id: _generateUniqueId(),
+                orderId: order2Id,
+                sellerId: sellerId,
+                productId: product2Id,
+                productName: 'Mechanical Keyboard',
+                quantity: 1,
+                itemPrice: 75.00,
+                buyerInfo: { name: 'Bob Johnson', address: '789 Pine Ln' },
+                status: 'shipped',
+                 orderDate: new Date(Date.now() - 86400000 * 10),
+                updatedAt: new Date(Date.now() - 86400000 * 8)
+            }),
+             new Order({
+                id: _generateUniqueId(),
+                orderId: order3Id,
+                sellerId: sellerId,
+                productId: product1Id,
+                productName: 'Wireless Mouse',
+                quantity: 1,
+                itemPrice: 25.99,
+                buyerInfo: { name: 'Charlie Brown', address: '1011 Maple Dr' },
+                status: 'pending',
+                 orderDate: new Date(Date.now() - 86400000 * 2),
+                updatedAt: new Date(Date.now() - 86400000 * 1)
+            }),
+             new Order({
+                id: _generateUniqueId(),
+                orderId: order4Id,
+                sellerId: sellerId,
+                productId: product3Id,
+                productName: 'Desk Lamp',
+                quantity: 1,
+                itemPrice: 35.50,
+                buyerInfo: { name: 'Diana Prince', address: '1213 Elm St' },
+                status: 'processing',
+                 orderDate: new Date(Date.now() - 86400000 * 0.5),
+                updatedAt: new Date(Date.now() - 86400000 * 0.1)
+            }),
+        ];
+         console.log('[YapiSellerService - Simulation] Simulated data populated.');
+    }
+}
+
+
+// --- Main Service Class ---
+
+/**
+ * @class YapiSellerService
+ * @description Provides methods for interacting with seller-specific data on the Yapi platform.
+ * All operations are simulated and asynchronous, mimicking real API calls.
+ */
+class YapiSellerService {
+
+    /**
+     * Creates an instance of YapiSellerService.
+     * @param {string} sellerId - The unique identifier for the seller.
+     * @throws {Error} If sellerId is not provided or is invalid.
+     */
+    constructor(sellerId) {
+        _validateString(sellerId, 'sellerId');
+        this._sellerId = sellerId;
+        _populateSimulatedData(this._sellerId); // Populate data specific to this seller instance (in simulation)
+        console.log(`[YapiSellerService] Initialized for seller: ${this._sellerId}`);
+    }
+
+    /**
+     * Get the seller's unique ID.
+     * @returns {string} The seller ID this service instance is associated with.
+     */
+    getSellerId() {
+        return this._sellerId;
+    }
+
+    // --- Seller Profile Methods ---
+
+    /**
+     * Retrieves the profile information for the current seller.
+     * @returns {Promise<SellerProfile>} A promise that resolves with the seller's profile object.
+     * @throws {Error} If the seller profile is not found (in simulation, this means it wasn't populated).
+     */
+    async getProfile() {
+        console.log(`[YapiSellerService] Attempting to get profile for seller: ${this._sellerId}`);
+        return this._simulateApiCall(() => {
+            if (!_sellerProfile || _sellerProfile.id !== this._sellerId) {
+                // This case should ideally not happen with _populateSimulatedData,
+                // but included for robust simulation logic.
+                console.error(`[YapiSellerService] Profile not found for seller: ${this._sellerId}`);
+                throw new Error(`Seller profile not found.`);
+            }
+            // Return a copy to prevent external modification of the internal state
+            return new SellerProfile(_sellerProfile.toObject());
+        });
+    }
+
+    /**
+     * Updates the profile information for the current seller.
+     * @param {object} updateData - An object containing the fields to update (e.g., { name, email, address }).
+     * @returns {Promise<SellerProfile>} A promise that resolves with the updated seller's profile object.
+     * @throws {Error} If the updateData is invalid or the profile is not found.
+     */
+    async updateProfile(updateData) {
+        console.log(`[YapiSellerService] Attempting to update profile for seller: ${this._sellerId}`);
+        return this._simulateApiCall(() => {
+            _validateSellerProfileUpdateData(updateData);
+
+            if (!_sellerProfile || _sellerProfile.id !== this._sellerId) {
+                 console.error(`[YapiSellerService] Profile not found for update for seller: ${this._sellerId}`);
+                 throw new Error(`Seller profile not found.`);
+            }
+
+            // Apply updates to the internal simulated profile object
+            _sellerProfile.update(updateData);
+
+            console.log(`[YapiSellerService] Profile updated successfully for seller: ${this._sellerId}`);
+            // Return a copy of the updated profile
+            return new SellerProfile(_sellerProfile.toObject());
+        });
+    }
+
+    // --- Product Management Methods ---
+
+    /**
+     * Creates a new product for the seller.
+     * @param {object} productData - The data for the new product (excluding id and sellerId).
+     * @param {string} productData.title - The title of the product.
+     * @param {string} [productData.description] - The description of the product.
+     * @param {number} productData.price - The price of the product.
+     * @param {number} productData.stock - The initial stock quantity.
+     * @param {string} [productData.imageUrl] - The URL of the main product image.
+     * @param {string} [productData.category] - The product category.
+     * @param {string} [productData.status='draft'] - The initial status of the product.
+     * @returns {Promise<Product>} A promise that resolves with the newly created Product object.
+     * @throws {Error} If the productData is invalid.
+     */
+    async createProduct(productData) {
+        console.log(`[YapiSellerService] Attempting to create product for seller: ${this._sellerId}`);
+        return this._simulateApiCall(() => {
+            _validateNewProductData(productData);
+
+            const newProductId = _generateUniqueId();
+            const product = new Product({
+                id: newProductId,
+                sellerId: this._sellerId,
+                ...productData,
+                createdAt: new Date(), // Set creation timestamp
+                updatedAt: new Date()  // Set update timestamp
+            });
+
+            _products.push(product);
+            console.log(`[YapiSellerService] Product created successfully with ID: ${newProductId} for seller: ${this._sellerId}`);
+            // Return a copy
+            return new Product(product.toObject());
+        }, SIMULATED_API_MIN_DELAY_MS, SIMULATED_API_MAX_DELAY_MS, SIMULATED_API_ERROR_CHANCE); // Potentially higher delay/error for creation
+
+    }
+
+    /**
+     * Retrieves a specific product by its ID.
+     * @param {string} productId - The unique identifier of the product.
+     * @returns {Promise<Product>} A promise that resolves with the Product object.
+     * @throws {Error} If the productId is invalid or the product is not found for this seller.
+     */
+    async getProductById(productId) {
+        console.log(`[YapiSellerService] Attempting to get product by ID: ${productId} for seller: ${this._sellerId}`);
+        return this._simulateApiCall(() => {
+            _validateString(productId, 'productId');
+
+            const product = _products.find(p => p.id === productId && p.sellerId === this._sellerId);
+
+            if (!product) {
+                console.error(`[YapiSellerService] Product with ID ${productId} not found for seller: ${this._sellerId}.`);
+                throw new Error(`Product with ID ${productId} not found.`);
+            }
+
+            console.log(`[YapiSellerService] Successfully retrieved product with ID: ${productId}`);
+             // Return a copy
+            return new Product(product.toObject());
+        });
+    }
+
+    /**
+     * Updates an existing product for the seller.
+     * Allows partial updates. Fields not included in updateData will not be changed.
+     * @param {string} productId - The unique identifier of the product to update.
+     * @param {object} updateData - An object containing the fields to update.
+     * @returns {Promise<Product>} A promise that resolves with the updated Product object.
+     * @throws {Error} If the productId is invalid, updateData is invalid, or the product is not found.
+     */
+    async updateProduct(productId, updateData) {
+        console.log(`[YapiSellerService] Attempting to update product ID: ${productId} for seller: ${this._sellerId}`);
+         return this._simulateApiCall(() => {
+            _validateString(productId, 'productId');
+            _validateProductUpdateData(updateData); // Validates the update data object structure and fields
+
+            const productIndex = _products.findIndex(p => p.id === productId && p.sellerId === this._sellerId);
+
+            if (productIndex === -1) {
+                console.error(`[YapiSellerService] Product with ID ${productId} not found for update for seller: ${this._sellerId}.`);
+                throw new Error(`Product with ID ${productId} not found.`);
+            }
+
+            // Apply updates to the found product instance
+            _products[productIndex].update(updateData);
+
+            console.log(`[YapiSellerService] Product ID: ${productId} updated successfully for seller: ${this._sellerId}`);
+            // Return a copy of the updated product
+            return new Product(_products[productIndex].toObject());
+        });
+    }
+
+    /**
+     * Deletes a product permanently.
+     * This simulates a hard delete.
+     * @param {string} productId - The unique identifier of the product to delete.
+     * @returns {Promise<void>} A promise that resolves when the product is deleted.
+     * @throws {Error} If the productId is invalid or the product is not found.
+     */
+    async deleteProduct(productId) {
+        console.log(`[YapiSellerService] Attempting to delete product ID: ${productId} for seller: ${this._sellerId}`);
+        return this._simulateApiCall(() => {
+            _validateString(productId, 'productId');
+
+            const initialLength = _products.length;
+            // Filter out the product. Assumes product IDs are unique to the seller.
+            _products = _products.filter(p => !(p.id === productId && p.sellerId === this._sellerId));
+
+            if (_products.length === initialLength) {
+                console.error(`[YapiSellerService] Product with ID ${productId} not found for delete for seller: ${this._sellerId}.`);
+                throw new Error(`Product with ID ${productId} not found or could not be deleted.`);
+            }
+
+            console.log(`[YapiSellerService] Product ID: ${productId} deleted successfully for seller: ${this._sellerId}`);
+        }, SIMULATED_API_MIN_DELAY_MS, SIMULATED_API_MAX_DELAY_MS * 2, SIMULATED_API_ERROR_CHANCE * 1.5); // Deletion might be slower/riskier
+
+    }
+
+     /**
+     * Archives a product (sets its status to 'archived').
+     * This simulates a soft delete or deactivation.
+     * @param {string} productId - The unique identifier of the product to archive.
+     * @returns {Promise<Product>} A promise that resolves with the updated Product object with status 'archived'.
+     * @throws {Error} If the productId is invalid or the product is not found.
+     */
+    async archiveProduct(productId) {
+         console.log(`[YapiSellerService] Attempting to archive product ID: ${productId} for seller: ${this._sellerId}`);
+         return this._simulateApiCall(async () => { // Use async here if updateProduct is async
+             _validateString(productId, 'productId');
+             // Use updateProduct to handle the actual status change and validation
+             const updatedProduct = await this.updateProduct(productId, { status: 'archived' });
+             console.log(`[YapiSellerService] Product ID: ${productId} archived successfully for seller: ${this._sellerId}`);
+             return updatedProduct; // updateProduct returns the product copy
+         }); // Simulate updateProduct's delay within its own call
+    }
+
+     /**
+     * Unarchives a product (sets its status to 'active').
+     * @param {string} productId - The unique identifier of the product to unarchive.
+     * @returns {Promise<Product>} A promise that resolves with the updated Product object with status 'active'.
+     * @throws {Error} If the productId is invalid or the product is not found or cannot be unarchived.
+     */
+    async unarchiveProduct(productId) {
+         console.log(`[YapiSellerService] Attempting to unarchive product ID: ${productId} for seller: ${this._sellerId}`);
+         return this._simulateApiCall(async () => { // Use async here if updateProduct is async
+             _validateString(productId, 'productId');
+             // Use updateProduct to handle the actual status change and validation
+              // Check current status before attempting to unarchive? Optional, updateProduct handles it.
+             const updatedProduct = await this.updateProduct(productId, { status: 'active' });
+             console.log(`[YapiSellerService] Product ID: ${productId} unarchived successfully for seller: ${this._sellerId}`);
+             return updatedProduct; // updateProduct returns the product copy
+         });
+    }
+
+
+    /**
+     * Lists products for the seller with pagination and filtering options.
+     * @param {object} [options] - Options for listing products.
+     * @param {number} [options.page=1] - The page number (1-based index).
+     * @param {number} [options.limit=10] - The number of items per page.
+     * @param {string} [options.status] - Filter by product status ('draft', 'active', 'archived').
+     * @param {string} [options.category] - Filter by product category.
+     * @param {string} [options.sortBy='createdAt'] - Field to sort by ('createdAt', 'updatedAt', 'title', 'price', 'stock').
+     * @param {'asc'|'desc'} [options.sortOrder='desc'] - Sort order ('asc' or 'desc').
+     * @param {string} [options.searchQuery] - A search term to filter by title or description.
+     * @returns {Promise<{products: Product[], totalCount: number, page: number, limit: number}>} A promise resolving with product data and pagination info.
+     * @throws {Error} If options are invalid.
+     */
+    async listProducts(options = {}) {
+         console.log(`[YapiSellerService] Attempting to list products for seller: ${this._sellerId} with options:`, options);
+         return this._simulateApiCall(() => {
+            // 1. Validate options
+            const page = options.page === undefined ? 1 : options.page;
+            const limit = options.limit === undefined ? 10 : options.limit;
+            const statusFilter = options.status;
+            const categoryFilter = options.category;
+            const sortBy = options.sortBy === undefined ? 'createdAt' : options.sortBy;
+            const sortOrder = options.sortOrder === undefined ? 'desc' : options.sortOrder;
+            const searchQuery = options.searchQuery;
+
+            _validateNonNegativeInteger(page, 'options.page');
+            if (page < 1) throw new Error('options.page must be at least 1.');
+            _validateNonNegativeInteger(limit, 'options.limit');
+            if (limit < 1 || limit > 100) throw new Error('options.limit must be between 1 and 100.'); // Arbitrary limit max
+
+            if (statusFilter !== undefined && statusFilter !== null) {
+                _validateStatus(statusFilter, PRODUCT_STATUSES, 'options.status');
+            }
+             if (categoryFilter !== undefined && categoryFilter !== null) {
+                _validateString(categoryFilter, 'options.category', true); // Allow empty string category
+            }
+             if (sortBy !== undefined && sortBy !== null) {
+                 _validateString(sortBy, 'options.sortBy');
+                 const validSortBy = ['createdAt', 'updatedAt', 'title', 'price', 'stock'];
+                 if (!validSortBy.includes(sortBy)) {
+                     throw new Error(`Invalid options.sortBy: "${sortBy}". Must be one of ${validSortBy.join(', ')}.`);
+                 }
+             }
+             if (sortOrder !== undefined && sortOrder !== null) {
+                 _validateString(sortOrder, 'options.sortOrder');
+                 if (sortOrder !== 'asc' && sortOrder !== 'desc') {
+                     throw new Error(`Invalid options.sortOrder: "${sortOrder}". Must be 'asc' or 'desc'.`);
+                 }
+             }
+             if (searchQuery !== undefined && searchQuery !== null) {
+                 _validateString(searchQuery, 'options.searchQuery', true);
+             }
+
+
+            // 2. Filter products relevant to this seller
+            let filteredProducts = _products.filter(p => p.sellerId === this._sellerId);
+
+            // 3. Apply filters
+            if (statusFilter !== undefined && statusFilter !== null) {
+                 filteredProducts = filteredProducts.filter(p => p.status === statusFilter);
+            }
+             if (categoryFilter !== undefined && categoryFilter !== null) {
+                 // Case-insensitive category filter
+                 filteredProducts = filteredProducts.filter(p => p.category.toLowerCase() === categoryFilter.toLowerCase());
+             }
+             if (searchQuery !== undefined && searchQuery !== null && searchQuery.trim().length > 0) {
+                 const lowerQuery = searchQuery.toLowerCase();
+                 filteredProducts = filteredProducts.filter(p =>
+                     (p.title && p.title.toLowerCase().includes(lowerQuery)) ||
+                     (p.description && p.description.toLowerCase().includes(lowerQuery))
+                 );
+             }
+
+
+            // 4. Apply sorting
+            const sortMultiplier = sortOrder === 'asc' ? 1 : -1;
+            filteredProducts.sort((a, b) => {
+                const valueA = a[sortBy];
+                const valueB = b[sortBy];
+
+                if (valueA === undefined || valueA === null) return -1 * sortMultiplier;
+                if (valueB === undefined || valueB === null) return 1 * sortMultiplier;
+
+                if (typeof valueA === 'string' && typeof valueB === 'string') {
+                    return valueA.localeCompare(valueB) * sortMultiplier;
+                }
+                 if (valueA < valueB) {
+                     return -1 * sortMultiplier;
+                 }
+                 if (valueA > valueB) {
+                     return 1 * sortMultiplier;
+                 }
+                 return 0; // Equal
+            });
+
+            // 5. Apply pagination
+            const totalCount = filteredProducts.length;
+            const startIndex = (page - 1) * limit;
+            const endIndex = startIndex + limit;
+            const paginatedProducts = filteredProducts.slice(startIndex, endIndex);
+
+            console.log(`[YapiSellerService] Listed ${paginatedProducts.length} products (total ${totalCount}) for seller: ${this._sellerId}`);
+
+            // Return copies of products
+            const productObjects = paginatedProducts.map(p => new Product(p.toObject()));
+
+            return {
+                products: productObjects,
+                totalCount: totalCount,
+                page: page,
+                limit: limit
+            };
+        });
+    }
+
+
+    /**
+     * Gets the total count of products for the seller, optionally filtered by status.
+     * @param {object} [filter] - Filter options.
+     * @param {string} [filter.status] - Filter by product status ('draft', 'active', 'archived').
+     * @returns {Promise<number>} A promise resolving with the total number of products.
+     * @throws {Error} If filter options are invalid.
+     */
+    async countProducts(filter = {}) {
+        console.log(`[YapiSellerService] Attempting to count products for seller: ${this._sellerId} with filter:`, filter);
+        return this._simulateApiCall(() => {
+            const statusFilter = filter.status;
+
+            if (statusFilter !== undefined && statusFilter !== null) {
+                _validateStatus(statusFilter, PRODUCT_STATUSES, 'filter.status');
+            }
+
+             let count = _products.filter(p => p.sellerId === this._sellerId).length;
+
+            if (statusFilter !== undefined && statusFilter !== null) {
+                 count = _products.filter(p => p.sellerId === this._sellerId && p.status === statusFilter).length;
+            }
+
+            console.log(`[YapiSellerService] Counted ${count} products for seller: ${this._sellerId}`);
+            return count;
+        });
+    }
+
+
+    // --- Order Management Methods ---
+
+    /**
+     * Lists orders relevant to this seller with pagination and filtering options.
+     * Orders are items where the ordered product belongs to this seller.
+     * @param {object} [options] - Options for listing orders.
+     * @param {number} [options.page=1] - The page number (1-based index).
+     * @param {number} [options.limit=10] - The number of items per page.
+     * @param {string} [options.status] - Filter by order status ('pending', 'processing', etc.).
+     * @param {string} [options.orderId] - Filter by the overall order ID.
+     * @param {string} [options.productId] - Filter by a specific product ID.
+     * @param {Date} [options.startDate] - Filter for orders placed on or after this date.
+     * @param {Date} [options.endDate] - Filter for orders placed on or before this date.
+     * @param {string} [options.sortBy='orderDate'] - Field to sort by ('orderDate', 'updatedAt', 'totalPrice', 'quantity').
+     * @param {'asc'|'desc'} [options.sortOrder='desc'] - Sort order ('asc' or 'desc').
+     * @returns {Promise<{orders: Order[], totalCount: number, page: number, limit: number}>} A promise resolving with order data and pagination info.
+     * @throws {Error} If options are invalid.
+     */
+    async listOrders(options = {}) {
+        console.log(`[YapiSellerService] Attempting to list orders for seller: ${this._sellerId} with options:`, options);
+         return this._simulateApiCall(() => {
+            // 1. Validate options
+            const page = options.page === undefined ? 1 : options.page;
+            const limit = options.limit === undefined ? 10 : options.limit;
+            const statusFilter = options.status;
+            const orderIdFilter = options.orderId;
+            const productIdFilter = options.productId;
+            const startDateFilter = options.startDate instanceof Date ? options.startDate : null;
+            const endDateFilter = options.endDate instanceof Date ? options.endDate : null;
+            const sortBy = options.sortBy === undefined ? 'orderDate' : options.sortBy;
+            const sortOrder = options.sortOrder === undefined ? 'desc' : options.sortOrder;
+
+
+            _validateNonNegativeInteger(page, 'options.page');
+            if (page < 1) throw new Error('options.page must be at least 1.');
+            _validateNonNegativeInteger(limit, 'options.limit');
+            if (limit < 1 || limit > 100) throw new Error('options.limit must be between 1 and 100.');
+
+            if (statusFilter !== undefined && statusFilter !== null) {
+                 _validateStatus(statusFilter, ORDER_STATUSES, 'options.status');
+            }
+             if (orderIdFilter !== undefined && orderIdFilter !== null) {
+                 _validateString(orderIdFilter, 'options.orderId');
+            }
+            if (productIdFilter !== undefined && productIdFilter !== null) {
+                 _validateString(productIdFilter, 'options.productId');
+            }
+             if (startDateFilter !== null && !(startDateFilter instanceof Date) || isNaN(startDateFilter.getTime())) {
+                  throw new Error('options.startDate must be a valid Date object.');
+             }
+             if (endDateFilter !== null && !(endDateFilter instanceof Date) || isNaN(endDateFilter.getTime())) {
+                  throw new Error('options.endDate must be a valid Date object.');
+             }
+             if (startDateFilter && endDateFilter && startDateFilter > endDateFilter) {
+                  throw new Error('options.startDate cannot be after options.endDate.');
+             }
+
+             if (sortBy !== undefined && sortBy !== null) {
+                 _validateString(sortBy, 'options.sortBy');
+                 const validSortBy = ['orderDate', 'updatedAt', 'totalPrice', 'quantity', 'itemPrice'];
+                 if (!validSortBy.includes(sortBy)) {
+                     throw new Error(`Invalid options.sortBy: "${sortBy}". Must be one of ${validSortBy.join(', ')}.`);
+                 }
+             }
+             if (sortOrder !== undefined && sortOrder !== null) {
+                 _validateString(sortOrder, 'options.sortOrder');
+                 if (sortOrder !== 'asc' && sortOrder !== 'desc') {
+                     throw new Error(`Invalid options.sortOrder: "${sortOrder}". Must be 'asc' or 'desc'.`);
+                 }
+             }
+
+
+            // 2. Filter orders relevant to this seller
+            let filteredOrders = _orders.filter(order => order.sellerId === this._sellerId);
+
+            // 3. Apply filters
+            if (statusFilter !== undefined && statusFilter !== null) {
+                 filteredOrders = filteredOrders.filter(order => order.status === statusFilter);
+            }
+            if (orderIdFilter !== undefined && orderIdFilter !== null) {
+                 filteredOrders = filteredOrders.filter(order => order.orderId === orderIdFilter);
+            }
+            if (productIdFilter !== undefined && productIdFilter !== null) {
+                 filteredOrders = filteredOrders.filter(order => order.productId === productIdFilter);
+            }
+            if (startDateFilter !== null) {
+                 filteredOrders = filteredOrders.filter(order => order.orderDate >= startDateFilter);
+            }
+            if (endDateFilter !== null) {
+                 // Include the end date itself
+                 const endOfDay = new Date(endDateFilter);
+                 endOfDay.setHours(23, 59, 59, 999);
+                 filteredOrders = filteredOrders.filter(order => order.orderDate <= endOfDay);
+            }
+
+
+            // 4. Apply sorting
+            const sortMultiplier = sortOrder === 'asc' ? 1 : -1;
+            filteredOrders.sort((a, b) => {
+                 const valueA = a[sortBy];
+                 const valueB = b[sortBy];
+
+                 if (valueA === undefined || valueA === null) return -1 * sortMultiplier;
+                 if (valueB === undefined || valueB === null) return 1 * sortMultiplier;
+
+                 // Handle Date comparison
+                 if (valueA instanceof Date && valueB instanceof Date) {
+                     return (valueA.getTime() - valueB.getTime()) * sortMultiplier;
+                 }
+                 // Handle string comparison
+                 if (typeof valueA === 'string' && typeof valueB === 'string') {
+                     return valueA.localeCompare(valueB) * sortMultiplier;
+                 }
+                 // Handle number comparison
+                 if (valueA < valueB) {
+                     return -1 * sortMultiplier;
+                 }
+                 if (valueA > valueB) {
+                     return 1 * sortMultiplier;
+                 }
+                 return 0; // Equal
+            });
+
+
+            // 5. Apply pagination
+            const totalCount = filteredOrders.length;
+            const startIndex = (page - 1) * limit;
+            const endIndex = startIndex + limit;
+            const paginatedOrders = filteredOrders.slice(startIndex, endIndex);
+
+            console.log(`[YapiSellerService] Listed ${paginatedOrders.length} orders (total ${totalCount}) for seller: ${this._sellerId}`);
+
+            // Return copies of orders
+             const orderObjects = paginatedOrders.map(o => new Order(o.toObject()));
+
+            return {
+                orders: orderObjects,
+                totalCount: totalCount,
+                page: page,
+                limit: limit
+            };
+        });
+    }
+
+    /**
+     * Retrieves a specific order item by its ID.
+     * Note: This retrieves a single item within a potentially larger order.
+     * @param {string} orderItemId - The unique identifier of the order item.
+     * @returns {Promise<Order>} A promise that resolves with the Order object.
+     * @throws {Error} If the orderItemId is invalid or the order item is not found for this seller.
+     */
+    async getOrderItemById(orderItemId) {
+        console.log(`[YapiSellerService] Attempting to get order item by ID: ${orderItemId} for seller: ${this._sellerId}`);
+         return this._simulateApiCall(() => {
+            _validateString(orderItemId, 'orderItemId');
+
+            const orderItem = _orders.find(o => o.id === orderItemId && o.sellerId === this._sellerId);
+
+            if (!orderItem) {
+                console.error(`[YapiSellerService] Order item with ID ${orderItemId} not found for seller: ${this._sellerId}.`);
+                throw new Error(`Order item with ID ${orderItemId} not found.`);
+            }
+
+            console.log(`[YapiSellerService] Successfully retrieved order item with ID: ${orderItemId}`);
+            // Return a copy
+            return new Order(orderItem.toObject());
+        });
+    }
+
+     /**
+     * Updates the status of a specific order item.
+     * @param {string} orderItemId - The unique identifier of the order item to update.
+     * @param {string} newStatus - The new status for the order item ('pending', 'processing', etc.).
+     * @returns {Promise<Order>} A promise that resolves with the updated Order object.
+     * @throws {Error} If the orderItemId is invalid, newStatus is invalid, or the order item is not found.
+     */
+    async updateOrderItemStatus(orderItemId, newStatus) {
+        console.log(`[YapiSellerService] Attempting to update status of order item ID: ${orderItemId} to "${newStatus}" for seller: ${this._sellerId}`);
+        return this._simulateApiCall(() => {
+            _validateString(orderItemId, 'orderItemId');
+            _validateStatus(newStatus, ORDER_STATUSES, 'newStatus');
+
+             const orderItem = _orders.find(o => o.id === orderItemId && o.sellerId === this._sellerId);
+
+            if (!orderItem) {
+                console.error(`[YapiSellerService] Order item with ID ${orderItemId} not found for status update for seller: ${this._sellerId}.`);
+                throw new Error(`Order item with ID ${orderItemId} not found.`);
+            }
+
+            // Apply status update using the Order class method
+            orderItem.updateStatus(newStatus);
+
+            console.log(`[YapiSellerService] Order item ID: ${orderItemId} status updated to "${newStatus}" for seller: ${this._sellerId}`);
+            // Return a copy of the updated order item
+            return new Order(orderItem.toObject());
+        });
+    }
+
+
+    /**
+     * Gets the total count of orders for the seller, optionally filtered by status.
+     * @param {object} [filter] - Filter options.
+     * @param {string} [filter.status] - Filter by order status ('pending', 'processing', etc.).
+     * @returns {Promise<number>} A promise resolving with the total number of orders.
+     * @throws {Error} If filter options are invalid.
+     */
+    async countOrders(filter = {}) {
+         console.log(`[YapiSellerService] Attempting to count orders for seller: ${this._sellerId} with filter:`, filter);
+         return this._simulateApiCall(() => {
+            const statusFilter = filter.status;
+
+            if (statusFilter !== undefined && statusFilter !== null) {
+                _validateStatus(statusFilter, ORDER_STATUSES, 'filter.status');
+            }
+
+            let count = _orders.filter(o => o.sellerId === this._sellerId).length;
+
+            if (statusFilter !== undefined && statusFilter !== null) {
+                 count = _orders.filter(o => o.sellerId === this._sellerId && o.status === statusFilter).length;
+            }
+
+            console.log(`[YapiSellerService] Counted ${count} orders for seller: ${this._sellerId}`);
+            return count;
+        });
+    }
+
+
+    // --- Inventory Methods (Basic) ---
+
+    /**
+     * Updates the stock level for a specific product.
+     * The change quantity can be positive (add stock) or negative (remove stock).
+     * @param {string} productId - The unique identifier of the product.
+     * @param {number} quantityChange - The amount to change the stock by. Can be positive or negative integer.
+     * @returns {Promise<Product>} A promise that resolves with the updated Product object.
+     * @throws {Error} If productId is invalid, quantityChange is not a valid integer, or the product is not found, or if the change results in negative stock.
+     */
+    async updateStock(productId, quantityChange) {
+         console.log(`[YapiSellerService] Attempting to update stock for product ID: ${productId} by ${quantityChange} for seller: ${this._sellerId}`);
+         return this._simulateApiCall(() => {
+            _validateString(productId, 'productId');
+            if (typeof quantityChange !== 'number' || !Number.isInteger(quantityChange)) {
+                 throw new Error('quantityChange must be an integer.');
+            }
+
+             const product = _products.find(p => p.id === productId && p.sellerId === this._sellerId);
+
+            if (!product) {
+                console.error(`[YapiSellerService] Product with ID ${productId} not found for stock update for seller: ${this._sellerId}.`);
+                throw new Error(`Product with ID ${productId} not found.`);
+            }
+
+            const newStock = product.stock + quantityChange;
+            if (newStock < 0) {
+                 console.error(`[YapiSellerService] Stock update for product ID ${productId} failed: Resulting stock would be negative (${newStock}).`);
+                 throw new Error(`Cannot update stock: Resulting stock quantity (${newStock}) cannot be negative.`);
+            }
+
+            product.stock = newStock;
+            product.updatedAt = new Date(); // Mark product as updated
+            console.log(`[YapiSellerService] Stock updated for product ID: ${productId}. New stock: ${product.stock} for seller: ${this._sellerId}`);
+
+            // Return a copy of the updated product
+            return new Product(product.toObject());
+         });
+    }
+
+    /**
+     * Gets the current stock level for a specific product.
+     * @param {string} productId - The unique identifier of the product.
+     * @returns {Promise<number>} A promise that resolves with the current stock quantity.
+     * @throws {Error} If productId is invalid or the product is not found.
+     */
+    async getStockLevel(productId) {
+         console.log(`[YapiSellerService] Attempting to get stock level for product ID: ${productId} for seller: ${this._sellerId}`);
+         return this._simulateApiCall(() => {
+            _validateString(productId, 'productId');
+
+            const product = _products.find(p => p.id === productId && p.sellerId === this._sellerId);
+
+            if (!product) {
+                console.error(`[YapiSellerService] Product with ID ${productId} not found for stock check for seller: ${this._sellerId}.`);
+                throw new Error(`Product with ID ${productId} not found.`);
+            }
+
+            console.log(`[YapiSellerService] Stock level for product ID: ${productId} is ${product.stock} for seller: ${this._sellerId}`);
+            return product.stock;
+         });
+    }
+
+    /**
+     * Lists products for the seller that are currently below a specified stock threshold.
+     * Only lists products with 'active' status by default.
+     * @param {number} threshold - The stock quantity threshold. Products with stock less than this will be listed.
+     * @returns {Promise<Product[]>} A promise that resolves with an array of Product objects with low stock.
+     * @throws {Error} If the threshold is invalid.
+     */
+    async listLowStockProducts(threshold) {
+        console.log(`[YapiSellerService] Attempting to list low stock products (threshold < ${threshold}) for seller: ${this._sellerId}`);
+        return this._simulateApiCall(() => {
+            _validateNonNegativeInteger(threshold, 'threshold');
+            if (threshold < 0) throw new Error('Threshold cannot be negative.');
+
+
+            const lowStockProducts = _products.filter(p =>
+                 p.sellerId === this._sellerId &&
+                 p.status === 'active' && // Typically only active products need stock monitoring
+                 p.stock < threshold
+            );
+
+            console.log(`[YapiSellerService] Found ${lowStockProducts.length} products below stock threshold ${threshold} for seller: ${this._sellerId}`);
+             // Return copies of products
+            return lowStockProducts.map(p => new Product(p.toObject()));
+        });
+    }
+
+
+    // --- Additional Utility/Simulation Methods (Private) ---
+
+    /**
+     * Internal helper to find a product index by ID.
+     * @param {string} productId - The product ID.
+     * @returns {number} The index of the product in the _products array, or -1 if not found.
+     * @private
+     */
+    _findProductIndexById(productId) {
+        // Note: Real API wouldn't expose indices, this is purely for simulation data manipulation
+        return _products.findIndex(p => p.id === productId && p.sellerId === this._sellerId);
+    }
+
+    /**
+     * Internal helper to find an order item index by ID.
+     * @param {string} orderItemId - The order item ID.
+     * @returns {number} The index of the order item in the _orders array, or -1 if not found.
+     * @private
+     */
+    _findOrderItemIndexById(orderItemId) {
+        // Note: Real API wouldn't expose indices, this is purely for simulation data manipulation
+        return _orders.findIndex(o => o.id === orderItemId && o.sellerId === this._sellerId);
+    }
+
+     /**
+     * Simulates clearing all in-memory data for the seller.
+     * Useful for testing or resetting the simulation state.
+     * In a real service, this method would not exist or would require high privileges.
+     * @returns {Promise<void>} A promise that resolves when data is cleared.
+     */
+    async _clearSimulatedData() {
+        console.warn(`[YapiSellerService - Simulation] Clearing simulated data for seller: ${this._sellerId}`);
+         return this._simulateApiCall(() => {
+             _sellerProfile = null; // Reset seller profile
+             _products = []; // Clear products
+             _orders = []; // Clear orders
+             console.warn(`[YapiSellerService - Simulation] Simulated data cleared for seller: ${this._sellerId}`);
+         }, 50, 100); // Faster simulation clear
+    }
+}
+
+// --- Exports ---
+
+/**
+ * @exports YapiSellerService
+ */
+module.exports = YapiSellerService;
+
+// Note: In a real ES Module environment, you would use `export default YapiSellerService;`
+// and potentially export the data classes if needed, e.g., `export { YapiSellerService, Product, Order, SellerProfile };`
+// Using module.exports for Node.js CommonJS compatibility, common in older npm packages.
+
+// Example Usage (Illustrative - would typically be in a separate test or example file)
+/*
+async function runExample() {
+    const sellerId = 'SELLER123';
+    const sellerService = new YapiSellerService(sellerId);
+
+    try {
+        // Get profile
+        const profile = await sellerService.getProfile();
+        console.log('\n--- Seller Profile ---');
+        console.log(profile.toObject());
+
+        // Update profile
+        await sellerService.updateProfile({ phone: '+1-555-9876', description: 'Updated description.' });
+        const updatedProfile = await sellerService.getProfile();
+        console.log('\n--- Updated Seller Profile ---');
+        console.log(updatedProfile.toObject());
+
+        // List products
+        console.log('\n--- Listing Products (Page 1) ---');
+        const productList = await sellerService.listProducts({ page: 1, limit: 2, status: 'active', sortBy: 'title', sortOrder: 'asc' });
+        console.log(`Total active products: ${productList.totalCount}`);
+        productList.products.forEach(p => console.log(p.toObject()));
+
+         console.log('\n--- Listing Products (Page 2) ---');
+        const productList2 = await sellerService.listProducts({ page: 2, limit: 2, status: 'active', sortBy: 'title', sortOrder: 'asc' });
+        productList2.products.forEach(p => console.log(p.toObject()));
+
+        // Get a specific product
+        if (productList.products.length > 0) {
+            const firstProductId = productList.products[0].id;
+            console.log(`\n--- Getting Product ID: ${firstProductId} ---`);
+            const specificProduct = await sellerService.getProductById(firstProductId);
+            console.log(specificProduct.toObject());
+
+             // Update a product
+             console.log(`\n--- Updating Stock for Product ID: ${firstProductId} ---`);
+             const updatedProduct = await sellerService.updateStock(firstProductId, -5); // Sell 5 units
+             console.log(updatedProduct.toObject());
+             const updatedProduct2 = await sellerService.updateStock(firstProductId, 10); // Restock 10 units
+             console.log(updatedProduct2.toObject());
+
+
+             // Archive a product
+             if (productList.products.length > 1) {
+                  const secondProductId = productList.products[1].id;
+                   console.log(`\n--- Archiving Product ID: ${secondProductId} ---`);
+                   await sellerService.archiveProduct(secondProductId);
+                   console.log(`Product ${secondProductId} status is now archived.`);
+             }
+
+
+        } else {
+             console.log('\nNo active products found to demonstrate get/update/archive.');
+        }
+
+
+        // List orders
+        console.log('\n--- Listing Orders (Page 1) ---');
+        const orderList = await sellerService.listOrders({ limit: 3, sortBy: 'orderDate' });
+        console.log(`Total orders: ${orderList.totalCount}`);
+        orderList.orders.forEach(o => console.log(o.toObject()));
+
+        // Get a specific order item
+        if (orderList.orders.length > 0) {
+             const firstOrderItemId = orderList.orders[0].id;
+             console.log(`\n--- Getting Order Item ID: ${firstOrderItemId} ---`);
+             const specificOrderItem = await sellerService.getOrderItemById(firstOrderItemId);
+             console.log(specificOrderItem.toObject());
+
+             // Update order status
+             console.log(`\n--- Updating Status for Order Item ID: ${firstOrderItemId} ---`);
+             const updatedOrderItem = await sellerService.updateOrderItemStatus(firstOrderItemId, 'shipped');
+             console.log(updatedOrderItem.toObject());
+        } else {
+            console.log('\nNo orders found to demonstrate get/update.');
+        }
+
+
+        // Count products by status
+        console.log('\n--- Counting Products by Status ---');
+        const activeCount = await sellerService.countProducts({ status: 'active' });
+        const archivedCount = await sellerService.countProducts({ status: 'archived' });
+         const draftCount = await sellerService.countProducts({ status: 'draft' });
+         const totalProductCount = await sellerService.countProducts();
+        console.log(`Active products: ${activeCount}`);
+        console.log(`Archived products: ${archivedCount}`);
+         console.log(`Draft products: ${draftCount}`);
+         console.log(`Total products: ${totalProductCount}`);
+
+        // Count orders by status
+        console.log('\n--- Counting Orders by Status ---');
+        const pendingCount = await sellerService.countOrders({ status: 'pending' });
+        const shippedCount = await sellerService.countOrders({ status: 'shipped' });
+         const totalOrderCount = await sellerService.countOrders();
+        console.log(`Pending orders: ${pendingCount}`);
+        console.log(`Shipped orders: ${shippedCount}`);
+         console.log(`Total order items: ${totalOrderCount}`);
+
+
+         // List low stock products
+         console.log('\n--- Listing Low Stock Products (Threshold 100) ---');
+         const lowStock = await sellerService.listLowStockProducts(100);
+         lowStock.forEach(p => console.log(`Low Stock: ${p.title} (${p.stock})`));
+
+        // Simulate an error case (e.g., get non-existent product)
+        console.log('\n--- Demonstrating Error Handling (Get non-existent product) ---');
+        try {
+            await sellerService.getProductById('non-existent-id');
+        } catch (error) {
+            console.error('Caught expected error:', error.message);
+        }
+
+        // Simulate an error case (e.g., invalid update data)
+         console.log('\n--- Demonstrating Error Handling (Invalid update data) ---');
+        try {
+            await sellerService.updateProfile({ name: '' }); // Invalid empty string
+        } catch (error) {
+            console.error('Caught expected error:', error.message);
+        }
+
+
+    } catch (error) {
+        console.error('\nAn unexpected error occurred during example execution:', error);
+    } finally {
+         // Clean up simulated data if needed (optional)
+         // await sellerService._clearSimulatedData();
+    }
+}
+
+// runExample();
+*/