project-startup 1.1.0 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-startup",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Minimal session-based auth starter using Express, MySQL, React, Vite, and React Router.",
   "main": "index.js",
   "bin": {

package/template/Logics/Stocks/controllers/sparePartController.js

@@ -2,24 +2,19 @@ const db = require("../db");
 
 // GET /api/parts
 exports.getAllParts = async (req, res) => {
-    const [parts] = await db.query(
-        "SELECT * FROM spare_parts ORDER BY name ASC"
-    );
+    const [parts] = await db.query("SELECT * FROM spare_parts ORDER BY name ASC");
     res.json(parts);
 };
 
 // GET /api/parts/:id
 exports.getPartById = async (req, res) => {
-    const [rows] = await db.query(
-        "SELECT * FROM spare_parts WHERE id = ?",
-        [req.params.id]
-    );
+    const [parts] = await db.query("SELECT * FROM spare_parts WHERE id = ?", [req.params.id]);
 
-    if (rows.length === 0) {
-        return res.status(404).json({ error: "Spare part not found." });
+    if (parts.length === 0) {
+        return res.status(404).json({ error: "Spare part not found" });
     }
 
-    res.json(rows[0]);
+    res.json(parts[0]);
 };
 
 // POST /api/parts
@@ -27,11 +22,11 @@ exports.createPart = async (req, res) => {
     const { name, quantity, unitPrice } = req.body;
 
     if (!name || quantity == null || !unitPrice) {
-        return res.status(400).json({ error: "name, quantity and unitPrice are required." });
+        return res.status(400).json({ error: "name, quantity and unitPrice required" });
     }
 
     if (quantity < 0) {
-        return res.status(400).json({ error: "Quantity cannot be negative." });
+        return res.status(400).json({ error: "Quantity cannot be negative" });
     }
 
     const [result] = await db.query(
@@ -39,66 +34,39 @@ exports.createPart = async (req, res) => {
         [name.trim(), quantity, unitPrice]
     );
 
-    const [rows] = await db.query(
-        "SELECT * FROM spare_parts WHERE id = ?",
-        [result.insertId]
-    );
-
-    res.status(201).json(rows[0]);
+    const [parts] = await db.query("SELECT * FROM spare_parts WHERE id = ?", [result.insertId]);
+    res.status(201).json(parts[0]);
 };
 
 // PUT /api/parts/:id
 exports.updatePart = async (req, res) => {
-    const [rows] = await db.query(
-        "SELECT * FROM spare_parts WHERE id = ?",
-        [req.params.id]
-    );
+    const [parts] = await db.query("SELECT * FROM spare_parts WHERE id = ?", [req.params.id]);
 
-    if (rows.length === 0) {
-        return res.status(404).json({ error: "Spare part not found." });
+    if (parts.length === 0) {
+        return res.status(404).json({ error: "Spare part not found" });
     }
 
     const { name, unitPrice } = req.body;
-    // Note: quantity is managed by stock-in / stock-out, not edited directly
 
     await db.query(
         `UPDATE spare_parts SET
-            name       = COALESCE(?, name),
+            name = COALESCE(?, name),
             unit_price = COALESCE(?, unit_price)
          WHERE id = ?`,
         [name || null, unitPrice || null, req.params.id]
     );
 
-    const [updated] = await db.query(
-        "SELECT * FROM spare_parts WHERE id = ?",
-        [req.params.id]
-    );
-
+    const [updated] = await db.query("SELECT * FROM spare_parts WHERE id = ?", [req.params.id]);
     res.json(updated[0]);
 };
 
-// DELETE /api/parts/:id
+// DELETE /api/parts/:id — SIMPLIFIED (removed stock-in check)
 exports.deletePart = async (req, res) => {
-    // Block deletion if there are any stock-in records for this part
-    const [stockIns] = await db.query(
-        "SELECT id FROM stock_in WHERE spare_part_id = ?",
-        [req.params.id]
-    );
-
-    if (stockIns.length > 0) {
-        return res.status(400).json({
-            error: "Cannot delete a part that has stock-in records.",
-        });
-    }
-
-    const [result] = await db.query(
-        "DELETE FROM spare_parts WHERE id = ?",
-        [req.params.id]
-    );
+    const [result] = await db.query("DELETE FROM spare_parts WHERE id = ?", [req.params.id]);
 
     if (result.affectedRows === 0) {
-        return res.status(404).json({ error: "Spare part not found." });
+        return res.status(404).json({ error: "Spare part not found" });
     }
 
-    res.json({ message: "Spare part deleted." });
-};
+    res.json({ message: "Spare part deleted" });
+};

package/template/Logics/Stocks/controllers/stockInController.js

@@ -1,18 +1,10 @@
 const db = require("../db");
 
 // GET /api/stock-in
-// Returns all import records joined with part name
 exports.getAllStockIn = async (req, res) => {
     const [rows] = await db.query(
-        `SELECT
-            si.id,
-            si.quantity,
-            si.remaining_qty,
-            si.unit_price,
-            si.total_price,
-            si.imported_at,
-            sp.id   AS spare_part_id,
-            sp.name AS spare_part_name
+        `SELECT si.id, si.quantity, si.remaining_qty, si.unit_price, si.total_price, 
+                si.imported_at, sp.id AS spare_part_id, sp.name AS spare_part_name
          FROM stock_in si
          JOIN spare_parts sp ON sp.id = si.spare_part_id
          ORDER BY si.imported_at DESC`
@@ -23,9 +15,7 @@ exports.getAllStockIn = async (req, res) => {
 // GET /api/stock-in/:id
 exports.getStockInById = async (req, res) => {
     const [rows] = await db.query(
-        `SELECT
-            si.*,
-            sp.name AS spare_part_name
+        `SELECT si.*, sp.name AS spare_part_name
          FROM stock_in si
          JOIN spare_parts sp ON sp.id = si.spare_part_id
          WHERE si.id = ?`,
@@ -33,127 +23,74 @@ exports.getStockInById = async (req, res) => {
     );
 
     if (rows.length === 0) {
-        return res.status(404).json({ error: "Stock-in record not found." });
+        return res.status(404).json({ error: "Stock-in record not found" });
     }
 
     res.json(rows[0]);
 };
 
-// POST /api/stock-in
-// Creates a new import batch and increments spare_parts.quantity
+// POST /api/stock-in — SIMPLIFIED (no transaction)
 exports.createStockIn = async (req, res) => {
     const { sparePartId, quantity, unitPrice } = req.body;
 
     if (!sparePartId || !quantity || !unitPrice) {
-        return res.status(400).json({
-            error: "sparePartId, quantity and unitPrice are required.",
-        });
+        return res.status(400).json({ error: "sparePartId, quantity and unitPrice required" });
     }
 
     if (quantity < 1) {
-        return res.status(400).json({ error: "Quantity must be at least 1." });
+        return res.status(400).json({ error: "Quantity must be at least 1" });
     }
 
-    // Verify the spare part exists
-    const [partRows] = await db.query(
-        "SELECT * FROM spare_parts WHERE id = ?",
-        [sparePartId]
-    );
-
-    if (partRows.length === 0) {
-        return res.status(404).json({ error: "Spare part not found." });
+    // Verify part exists
+    const [parts] = await db.query("SELECT * FROM spare_parts WHERE id = ?", [sparePartId]);
+    if (parts.length === 0) {
+        return res.status(404).json({ error: "Spare part not found" });
     }
 
     const totalPrice = quantity * unitPrice;
 
-    const conn = await db.getConnection();
-
-    try {
-        await conn.beginTransaction();
-
-        // Insert the stock-in batch
-        // remaining_qty starts equal to quantity — decremented by stock-out later
-        const [result] = await conn.query(
-            `INSERT INTO stock_in
-                (spare_part_id, quantity, remaining_qty, unit_price, total_price)
-             VALUES (?, ?, ?, ?, ?)`,
-            [sparePartId, quantity, quantity, unitPrice, totalPrice]
-        );
-
-        // Increment the part's total stock quantity
-        await conn.query(
-            "UPDATE spare_parts SET quantity = quantity + ? WHERE id = ?",
-            [quantity, sparePartId]
-        );
-
-        await conn.commit();
-
-        // Return the full record with part name
-        const [rows] = await conn.query(
-            `SELECT si.*, sp.name AS spare_part_name
-             FROM stock_in si
-             JOIN spare_parts sp ON sp.id = si.spare_part_id
-             WHERE si.id = ?`,
-            [result.insertId]
-        );
-
-        res.status(201).json(rows[0]);
-
-    } catch (err) {
-        await conn.rollback();
-        throw err;
-    } finally {
-        conn.release();
-    }
-};
+    // Insert stock-in batch
+    const [result] = await db.query(
+        `INSERT INTO stock_in (spare_part_id, quantity, remaining_qty, unit_price, total_price)
+         VALUES (?, ?, ?, ?, ?)`,
+        [sparePartId, quantity, quantity, unitPrice, totalPrice]
+    );
 
-// DELETE /api/stock-in/:id
-// Only allowed if no stock-out records reference this batch
-exports.deleteStockIn = async (req, res) => {
+    // Increment part's total stock
+    await db.query(
+        "UPDATE spare_parts SET quantity = quantity + ? WHERE id = ?",
+        [quantity, sparePartId]
+    );
+
+    // Return full record with part name
     const [rows] = await db.query(
-        "SELECT * FROM stock_in WHERE id = ?",
-        [req.params.id]
+        `SELECT si.*, sp.name AS spare_part_name
+         FROM stock_in si
+         JOIN spare_parts sp ON sp.id = si.spare_part_id
+         WHERE si.id = ?`,
+        [result.insertId]
     );
 
+    res.status(201).json(rows[0]);
+};
+
+// DELETE /api/stock-in/:id — SIMPLIFIED (no transaction, no stock-out check)
+exports.deleteStockIn = async (req, res) => {
+    const [rows] = await db.query("SELECT * FROM stock_in WHERE id = ?", [req.params.id]);
+
     if (rows.length === 0) {
-        return res.status(404).json({ error: "Stock-in record not found." });
+        return res.status(404).json({ error: "Stock-in record not found" });
     }
 
     const stockIn = rows[0];
 
-    // Block deletion if sales came out of this batch
-    const [sales] = await db.query(
-        "SELECT id FROM stock_out WHERE stock_in_id = ?",
-        [req.params.id]
+    // Give quantity back to spare part
+    await db.query(
+        "UPDATE spare_parts SET quantity = quantity - ? WHERE id = ?",
+        [stockIn.quantity, stockIn.spare_part_id]
     );
 
-    if (sales.length > 0) {
-        return res.status(400).json({
-            error: "Cannot delete a batch that has stock-out records.",
-        });
-    }
-
-    const conn = await db.getConnection();
-
-    try {
-        await conn.beginTransaction();
+    await db.query("DELETE FROM stock_in WHERE id = ?", [req.params.id]);
 
-        // Give the quantity back to the spare part
-        await conn.query(
-            "UPDATE spare_parts SET quantity = quantity - ? WHERE id = ?",
-            [stockIn.quantity, stockIn.spare_part_id]
-        );
-
-        await conn.query("DELETE FROM stock_in WHERE id = ?", [req.params.id]);
-
-        await conn.commit();
-
-        res.json({ message: "Stock-in record deleted and quantity reversed." });
-
-    } catch (err) {
-        await conn.rollback();
-        throw err;
-    } finally {
-        conn.release();
-    }
-};
+    res.json({ message: "Stock-in deleted and quantity reversed" });
+};

package/template/Logics/Stocks/controllers/stockOutController.js

@@ -3,19 +3,11 @@ const db = require("../db");
 // GET /api/stock-out
 exports.getAllStockOut = async (req, res) => {
     const [rows] = await db.query(
-        `SELECT
-            so.id,
-            so.quantity,
-            so.unit_price,
-            so.total_price,
-            so.sold_at,
-            sp.id   AS spare_part_id,
-            sp.name AS spare_part_name,
-            si.id           AS stock_in_id,
-            si.unit_price   AS import_unit_price,
-            si.imported_at
+        `SELECT so.id, so.quantity, so.unit_price, so.total_price, so.sold_at,
+                sp.id AS spare_part_id, sp.name AS spare_part_name,
+                si.id AS stock_in_id, si.unit_price AS import_unit_price, si.imported_at
          FROM stock_out so
-         JOIN stock_in   si ON si.id = so.stock_in_id
+         JOIN stock_in si ON si.id = so.stock_in_id
          JOIN spare_parts sp ON sp.id = so.spare_part_id
          ORDER BY so.sold_at DESC`
     );
@@ -25,159 +17,112 @@ exports.getAllStockOut = async (req, res) => {
 // GET /api/stock-out/:id
 exports.getStockOutById = async (req, res) => {
     const [rows] = await db.query(
-        `SELECT
-            so.*,
-            sp.name AS spare_part_name,
-            si.remaining_qty,
-            si.unit_price AS import_unit_price
+        `SELECT so.*, sp.name AS spare_part_name, si.remaining_qty, si.unit_price AS import_unit_price
          FROM stock_out so
-         JOIN stock_in   si ON si.id = so.stock_in_id
+         JOIN stock_in si ON si.id = so.stock_in_id
          JOIN spare_parts sp ON sp.id = so.spare_part_id
          WHERE so.id = ?`,
         [req.params.id]
     );
 
     if (rows.length === 0) {
-        return res.status(404).json({ error: "Stock-out record not found." });
+        return res.status(404).json({ error: "Stock-out record not found" });
     }
 
     res.json(rows[0]);
 };
 
-// POST /api/stock-out
-// Validates against stock_in.remaining_qty, then decrements both
-// stock_in.remaining_qty and spare_parts.quantity
+// POST /api/stock-out — SIMPLIFIED (no transaction, no FOR UPDATE lock)
 exports.createStockOut = async (req, res) => {
     const { stockInId, quantity, unitPrice } = req.body;
 
     if (!stockInId || !quantity || !unitPrice) {
-        return res.status(400).json({
-            error: "stockInId, quantity and unitPrice are required.",
-        });
+        return res.status(400).json({ error: "stockInId, quantity and unitPrice required" });
     }
 
     if (quantity < 1) {
-        return res.status(400).json({ error: "Quantity must be at least 1." });
+        return res.status(400).json({ error: "Quantity must be at least 1" });
     }
 
-    const conn = await db.getConnection();
-
-    try {
-        await conn.beginTransaction();
-
-        // Lock the stock_in row so two concurrent sales can't oversell the batch
-        const [siRows] = await conn.query(
-            `SELECT si.*, sp.id AS part_id
-             FROM stock_in si
-             JOIN spare_parts sp ON sp.id = si.spare_part_id
-             WHERE si.id = ?
-             FOR UPDATE`,
-            [stockInId]
-        );
-
-        if (siRows.length === 0) {
-            await conn.rollback();
-            return res.status(404).json({ error: "Stock-in batch not found." });
-        }
-
-        const batch = siRows[0];
-
-        // Quantity sold must not exceed what remains in this specific batch
-        if (quantity > batch.remaining_qty) {
-            await conn.rollback();
-            return res.status(400).json({
-                error: `Only ${batch.remaining_qty} unit(s) remaining in this batch.`,
-            });
-        }
-
-        const totalPrice = quantity * unitPrice;
-
-        // Insert the sale record
-        const [result] = await conn.query(
-            `INSERT INTO stock_out
-                (stock_in_id, spare_part_id, quantity, unit_price, total_price)
-             VALUES (?, ?, ?, ?, ?)`,
-            [stockInId, batch.spare_part_id, quantity, unitPrice, totalPrice]
-        );
-
-        // Decrement remaining units in this import batch
-        await conn.query(
-            "UPDATE stock_in SET remaining_qty = remaining_qty - ? WHERE id = ?",
-            [quantity, stockInId]
-        );
-
-        // Decrement the part's total stock
-        await conn.query(
-            "UPDATE spare_parts SET quantity = quantity - ? WHERE id = ?",
-            [quantity, batch.spare_part_id]
-        );
-
-        await conn.commit();
-
-        // Return full record with names attached
-        const [rows] = await conn.query(
-            `SELECT
-                so.*,
-                sp.name AS spare_part_name,
-                si.unit_price AS import_unit_price,
-                si.remaining_qty
-             FROM stock_out so
-             JOIN stock_in   si ON si.id = so.stock_in_id
-             JOIN spare_parts sp ON sp.id = so.spare_part_id
-             WHERE so.id = ?`,
-            [result.insertId]
-        );
-
-        res.status(201).json(rows[0]);
-
-    } catch (err) {
-        await conn.rollback();
-        throw err;
-    } finally {
-        conn.release();
+    // Get the stock-in batch
+    const [siRows] = await db.query(
+        `SELECT si.*, sp.id AS part_id
+         FROM stock_in si
+         JOIN spare_parts sp ON sp.id = si.spare_part_id
+         WHERE si.id = ?`,
+        [stockInId]
+    );
+
+    if (siRows.length === 0) {
+        return res.status(404).json({ error: "Stock-in batch not found" });
     }
-};
 
-// DELETE /api/stock-out/:id
-// Reverses the sale: restores remaining_qty on the batch and quantity on the part
-exports.deleteStockOut = async (req, res) => {
-    const [rows] = await db.query(
-        "SELECT * FROM stock_out WHERE id = ?",
-        [req.params.id]
-    );
+    const batch = siRows[0];
 
-    if (rows.length === 0) {
-        return res.status(404).json({ error: "Stock-out record not found." });
+    // Check remaining quantity (simple check, no lock)
+    if (quantity > batch.remaining_qty) {
+        return res.status(400).json({ 
+            error: `Only ${batch.remaining_qty} unit(s) remaining in this batch` 
+        });
     }
 
-    const sale = rows[0];
-    const conn = await db.getConnection();
+    const totalPrice = quantity * unitPrice;
 
-    try {
-        await conn.beginTransaction();
+    // Insert sale record
+    const [result] = await db.query(
+        `INSERT INTO stock_out (stock_in_id, spare_part_id, quantity, unit_price, total_price)
+         VALUES (?, ?, ?, ?, ?)`,
+        [stockInId, batch.part_id, quantity, unitPrice, totalPrice]
+    );
 
-        // Restore the batch's remaining quantity
-        await conn.query(
-            "UPDATE stock_in SET remaining_qty = remaining_qty + ? WHERE id = ?",
-            [sale.quantity, sale.stock_in_id]
-        );
+    // Decrement remaining units in batch
+    await db.query(
+        "UPDATE stock_in SET remaining_qty = remaining_qty - ? WHERE id = ?",
+        [quantity, stockInId]
+    );
 
-        // Restore the part's total stock
-        await conn.query(
-            "UPDATE spare_parts SET quantity = quantity + ? WHERE id = ?",
-            [sale.quantity, sale.spare_part_id]
-        );
+    // Decrement part's total stock
+    await db.query(
+        "UPDATE spare_parts SET quantity = quantity - ? WHERE id = ?",
+        [quantity, batch.part_id]
+    );
 
-        await conn.query("DELETE FROM stock_out WHERE id = ?", [sale.id]);
+    // Return full record
+    const [rows] = await db.query(
+        `SELECT so.*, sp.name AS spare_part_name, si.unit_price AS import_unit_price, si.remaining_qty
+         FROM stock_out so
+         JOIN stock_in si ON si.id = so.stock_in_id
+         JOIN spare_parts sp ON sp.id = so.spare_part_id
+         WHERE so.id = ?`,
+        [result.insertId]
+    );
 
-        await conn.commit();
+    res.status(201).json(rows[0]);
+};
 
-        res.json({ message: "Stock-out record deleted and quantity restored." });
+// DELETE /api/stock-out/:id — SIMPLIFIED (no transaction)
+exports.deleteStockOut = async (req, res) => {
+    const [rows] = await db.query("SELECT * FROM stock_out WHERE id = ?", [req.params.id]);
 
-    } catch (err) {
-        await conn.rollback();
-        throw err;
-    } finally {
-        conn.release();
+    if (rows.length === 0) {
+        return res.status(404).json({ error: "Stock-out record not found" });
     }
-};
+
+    const sale = rows[0];
+
+    // Restore batch's remaining quantity
+    await db.query(
+        "UPDATE stock_in SET remaining_qty = remaining_qty + ? WHERE id = ?",
+        [sale.quantity, sale.stock_in_id]
+    );
+
+    // Restore part's total stock
+    await db.query(
+        "UPDATE spare_parts SET quantity = quantity + ? WHERE id = ?",
+        [sale.quantity, sale.spare_part_id]
+    );
+
+    await db.query("DELETE FROM stock_out WHERE id = ?", [sale.id]);
+
+    res.json({ message: "Stock-out deleted and quantity restored" });
+};