@shyntech-proximity/inventories 1.0.0

package/README.md

@@ -0,0 +1,135 @@
+# Inventory Backend API Documentation
+
+**Base URL:** `/api` (example)
+**Auth:** Currently relies on device headers (`x-device-sig`, `x-ws-token`) and IP-based identification for proximity features.
+
+**Models:**
+
+* **Vendor**: Contains vendor_info and inventory arrays.
+* **DeviceScan**: Records devices’ last scan (SSID info, timestamp, etc.).
+
+---
+
+## 1. Common Headers
+
+| Header         | Description                | Required                               |
+| -------------- | -------------------------- | -------------------------------------- |
+| `x-device-sig` | Unique device signature    | Optional (used in proximity detection) |
+| `x-ws-token`   | Session or workspace token | Optional                               |
+| `public_ip`    | Client IP address          | Optional                               |
+
+---
+
+## 2. Inventory Endpoints
+
+### 2.1 Get Inventory by Item ID
+
+**GET** `/inventory/:itemId`
+
+| Parameter | Type   | Required | Description              |
+| --------- | ------ | -------- | ------------------------ |
+| `itemId`  | String | Yes      | Unique inventory item ID |
+
+**Response:**
+
+| Field    | Type   | Description                                 |
+| -------- | ------ | ------------------------------------------- |
+| `vendor` | Object | Vendor info containing `vendor_info` fields |
+| `item`   | Object | Inventory item matching `itemId`            |
+
+**Error Codes:**
+
+| Status | Message                  |
+| ------ | ------------------------ |
+| 404    | Inventory item not found |
+| 500    | Internal server error    |
+
+---
+
+### 2.2 Get Inventory by Proximity
+
+**GET** `/inventory`
+
+**Headers used:** `x-device-sig`, `public_ip`, `x-ws-token`
+
+**Response:**
+
+* List of vendors matching the last device scan SSIDs
+
+| Field         | Type   | Description             |
+| ------------- | ------ | ----------------------- |
+| `vendor_id`   | String | Vendor identifier       |
+| `vendor_name` | String | Name of vendor          |
+| `address`     | String | Vendor address          |
+| `inventory`   | Array  | List of inventory items |
+
+**Error Codes:**
+
+| Status | Message                                    |
+| ------ | ------------------------------------------ |
+| 404    | No recent proximity data found for this IP |
+| 500    | Internal server error                      |
+
+---
+
+### 2.3 Search Inventory
+
+**GET** `/search?query=<query>`
+
+| Query Parameter | Type   | Required | Description                                                    |
+| --------------- | ------ | -------- | -------------------------------------------------------------- |
+| `query`         | String | Yes      | Fuzzy search term for inventory, vendor name, address, or tags |
+
+**Response:**
+
+| Field     | Type   | Description                    |
+| --------- | ------ | ------------------------------ |
+| `query`   | String | Search term                    |
+| `results` | Array  | List of vendors matching query |
+
+**Error Codes:**
+
+| Status | Message                     |
+| ------ | --------------------------- |
+| 400    | Query parameter is required |
+| 500    | Internal server error       |
+
+---
+
+### 2.4 Create / Update / Delete Inventory
+
+| Method | Endpoint                           | Request Body                              | Response                      | Notes                        |
+| ------ | ---------------------------------- | ----------------------------------------- | ----------------------------- | ---------------------------- |
+| POST   | `/vendor/:vendorId/inventory`      | `{ item_id, name, category, price, ... }` | 200, added item               | Add single inventory item    |
+| POST   | `/vendor/:vendorId/inventory/bulk` | `{ items: [{ item_id, name, ...}, ...] }` | 200, items added              | Add multiple inventory items |
+| PUT    | `/inventory/:itemId`               | `{ field: value, ... }`                   | 200, updated item             | Update fields of single item |
+| PUT    | `/inventory/:vendorId/bulk`        | `[ { item_id, field: value }, ... ]`      | 200, summary of updated items | Bulk update inventory items  |
+| DELETE | `/inventory/:itemId`               | None                                      | 200, deleted item             | Delete single item           |
+| DELETE | `/inventory`                       | `{ itemIds: [id1, id2, ...] }`            | 200, `deletedCount`           | Bulk delete items            |
+
+---
+
+## 3. Error Response Format
+
+| Field     | Type   | Description                                      |
+| --------- | ------ | ------------------------------------------------ |
+| `error`   | String | Error message                                    |
+| `message` | String | Optional descriptive message for success/failure |
+
+**Example:**
+
+```json
+{
+  "error": "Vendor not found"
+}
+```
+
+---
+
+## 4. Notes / Guidelines
+
+1. **Proximity detection:** `GET /inventory` uses device signature, token, or IP as a fallback to retrieve recent Wi-Fi scans.
+2. **Bulk operations:** Partial success is possible; the response includes per-item update status.
+3. **Consistency:** All update operations return the new state of the object after modification.
+4. **Pagination:** Not implemented yet for search; consider adding `limit` and `offset` query params for large datasets.
+5. **Logging:** Server logs device signatures and SSIDs for audit/debugging.

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@shyntech-proximity/inventories",
+  "version": "1.0.0",
+  "main": "src/index.js",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "echo 'no build'",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "@shyntech:registry": "https://gitlab.com/api/v4/projects/78314798/packages/npm/"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}

package/src/index.js

@@ -0,0 +1,536 @@
+import express from "express";
+import { DeviceScan } from "../models/DeviceScan.js";
+import { Vendor } from "../models/Vendor.js";
+
+const router = express.Router();
+router.proximityCache = {};
+/**
+ * Browser client calls this endpoint.
+ * Server finds last scan from same IP and returns matching vendor inventories.
+ */
+
+// 🧠 Fallback Matching Logic
+function findProximityKey(req) {
+  const ip = req.headers["public_ip"];
+  const deviceSig = req.headers["x-device-sig"];
+  const token = req.headers["x-ws-token"];
+  console.log("Device: ", deviceSig);
+  if (deviceSig) return deviceSig;
+  if (ip) return ip;
+  if (token) return token;
+  return null;
+}
+
+
+
+
+
+
+router.get("/inventory/:itemId", async (req, res) => {
+  try {
+    const itemId = req.params.itemId;
+
+    // Find the vendor that contains the inventory item
+    const vendor = await Vendor.findOne(
+      { "inventory.item_id": itemId },
+      { "inventory.$": 1, vendor_info: 1 } // project only the matching inventory item and vendor_info
+    ).lean();
+
+    if (!vendor || !vendor.inventory || vendor.inventory.length === 0) {
+      return res.status(404).json({ error: "Inventory item not found" });
+    }
+
+    res.json({
+      vendor: vendor.vendor_info,
+      item: vendor.inventory[0]
+    });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+router.get("/search", async (req, res) => {
+  try {
+    const { query } = req.query;
+
+    if (!query || query.trim() === "") {
+      return res.status(400).json({ error: "Query parameter is required" });
+    }
+
+    const regex = new RegExp(query, "i"); // case-insensitive fuzzy match
+
+    // Search inventory items
+    const vendors = await Vendor.find({
+      $or: [
+        { "vendor_info.name": regex },
+        { "vendor_info.address": regex },
+        { "inventory.name": regex },
+        { "inventory.category": regex },
+        { "inventory.tags": regex }
+      ]
+    }).lean();
+
+    const results = vendors.map(vendor => {
+      // Filter inventory items in vendor that match the query
+      const matchingItems = vendor.inventory.filter(item => 
+        regex.test(item.name) ||
+        regex.test(item.category) ||
+        item.tags.some(tag => regex.test(tag))
+      );
+
+      return {
+        vendor_id: vendor.vendor_info.vendor_id,
+        vendor_name: vendor.vendor_info.name,
+        address: vendor.vendor_info.address,
+        inventory: matchingItems
+      };
+    }).filter(vendor => vendor.inventory.length > 0 || regex.test(vendor.vendor_name) || regex.test(vendor.address));
+
+    res.json({
+      query,
+      results
+    });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+router.get("/inventory", async (req, res) => {
+  const deviceId = findProximityKey(req)|| req.socket.remoteAddress;
+
+  try {
+    const lastScan = await DeviceScan.findOne({ device_id: deviceId })
+      .sort({ timestamp: -1 })
+      .lean();
+    if (!lastScan) {
+      return res.status(404).json({ message: "No recent proximity data found for this IP" });
+    }
+    const ssids = lastScan?.detected_wifi.map(w => w.ssid);
+    console.log(ssids)
+    const vendors = await Vendor.find({ ssid: { $in: ssids } }).lean();
+    console.log(vendors);
+    res.json(vendors);
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+// =========================
+// Get vendor by phoneNumber
+// =========================
+router.get("/vendor", async (req, res) => {
+  try {
+    const { phoneNumber } = req.query;
+    console.log(phoneNumber);
+    if (!phoneNumber) {
+      return res
+        .status(400)
+        .json({ error: "phoneNumber query parameter is required" });
+    }
+
+    // Find vendor using vendor_info.phoneNumber
+    const vendor = await Vendor.findOne({ "phoneNumber": phoneNumber })
+      .lean();
+
+    if (!vendor) {
+      return res.status(404).json({ error: "Vendor not found" });
+    }
+
+    res.json(vendor);
+
+  } catch (error) {
+    console.error("Error fetching vendor by phoneNumber:", error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+
+// Get inventory for a specific vendor
+router.get("/vendor/:vendorId/inventory", async (req, res) => {
+  try {
+    const vendorId = req.params.vendorId;
+    // Find the vendor by vendor_info.vendor_id
+    const vendor = await Vendor.findOne({ "vendor_info.vendor_id": vendorId })
+      .select("inventory") // only return inventory and vendor_info
+      .lean();
+
+    if (!vendor) {
+      return res.status(404).json({ error: "Vendor not found" });
+    }
+
+    res.json(vendor.inventory);
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+
+
+// STORE MANAGEMENT STARTS HERE 
+router.get("/vendor/:vendorId", async (req, res) => {
+  try {
+    const vendorId = req.params.vendorId;
+    // vendor_id is inside vendor_info
+    const vendor = await Vendor.findOne({ "vendor_info.vendor_id": vendorId }).lean();
+
+    if (!vendor) {
+      return res.status(404).json({ error: "Vendor not found" });
+    }
+
+    res.json(vendor);
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+// POST /vendor
+// body: { vendor_id, name, address, contact, gps_location, opening_hours, inventory }
+router.post("/vendor", async (req, res) => {
+  try {
+    const vendorData = req.body;
+
+    // Check if vendor already exists
+    const existing = await Vendor.findOne({ vendor_id: vendorData.vendor_id });
+    if (existing) {
+      return res.status(400).json({ error: "Vendor with this ID already exists" });
+    }
+
+    const newVendor = await Vendor.create(vendorData);
+    res.status(201).json({
+      message: "Vendor created successfully",
+      vendor: newVendor,
+    });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+// body: fields to update: { name, address, contact, gps_location, opening_hours, inventory }
+// PUT /vendor/:vendorId
+router.put("/vendor/:vendorId", async (req, res) => {
+  try {
+    const { vendorId } = req.params;
+    const updateData = req.body;
+
+    // Check if a vendor with this vendor_id exists
+    const existingVendor = await Vendor.findOne({ "vendor_info.vendor_id": vendorId });
+    if (!existingVendor) {
+      return res.status(404).json({ error: "Vendor not found" });
+    }
+
+    // Flatten nested updateData to update specific fields (so we don’t overwrite everything)
+    const setFields = {};
+    for (const [key, value] of Object.entries(updateData)) {
+      setFields[`vendor_info.${key}`] = value;
+    }
+
+    // Update vendor info
+    const updatedVendor = await Vendor.findOneAndUpdate(
+      { "vendor_info.vendor_id": vendorId },
+      { $set: setFields },
+      { new: true }
+    ).lean();
+
+    res.json({
+      message: "Vendor updated successfully",
+      vendor: updatedVendor,
+    });
+  } catch (error) {
+    console.error("Error updating vendor:", error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+// DELETE /vendor/:vendorId
+router.delete("/vendor/:vendorId", async (req, res) => {
+  try {
+    const { vendorId } = req.params;
+
+    const deletedVendor = await Vendor.findOneAndDelete({ vendor_id: vendorId }).lean();
+
+    if (!deletedVendor) {
+      return res.status(404).json({ error: "Vendor not found" });
+    }
+
+    res.json({
+      message: "Vendor deleted successfully",
+      vendor: deletedVendor,
+    });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+//INVENTORY STARTS HERE
+
+
+
+// Add a single inventory item to a vendor
+router.post("/vendor/:vendorId/inventory", async (req, res) => {
+  try {
+    const vendorId = req.params.vendorId;
+    const newItem = req.body; // e.g., { item_id, name, category, price, ... }
+
+    const updatedVendor = await Vendor.findOneAndUpdate(
+      { vendor_id: vendorId },
+      { $push: { inventory: newItem } },
+      { new: true, projection: { inventory: 1, vendor_info: 1 } }
+    ).lean();
+
+    if (!updatedVendor) {
+      return res.status(404).json({ error: "Vendor not found" });
+    }
+
+    res.json({
+      message: "Inventory item added successfully",
+      vendor: updatedVendor.vendor_info,
+      item: newItem,
+    });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+
+
+// Add multiple inventory items to a vendor
+router.post("/vendor/:vendorId/inventory/bulk", async (req, res) => {
+  try {
+    const vendorId = req.params.vendorId;
+    const newItems = req.body.items; // e.g., [{ item_id, name, ... }, {...}]
+
+    if (!Array.isArray(newItems) || newItems.length === 0) {
+      return res.status(400).json({ error: "Items array is required" });
+    }
+
+    const updatedVendor = await Vendor.findOneAndUpdate(
+      { vendor_id: vendorId },
+      { $push: { inventory: { $each: newItems } } },
+      { new: true, projection: { inventory: 1, vendor_info: 1 } }
+    ).lean();
+
+    if (!updatedVendor) {
+      return res.status(404).json({ error: "Vendor not found" });
+    }
+
+    res.json({
+      message: `${newItems.length} inventory items added successfully`,
+      vendor: updatedVendor.vendor_info,
+      items: newItems,
+    });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+
+router.put("/inventory/:itemId", async (req, res) => {
+  try {
+    const itemId = req.params.itemId;
+    const updateData = req.body; // e.g., { price: 300, quantity_available: 50 }
+
+    // Find the vendor containing the item and update the matching inventory element
+    const result = await Vendor.findOneAndUpdate(
+      { "inventory.item_id": itemId },
+      { $set: Object.fromEntries(
+          Object.entries(updateData).map(([key, value]) => [`inventory.$.${key}`, value])
+        )
+      },
+      { new: true, projection: { "inventory.$": 1, vendor_info: 1 } } // return updated item
+    ).lean();
+
+    if (!result || !result.inventory || result.inventory.length === 0) {
+      return res.status(404).json({ error: "Inventory item not found" });
+    }
+
+    res.json({
+      message: "Inventory item updated successfully",
+      vendor: result.vendor_info,
+      item: result.inventory[0],
+    });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+
+
+router.put("/inventory/:vendorId/bulk", async (req, res) => {
+  try {
+    const { vendorId } = req.params;
+    const itemsToUpdate = req.body;
+
+    if (!Array.isArray(itemsToUpdate) || itemsToUpdate.length === 0) {
+      return res.status(400).json({ error: "Items array is required" });
+    }
+
+    // Validate the vendor first
+    const vendor = await Vendor.findOne({ "vendor_info.vendor_id": vendorId });
+    if (!vendor) {
+      return res.status(404).json({ error: `Vendor ${vendorId} not found` });
+    }
+
+    // Perform updates in parallel
+    const updateResults = await Promise.all(
+      itemsToUpdate.map(async (item) => {
+        const { item_id, ...updates } = item;
+        const updateQuery = {};
+
+        // Dynamically build the update fields
+        for (const [key, value] of Object.entries(updates)) {
+          updateQuery[`inventory.$.${key}`] = value;
+        }
+
+        const result = await Vendor.updateOne(
+          { "vendor_info.vendor_id": vendorId, "inventory.item_id": item_id },
+          { $set: updateQuery }
+        );
+
+        return { item_id, matched: result.matchedCount, modified: result.modifiedCount };
+      })
+    );
+
+    // Fetch the fresh vendor document after updates
+    const updatedVendor = await Vendor.findOne({ "vendor_info.vendor_id": vendorId }).lean();
+
+
+    console.log(updateResults)
+
+    res.json({
+      message: `${updateResults.filter(r => r.modified > 0).length} of ${itemsToUpdate.length} items updated successfully`,
+      updateResults,
+      vendor: updatedVendor?.vendor_info,
+      inventory: updatedVendor?.inventory,
+    });
+
+  } catch (error) {
+    console.error("Bulk update error:", error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+
+// DELETE /inventory/:itemId
+router.delete("/inventory/:itemId", async (req, res) => {
+  try {
+    const { itemId } = req.params;
+
+    const result = await Vendor.findOneAndUpdate(
+      { "inventory.item_id": itemId },
+      { $pull: { inventory: { item_id: itemId } } },
+      { new: true, projection: { vendor_info: 1 } }
+    ).lean();
+
+    if (!result) {
+      return res.status(404).json({ error: "Inventory item not found" });
+    }
+
+    res.json({
+      message: "Inventory item deleted successfully",
+      vendor: result.vendor_info,
+    });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+
+// DELETE /inventory
+// body: { itemIds: ["INV001", "INV002", ...] }
+router.delete("/inventory", async (req, res) => {
+  try {
+    const { itemIds } = req.body;
+
+    if (!Array.isArray(itemIds) || itemIds.length === 0) {
+      return res.status(400).json({ error: "itemIds array is required" });
+    }
+
+    const result = await Vendor.updateMany(
+      { "inventory.item_id": { $in: itemIds } },
+      { $pull: { inventory: { item_id: { $in: itemIds } } } }
+    );
+
+    res.json({
+      message: "Inventory items deleted successfully",
+      deletedCount: result.modifiedCount,
+    });
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: "Internal server error" });
+  }
+});
+
+
+
+
+
+
+
+export default router;
+
+