@smess/networking 1.0.23 → 1.0.25

package/dist/scripts/dev-test.js

@@ -0,0 +1,803 @@
+import "fake-indexeddb/auto";
+import { timeout, catchError, of } from "rxjs";
+import { AuthService } from "../src/services/auth.service";
+import { StoreService } from "../src/services/store.service";
+import { $logger } from "../src/services/logger.service";
+import { StoreCartService } from "../src/services/store.cart.service";
+import { StoreProductService } from "../src/services/store.product.service";
+function isNetworkingUIEventWrapped(val) {
+    return (typeof val === "object" &&
+        val !== null &&
+        "hasSuccess" in val &&
+        "hasFailed" in val &&
+        "response" in val);
+}
+async function testE2EStoreFlow() {
+    $logger.info("🚀 Starting E2E Store Flow Test", undefined, "dev-test");
+    const config = {
+        baseUrl: "http://server-dev.localhost",
+        version: "api/v1",
+        isProd: false,
+        clientId: "0338bd6b-9e8b-11ef-bd86-5d6b03cdf979",
+    };
+    const authService = new AuthService(config);
+    const storeService = new StoreService(config);
+    const productService = new StoreProductService(config);
+    // Step 1: Get all stores
+    $logger.info("📋 Step 1: Getting all stores...", undefined, "dev-test");
+    let storeId = null;
+    try {
+        const storeListObs$ = storeService.list().pipe(timeout({ first: 10000 }), catchError((err) => {
+            $logger.error("❌ Get store list error", err, "dev-test");
+            return of(undefined);
+        }));
+        await new Promise((resolve, reject) => {
+            let emitted = false;
+            storeListObs$.subscribe({
+                next: (val) => {
+                    emitted = true;
+                    if (isNetworkingUIEventWrapped(val) &&
+                        val.hasSuccess &&
+                        val.response) {
+                        $logger.info("✅ Step 1: Store list retrieved successfully", val.response, "dev-test");
+                        // Use the provided store ID for next steps
+                        storeId = "60e23399-be11-11ef-807e-0242ac120004";
+                        resolve(undefined);
+                    }
+                    else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
+                        $logger.error("❌ Step 1: Failed to get store list", val.alertModel || val, "dev-test");
+                        reject(new Error("Get store list failed"));
+                    }
+                },
+                error: (err) => {
+                    $logger.error("❌ Step 1: Observable error", err, "dev-test");
+                    reject(err);
+                },
+                complete: () => {
+                    if (!emitted) {
+                        reject(new Error("No emission"));
+                    }
+                },
+            });
+        });
+    }
+    catch (err) {
+        $logger.error("❌ Step 1 failed", err, "dev-test");
+        throw err;
+    }
+    if (!storeId) {
+        $logger.error("❌ No store ID available", undefined, "dev-test");
+        throw new Error("No store ID");
+    }
+    // Step 1.5: Get product categories
+    $logger.info("📋 Step 1.5: Getting product categories...", undefined, "dev-test");
+    try {
+        const productCategoriesObs$ = productService.getProductCategoryList().pipe(timeout({ first: 10000 }), catchError((err) => {
+            $logger.error("❌ Get product categories error", err, "dev-test");
+            return of(undefined);
+        }));
+        await new Promise((resolve, reject) => {
+            let emitted = false;
+            productCategoriesObs$.subscribe({
+                next: (val) => {
+                    emitted = true;
+                    if (isNetworkingUIEventWrapped(val) &&
+                        val.hasSuccess &&
+                        val.response) {
+                        const response = val.response;
+                        const categories = response?.data || response;
+                        $logger.info("✅ Step 1.5: Product categories retrieved successfully", undefined, "dev-test");
+                        $logger.info(`📊 Categories found: ${Array.isArray(categories) ? categories.length : 0}`, { categories: Array.isArray(categories) ? categories.slice(0, 5) : [] }, "dev-test");
+                        resolve(undefined);
+                    }
+                    else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
+                        $logger.error("❌ Step 1.5: Failed to get product categories", val.alertModel || val, "dev-test");
+                        reject(new Error("Get product categories failed"));
+                    }
+                },
+                error: (err) => {
+                    $logger.error("❌ Step 1.5: Observable error", err, "dev-test");
+                    reject(err);
+                },
+                complete: () => {
+                    if (!emitted) {
+                        reject(new Error("No emission"));
+                    }
+                },
+            });
+        });
+    }
+    catch (err) {
+        $logger.error("❌ Step 1.5 failed", err, "dev-test");
+        throw err;
+    }
+    // Step 2: Get product collection
+    $logger.info(`📋 Step 2: Getting product collection for store ${storeId}...`, undefined, "dev-test");
+    let productIds = [];
+    try {
+        const productCollectionPayload = {
+            page: 1,
+            per_page: 10,
+        };
+        const productCollectionObs$ = productService
+            .getProductCollectionByStore(storeId, productCollectionPayload)
+            .pipe(timeout({ first: 10000 }), catchError((err) => {
+            $logger.error("❌ Get product collection error", err, "dev-test");
+            return of(undefined);
+        }));
+        await new Promise((resolve, reject) => {
+            let emitted = false;
+            productCollectionObs$.subscribe({
+                next: (val) => {
+                    emitted = true;
+                    if (isNetworkingUIEventWrapped(val) &&
+                        val.hasSuccess &&
+                        val.response) {
+                        $logger.info("✅ Step 2: Product collection retrieved successfully", undefined, "dev-test");
+                        // Extract product IDs from the response
+                        let response = val.response;
+                        // Handle string response - parse it as JSON
+                        if (typeof response === 'string') {
+                            try {
+                                // Find the first complete JSON object by looking for balanced braces
+                                let jsonStart = response.indexOf('{');
+                                if (jsonStart === -1) {
+                                    throw new Error("No JSON object found in response");
+                                }
+                                let braceCount = 0;
+                                let jsonEnd = -1;
+                                for (let i = jsonStart; i < response.length; i++) {
+                                    if (response[i] === '{') {
+                                        braceCount++;
+                                    }
+                                    else if (response[i] === '}') {
+                                        braceCount--;
+                                        if (braceCount === 0) {
+                                            jsonEnd = i + 1;
+                                            break;
+                                        }
+                                    }
+                                }
+                                if (jsonEnd === -1) {
+                                    throw new Error("Incomplete JSON object in response");
+                                }
+                                const jsonString = response.substring(jsonStart, jsonEnd);
+                                response = JSON.parse(jsonString);
+                                $logger.info("✅ Parsed string response as JSON", undefined, "dev-test");
+                            }
+                            catch (e) {
+                                $logger.error("❌ Failed to parse string response as JSON", e, "dev-test");
+                                resolve(undefined);
+                                return;
+                            }
+                        }
+                        // Log the response structure for debugging
+                        $logger.info("📊 Response structure:", {
+                            hasData: !!response?.data,
+                            hasItems: !!response?.items,
+                            dataItemsLength: response?.data?.items?.length,
+                            itemsLength: response?.items?.length,
+                            responseType: typeof response,
+                            responseKeys: response ? Object.keys(response) : [],
+                        }, "dev-test");
+                        // Try different response structures
+                        let items = null;
+                        if (response?.data?.items && Array.isArray(response.data.items)) {
+                            items = response.data.items;
+                            $logger.info("✅ Using response.data.items", undefined, "dev-test");
+                        }
+                        else if (response?.items && Array.isArray(response.items)) {
+                            items = response.items;
+                            $logger.info("✅ Using response.items", undefined, "dev-test");
+                        }
+                        else {
+                            $logger.warn("❌ No items found in response", {
+                                responseType: typeof response,
+                                responseKeys: response ? Object.keys(response) : [],
+                                dataKeys: response?.data ? Object.keys(response.data) : [],
+                            }, "dev-test");
+                        }
+                        if (items && items.length > 0) {
+                            // Extract all product IDs
+                            productIds = items.map((item) => item.id);
+                            $logger.info(`📦 Product IDs extracted: ${productIds.length} products`, { productIds: productIds.slice(0, 5) }, // Show first 5
+                            "dev-test");
+                        }
+                        else {
+                            $logger.warn("⚠️ No products found in collection", {
+                                responseType: typeof response,
+                                responseKeys: response ? Object.keys(response) : [],
+                                dataKeys: response?.data ? Object.keys(response.data) : [],
+                                itemsType: typeof items,
+                                itemsLength: items?.length
+                            }, "dev-test");
+                        }
+                        resolve(undefined);
+                    }
+                    else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
+                        $logger.error("❌ Step 2: Failed to get product collection", val.alertModel || val, "dev-test");
+                        reject(new Error("Get product collection failed"));
+                    }
+                },
+                error: (err) => {
+                    $logger.error("❌ Step 2: Observable error", err, "dev-test");
+                    reject(err);
+                },
+                complete: () => {
+                    if (!emitted) {
+                        reject(new Error("No emission"));
+                    }
+                },
+            });
+        });
+    }
+    catch (err) {
+        $logger.error("❌ Step 2 failed", err, "dev-test");
+        throw err;
+    }
+    if (productIds.length === 0) {
+        $logger.warn("⚠️ No product IDs available, skipping remaining steps", undefined, "dev-test");
+        return;
+    }
+    // Step 3: Get product details using StoreProductService
+    const productId = productIds[0]; // Use first product
+    $logger.info(`📋 Step 3: Getting product details for ${productId}...`, undefined, "dev-test");
+    try {
+        const productDetailsObs$ = productService.getProductById(productId).pipe(timeout({ first: 10000 }), catchError((err) => {
+            $logger.error("❌ Get product details error", err, "dev-test");
+            return of(undefined);
+        }));
+        await new Promise((resolve, reject) => {
+            let emitted = false;
+            productDetailsObs$.subscribe({
+                next: (val) => {
+                    emitted = true;
+                    if (isNetworkingUIEventWrapped(val) &&
+                        val.hasSuccess &&
+                        val.response) {
+                        $logger.info("✅ Step 3: Product details retrieved successfully", val.response, "dev-test");
+                        resolve(undefined);
+                    }
+                    else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
+                        $logger.error("❌ Step 3: Failed to get product details", val.alertModel || val, "dev-test");
+                        reject(new Error("Get product details failed"));
+                    }
+                },
+                error: (err) => {
+                    $logger.error("❌ Step 3: Observable error", err, "dev-test");
+                    reject(err);
+                },
+                complete: () => {
+                    if (!emitted) {
+                        reject(new Error("No emission"));
+                    }
+                },
+            });
+        });
+    }
+    catch (err) {
+        $logger.error("❌ Step 3 failed", err, "dev-test");
+        throw err;
+    }
+    // Step 4: Get cart using StoreCartService
+    $logger.info(`📋 Step 4: Getting cart for store ${storeId}...`, undefined, "dev-test");
+    // Set the selected store ID in StoreService
+    storeService.setSelectedStoreId(storeId);
+    // Create cart service with the shared storeId observable from StoreService
+    const cartService = new StoreCartService(config, storeService.$selectedStoreId);
+    try {
+        const cartObs$ = cartService.getCart().pipe(timeout({ first: 10000 }), catchError((err) => {
+            $logger.error("❌ Get cart error", err, "dev-test");
+            return of(undefined);
+        }));
+        await new Promise((resolve, reject) => {
+            let emitted = false;
+            cartObs$.subscribe({
+                next: (val) => {
+                    emitted = true;
+                    if (isNetworkingUIEventWrapped(val) &&
+                        val.hasSuccess &&
+                        val.response) {
+                        $logger.info("✅ Step 4: Cart retrieved successfully", undefined, "dev-test");
+                        // Extract actual cart data
+                        const cartResponse = val.response;
+                        const actualCart = cartResponse?.data || cartResponse;
+                        $logger.info("📊 Cart Response Structure:", {
+                            hasData: !!cartResponse?.data,
+                            hasCartItems: !!actualCart?.cartItems,
+                            hasCartHash: !!actualCart?.cartHash,
+                        }, "dev-test");
+                        if (actualCart?.cartHash) {
+                            $logger.info(`🔐 Cart Hash: ${actualCart.cartHash}`, undefined, "dev-test");
+                        }
+                        resolve(undefined);
+                    }
+                    else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
+                        $logger.error("❌ Step 4: Failed to get cart", val.alertModel || val, "dev-test");
+                        reject(new Error("Get cart failed"));
+                    }
+                },
+                error: (err) => {
+                    $logger.error("❌ Step 4: Observable error", err, "dev-test");
+                    reject(err);
+                },
+                complete: () => {
+                    if (!emitted) {
+                        reject(new Error("No emission"));
+                    }
+                },
+            });
+        });
+    }
+    catch (err) {
+        $logger.error("❌ Step 4 failed", err, "dev-test");
+        throw err;
+    }
+    // Step 5: Add item to cart
+    let cartItemId = null;
+    $logger.info(`📋 Step 5: Adding product ${productId} to cart...`, undefined, "dev-test");
+    try {
+        const addItemPayload = {
+            product_id: productId,
+            quantity: 2,
+        };
+        const addItemObs$ = cartService.addItem(addItemPayload).pipe(timeout({ first: 10000 }), catchError((err) => {
+            $logger.error("❌ Add item to cart error", err, "dev-test");
+            return of(undefined);
+        }));
+        await new Promise((resolve, reject) => {
+            let emitted = false;
+            addItemObs$.subscribe({
+                next: (val) => {
+                    emitted = true;
+                    if (isNetworkingUIEventWrapped(val) &&
+                        val.hasSuccess &&
+                        val.response) {
+                        $logger.info("✅ Step 5: Item added to cart successfully", undefined, "dev-test");
+                        // Log updated cart details
+                        const cartResponse = val.response;
+                        // Check if response has data wrapper
+                        const actualCart = cartResponse?.data || cartResponse;
+                        $logger.info("📊 Cart Response Structure:", {
+                            hasData: !!cartResponse?.data,
+                            hasCartItems: !!actualCart?.cartItems,
+                            hasCartHash: !!actualCart?.cartHash,
+                        }, "dev-test");
+                        $logger.info(`🛒 Cart updated:`, {
+                            totalItems: actualCart?.cartItems?.length || 0,
+                            total: actualCart?.total || 0,
+                            cartHash: actualCart?.cartHash,
+                        }, "dev-test");
+                        // Extract cart item ID for next step
+                        if (actualCart?.cartItems && actualCart.cartItems.length > 0) {
+                            cartItemId = actualCart.cartItems[0].id;
+                            $logger.info(`🔖 Cart Item ID: ${cartItemId}`, undefined, "dev-test");
+                        }
+                        resolve(undefined);
+                    }
+                    else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
+                        $logger.error("❌ Step 5: Failed to add item to cart", val.alertModel || val, "dev-test");
+                        reject(new Error("Add item to cart failed"));
+                    }
+                },
+                error: (err) => {
+                    $logger.error("❌ Step 5: Observable error", err, "dev-test");
+                    reject(err);
+                },
+                complete: () => {
+                    if (!emitted) {
+                        reject(new Error("No emission"));
+                    }
+                },
+            });
+        });
+    }
+    catch (err) {
+        $logger.error("❌ Step 5 failed", err, "dev-test");
+        throw err;
+    }
+    // Step 6: Update item quantity
+    if (!cartItemId) {
+        $logger.warn("⚠️ No cart item ID available, skipping update quantity step", undefined, "dev-test");
+    }
+    else {
+        $logger.info(`📋 Step 6: Updating quantity for cart item ${cartItemId}...`, undefined, "dev-test");
+        try {
+            const updateQuantityPayload = {
+                quantity: 5,
+            };
+            const updateQuantityObs$ = cartService
+                .updateItemQuantity(cartItemId, updateQuantityPayload)
+                .pipe(timeout({ first: 10000 }), catchError((err) => {
+                $logger.error("❌ Update item quantity error", err, "dev-test");
+                return of(undefined);
+            }));
+            await new Promise((resolve, reject) => {
+                let emitted = false;
+                updateQuantityObs$.subscribe({
+                    next: (val) => {
+                        emitted = true;
+                        if (isNetworkingUIEventWrapped(val) &&
+                            val.hasSuccess &&
+                            val.response) {
+                            $logger.info("✅ Step 6: Item quantity updated successfully", undefined, "dev-test");
+                            // Log updated cart details
+                            const cartResponse = val.response;
+                            const actualCart = cartResponse?.data || cartResponse;
+                            $logger.info(`🛒 Cart after quantity update:`, {
+                                totalItems: actualCart?.cartItems?.length || 0,
+                                total: actualCart?.total || 0,
+                                cartHash: actualCart?.cartHash,
+                            }, "dev-test");
+                            resolve(undefined);
+                        }
+                        else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
+                            $logger.error("❌ Step 6: Failed to update item quantity", val.alertModel || val, "dev-test");
+                            reject(new Error("Update item quantity failed"));
+                        }
+                    },
+                    error: (err) => {
+                        $logger.error("❌ Step 6: Observable error", err, "dev-test");
+                        reject(err);
+                    },
+                    complete: () => {
+                        if (!emitted) {
+                            reject(new Error("No emission"));
+                        }
+                    },
+                });
+            });
+        }
+        catch (err) {
+            $logger.error("❌ Step 6 failed", err, "dev-test");
+            throw err;
+        }
+    }
+    // Step 7: Add 2 more items from product IDs
+    let cartItem2Id = null;
+    $logger.info("📋 Step 7: Adding 2 more items to cart...", undefined, "dev-test");
+    if (productIds.length < 3) {
+        $logger.warn(`⚠️ Not enough products (need 3, have ${productIds.length}), skipping step 7`, undefined, "dev-test");
+    }
+    else {
+        try {
+            // Use 2nd and 3rd products from our product IDs array
+            const product2Id = productIds[1];
+            const product3Id = productIds[2];
+            $logger.info(`➕ Adding product 2: ${product2Id}`, undefined, "dev-test");
+            // Add second product
+            try {
+                const addItem2Obs$ = cartService.addItem({
+                    product_id: product2Id,
+                    quantity: 1,
+                }).pipe(timeout({ first: 10000 }), catchError((err) => {
+                    $logger.error("❌ Add item 2 error", err, "dev-test");
+                    return of(undefined);
+                }));
+                await new Promise((resolve2, reject2) => {
+                    addItem2Obs$.subscribe({
+                        next: (val2) => {
+                            if (isNetworkingUIEventWrapped(val2) &&
+                                val2.hasSuccess &&
+                                val2.response) {
+                                // Extract cart item 2 ID for later removal
+                                const cartResponse = val2.response;
+                                const actualCart = cartResponse?.data || cartResponse;
+                                $logger.info("✅ Product 2 added successfully", {
+                                    totalItems: actualCart?.cartItems?.length || 0,
+                                    cartHash: actualCart?.cartHash,
+                                }, "dev-test");
+                                // Find the item we just added (should be the second item in the cart)
+                                if (actualCart?.cartItems && actualCart.cartItems.length >= 2) {
+                                    // The second item (index 1) should be the one we just added
+                                    cartItem2Id = actualCart.cartItems[1].id;
+                                    $logger.info(`🔖 Cart Item 2 ID: ${cartItem2Id}`, undefined, "dev-test");
+                                }
+                                else if (actualCart?.cartItems && actualCart.cartItems.length === 1) {
+                                    // If there's only 1 item, it means this is the first item added
+                                    // This shouldn't happen in our flow, but handle it
+                                    cartItem2Id = actualCart.cartItems[0].id;
+                                    $logger.warn(`⚠️ Only 1 item in cart, using item ID: ${cartItem2Id}`, undefined, "dev-test");
+                                }
+                                else {
+                                    $logger.error("❌ No items in cart after adding product 2", { actualCart }, "dev-test");
+                                }
+                                resolve2();
+                            }
+                            else if (isNetworkingUIEventWrapped(val2) && val2.hasFailed) {
+                                reject2(new Error("Add product 2 failed"));
+                            }
+                        },
+                        error: reject2,
+                        complete: () => { },
+                    });
+                });
+            }
+            catch (err) {
+                $logger.error("❌ Failed to add product 2", err, "dev-test");
+            }
+            $logger.info(`➕ Adding product 3: ${product3Id}`, undefined, "dev-test");
+            // Add third product
+            try {
+                const addItem3Obs$ = cartService.addItem({
+                    product_id: product3Id,
+                    quantity: 3,
+                }).pipe(timeout({ first: 10000 }), catchError((err) => {
+                    $logger.error("❌ Add item 3 error", err, "dev-test");
+                    return of(undefined);
+                }));
+                await new Promise((resolve3, reject3) => {
+                    addItem3Obs$.subscribe({
+                        next: (val3) => {
+                            if (isNetworkingUIEventWrapped(val3) &&
+                                val3.hasSuccess &&
+                                val3.response) {
+                                const cartResponse = val3.response;
+                                $logger.info("✅ Product 3 added successfully", undefined, "dev-test");
+                                // Log the full response structure to debug
+                                $logger.info("📊 Cart Response Structure:", {
+                                    hasData: !!cartResponse?.data,
+                                    hasCartItems: !!cartResponse?.cartItems,
+                                    hasDataCartItems: !!cartResponse?.data?.cartItems,
+                                    dataCartItemsLength: cartResponse?.data?.cartItems?.length,
+                                    cartItemsLength: cartResponse?.cartItems?.length,
+                                    hasCartHash: !!cartResponse?.cartHash,
+                                    hasDataCartHash: !!cartResponse?.data?.cartHash,
+                                }, "dev-test");
+                                // Try to extract from different possible structures
+                                let finalCartItems = null;
+                                let finalTotal = 0;
+                                let finalCartHash = null;
+                                if (cartResponse?.data) {
+                                    finalCartItems = cartResponse.data.cartItems || [];
+                                    finalTotal = cartResponse.data.total || 0;
+                                    finalCartHash = cartResponse.data.cartHash;
+                                }
+                                else {
+                                    finalCartItems = cartResponse?.cartItems || [];
+                                    finalTotal = cartResponse?.total || 0;
+                                    finalCartHash = cartResponse?.cartHash;
+                                }
+                                $logger.info(`🛒 Final cart status:`, {
+                                    totalItems: finalCartItems?.length || 0,
+                                    total: finalTotal,
+                                    cartHash: finalCartHash,
+                                }, "dev-test");
+                                resolve3();
+                            }
+                            else if (isNetworkingUIEventWrapped(val3) && val3.hasFailed) {
+                                reject3(new Error("Add product 3 failed"));
+                            }
+                        },
+                        error: reject3,
+                        complete: () => { },
+                    });
+                });
+            }
+            catch (err) {
+                $logger.error("❌ Failed to add product 3", err, "dev-test");
+            }
+            $logger.info("✅ Step 7: All items added successfully", undefined, "dev-test");
+        }
+        catch (err) {
+            $logger.error("❌ Step 7 failed", err, "dev-test");
+            throw err;
+        }
+    }
+    // Step 8: Remove item 2 from cart
+    // Step 7.5: Batch add/update items using new endpoint
+    $logger.info("📋 Step 7.5: Batch add/update items...", undefined, "dev-test");
+    try {
+        // Build a dynamic payload based on available product IDs
+        const createPayload = [];
+        const updatePayload = [];
+        // Use additional product IDs for 'create' if available
+        if (productIds.length >= 4) {
+            createPayload.push({ product_id: productIds[3], quantity: 2 });
+        }
+        if (productIds.length >= 5) {
+            createPayload.push({ product_id: productIds[4], quantity: 1 });
+        }
+        // Update the first product quantity if present
+        if (productIds.length >= 1) {
+            updatePayload.push({ product_id: productIds[0], quantity: 5 });
+        }
+        if (createPayload.length === 0 && updatePayload.length === 0) {
+            $logger.warn("⚠️ Not enough products to perform batch operation, skipping step 7.5", undefined, "dev-test");
+        }
+        else {
+            const batchPayload = {};
+            if (createPayload.length > 0)
+                batchPayload.create = createPayload;
+            if (updatePayload.length > 0)
+                batchPayload.update = updatePayload;
+            const batchObs$ = (new StoreCartService(config, storeService.$selectedStoreId))
+                .batchItems(batchPayload)
+                .pipe(timeout({ first: 10000 }), catchError((err) => {
+                $logger.error("❌ Batch add/update items error", err, "dev-test");
+                return of(undefined);
+            }));
+            await new Promise((resolve, reject) => {
+                let emitted = false;
+                batchObs$.subscribe({
+                    next: (val) => {
+                        emitted = true;
+                        if (isNetworkingUIEventWrapped(val) &&
+                            val.hasSuccess &&
+                            val.response) {
+                            const cartResponse = val.response;
+                            const actualCart = cartResponse?.data || cartResponse;
+                            $logger.info("✅ Step 7.5: Batch operation succeeded", undefined, "dev-test");
+                            $logger.info("🛒 Cart after batch operation:", {
+                                totalItems: actualCart?.cartItems?.length || 0,
+                                total: actualCart?.total || 0,
+                                cartHash: actualCart?.cartHash,
+                            }, "dev-test");
+                            resolve(undefined);
+                        }
+                        else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
+                            $logger.error("❌ Step 7.5: Batch operation failed", val.alertModel || val, "dev-test");
+                            reject(new Error("Batch items failed"));
+                        }
+                    },
+                    error: (err) => {
+                        $logger.error("❌ Step 7.5: Observable error", err, "dev-test");
+                        reject(err);
+                    },
+                    complete: () => {
+                        if (!emitted) {
+                            reject(new Error("No emission"));
+                        }
+                    },
+                });
+            });
+        }
+    }
+    catch (err) {
+        $logger.error("❌ Step 7.5 failed", err, "dev-test");
+        throw err;
+    }
+    // Step 8: Remove item 2 from cart
+    if (!cartItem2Id) {
+        $logger.warn("⚠️ No cart item 2 ID available, skipping remove item step", undefined, "dev-test");
+    }
+    else {
+        $logger.info(`📋 Step 8: Removing item 2 (${cartItem2Id}) from cart...`, undefined, "dev-test");
+        try {
+            const deleteItemObs$ = cartService.deleteItem(cartItem2Id).pipe(timeout({ first: 10000 }), catchError((err) => {
+                $logger.error("❌ Delete item error", err, "dev-test");
+                return of(undefined);
+            }));
+            await new Promise((resolve, reject) => {
+                let emitted = false;
+                deleteItemObs$.subscribe({
+                    next: (val) => {
+                        emitted = true;
+                        if (isNetworkingUIEventWrapped(val) &&
+                            val.hasSuccess) {
+                            $logger.info("✅ Step 8: Item 2 removed successfully", undefined, "dev-test");
+                            // Get cart to see updated state
+                            cartService.getCart().pipe(timeout({ first: 10000 }), catchError((err) => {
+                                $logger.error("❌ Get cart after delete error", err, "dev-test");
+                                return of(undefined);
+                            })).subscribe({
+                                next: (cartVal) => {
+                                    if (isNetworkingUIEventWrapped(cartVal) &&
+                                        cartVal.hasSuccess &&
+                                        cartVal.response) {
+                                        const cartResponse = cartVal.response;
+                                        const actualCart = cartResponse?.data || cartResponse;
+                                        $logger.info(`🛒 Cart after removing item 2:`, {
+                                            totalItems: actualCart?.cartItems?.length || 0,
+                                            total: actualCart?.total || 0,
+                                            cartHash: actualCart?.cartHash,
+                                        }, "dev-test");
+                                    }
+                                },
+                            });
+                            resolve(undefined);
+                        }
+                        else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
+                            $logger.error("❌ Step 8: Failed to remove item 2", val.alertModel || val, "dev-test");
+                            reject(new Error("Delete item failed"));
+                        }
+                    },
+                    error: (err) => {
+                        $logger.error("❌ Step 8: Observable error", err, "dev-test");
+                        reject(err);
+                    },
+                    complete: () => {
+                        if (!emitted) {
+                            reject(new Error("No emission"));
+                        }
+                    },
+                });
+            });
+        }
+        catch (err) {
+            $logger.error("❌ Step 8 failed", err, "dev-test");
+            throw err;
+        }
+    }
+    // Step 9: Update cart with customer information
+    $logger.info("📋 Step 9: Updating cart with customer information...", undefined, "dev-test");
+    try {
+        const updateCartPayload = {
+            status: "submitted",
+            customer_note: "Customer Note Example",
+            customer_id: "f1df6e9a-0160-11f0-82c2-6cac1a7e2953",
+            payment_method: "bank_transfer",
+            delivery_type: "delivery",
+            billing_information: {
+                email: "billing@example.com",
+                phone_number: "+1-555-111-2222",
+                street: "456 Market Street",
+                city: "san_francisco",
+                postal_code: "94103",
+                state: "ca",
+                country: "us",
+            },
+            shipping_information: {
+                email: "john.doe@example.com",
+                phone_number: "+1-555-123-4567",
+                street: "123 Main Street",
+                city: "san_francisco",
+                postal_code: "94105",
+                state: "ca",
+                country: "us",
+            },
+        };
+        const updateCartObs$ = cartService.updateCart(updateCartPayload).pipe(timeout({ first: 10000 }), catchError((err) => {
+            $logger.error("❌ Update cart error", err, "dev-test");
+            return of(undefined);
+        }));
+        await new Promise((resolve, reject) => {
+            let emitted = false;
+            updateCartObs$.subscribe({
+                next: (val) => {
+                    emitted = true;
+                    if (isNetworkingUIEventWrapped(val) &&
+                        val.hasSuccess &&
+                        val.response) {
+                        $logger.info("✅ Step 9: Cart updated successfully", undefined, "dev-test");
+                        const cartResponse = val.response;
+                        const actualCart = cartResponse?.data || cartResponse;
+                        $logger.info(`🛒 Complete Final Cart Information:`, actualCart, "dev-test");
+                        resolve(undefined);
+                    }
+                    else if (isNetworkingUIEventWrapped(val) && val.hasFailed) {
+                        $logger.error("❌ Step 9: Failed to update cart", val.alertModel || val, "dev-test");
+                        reject(new Error("Update cart failed"));
+                    }
+                },
+                error: (err) => {
+                    $logger.error("❌ Step 9: Observable error", err, "dev-test");
+                    reject(err);
+                },
+                complete: () => {
+                    if (!emitted) {
+                        reject(new Error("No emission"));
+                    }
+                },
+            });
+        });
+    }
+    catch (err) {
+        $logger.error("❌ Step 9 failed", err, "dev-test");
+        throw err;
+    }
+    $logger.info("🎉 E2E Store Flow completed successfully!", undefined, "dev-test");
+}
+(async () => {
+    try {
+        // E2E Store Flow Test
+        await testE2EStoreFlow();
+        $logger.info("✅ E2E Store Flow test passed!", undefined, "dev-test");
+        $logger.info("🎉 All dev API tests passed!", undefined, "dev-test");
+        process.exit(0);
+    }
+    catch (err) {
+        $logger.error("❌ E2E Store Flow test failed", err, "dev-test");
+        process.exit(1);
+    }
+})();