@ozdao/prometheus-framework 0.2.330 → 0.2.332

package/dist/products.server.mjs

@@ -1,677 +1,720 @@
 import { g as getDefaultExportFromCjs } from "./_commonjsHelpers-CUmg6egw.mjs";
-import { o as ownership_schema } from "./ownership.schema-oyx6eNkZ.mjs";
-import "uuid";
-import require$$0 from "mongoose";
+import { r as requireOwnership_schema } from "./ownership.schema-C0w02Vw1.mjs";
+import require$$0 from "uuid";
+import require$$0$1 from "mongoose";
 import "path";
 import require$$3 from "openai";
-import { q as queryProcessor } from "./queryProcessor-CyQch65j.mjs";
-const applyOwnershipSchema$1 = ownership_schema;
-var product_model = (db) => {
-  const ProductSchema = new db.mongoose.Schema({
-    status: {
-      type: String
-    },
-    listing: {
-      type: String,
-      enum: ["sale", "rent"]
-    },
-    name: { type: String },
-    category: { type: Array },
-    description: { type: String },
-    sale: { type: Number },
-    images: { type: Array },
-    // ЗАДАЧА: Отрефачить популярити и заменить на views из community
-    popularity: { type: Number },
-    // 
-    localization: { type: Array },
-    information: [{
-      name: { type: String },
-      value: { type: String }
-    }],
-    // ЗАДАЧА: Нужно отрефачить price, перенести его в default variant
-    price: {
-      type: Number
-    },
-    price_currency: {
-      type: String,
-      default: "$"
-    },
-    prices: { type: Array },
-    // 
-    variants: [{
-      _id: { type: db.mongoose.Schema.Types.ObjectId, auto: true },
+import { r as requireQueryProcessor } from "./queryProcessor-C_l-zkrM.mjs";
+var product_model;
+var hasRequiredProduct_model;
+function requireProduct_model() {
+  if (hasRequiredProduct_model) return product_model;
+  hasRequiredProduct_model = 1;
+  const applyOwnershipSchema = requireOwnership_schema();
+  product_model = (db) => {
+    const ProductSchema = new db.mongoose.Schema({
+      status: {
+        type: String
+      },
+      listing: {
+        type: String,
+        enum: ["sale", "rent"]
+      },
       name: { type: String },
-      price: { type: Number },
-      options: [{
+      category: { type: Array },
+      description: { type: String },
+      sale: { type: Number },
+      images: { type: Array },
+      // ЗАДАЧА: Отрефачить популярити и заменить на views из community
+      popularity: { type: Number },
+      // 
+      localization: { type: Array },
+      information: [{
         name: { type: String },
         value: { type: String }
       }],
-      default: { type: Boolean }
-    }],
-    ingredients: [{
-      _id: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: "Product"
-      },
+      // ЗАДАЧА: Нужно отрефачить price, перенести его в default variant
       price: {
-        type: Number,
-        required: true,
-        default: 0,
-        min: [0, "Price cannot be less than 0"]
-      },
-      quantity: {
-        type: Number,
-        required: true,
-        min: [1, "Quantity cannot be less than 1"]
+        type: Number
       },
-      type: {
+      price_currency: {
         type: String,
-        required: true,
-        default: "g"
-      }
-    }],
-    quantityDiscount: [{
-      quantity: {
-        type: Number,
-        required: true,
-        min: [1, "Quantity cannot be less than 1"]
+        default: "$"
       },
-      discount: {
-        type: Number,
-        required: true,
-        min: [0, "Quantity-based discount cannot be less than 0"],
-        max: [100, "Quantity-based discount cannot be more than 100"]
+      prices: { type: Array },
+      // 
+      variants: [{
+        _id: { type: db.mongoose.Schema.Types.ObjectId, auto: true },
+        name: { type: String },
+        price: { type: Number },
+        options: [{
+          name: { type: String },
+          value: { type: String }
+        }],
+        default: { type: Boolean }
+      }],
+      ingredients: [{
+        _id: {
+          type: db.mongoose.Schema.Types.ObjectId,
+          ref: "Product"
+        },
+        price: {
+          type: Number,
+          required: true,
+          default: 0,
+          min: [0, "Price cannot be less than 0"]
+        },
+        quantity: {
+          type: Number,
+          required: true,
+          min: [1, "Quantity cannot be less than 1"]
+        },
+        type: {
+          type: String,
+          required: true,
+          default: "g"
+        }
+      }],
+      quantityDiscount: [{
+        quantity: {
+          type: Number,
+          required: true,
+          min: [1, "Quantity cannot be less than 1"]
+        },
+        discount: {
+          type: Number,
+          required: true,
+          min: [0, "Quantity-based discount cannot be less than 0"],
+          max: [100, "Quantity-based discount cannot be more than 100"]
+        }
+      }]
+    }, {
+      timestamps: {
+        currentTime: () => Date.now()
       }
-    }]
-  }, {
-    timestamps: {
-      currentTime: () => Date.now()
-    }
-  });
-  applyOwnershipSchema$1(ProductSchema, db);
-  ProductSchema.index({ category: 1 });
-  ProductSchema.index({ price: 1 });
-  const Product = db.mongoose.model("Product", ProductSchema);
-  return Product;
-};
-var category_model = (db) => {
-  const CategorySchema = new db.mongoose.Schema({
-    name: { type: String, required: true, trim: true },
-    description: { type: String, trim: true },
-    photo: {
-      type: String
-    },
-    status: {
-      type: String,
-      enum: ["draft", "internal", "published", "removed"],
-      default: "draft",
-      required: true
-    },
-    order: { type: Number, required: true },
-    url: { type: String, required: true, trim: true },
-    parent: { type: db.mongoose.Schema.Types.ObjectId, ref: "Category" },
-    localization: { type: Array },
-    filters: { type: Array }
-  }, {
-    timestamps: { currentTime: () => Date.now() }
-  });
-  CategorySchema.index({ parent: 1 });
-  CategorySchema.index({ "owner.target": 1, "creator.target": 1 });
-  const Category = db.mongoose.model("Category", CategorySchema, "categories");
-  return Category;
-};
-const applyOwnershipSchema = ownership_schema;
-var leftover_model = (db) => {
-  const LeftoverSchema = new db.mongoose.Schema({
-    organization: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: "Organization"
-    },
-    type: {
-      type: String,
-      enum: ["stock-in", "stock-out", "write-off"],
-      default: "stock-in",
-      required: true
-    },
-    order: {
-      type: String
-    },
-    comment: {
-      type: String
-    },
-    store: {
-      type: Object
-    },
-    positions: [{
-      _id: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: "Product"
-      },
-      name: {
+    });
+    applyOwnershipSchema(ProductSchema, db);
+    ProductSchema.index({ category: 1 });
+    ProductSchema.index({ price: 1 });
+    const Product = db.mongoose.model("Product", ProductSchema);
+    return Product;
+  };
+  return product_model;
+}
+var category_model;
+var hasRequiredCategory_model;
+function requireCategory_model() {
+  if (hasRequiredCategory_model) return category_model;
+  hasRequiredCategory_model = 1;
+  category_model = (db) => {
+    const CategorySchema = new db.mongoose.Schema({
+      name: { type: String, required: true, trim: true },
+      description: { type: String, trim: true },
+      photo: {
         type: String
       },
-      quantity: {
-        type: Number
+      status: {
+        type: String,
+        enum: ["draft", "internal", "published", "removed"],
+        default: "draft",
+        required: true
       },
-      price: {
-        type: Number
+      order: { type: Number, required: true },
+      url: { type: String, required: true, trim: true },
+      parent: { type: db.mongoose.Schema.Types.ObjectId, ref: "Category" },
+      localization: { type: Array },
+      filters: { type: Array }
+    }, {
+      timestamps: { currentTime: () => Date.now() }
+    });
+    CategorySchema.index({ parent: 1 });
+    CategorySchema.index({ "owner.target": 1, "creator.target": 1 });
+    const Category = db.mongoose.model("Category", CategorySchema, "categories");
+    return Category;
+  };
+  return category_model;
+}
+var leftover_model;
+var hasRequiredLeftover_model;
+function requireLeftover_model() {
+  if (hasRequiredLeftover_model) return leftover_model;
+  hasRequiredLeftover_model = 1;
+  const applyOwnershipSchema = requireOwnership_schema();
+  leftover_model = (db) => {
+    const LeftoverSchema = new db.mongoose.Schema({
+      organization: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Organization"
       },
       type: {
+        type: String,
+        enum: ["stock-in", "stock-out", "write-off"],
+        default: "stock-in",
+        required: true
+      },
+      order: {
+        type: String
+      },
+      comment: {
         type: String
+      },
+      store: {
+        type: Object
+      },
+      positions: [{
+        _id: {
+          type: db.mongoose.Schema.Types.ObjectId,
+          ref: "Product"
+        },
+        name: {
+          type: String
+        },
+        quantity: {
+          type: Number
+        },
+        price: {
+          type: Number
+        },
+        type: {
+          type: String
+        }
+      }]
+    }, {
+      timestamps: {
+        currentTime: () => Date.now()
       }
-    }]
-  }, {
-    timestamps: {
-      currentTime: () => Date.now()
-    }
-  });
-  applyOwnershipSchema(LeftoverSchema, db);
-  LeftoverSchema.index({ user: 1, type: 1, target: 1 });
-  const Leftover = db.mongoose.model("Leftover", LeftoverSchema);
-  return Leftover;
-};
-const ObjectId = require$$0.Types.ObjectId;
-const OpenAI = require$$3;
-const openai = new OpenAI({
-  organization: process.env.OPENAI_ORG_KEY,
-  apiKey: process.env.OPENAI_API_KEY
-});
-const controllerFactory$5 = (db) => {
-  const Product = db.product;
-  db.modification;
-  db.leftover;
-  const Create = async (req, res) => {
-    try {
-      const newProduct = new Product(req.body);
-      const data = await newProduct.save();
-      res.send(data);
-    } catch (err) {
-      console.log(err);
-      res.status(500).send({ message: err.message });
-    }
+    });
+    applyOwnershipSchema(LeftoverSchema, db);
+    LeftoverSchema.index({ user: 1, type: 1, target: 1 });
+    const Leftover = db.mongoose.model("Leftover", LeftoverSchema);
+    return Leftover;
   };
-  const Read = async (req, res) => {
-    try {
-      const query = {};
-      if (req.query.owner) {
-        query["owner.target"] = new ObjectId(req.query.owner);
-      }
-      if (req.query._id) {
-        query._id = new ObjectId(req.query._id);
-      }
-      if (req.query.status) {
-        query.status = req.query.status;
-      }
-      const categories = req.query.categories?.split(",") || [];
-      if (categories.length) {
-        query.category = { $in: categories.map((cat) => new ObjectId(cat)) };
-      }
-      const deliveryOptions = req.query.delivery?.split(",") || [];
-      if (deliveryOptions.length) {
-        query.delivery = { $in: deliveryOptions };
+  return leftover_model;
+}
+var products_controller;
+var hasRequiredProducts_controller;
+function requireProducts_controller() {
+  if (hasRequiredProducts_controller) return products_controller;
+  hasRequiredProducts_controller = 1;
+  const { v1: uuidv1, v4: uuidv4 } = require$$0;
+  const ObjectId = require$$0$1.Types.ObjectId;
+  const OpenAI = require$$3;
+  const openai = new OpenAI({
+    organization: process.env.OPENAI_ORG_KEY,
+    apiKey: process.env.OPENAI_API_KEY
+  });
+  const controllerFactory = (db) => {
+    const Product = db.product;
+    db.modification;
+    db.leftover;
+    const Create = async (req, res) => {
+      try {
+        const newProduct = new Product(req.body);
+        const data = await newProduct.save();
+        res.send(data);
+      } catch (err) {
+        console.log(err);
+        res.status(500).send({ message: err.message });
       }
-      const search = req.query.search;
-      if (search) {
-        const parts = search.split(".");
-        let regexPattern = "";
-        if (parts.length === 2) {
-          regexPattern = parts.map((part) => part.substr(0, part.length - 1) + ".{1}").join("\\.");
-        } else {
-          regexPattern = search.substr(0, search.length - 1) + ".{1}";
+    };
+    const Read = async (req, res) => {
+      try {
+        const query = {};
+        if (req.query.owner) {
+          query["owner.target"] = new ObjectId(req.query.owner);
         }
-        query.name = { $regex: regexPattern, $options: "i" };
-      }
-      const prices = req.query.prices?.split(",") || [];
-      if (prices.length) {
-        const priceConditions = prices.map((priceRange) => {
-          if (priceRange.startsWith("<")) {
-            return { price: { $lt: parseInt(priceRange.slice(1)) } };
+        if (req.query._id) {
+          query._id = new ObjectId(req.query._id);
+        }
+        if (req.query.status) {
+          query.status = req.query.status;
+        }
+        const categories = req.query.categories?.split(",") || [];
+        if (categories.length) {
+          query.category = { $in: categories.map((cat) => new ObjectId(cat)) };
+        }
+        const deliveryOptions = req.query.delivery?.split(",") || [];
+        if (deliveryOptions.length) {
+          query.delivery = { $in: deliveryOptions };
+        }
+        const search = req.query.search;
+        if (search) {
+          const parts = search.split(".");
+          let regexPattern = "";
+          if (parts.length === 2) {
+            regexPattern = parts.map((part) => part.substr(0, part.length - 1) + ".{1}").join("\\.");
+          } else {
+            regexPattern = search.substr(0, search.length - 1) + ".{1}";
           }
-          if (priceRange.startsWith(">")) {
-            return { price: { $gt: parseInt(priceRange.slice(1)) } };
+          query.name = { $regex: regexPattern, $options: "i" };
+        }
+        const prices = req.query.prices?.split(",") || [];
+        if (prices.length) {
+          const priceConditions = prices.map((priceRange) => {
+            if (priceRange.startsWith("<")) {
+              return { price: { $lt: parseInt(priceRange.slice(1)) } };
+            }
+            if (priceRange.startsWith(">")) {
+              return { price: { $gt: parseInt(priceRange.slice(1)) } };
+            }
+            const [min, max] = priceRange.split("-").map(Number);
+            return { price: { $gte: min, $lte: max } };
+          });
+          if (priceConditions.length) {
+            query.$or = priceConditions;
           }
-          const [min, max] = priceRange.split("-").map(Number);
-          return { price: { $gte: min, $lte: max } };
-        });
-        if (priceConditions.length) {
-          query.$or = priceConditions;
         }
-      }
-      const options = {
-        skip: parseInt(req.query.skip) || 0,
-        limit: parseInt(req.query.limit) || 10,
-        sort: { createdAt: -1 }
-      };
-      const aggregationPipeline = [
-        { $match: query },
-        { $sort: options.sort },
-        { $skip: options.skip },
-        { $limit: options.limit },
-        {
-          $lookup: {
-            from: "leftovers",
-            let: { productId: "$_id", ingredientsIds: "$ingredients._id" },
-            pipeline: [
-              { $unwind: "$positions" },
-              {
-                $match: {
-                  $expr: {
-                    $or: [
-                      { $eq: ["$positions._id", "$$productId"] },
-                      { $in: ["$positions._id", { $ifNull: ["$$ingredientsIds", []] }] }
-                    ]
+        const options = {
+          skip: parseInt(req.query.skip) || 0,
+          limit: parseInt(req.query.limit) || 10,
+          sort: { createdAt: -1 }
+        };
+        const aggregationPipeline = [
+          { $match: query },
+          { $sort: options.sort },
+          { $skip: options.skip },
+          { $limit: options.limit },
+          {
+            $lookup: {
+              from: "leftovers",
+              let: { productId: "$_id", ingredientsIds: "$ingredients._id" },
+              pipeline: [
+                { $unwind: "$positions" },
+                {
+                  $match: {
+                    $expr: {
+                      $or: [
+                        { $eq: ["$positions._id", "$$productId"] },
+                        { $in: ["$positions._id", { $ifNull: ["$$ingredientsIds", []] }] }
+                      ]
+                    }
                   }
-                }
-              },
-              {
-                "$addFields": {
-                  "positions.quantity": {
-                    $cond: {
-                      if: { $eq: ["$type", "stock-in"] },
-                      then: "$positions.quantity",
-                      else: { $multiply: ["$positions.quantity", -1] }
+                },
+                {
+                  "$addFields": {
+                    "positions.quantity": {
+                      $cond: {
+                        if: { $eq: ["$type", "stock-in"] },
+                        then: "$positions.quantity",
+                        else: { $multiply: ["$positions.quantity", -1] }
+                      }
                     }
                   }
+                },
+                {
+                  "$project": {
+                    _id: "$positions._id",
+                    quantity: "$positions.quantity",
+                    name: "$positions.name"
+                  }
                 }
-              },
-              {
-                "$project": {
-                  _id: "$positions._id",
-                  quantity: "$positions.quantity",
-                  name: "$positions.name"
-                }
-              }
-            ],
-            as: "leftovers"
-          }
-        },
-        {
-          $addFields: {
-            ingredientsQuantities: {
-              $cond: {
-                if: { $isArray: "$ingredients" },
-                then: {
-                  $map: {
-                    input: "$ingredients",
-                    as: "ingredient",
-                    in: {
-                      $let: {
-                        vars: {
-                          ingredientId: "$$ingredient._id",
-                          ingredientQuantity: { $ifNull: ["$$ingredient.quantity", 0] }
-                        },
-                        in: {
-                          $divide: [
-                            {
-                              $sum: {
-                                $map: {
-                                  input: "$leftovers",
-                                  as: "leftover",
-                                  in: {
-                                    $cond: {
-                                      if: { $eq: ["$$leftover._id", "$$ingredientId"] },
-                                      then: "$$leftover.quantity",
-                                      else: 0
+              ],
+              as: "leftovers"
+            }
+          },
+          {
+            $addFields: {
+              ingredientsQuantities: {
+                $cond: {
+                  if: { $isArray: "$ingredients" },
+                  then: {
+                    $map: {
+                      input: "$ingredients",
+                      as: "ingredient",
+                      in: {
+                        $let: {
+                          vars: {
+                            ingredientId: "$$ingredient._id",
+                            ingredientQuantity: { $ifNull: ["$$ingredient.quantity", 0] }
+                          },
+                          in: {
+                            $divide: [
+                              {
+                                $sum: {
+                                  $map: {
+                                    input: "$leftovers",
+                                    as: "leftover",
+                                    in: {
+                                      $cond: {
+                                        if: { $eq: ["$$leftover._id", "$$ingredientId"] },
+                                        then: "$$leftover.quantity",
+                                        else: 0
+                                      }
                                     }
                                   }
                                 }
+                              },
+                              {
+                                $cond: {
+                                  if: { $eq: ["$$ingredientQuantity", 0] },
+                                  then: 1,
+                                  else: "$$ingredientQuantity"
+                                }
                               }
-                            },
-                            {
-                              $cond: {
-                                if: { $eq: ["$$ingredientQuantity", 0] },
-                                then: 1,
-                                else: "$$ingredientQuantity"
-                              }
-                            }
-                          ]
+                            ]
+                          }
                         }
                       }
                     }
-                  }
-                },
-                else: []
+                  },
+                  else: []
+                }
               }
             }
-          }
-        },
-        {
-          $set: {
-            quantity: {
-              $cond: {
-                if: { $gt: [{ $size: { $ifNull: ["$ingredients", []] } }, 0] },
-                then: { $floor: { $min: "$ingredientsQuantities" } },
-                else: { $sum: "$leftovers.quantity" }
+          },
+          {
+            $set: {
+              quantity: {
+                $cond: {
+                  if: { $gt: [{ $size: { $ifNull: ["$ingredients", []] } }, 0] },
+                  then: { $floor: { $min: "$ingredientsQuantities" } },
+                  else: { $sum: "$leftovers.quantity" }
+                }
               }
             }
-          }
-        },
-        { $unset: ["leftovers", "ingredientsQuantities"] }
-      ];
-      const products = await Product.aggregate(aggregationPipeline);
-      if (req.query.count) {
-        const count = products.length;
-        return res.status(200).json({ count });
-      }
-      res.status(200).json(products);
-    } catch (err) {
-      return res.status(500).json({ message: err.message });
-    }
-  };
-  const Update = async (req, res) => {
-    try {
-      const { _id } = req.params;
-      console.log(req.body.ingredients);
-      const updatedProduct = await Product.findOneAndUpdate(
-        { _id },
-        {
-          name: req.body.name,
-          status: req.body.status,
-          listing: req.body.listing,
-          description: req.body.description,
-          price: req.body.price,
-          price_currency: req.body.price_currency,
-          sale: req.body.sale,
-          category: req.body.category,
-          images: req.body.images,
-          information: req.body.information,
-          localization: req.body.localization,
-          quantity: req.body.quantity,
-          quantityDiscount: req.body.quantityDiscount,
-          ingredients: req.body.ingredients
-        },
-        { new: true }
-      );
-      if (!updatedProduct) {
-        return res.status(404).send({ message: "Something wrong when updating product." });
+          },
+          { $unset: ["leftovers", "ingredientsQuantities"] }
+        ];
+        const products = await Product.aggregate(aggregationPipeline);
+        if (req.query.count) {
+          const count = products.length;
+          return res.status(200).json({ count });
+        }
+        res.status(200).json(products);
+      } catch (err) {
+        return res.status(500).json({ message: err.message });
       }
-      res.status(200).send(updatedProduct);
-    } catch (err) {
-      res.status(500).send({ message: err.message });
-    }
-  };
-  const Delete = async (req, res) => {
-    try {
-      const { _id } = req.params;
-      const deletedProduct = await Product.findOneAndDelete({ _id });
-      if (!deletedProduct) {
-        return res.status(404).send({ message: "Product not found for deletion." });
+    };
+    const Update = async (req, res) => {
+      try {
+        const { _id } = req.params;
+        console.log(req.body.ingredients);
+        const updatedProduct = await Product.findOneAndUpdate(
+          { _id },
+          {
+            name: req.body.name,
+            status: req.body.status,
+            listing: req.body.listing,
+            description: req.body.description,
+            price: req.body.price,
+            price_currency: req.body.price_currency,
+            sale: req.body.sale,
+            category: req.body.category,
+            images: req.body.images,
+            information: req.body.information,
+            localization: req.body.localization,
+            quantity: req.body.quantity,
+            quantityDiscount: req.body.quantityDiscount,
+            ingredients: req.body.ingredients
+          },
+          { new: true }
+        );
+        if (!updatedProduct) {
+          return res.status(404).send({ message: "Something wrong when updating product." });
+        }
+        res.status(200).send(updatedProduct);
+      } catch (err) {
+        res.status(500).send({ message: err.message });
       }
-      res.status(200).send(deletedProduct);
-    } catch (err) {
-      res.status(500).send({ message: err.message });
-    }
-  };
-  const getProductRecommendation = async (req, res) => {
-    const { mood } = req.body;
-    try {
-      const products = await Product.find({
-        status: "published"
-      }).limit(40);
-      if (!products) {
-        console.log("no products");
-        return res.status(404).send({ message: "Products not found." });
+    };
+    const Delete = async (req, res) => {
+      try {
+        const { _id } = req.params;
+        const deletedProduct = await Product.findOneAndDelete({ _id });
+        if (!deletedProduct) {
+          return res.status(404).send({ message: "Product not found for deletion." });
+        }
+        res.status(200).send(deletedProduct);
+      } catch (err) {
+        res.status(500).send({ message: err.message });
       }
-      const productsList = products.map((p) => {
-        const info = p.information || [];
-        const value0 = info[0] ? info[0].value : "";
-        const value1 = info[1] ? `(${info[1].value}%)` : "";
-        const value2 = info[2] ? `(${info[2].value})` : "";
-        return `${p._id}: ${p.name} (${value0}) ${value1} ${value2}`;
-      }).join(", ");
-      const prompt = `
+    };
+    const getProductRecommendation = async (req, res) => {
+      const { mood } = req.body;
+      try {
+        const products = await Product.find({
+          status: "published"
+        }).limit(40);
+        if (!products) {
+          console.log("no products");
+          return res.status(404).send({ message: "Products not found." });
+        }
+        const productsList = products.map((p) => {
+          const info = p.information || [];
+          const value0 = info[0] ? info[0].value : "";
+          const value1 = info[1] ? `(${info[1].value}%)` : "";
+          const value2 = info[2] ? `(${info[2].value})` : "";
+          return `${p._id}: ${p.name} (${value0}) ${value1} ${value2}`;
+        }).join(", ");
+        const prompt = `
         1. When asked how the client wants to feel, they responded "${mood}". 
         2. Here is a list of products in our store: ${productsList}. 
         3. Based on the information about the products (strain, THC content) and the user's desires, choose 1 product to recommend to the user.
         4. The response should be in the language that the user used in mood (${mood}).
         5. Please format your response as a JSON object '{"_id": "ID of the recommended product (it must correspond to one of the product IDs I sent)", "recommendationText": "Text explaining why this particular product"'. Write only the JSON object without any other text outside of it.
       `;
-      console.log(prompt);
-      let response;
-      let result;
-      while (true) {
-        try {
-          response = await openai.chat.completions.create({
-            model: "gpt-3.5-turbo",
-            messages: [{ role: "user", content: prompt }]
-          });
-          console.log(response);
-          result = JSON.parse(response.choices[0].message.content);
-          break;
-        } catch (err) {
-          if (err instanceof SyntaxError) {
-            console.log("Received invalid JSON, retrying...");
-          } else {
-            console.log(err);
-            res.status(500).send({ message: err });
-            return;
+        console.log(prompt);
+        let response;
+        let result;
+        while (true) {
+          try {
+            response = await openai.chat.completions.create({
+              model: "gpt-3.5-turbo",
+              messages: [{ role: "user", content: prompt }]
+            });
+            console.log(response);
+            result = JSON.parse(response.choices[0].message.content);
+            break;
+          } catch (err) {
+            if (err instanceof SyntaxError) {
+              console.log("Received invalid JSON, retrying...");
+            } else {
+              console.log(err);
+              res.status(500).send({ message: err });
+              return;
+            }
           }
         }
+        console.log(result._id);
+        console.log(result.recommendationText);
+        const recommendedProduct = await Product.findById(result._id);
+        if (!recommendedProduct) {
+          console.log(`No product found with _id: ${result._id}`);
+          return res.status(404).send({ message: "Recommended product not found." });
+        }
+        res.status(200).json({ product: recommendedProduct, recommendationText: result.recommendationText });
+      } catch (err) {
+        console.log(err);
+        res.status(500).send({ message: err });
       }
-      console.log(result._id);
-      console.log(result.recommendationText);
-      const recommendedProduct = await Product.findById(result._id);
-      if (!recommendedProduct) {
-        console.log(`No product found with _id: ${result._id}`);
-        return res.status(404).send({ message: "Recommended product not found." });
-      }
-      res.status(200).json({ product: recommendedProduct, recommendationText: result.recommendationText });
-    } catch (err) {
-      console.log(err);
-      res.status(500).send({ message: err });
-    }
-  };
-  const getProductsPopular = (req, res) => {
-    Product.find({
-      status: "published",
-      popularity: { $gt: 10 }
-    }).populate("modifications").limit(10).exec((err, products) => {
-      if (err) {
-        return res.status(500).send({ message: err });
-      }
-      if (!products) {
-        return res.status(404).send({ message: "Products not found." });
-      }
-      res.status(200).send(products);
-    });
+    };
+    const getProductsPopular = (req, res) => {
+      Product.find({
+        status: "published",
+        popularity: { $gt: 10 }
+      }).populate("modifications").limit(10).exec((err, products) => {
+        if (err) {
+          return res.status(500).send({ message: err });
+        }
+        if (!products) {
+          return res.status(404).send({ message: "Products not found." });
+        }
+        res.status(200).send(products);
+      });
+    };
+    return {
+      Create,
+      Read,
+      Update,
+      Delete,
+      getProductsPopular,
+      getProductRecommendation
+    };
   };
-  return {
-    Create,
-    Read,
-    Update,
-    Delete,
-    getProductsPopular,
-    getProductRecommendation
+  products_controller = controllerFactory;
+  return products_controller;
+}
+var products_routes;
+var hasRequiredProducts_routes;
+function requireProducts_routes() {
+  if (hasRequiredProducts_routes) return products_routes;
+  hasRequiredProducts_routes = 1;
+  const controllerFactory = requireProducts_controller();
+  products_routes = function(app, db, allowedOrigins) {
+    const controller = controllerFactory(db);
+    app.post(
+      "/api/products/create",
+      controller.Create
+    );
+    app.get(
+      "/api/products/read",
+      controller.Read
+    );
+    app.post(
+      "/api/products/:_id",
+      controller.Update
+    );
+    app.delete(
+      "/api/products/:_id",
+      controller.Delete
+    );
+    app.post(
+      "/api/product/recommended",
+      controller.getProductRecommendation
+    );
   };
-};
-var products_controller = controllerFactory$5;
-const controllerFactory$4 = products_controller;
-var products_routes = function(app, db, allowedOrigins) {
-  const controller = controllerFactory$4(db);
-  app.post(
-    "/api/products/create",
-    controller.Create
-  );
-  app.get(
-    "/api/products/read",
-    controller.Read
-  );
-  app.post(
-    "/api/products/:_id",
-    controller.Update
-  );
-  app.delete(
-    "/api/products/:_id",
-    controller.Delete
-  );
-  app.post(
-    "/api/product/recommended",
-    controller.getProductRecommendation
-  );
-};
+  return products_routes;
+}
 var categories_routes = { exports: {} };
-const controllerFactory$3 = (db) => {
-  const Category = db.category;
-  return {
-    async read(req, res) {
-      try {
-        let buildTree = function(items) {
-          const itemMap = {};
-          const roots = [];
-          items.forEach((item) => {
-            itemMap[item._id.toString()] = {
-              ...item,
-              children: []
+var categories_controller;
+var hasRequiredCategories_controller;
+function requireCategories_controller() {
+  if (hasRequiredCategories_controller) return categories_controller;
+  hasRequiredCategories_controller = 1;
+  const controllerFactory = (db) => {
+    const Category = db.category;
+    return {
+      async read(req, res) {
+        try {
+          let buildTree = function(items) {
+            const itemMap = {};
+            const roots = [];
+            items.forEach((item) => {
+              itemMap[item._id.toString()] = {
+                ...item,
+                children: []
+              };
+            });
+            items.forEach((item) => {
+              const itemId = item._id.toString();
+              const parentId = item.parent?._id?.toString();
+              if (parentId && itemMap[parentId]) {
+                itemMap[parentId].children.push(itemMap[itemId]);
+              } else {
+                roots.push(itemMap[itemId]);
+              }
+            });
+            const sortByOrder = (a, b) => {
+              const orderA = a.order ?? Number.MAX_SAFE_INTEGER;
+              const orderB = b.order ?? Number.MAX_SAFE_INTEGER;
+              return orderA - orderB;
             };
+            const sortChildren = (node) => {
+              if (node.children && node.children.length > 0) {
+                node.children.sort(sortByOrder);
+                node.children.forEach(sortChildren);
+              }
+            };
+            roots.sort(sortByOrder);
+            roots.forEach(sortChildren);
+            return roots;
+          };
+          const {
+            parent,
+            url,
+            search,
+            sort = "order",
+            order = 1,
+            page = 1,
+            limit = 10,
+            excludeChildren = false,
+            rootOnly = false
+          } = req.query;
+          const matchStage = {
+            ...req.query.status && { status: req.query.status },
+            ...req.query.url && { url: req.query.url },
+            ...search && { name: { $regex: search, $options: "i" } },
+            ...parent ? { parent: new db.mongoose.Types.ObjectId(parent) } : {},
+            ...rootOnly ? { parent: null } : {}
+          };
+          const pipeline = [
+            { $match: matchStage },
+            {
+              $graphLookup: {
+                from: "categories",
+                startWith: "$_id",
+                connectFromField: "_id",
+                connectToField: "parent",
+                as: "allDescendants",
+                maxDepth: 10
+              }
+            },
+            { $sort: { [sort]: order === "asc" ? 1 : -1 } },
+            { $skip: (page - 1) * limit },
+            { $limit: Number(limit) }
+          ];
+          const flatResults = await Category.aggregate(pipeline);
+          const treeResults = flatResults.map((doc) => {
+            const descendants = doc.allDescendants || [];
+            const allItems = [doc, ...descendants];
+            const tree = buildTree(allItems);
+            return tree.find((node) => node._id.toString() === doc._id.toString());
           });
-          items.forEach((item) => {
-            const itemId = item._id.toString();
-            const parentId = item.parent?._id?.toString();
-            if (parentId && itemMap[parentId]) {
-              itemMap[parentId].children.push(itemMap[itemId]);
-            } else {
-              roots.push(itemMap[itemId]);
-            }
-          });
-          const sortByOrder = (a, b) => {
+          treeResults.sort((a, b) => {
             const orderA = a.order ?? Number.MAX_SAFE_INTEGER;
             const orderB = b.order ?? Number.MAX_SAFE_INTEGER;
             return orderA - orderB;
-          };
-          const sortChildren = (node) => {
-            if (node.children && node.children.length > 0) {
-              node.children.sort(sortByOrder);
-              node.children.forEach(sortChildren);
-            }
-          };
-          roots.sort(sortByOrder);
-          roots.forEach(sortChildren);
-          return roots;
-        };
-        const {
-          parent,
-          url,
-          search,
-          sort = "order",
-          order = 1,
-          page = 1,
-          limit = 10,
-          excludeChildren = false,
-          rootOnly = false
-        } = req.query;
-        const matchStage = {
-          ...req.query.status && { status: req.query.status },
-          ...req.query.url && { url: req.query.url },
-          ...search && { name: { $regex: search, $options: "i" } },
-          ...parent ? { parent: new db.mongoose.Types.ObjectId(parent) } : {},
-          ...rootOnly ? { parent: null } : {}
-        };
-        const pipeline = [
-          { $match: matchStage },
-          {
-            $graphLookup: {
-              from: "categories",
-              startWith: "$_id",
-              connectFromField: "_id",
-              connectToField: "parent",
-              as: "allDescendants",
-              maxDepth: 10
-            }
-          },
-          { $sort: { [sort]: order === "asc" ? 1 : -1 } },
-          { $skip: (page - 1) * limit },
-          { $limit: Number(limit) }
-        ];
-        const flatResults = await Category.aggregate(pipeline);
-        const treeResults = flatResults.map((doc) => {
-          const descendants = doc.allDescendants || [];
-          const allItems = [doc, ...descendants];
-          const tree = buildTree(allItems);
-          return tree.find((node) => node._id.toString() === doc._id.toString());
-        });
-        treeResults.sort((a, b) => {
-          const orderA = a.order ?? Number.MAX_SAFE_INTEGER;
-          const orderB = b.order ?? Number.MAX_SAFE_INTEGER;
-          return orderA - orderB;
-        });
-        res.json(treeResults);
-      } catch (err) {
-        res.status(500).json({ message: err.message });
-      }
-    },
-    async create(req, res) {
-      try {
-        const highestOrder = await Category.findOne().sort("-order");
-        const order = highestOrder ? highestOrder.order + 1 : 1;
-        const category = new Category({ ...req.body, order });
-        if (req.body.parent) {
-          const parent = await Category.findByIdAndUpdate(
-            req.body.parent,
-            { $push: { children: category._id } },
-            { new: true }
-          );
-          if (!parent) throw new Error("Parent category not found");
-          category.parent = parent._id;
+          });
+          res.json(treeResults);
+        } catch (err) {
+          res.status(500).json({ message: err.message });
         }
-        if (req.body.children && req.body.children.length > 0) {
-          await Category.updateMany(
-            { _id: { $in: req.body.children } },
-            { $set: { parent: category._id } }
-          );
+      },
+      async create(req, res) {
+        try {
+          const highestOrder = await Category.findOne().sort("-order");
+          const order = highestOrder ? highestOrder.order + 1 : 1;
+          const category = new Category({ ...req.body, order });
+          if (req.body.parent) {
+            const parent = await Category.findByIdAndUpdate(
+              req.body.parent,
+              { $push: { children: category._id } },
+              { new: true }
+            );
+            if (!parent) throw new Error("Parent category not found");
+            category.parent = parent._id;
+          }
+          if (req.body.children && req.body.children.length > 0) {
+            await Category.updateMany(
+              { _id: { $in: req.body.children } },
+              { $set: { parent: category._id } }
+            );
+          }
+          await category.save();
+          res.status(201).json(category);
+        } catch (err) {
+          res.status(err.message === "Parent category not found" ? 404 : 500).json({ message: err.message });
         }
-        await category.save();
-        res.status(201).json(category);
-      } catch (err) {
-        res.status(err.message === "Parent category not found" ? 404 : 500).json({ message: err.message });
-      }
-    },
-    async update(req, res) {
-      try {
-        const { categories } = req.body;
-        const bulkOps = categories.map((category) => ({
-          updateOne: {
-            filter: { _id: category._id },
-            update: {
-              $set: {
-                order: category.order,
-                parent: category.parent ? new db.mongoose.Types.ObjectId(category.parent) : null
+      },
+      async update(req, res) {
+        try {
+          const { categories } = req.body;
+          const bulkOps = categories.map((category) => ({
+            updateOne: {
+              filter: { _id: category._id },
+              update: {
+                $set: {
+                  order: category.order,
+                  parent: category.parent ? new db.mongoose.Types.ObjectId(category.parent) : null
+                }
               }
             }
-          }
-        }));
-        await Category.bulkWrite(bulkOps);
-        const updatedCategories = await Category.find().sort({ order: "asc" }).lean();
-        res.status(200).json(updatedCategories);
-      } catch (err) {
-        console.error("Category update error:", err);
-        res.status(500).json({ message: "Failed to update categories" });
-      }
-    },
-    async delete(req, res) {
-      try {
-        const category = await Category.findOne({ url: req.body.url });
-        if (!category) throw new Error("Category not found");
-        const deleteSubcategories = async (categoryId) => {
-          const cat = await Category.findById(categoryId);
-          if (cat) {
-            for (const childId of cat.children) {
-              await deleteSubcategories(childId);
+          }));
+          await Category.bulkWrite(bulkOps);
+          const updatedCategories = await Category.find().sort({ order: "asc" }).lean();
+          res.status(200).json(updatedCategories);
+        } catch (err) {
+          console.error("Category update error:", err);
+          res.status(500).json({ message: "Failed to update categories" });
+        }
+      },
+      async delete(req, res) {
+        try {
+          const category = await Category.findOne({ url: req.body.url });
+          if (!category) throw new Error("Category not found");
+          const deleteSubcategories = async (categoryId) => {
+            const cat = await Category.findById(categoryId);
+            if (cat) {
+              for (const childId of cat.children) {
+                await deleteSubcategories(childId);
+              }
+              await Category.findByIdAndDelete(categoryId);
             }
-            await Category.findByIdAndDelete(categoryId);
+          };
+          if (category.parent) {
+            await Category.findByIdAndUpdate(category.parent, { $pull: { children: category._id } });
           }
-        };
-        if (category.parent) {
-          await Category.findByIdAndUpdate(category.parent, { $pull: { children: category._id } });
+          await deleteSubcategories(category._id);
+          res.status(200).json({ message: "Category deleted successfully" });
+        } catch (err) {
+          res.status(err.message === "Category not found" ? 404 : 500).json({ message: err.message });
         }
-        await deleteSubcategories(category._id);
-        res.status(200).json({ message: "Category deleted successfully" });
-      } catch (err) {
-        res.status(err.message === "Category not found" ? 404 : 500).json({ message: err.message });
       }
-    }
+    };
   };
-};
-var categories_controller = controllerFactory$3;
+  categories_controller = controllerFactory;
+  return categories_controller;
+}
 var verifyCategory;
 var hasRequiredVerifyCategory;
 function requireVerifyCategory() {
@@ -698,206 +741,240 @@ function requireVerifyCategory() {
   verifyCategory = middlewareFactory;
   return verifyCategory;
 }
-const middlewareIndexFactory = (db) => {
-  const verifyCategory2 = requireVerifyCategory()(db);
-  return {
-    verifyCategory: verifyCategory2
+var middlewares;
+var hasRequiredMiddlewares;
+function requireMiddlewares() {
+  if (hasRequiredMiddlewares) return middlewares;
+  hasRequiredMiddlewares = 1;
+  const middlewareIndexFactory = (db) => {
+    const verifyCategory2 = requireVerifyCategory()(db);
+    return {
+      verifyCategory: verifyCategory2
+    };
   };
-};
-var middlewares = middlewareIndexFactory;
-const controllerFactory$2 = categories_controller;
-const middlewareFactoryProducts = middlewares;
-categories_routes.exports = function(app, db) {
-  const controller = controllerFactory$2(db);
-  const { verifyCategory: verifyCategory2 } = middlewareFactoryProducts(db);
-  app.get("/api/categories", controller.read);
-  app.post("/api/categories/create", [verifyCategory2.checkCategoryExistOrNot], controller.create);
-  app.post("/api/categories/update", controller.update);
-  app.post("/api/categories/delete", controller.delete);
-};
-categories_routes.exports.controllerFactory = controllerFactory$2;
-var categories_routesExports = categories_routes.exports;
-const queryProcessorGlobals = queryProcessor;
-const controllerFactory$1 = (db) => {
-  const Leftover = db.leftover;
-  const read = async (req, res) => {
-    try {
-      let matchConditions = [];
-      const search = req.query.search;
-      if (search) {
-        const parts = search.split(".");
-        let regexPattern = "";
-        if (parts.length === 2) {
-          regexPattern = parts.map((part) => part.substr(0, part.length - 1) + ".{1}").join("\\.");
-        } else {
-          regexPattern = search.substr(0, search.length - 1) + ".{1}";
+  middlewares = middlewareIndexFactory;
+  return middlewares;
+}
+var hasRequiredCategories_routes;
+function requireCategories_routes() {
+  if (hasRequiredCategories_routes) return categories_routes.exports;
+  hasRequiredCategories_routes = 1;
+  const controllerFactory = requireCategories_controller();
+  const middlewareFactoryProducts = requireMiddlewares();
+  categories_routes.exports = function(app, db) {
+    const controller = controllerFactory(db);
+    const { verifyCategory: verifyCategory2 } = middlewareFactoryProducts(db);
+    app.get("/api/categories", controller.read);
+    app.post("/api/categories/create", [verifyCategory2.checkCategoryExistOrNot], controller.create);
+    app.post("/api/categories/update", controller.update);
+    app.post("/api/categories/delete", controller.delete);
+  };
+  categories_routes.exports.controllerFactory = controllerFactory;
+  return categories_routes.exports;
+}
+var leftovers_controller;
+var hasRequiredLeftovers_controller;
+function requireLeftovers_controller() {
+  if (hasRequiredLeftovers_controller) return leftovers_controller;
+  hasRequiredLeftovers_controller = 1;
+  const queryProcessorGlobals = requireQueryProcessor();
+  const controllerFactory = (db) => {
+    const Leftover = db.leftover;
+    const read = async (req, res) => {
+      try {
+        let matchConditions = [];
+        const search = req.query.search;
+        if (search) {
+          const parts = search.split(".");
+          let regexPattern = "";
+          if (parts.length === 2) {
+            regexPattern = parts.map((part) => part.substr(0, part.length - 1) + ".{1}").join("\\.");
+          } else {
+            regexPattern = search.substr(0, search.length - 1) + ".{1}";
+          }
+          matchConditions.push({
+            $or: [
+              { "comment": { $regex: regexPattern, $options: "i" } },
+              { "positions.name": { $regex: regexPattern, $options: "i" } }
+            ]
+          });
         }
-        matchConditions.push({
-          $or: [
-            { "comment": { $regex: regexPattern, $options: "i" } },
-            { "positions.name": { $regex: regexPattern, $options: "i" } }
-          ]
+        const matchStage = matchConditions.length > 0 ? { $match: { $and: matchConditions } } : null;
+        let stages = [
+          ...queryProcessorGlobals.getBasicOptions(
+            req.query
+          ),
+          // For creator
+          queryProcessorGlobals.getCreatorUserLookupStage(),
+          queryProcessorGlobals.getCreatorOrganizationLookupStage(),
+          // For owner
+          queryProcessorGlobals.getOwnerUserLookupStage(),
+          queryProcessorGlobals.getOwnerOrganizationLookupStage(),
+          queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
+          ...matchStage != null ? [matchStage] : [],
+          // Pagination
+          ...queryProcessorGlobals.getSortingOptions(
+            req.query.sortParam,
+            req.query.sortOrder
+          ),
+          ...queryProcessorGlobals.getPaginationOptions(
+            req.query.skip,
+            req.query.limit
+          )
+        ];
+        const leftoveres = await Leftover.aggregate(stages).exec();
+        if (!leftoveres) {
+          return res.status(404).send({ message: "LEFTOVERES_NOT_FOUND" });
+        }
+        res.status(200).send(leftoveres);
+      } catch (err) {
+        console.error(err);
+        res.status(500).send({ message: "ERROR_GET_ALL_LEFTOVERES" });
+      }
+    };
+    const create = async (req, res) => {
+      try {
+        console.log("order is", req.body.order);
+        const leftover = await Leftover.create({
+          organization: req.body.organization,
+          type: req.body.type,
+          order: req.body.order,
+          comment: req.body.comment,
+          positions: req.body.positions,
+          creator: req.body.creator,
+          owner: req.body.owner
         });
+        if (!leftover) {
+          return res.status(404).send({ message: "ERROR_CREATING_LEFTOVER" });
+        }
+        res.status(200).send(leftover);
+      } catch (err) {
+        console.log(err);
+        res.status(500).send({ message: "ERROR_CREATE_LEFTOVER" });
+      }
+    };
+    const get = async (req, res) => {
+      try {
+        const leftover = await Leftover.findOne({ _id: req.params._id }).exec();
+        if (!leftover) {
+          return res.status(404).send({ message: "LEFTOVER_NOT_FOUND" });
+        }
+        res.status(200).send(leftover);
+      } catch (err) {
+        res.status(500).send({ message: "ERROR_GET_LEFTOVER" });
       }
-      const matchStage = matchConditions.length > 0 ? { $match: { $and: matchConditions } } : null;
-      let stages = [
-        ...queryProcessorGlobals.getBasicOptions(
-          req.query
-        ),
-        // For creator
-        queryProcessorGlobals.getCreatorUserLookupStage(),
-        queryProcessorGlobals.getCreatorOrganizationLookupStage(),
-        // For owner
-        queryProcessorGlobals.getOwnerUserLookupStage(),
-        queryProcessorGlobals.getOwnerOrganizationLookupStage(),
-        queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
-        ...matchStage != null ? [matchStage] : [],
-        // Pagination
-        ...queryProcessorGlobals.getSortingOptions(
-          req.query.sortParam,
-          req.query.sortOrder
-        ),
-        ...queryProcessorGlobals.getPaginationOptions(
-          req.query.skip,
-          req.query.limit
-        )
-      ];
-      const leftoveres = await Leftover.aggregate(stages).exec();
-      if (!leftoveres) {
-        return res.status(404).send({ message: "LEFTOVERES_NOT_FOUND" });
+    };
+    const update = async (req, res) => {
+      try {
+        const leftover = await Leftover.findOneAndUpdate({ _id: req.params._id }, req.body, { new: true, upsert: true }).exec();
+        if (!leftover) {
+          return res.status(404).send({ message: "LEFTOVER_NOT_FOUND" });
+        }
+        res.status(200).send(leftover);
+      } catch (err) {
+        console.log(err);
+        res.status(500).send({ message: "ERROR_UPDATING_LEFTOVER" });
       }
-      res.status(200).send(leftoveres);
-    } catch (err) {
-      console.error(err);
-      res.status(500).send({ message: "ERROR_GET_ALL_LEFTOVERES" });
-    }
-  };
-  const create = async (req, res) => {
-    try {
-      console.log("order is", req.body.order);
-      const leftover = await Leftover.create({
-        organization: req.body.organization,
-        type: req.body.type,
-        order: req.body.order,
-        comment: req.body.comment,
-        positions: req.body.positions,
-        creator: req.body.creator,
-        owner: req.body.owner
-      });
-      if (!leftover) {
-        return res.status(404).send({ message: "ERROR_CREATING_LEFTOVER" });
+    };
+    const deleteLeftover = async (req, res) => {
+      try {
+        const leftover = await Leftover.findOneAndDelete({ _id: req.params._id });
+        if (!leftover) {
+          return res.status(404).send({ message: "ERROR_DELETING_LEFTOVER" });
+        }
+        res.status(200).send(leftover);
+      } catch (err) {
+        res.status(500).send({ message: "ERROR_DELETE_LEFTOVER" });
       }
-      res.status(200).send(leftover);
-    } catch (err) {
-      console.log(err);
-      res.status(500).send({ message: "ERROR_CREATE_LEFTOVER" });
-    }
+    };
+    return {
+      read,
+      create,
+      get,
+      update,
+      delete: deleteLeftover
+    };
   };
-  const get = async (req, res) => {
-    try {
-      const leftover = await Leftover.findOne({ _id: req.params._id }).exec();
-      if (!leftover) {
-        return res.status(404).send({ message: "LEFTOVER_NOT_FOUND" });
-      }
-      res.status(200).send(leftover);
-    } catch (err) {
-      res.status(500).send({ message: "ERROR_GET_LEFTOVER" });
-    }
+  leftovers_controller = controllerFactory;
+  return leftovers_controller;
+}
+var leftovers_routes;
+var hasRequiredLeftovers_routes;
+function requireLeftovers_routes() {
+  if (hasRequiredLeftovers_routes) return leftovers_routes;
+  hasRequiredLeftovers_routes = 1;
+  const controllerFactory = requireLeftovers_controller();
+  leftovers_routes = function(app, db) {
+    const controller = controllerFactory(db);
+    app.get(
+      "/leftovers",
+      controller.read
+    );
+    app.get(
+      "/leftovers/:_id",
+      controller.get
+    );
+    app.post(
+      "/leftovers/:_id",
+      controller.update
+    );
+    app.post(
+      "/leftovers",
+      controller.create
+    );
+    app.delete(
+      "/leftovers/:_id",
+      controller.delete
+    );
   };
-  const update = async (req, res) => {
-    try {
-      const leftover = await Leftover.findOneAndUpdate({ _id: req.params._id }, req.body, { new: true, upsert: true }).exec();
-      if (!leftover) {
-        return res.status(404).send({ message: "LEFTOVER_NOT_FOUND" });
-      }
-      res.status(200).send(leftover);
-    } catch (err) {
-      console.log(err);
-      res.status(500).send({ message: "ERROR_UPDATING_LEFTOVER" });
+  return leftovers_routes;
+}
+var products_server$1;
+var hasRequiredProducts_server;
+function requireProducts_server() {
+  if (hasRequiredProducts_server) return products_server$1;
+  hasRequiredProducts_server = 1;
+  const ProductModel = requireProduct_model();
+  const CategoryModel = requireCategory_model();
+  const LeftoverModel = requireLeftover_model();
+  const productsRoutes = requireProducts_routes();
+  const categoriesRoutes = requireCategories_routes();
+  const leftoversRoutes = requireLeftovers_routes();
+  const ProductController = requireProducts_controller();
+  const CategoryController = requireCategories_controller();
+  const LeftoverController = requireLeftovers_controller();
+  function initializeProduct(app, db, origins, publicPath) {
+    db.product = ProductModel(db);
+    db.category = CategoryModel(db);
+    db.leftover = LeftoverModel(db);
+    if (app) {
+      productsRoutes(app, db, origins, publicPath);
+      categoriesRoutes(app, db, origins, publicPath);
+      leftoversRoutes(app, db, origins, publicPath);
     }
-  };
-  const deleteLeftover = async (req, res) => {
-    try {
-      const leftover = await Leftover.findOneAndDelete({ _id: req.params._id });
-      if (!leftover) {
-        return res.status(404).send({ message: "ERROR_DELETING_LEFTOVER" });
-      }
-      res.status(200).send(leftover);
-    } catch (err) {
-      res.status(500).send({ message: "ERROR_DELETE_LEFTOVER" });
+  }
+  products_server$1 = {
+    initialize: initializeProduct,
+    models: {
+      ProductModel,
+      CategoryModel,
+      LeftoverModel
+    },
+    routes: {
+      productsRoutes,
+      categoriesRoutes,
+      leftoversRoutes
+    },
+    controllers: {
+      ProductController,
+      CategoryController,
+      LeftoverController
     }
   };
-  return {
-    read,
-    create,
-    get,
-    update,
-    delete: deleteLeftover
-  };
-};
-var leftovers_controller = controllerFactory$1;
-const controllerFactory = leftovers_controller;
-var leftovers_routes = function(app, db) {
-  const controller = controllerFactory(db);
-  app.get(
-    "/leftovers",
-    controller.read
-  );
-  app.get(
-    "/leftovers/:_id",
-    controller.get
-  );
-  app.post(
-    "/leftovers/:_id",
-    controller.update
-  );
-  app.post(
-    "/leftovers",
-    controller.create
-  );
-  app.delete(
-    "/leftovers/:_id",
-    controller.delete
-  );
-};
-const ProductModel = product_model;
-const CategoryModel = category_model;
-const LeftoverModel = leftover_model;
-const productsRoutes = products_routes;
-const categoriesRoutes = categories_routesExports;
-const leftoversRoutes = leftovers_routes;
-const ProductController = products_controller;
-const CategoryController = categories_controller;
-const LeftoverController = leftovers_controller;
-function initializeProduct(app, db, origins, publicPath) {
-  db.product = ProductModel(db);
-  db.category = CategoryModel(db);
-  db.leftover = LeftoverModel(db);
-  if (app) {
-    productsRoutes(app, db);
-    categoriesRoutes(app, db, origins, publicPath);
-    leftoversRoutes(app, db);
-  }
+  return products_server$1;
 }
-var products_server = {
-  initialize: initializeProduct,
-  models: {
-    ProductModel,
-    CategoryModel,
-    LeftoverModel
-  },
-  routes: {
-    productsRoutes,
-    categoriesRoutes,
-    leftoversRoutes
-  },
-  controllers: {
-    ProductController,
-    CategoryController,
-    LeftoverController
-  }
-};
-const products_server$1 = /* @__PURE__ */ getDefaultExportFromCjs(products_server);
+var products_serverExports = requireProducts_server();
+const products_server = /* @__PURE__ */ getDefaultExportFromCjs(products_serverExports);
 export {
-  products_server$1 as default
+  products_server as default
 };