@ozdao/martyrs 0.2.477 → 0.2.479

package/dist/products.server.mjs

@@ -1,1381 +0,0 @@
-import { g as getDefaultExportFromCjs } from "./_commonjsHelpers-CUmg6egw.mjs";
-import { r as requireOwnership_schema } from "./ownership.schema-CNCotD3D.mjs";
-import { r as requireCommon_schema } from "./common.schema-C2m3O1XY.mjs";
-import { r as requireMetadata_schema } from "./metadata.schema--tle-GU8.mjs";
-import { r as requireEngagement_schema } from "./engagement.schema-DnDD7Bn3.mjs";
-import require$$0 from "uuid";
-import require$$0$1 from "mongoose";
-import "path";
-import require$$3 from "openai";
-import { r as requireQueryProcessor } from "./queryProcessor-CVKI651_.mjs";
-import { r as requireGlobals_logger } from "./globals.logger-DusiFsxN.mjs";
-import { r as requireGlobals_cache } from "./globals.cache-BT6q3vOf.mjs";
-import { r as requireGlobals_verifier, a as requireGlobals_validator } from "./globals.verifier-BdJxc8-8.mjs";
-import { r as requireAuthJwt } from "./authJwt-DnXu3BFq.mjs";
-import { r as requireGlobals_abac } from "./globals.abac-DZpTRxKR.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"]
-      },
-      category: {
-        type: Array
-      },
-      name: {
-        type: String
-      },
-      description: {
-        type: String
-      },
-      information: [{
-        name: { type: String },
-        value: { type: String }
-      }],
-      images: {
-        type: Array
-      },
-      localization: {
-        type: Array
-      },
-      // ЗАДАЧА: Нужно отрефачить price, перенести его в default variant
-      price: {
-        type: Number,
-        required: true
-      },
-      price_cost: {
-        type: Number,
-        default: 0
-      },
-      price_currency: {
-        type: String,
-        default: "$"
-      },
-      quantity: {
-        type: Number,
-        default: 1
-      },
-      unit: {
-        type: String,
-        required: true,
-        default: "pcs"
-      },
-      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()
-      }
-    });
-    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 },
-      order: { type: Number, required: true },
-      url: { type: String, required: true, trim: true, unique: true },
-      parent: { type: db.mongoose.Schema.Types.ObjectId, ref: "Category" },
-      localization: { type: Array },
-      filters: { type: Array }
-    }, {
-      timestamps: { currentTime: () => Date.now() }
-    });
-    requireCommon_schema()(CategorySchema, db);
-    requireOwnership_schema()(CategorySchema, db);
-    requireMetadata_schema()(CategorySchema, db);
-    requireEngagement_schema()(CategorySchema, db);
-    CategorySchema.index({ parent: 1 });
-    CategorySchema.index({ name: 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()
-      }
-    });
-    applyOwnershipSchema(LeftoverSchema, db);
-    LeftoverSchema.index({ user: 1, type: 1, target: 1 });
-    const Leftover = db.mongoose.model("Leftover", LeftoverSchema);
-    return Leftover;
-  };
-  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 queryProcessorGlobals = requireQueryProcessor();
-  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 Read = async (req, res) => {
-      console.log(req.query);
-      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 };
-        }
-        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}";
-          }
-          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;
-          }
-        }
-        if (req.query.filters) {
-          let escapeRegex = function(string) {
-            return string.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
-          };
-          try {
-            const filters = JSON.parse(req.query.filters);
-            filters.forEach((filter) => {
-              const { parameter, values, caseSensitive = false } = filter;
-              const conditions = values.map((value) => {
-                if (caseSensitive) {
-                  return {
-                    "information": {
-                      $elemMatch: {
-                        "name": parameter,
-                        "value": value
-                      }
-                    }
-                  };
-                } else {
-                  return {
-                    "information": {
-                      $elemMatch: {
-                        "name": parameter,
-                        "value": { $regex: `^${escapeRegex(value)}$`, $options: "i" }
-                      }
-                    }
-                  };
-                }
-              });
-              if (conditions.length > 0) {
-                if (query.$or) {
-                  if (!query.$and) {
-                    query.$and = [];
-                  }
-                  query.$and.push({ $or: query.$or });
-                  query.$and.push({ $or: conditions });
-                  delete query.$or;
-                } else {
-                  query.$or = conditions;
-                }
-              }
-            });
-          } catch (error) {
-            console.error("Error parsing filters:", error);
-          }
-        }
-        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] }
-                      }
-                    }
-                  }
-                },
-                {
-                  "$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
-                                      }
-                                    }
-                                  }
-                                }
-                              },
-                              {
-                                $cond: {
-                                  if: { $eq: ["$$ingredientQuantity", 0] },
-                                  then: 1,
-                                  else: "$$ingredientQuantity"
-                                }
-                              }
-                            ]
-                          }
-                        }
-                      }
-                    }
-                  },
-                  else: []
-                }
-              }
-            }
-          },
-          // For owner
-          queryProcessorGlobals.getOwnerUserLookupStage(),
-          queryProcessorGlobals.getOwnerOrganizationLookupStage(),
-          queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
-          {
-            $set: {
-              available: {
-                $cond: {
-                  if: { $eq: ["$listing", "rent"] },
-                  then: "$quantity",
-                  else: {
-                    $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,
-            price_cost: req.body.price_cost,
-            unit: req.body.unit,
-            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 });
-      }
-    };
-    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 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(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",
-        views: { $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
-    };
-  };
-  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
-    );
-  };
-  return products_routes;
-}
-var categories_routes = { exports: {} };
-var categories_controller;
-var hasRequiredCategories_controller;
-function requireCategories_controller() {
-  if (hasRequiredCategories_controller) return categories_controller;
-  hasRequiredCategories_controller = 1;
-  const globalsQuery = requireQueryProcessor();
-  const Logger = requireGlobals_logger();
-  const Cache = requireGlobals_cache();
-  const controllerFactory = (db) => {
-    const Category = db.category;
-    const logger = new Logger(db);
-    const cache = new Cache();
-    return {
-      async read(req, res) {
-        try {
-          const {
-            parent,
-            url,
-            search,
-            sortParam,
-            sortOrder,
-            skip,
-            limit,
-            excludeChildren,
-            rootOnly,
-            type
-          } = req.verifiedQuery;
-          const cacheKey = JSON.stringify(req.verifiedQuery);
-          let cachedResult = await cache.get(cacheKey);
-          if (cachedResult) {
-            return res.status(200).json(cachedResult);
-          }
-          const matchStage = {
-            ...req.query.status && { status: req.query.status },
-            ...url && { url },
-            ...search && { name: { $regex: search, $options: "i" } },
-            ...parent ? { parent: new db.mongoose.Types.ObjectId(parent) } : {},
-            ...rootOnly === "true" && !search ? { parent: null } : {}
-          };
-          if (type === "platform") {
-            matchStage["owner.type"] = "platform";
-          } else if (type === "organization" && req.query.organizationId) {
-            matchStage["owner.type"] = "organization";
-            matchStage["owner.target"] = new db.mongoose.Types.ObjectId(req.query.organizationId);
-          }
-          if (search) {
-            excludeChildren = "true";
-          }
-          const pipeline = [
-            { $match: matchStage },
-            globalsQuery.getCreatorUserLookupStage(),
-            globalsQuery.getCreatorOrganizationLookupStage(),
-            // For owner
-            globalsQuery.getOwnerUserLookupStage(),
-            globalsQuery.getOwnerOrganizationLookupStage(),
-            globalsQuery.getAddFieldsCreatorOwnerStage(),
-            { $sort: { [sortParam]: sortOrder === "asc" ? 1 : -1 } },
-            { $skip: Number(skip) },
-            { $limit: Number(limit) },
-            globalsQuery.removeTempPropeties()
-          ];
-          if (excludeChildren !== "true") {
-            pipeline.push({
-              $graphLookup: {
-                from: "categories",
-                startWith: "$_id",
-                connectFromField: "_id",
-                connectToField: "parent",
-                as: "allDescendants",
-                maxDepth: 10
-              }
-            });
-          }
-          const results = await Category.aggregate(pipeline);
-          let response;
-          if (excludeChildren === "true") {
-            response = results;
-          } else {
-            const allCategories = [];
-            results.forEach((doc) => {
-              const category = { ...doc };
-              delete category.allDescendants;
-              allCategories.push(category);
-              if (doc.allDescendants && doc.allDescendants.length > 0) {
-                allCategories.push(...doc.allDescendants);
-              }
-            });
-            const uniqueCategories = Array.from(
-              new Map(allCategories.map((item) => [item._id.toString(), item])).values()
-            );
-            const tree = buildAdjacencyTree(uniqueCategories, sortParam, sortOrder);
-            if (rootOnly === "true") {
-              response = tree;
-            } else {
-              const requestedCategoryIds = results.map((r) => r._id.toString());
-              response = tree.filter(
-                (category) => requestedCategoryIds.includes(category._id.toString())
-              );
-            }
-          }
-          const tags = ["categories"];
-          if (type === "organization" && req.query.organizationId) {
-            tags.push(`organization_${req.query.organizationId}`);
-          }
-          for (const cat of response) {
-            if (cat._id) {
-              tags.push(`category_${cat._id}`);
-            }
-          }
-          await cache.setWithTags(cacheKey, response, tags);
-          res.status(200).json(response);
-        } catch (err) {
-          logger.error(`Error reading categories: ${err.message}`);
-          res.status(500).json({ message: err.message });
-        }
-      },
-      async create(req, res) {
-        try {
-          const categoryData = req.verifiedBody;
-          if (!categoryData.creator && req.userId) {
-            categoryData.creator = {
-              type: "user",
-              target: req.userId
-            };
-          }
-          if (!categoryData.owner) {
-            if (req.query.organizationId) {
-              categoryData.owner = {
-                type: "organization",
-                target: req.query.organizationId
-              };
-            } else {
-              categoryData.owner = {
-                type: "platform",
-                target: null
-              };
-            }
-          }
-          const highestOrder = await Category.findOne().sort("-order");
-          const order = highestOrder ? highestOrder.order + 1 : 1;
-          const category = new Category({
-            ...categoryData,
-            order
-          });
-          if (categoryData.parent) {
-            const parent = await Category.findByIdAndUpdate(
-              categoryData.parent,
-              { $push: { children: category._id } },
-              { new: true }
-            );
-            if (!parent) throw new Error("Parent category not found");
-            category.parent = parent._id;
-          }
-          if (categoryData.children && categoryData.children.length > 0) {
-            await Category.updateMany(
-              { _id: { $in: categoryData.children } },
-              { $set: { parent: category._id } }
-            );
-          }
-          await category.save();
-          await cache.delByTags(["categories"]);
-          if (category.owner.type === "organization") {
-            await cache.delByTag(`organization_${category.owner.target}`);
-          }
-          logger.info(`Category created: ${category._id}`);
-          res.status(201).json(category);
-        } catch (err) {
-          logger.error(`Error creating category: ${err.message}`);
-          res.status(err.message === "Parent category not found" ? 404 : 500).json({ message: err.message });
-        }
-      },
-      async update(req, res) {
-        try {
-          const category = req.verifiedBody;
-          const updatedCategory = await Category.findByIdAndUpdate(
-            category._id,
-            { $set: category },
-            { new: true }
-          ).lean();
-          if (!updatedCategory) {
-            return res.status(404).json({ message: "Category not found" });
-          }
-          await cache.delByTag(`category_${category._id}`);
-          await cache.delByTags(["categories"]);
-          if (updatedCategory.owner && updatedCategory.owner.type === "organization") {
-            await cache.delByTag(`organization_${updatedCategory.owner.target}`);
-          }
-          logger.info(`Category updated: ${category._id}`);
-          res.status(200).json(updatedCategory);
-        } catch (err) {
-          logger.error(`Category update error: ${err.message}`);
-          res.status(500).json({ message: "Failed to update category" });
-        }
-      },
-      async updateOrder(req, res) {
-        try {
-          const { categories } = req.verifiedBody;
-          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 categoryIds = categories.map((cat) => cat._id);
-          const organizationIds = /* @__PURE__ */ new Set();
-          const updatedCategories = await Category.find({ _id: { $in: categoryIds } }).lean();
-          updatedCategories.forEach((cat) => {
-            if (cat.owner && cat.owner.type === "organization") {
-              organizationIds.add(cat.owner.target.toString());
-            }
-          });
-          await cache.delByTags(["categories"]);
-          for (const catId of categoryIds) {
-            await cache.delByTag(`category_${catId}`);
-          }
-          for (const orgId of organizationIds) {
-            await cache.delByTag(`organization_${orgId}`);
-          }
-          let query = {};
-          if (req.query.type === "platform") {
-            query = { "owner.type": "platform" };
-          } else if (req.query.type === "organization" && req.query.organizationId) {
-            query = {
-              "owner.type": "organization",
-              "owner.target": new db.mongoose.Types.ObjectId(req.query.organizationId)
-            };
-          }
-          const result = await Category.find(query).sort({ order: "asc" }).lean();
-          logger.info(`Categories order updated: ${categoryIds.join(", ")}`);
-          res.status(200).json(result);
-        } catch (err) {
-          logger.error(`Category order update error: ${err.message}`);
-          res.status(500).json({ message: "Failed to update categories order" });
-        }
-      },
-      async delete(req, res) {
-        try {
-          const category = req.currentResource;
-          let ownerOrgId = null;
-          if (category.owner && category.owner.type === "organization") {
-            ownerOrgId = category.owner.target;
-          }
-          const result = await Category.aggregate([
-            { $match: { _id: category._id } },
-            {
-              $graphLookup: {
-                from: "categories",
-                startWith: "$_id",
-                connectFromField: "_id",
-                connectToField: "parent",
-                as: "descendants"
-              }
-            },
-            {
-              $project: { descendants: 1 }
-            }
-          ]);
-          const idsToDelete = [category._id, ...(result[0]?.descendants || []).map(({ _id }) => _id)];
-          const categoryIdsTags = idsToDelete.map((id) => `category_${id}`);
-          await Category.deleteMany({ _id: { $in: idsToDelete } });
-          await cache.delByTags(["categories"]);
-          await cache.delByTags(categoryIdsTags);
-          if (ownerOrgId) {
-            await cache.delByTag(`organization_${ownerOrgId}`);
-          }
-          logger.info(`Category and its subcategories deleted: ${category.url}`);
-          res.status(200).json({ message: "Category and its subcategories deleted successfully" });
-        } catch (err) {
-          logger.error(`Error deleting category: ${err.message}`);
-          res.status(500).json({ message: err.message || "Internal server error" });
-        }
-      }
-    };
-    function buildAdjacencyTree(categories, sortParam, sortOrder) {
-      const categoryMap = /* @__PURE__ */ new Map();
-      categories.forEach((category) => {
-        categoryMap.set(category._id.toString(), {
-          ...category,
-          children: []
-        });
-      });
-      const rootCategories = [];
-      categories.forEach((category) => {
-        const categoryWithChildren = categoryMap.get(category._id.toString());
-        if (category.parent && categoryMap.has(category.parent.toString())) {
-          const parentCategory = categoryMap.get(category.parent.toString());
-          parentCategory.children.push(categoryWithChildren);
-        } else if (!category.parent) {
-          rootCategories.push(categoryWithChildren);
-        }
-      });
-      function sortCategories(nodes) {
-        if (!nodes || nodes.length === 0) {
-          return nodes;
-        }
-        nodes.sort((a, b) => {
-          const valueA = a[sortParam] ?? (sortParam === "order" ? Number.MAX_SAFE_INTEGER : "");
-          const valueB = b[sortParam] ?? (sortParam === "order" ? Number.MAX_SAFE_INTEGER : "");
-          if (typeof valueA === "number" && typeof valueB === "number") {
-            return sortOrder === "asc" ? valueA - valueB : valueB - valueA;
-          } else {
-            const stringA = String(valueA);
-            const stringB = String(valueB);
-            return sortOrder === "asc" ? stringA.localeCompare(stringB) : stringB.localeCompare(stringA);
-          }
-        });
-        nodes.forEach((node) => {
-          if (node.children && node.children.length > 0) {
-            sortCategories(node.children);
-          }
-        });
-        return nodes;
-      }
-      return sortCategories(rootCategories);
-    }
-  };
-  categories_controller = controllerFactory;
-  return categories_controller;
-}
-var categories_verifier;
-var hasRequiredCategories_verifier;
-function requireCategories_verifier() {
-  if (hasRequiredCategories_verifier) return categories_verifier;
-  hasRequiredCategories_verifier = 1;
-  const Verifier = requireGlobals_verifier();
-  const Validator = requireGlobals_validator();
-  categories_verifier = function(db) {
-    const queryValidatorConfig = {
-      parent: { allowed: true, validator: Validator.schema().string() },
-      url: { allowed: true, validator: Validator.schema().string() },
-      search: { allowed: true, validator: Validator.schema().string() },
-      sortParam: { allowed: true, validator: Validator.schema().string().oneOf(["order", "name", "createdAt", "updatedAt"]), default: "order" },
-      sortOrder: { allowed: true, validator: Validator.schema().string().oneOf(["asc", "desc"]), default: "asc" },
-      skip: { allowed: true, validator: Validator.schema().number().integer().min(0), default: 0 },
-      limit: { allowed: true, validator: Validator.schema().number().integer().min(1).max(100), default: 10 },
-      excludeChildren: { allowed: true, validator: Validator.schema().string().oneOf(["true", "false"]), default: "true" },
-      rootOnly: { allowed: true, validator: Validator.schema().string().oneOf(["true", "false"]), default: "false" },
-      status: { allowed: true, validator: Validator.schema().string().oneOf(["draft", "internal", "published", "removed"]) },
-      type: { allowed: true, validator: Validator.schema().string().oneOf(["platform", "organization", "all"]), default: "all" },
-      organizationId: { allowed: true, validator: Validator.schema().string() }
-    };
-    const bodyValidatorConfig = {
-      _id: { allowed: true, validator: Validator.schema().string() },
-      name: { allowed: true, validator: Validator.schema().string().required() },
-      description: { allowed: true, validator: Validator.schema().string() },
-      photo: { allowed: true, validator: Validator.schema().string() },
-      status: { allowed: true, validator: Validator.schema().string().oneOf(["draft", "internal", "published", "removed"]), default: "draft" },
-      url: { allowed: true, validator: Validator.schema().string().required() },
-      parent: { allowed: true, validator: Validator.schema().oneOfTypes(["string", "null"]) },
-      localization: { allowed: true },
-      filters: { allowed: true },
-      owner: { allowed: true, validator: Validator.schema().object({
-        type: Validator.schema().string().oneOf(["platform", "organization"]).required(),
-        target: Validator.schema().string()
-      }) },
-      creator: { allowed: true, validator: Validator.schema().object({
-        type: Validator.schema().string().oneOf(["user", "organization"]).required(),
-        target: Validator.schema().string()
-      }) },
-      children: { allowed: true, validator: Validator.schema().array() },
-      order: { allowed: true, validator: Validator.schema().number() }
-    };
-    const orderBodyValidatorConfig = {
-      categories: {
-        allowed: true,
-        validator: Validator.schema().array().required(),
-        default: []
-      }
-    };
-    const deleteBodyValidatorConfig = {
-      url: {
-        allowed: true,
-        validator: Validator.schema().string().required()
-      }
-    };
-    const queryVerifier = new Verifier(queryValidatorConfig);
-    const bodyVerifier = new Verifier(bodyValidatorConfig);
-    const orderBodyVerifier = new Verifier(orderBodyValidatorConfig);
-    const deleteBodyVerifier = new Verifier(deleteBodyValidatorConfig);
-    return {
-      // Верификация параметров запроса
-      verifyQuery(req, res, next) {
-        const verification = queryVerifier.verify(req.query);
-        if (!verification.isValid) {
-          return res.status(400).json({
-            errors: verification.verificationErrors,
-            message: "Invalid query parameters"
-          });
-        }
-        req.verifiedQuery = verification.verifiedData;
-        next();
-      },
-      // Верификация тела запроса для создания/обновления категории
-      verifyBody(req, res, next) {
-        const verification = bodyVerifier.verify(req.body);
-        if (!verification.isValid) {
-          return res.status(400).json({
-            errors: verification.verificationErrors,
-            message: "Invalid request data"
-          });
-        }
-        req.verifiedBody = verification.verifiedData;
-        next();
-      },
-      // Верификация тела запроса для обновления порядка категорий
-      verifyOrderBody(req, res, next) {
-        const verification = orderBodyVerifier.verify(req.body);
-        if (!verification.isValid) {
-          return res.status(400).json({
-            errors: verification.verificationErrors,
-            message: "Invalid request data"
-          });
-        }
-        req.verifiedBody = verification.verifiedData;
-        next();
-      },
-      // Верификация тела запроса для удаления категории
-      verifyDeleteBody(req, res, next) {
-        const verification = deleteBodyVerifier.verify(req.body);
-        if (!verification.isValid) {
-          return res.status(400).json({
-            errors: verification.verificationErrors,
-            message: "Invalid request data"
-          });
-        }
-        req.verifiedBody = verification.verifiedData;
-        next();
-      },
-      // Проверка на существование категории с тем же URL (для создания)
-      async checkCategoryExistOrNot(req, res, next) {
-        try {
-          if (!req.verifiedBody.url) {
-            return res.status(400).json({ message: "URL is required" });
-          }
-          const existingCategory = await db.category.findOne({ url: req.verifiedBody.url });
-          if (existingCategory) {
-            return res.status(409).json({
-              message: "Category with this URL already exists",
-              category: existingCategory
-            });
-          }
-          next();
-        } catch (error) {
-          res.status(500).json({ message: error.message });
-        }
-      },
-      // Загрузка категории для проверки ABAC (для обновления и удаления)
-      async loadCategoryForUpdate(req, res, next) {
-        try {
-          const categoryId = req.verifiedBody._id;
-          if (!categoryId) {
-            return res.status(400).json({ message: "Category ID is required" });
-          }
-          const category = await db.category.findById(categoryId).lean();
-          if (!category) {
-            return res.status(404).json({ message: "Category not found" });
-          }
-          req.currentResource = category;
-          next();
-        } catch (error) {
-          res.status(500).json({ message: error.message });
-        }
-      },
-      // Загрузка категории по URL для удаления
-      async loadCategoryForDelete(req, res, next) {
-        try {
-          const url = req.verifiedBody.url;
-          if (!url) {
-            return res.status(400).json({ message: "Category URL is required" });
-          }
-          const category = await db.category.findOne({ url }).lean();
-          if (!category) {
-            return res.status(404).json({ message: "Category not found" });
-          }
-          req.currentResource = category;
-          next();
-        } catch (error) {
-          res.status(500).json({ message: error.message });
-        }
-      }
-    };
-  };
-  return categories_verifier;
-}
-var hasRequiredCategories_routes;
-function requireCategories_routes() {
-  if (hasRequiredCategories_routes) return categories_routes.exports;
-  hasRequiredCategories_routes = 1;
-  const controllerFactory = requireCategories_controller();
-  const verifierFactory = requireCategories_verifier();
-  const jwtFactory = requireAuthJwt();
-  const { getInstance } = requireGlobals_abac();
-  categories_routes.exports = function(app, db) {
-    const jwt = jwtFactory(db);
-    const verifier = verifierFactory(db);
-    const abac = getInstance(db);
-    const controller = controllerFactory(db);
-    app.get(
-      "/api/categories",
-      jwt.verifyToken(true),
-      verifier.verifyQuery,
-      controller.read
-    );
-    app.post(
-      "/api/categories/create",
-      jwt.verifyToken(),
-      verifier.verifyBody,
-      verifier.checkCategoryExistOrNot,
-      abac.middleware("category", "create"),
-      controller.create
-    );
-    app.post(
-      "/api/categories/update",
-      jwt.verifyToken(),
-      verifier.verifyBody,
-      verifier.loadCategoryForUpdate,
-      abac.middleware("category", "edit"),
-      controller.update
-    );
-    app.post(
-      "/api/categories/updateOrder",
-      jwt.verifyToken(),
-      verifier.verifyOrderBody,
-      abac.middleware("category", "edit"),
-      controller.updateOrder
-    );
-    app.post(
-      "/api/categories/delete",
-      jwt.verifyToken(),
-      verifier.verifyDeleteBody,
-      verifier.loadCategoryForDelete,
-      abac.middleware("category", "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" } }
-            ]
-          });
-        }
-        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 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" });
-      }
-    };
-    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" });
-      }
-    };
-    return {
-      read,
-      create,
-      get,
-      update,
-      delete: deleteLeftover
-    };
-  };
-  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
-    );
-  };
-  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);
-    }
-  }
-  products_server$1 = {
-    initialize: initializeProduct,
-    models: {
-      ProductModel,
-      CategoryModel,
-      LeftoverModel
-    },
-    routes: {
-      productsRoutes,
-      categoriesRoutes,
-      leftoversRoutes
-    },
-    controllers: {
-      ProductController,
-      CategoryController,
-      LeftoverController
-    }
-  };
-  return products_server$1;
-}
-var products_serverExports = requireProducts_server();
-const products_server = /* @__PURE__ */ getDefaultExportFromCjs(products_serverExports);
-export {
-  products_server as default
-};