@ozdao/martyrs 0.2.488 → 0.2.491

package/dist/products.server.js

@@ -0,0 +1,1402 @@
+import { L as Logger, C as Cache } from "./globals.logger-Bf6rRU7j.js";
+import { q as queryProcessorGlobals } from "./queryProcessor-CVcLPEnv.js";
+import OpenAI from "openai";
+import { Types } from "mongoose";
+import { a as applyCommonSchema } from "./common.schema-Bw1O5_2Q.js";
+import { a as applyEngagementSchema } from "./engagement.schema-Dh1adRsn.js";
+import { a as applyMetadataSchema } from "./metadata.schema-CWmcDJN7.js";
+import { a as applyOwnershipSchema } from "./ownership.schema-BqH4v5vH.js";
+import { m as middlewareFactory } from "./authJwt-J1csaMWA.js";
+import { g as globalsabac } from "./globals.abac-DNdtSYop.js";
+import { a as Validator, V as Verifier } from "./globals.verifier-CWFz5Gh2.js";
+import { C as CRUD } from "./crud-Cwx5VlSm.js";
+import { A as ABAC } from "./abac-Cf_9lCSh.js";
+const controllerFactory$1 = (db) => {
+  const Category = db.category;
+  const logger = new Logger(db);
+  const cache = new Cache();
+  return {
+    async read(req, res) {
+      try {
+        let { 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";
+        }
+        let pipeline = [
+          { $match: matchStage },
+          queryProcessorGlobals.getCreatorUserLookupStage(),
+          queryProcessorGlobals.getCreatorOrganizationLookupStage(),
+          // For owner
+          queryProcessorGlobals.getOwnerUserLookupStage(),
+          queryProcessorGlobals.getOwnerOrganizationLookupStage(),
+          queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
+          { $sort: { [sortParam]: sortOrder === "asc" ? 1 : -1 } },
+          { $skip: Number(skip) },
+          { $limit: Number(limit) },
+          queryProcessorGlobals.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 {
+          let allCategories = [];
+          results.forEach((doc) => {
+            let category = { ...doc };
+            delete category.allDescendants;
+            allCategories.push(category);
+            if (doc.allDescendants && doc.allDescendants.length > 0) {
+              allCategories.push(...doc.allDescendants);
+            }
+          });
+          let uniqueCategories = Array.from(new Map(allCategories.map((item) => [item._id.toString(), item])).values());
+          let 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()));
+          }
+        }
+        let 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) {
+        console.log(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);
+  }
+};
+class OpenAIGlobal {
+  constructor() {
+    if (OpenAIGlobal.instance) {
+      return OpenAIGlobal.instance;
+    }
+    this.client = new OpenAI({
+      organization: process.env.OPENAI_ORG_KEY,
+      apiKey: process.env.OPENAI_API_KEY
+    });
+    this.models = {
+      chat: "gpt-3.5-turbo",
+      vision: "gpt-4-vision-preview",
+      embedding: "text-embedding-ada-002"
+    };
+    OpenAIGlobal.instance = this;
+  }
+  /**
+   * Generate completions with retry logic for handling JSON parsing errors
+   * @param {string} prompt - The prompt text
+   * @param {Object} options - Additional options
+   * @returns {Promise<Object|string>} - Parsed JSON response or raw content
+   */
+  async createChatCompletion(prompt, options = {}) {
+    const {
+      model = this.models.chat,
+      maxRetries = 3,
+      temperature = 0.7,
+      parseJSON = true,
+      systemPrompt = ""
+    } = options;
+    let attempt = 0;
+    while (attempt < maxRetries) {
+      try {
+        const messages = [];
+        if (systemPrompt) {
+          messages.push({ role: "system", content: systemPrompt });
+        }
+        messages.push({ role: "user", content: prompt });
+        const response = await this.client.chat.completions.create({
+          model,
+          messages,
+          temperature,
+          response_format: parseJSON ? { type: "json_object" } : void 0
+        });
+        const content = response.choices[0].message.content;
+        if (parseJSON) {
+          return JSON.parse(content);
+        }
+        return content;
+      } catch (err) {
+        attempt++;
+        if (err instanceof SyntaxError && attempt < maxRetries) {
+          console.error(`Invalid JSON in OpenAI response (attempt ${attempt}/${maxRetries}): ${err.message}`);
+        } else if (attempt >= maxRetries) {
+          console.error(`Max retries (${maxRetries}) reached for OpenAI completion: ${err.message}`);
+          throw err;
+        } else {
+          console.error(`OpenAI API error (attempt ${attempt}/${maxRetries}): ${err.message}`);
+          if (err.status === 429) {
+            const waitTime = Math.pow(2, attempt) * 1e3;
+            await new Promise((resolve) => setTimeout(resolve, waitTime));
+          }
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1e3 * attempt));
+      }
+    }
+  }
+  /**
+   * Get direct access to OpenAI client instance
+   * @returns {OpenAI} - OpenAI client instance
+   */
+  getClient() {
+    return this.client;
+  }
+  /**
+   * Set default model for specific API
+   * @param {string} type - API type ('chat', 'vision', 'embedding')
+   * @param {string} modelId - Model identifier
+   */
+  setDefaultModel(type, modelId) {
+    if (this.models[type]) {
+      this.models[type] = modelId;
+    }
+  }
+}
+const openaiGlobal = new OpenAIGlobal();
+const ObjectId = Types.ObjectId;
+function getCategoriesFilterStage(categories) {
+  if (!categories) return [];
+  const categoryIds = categories.split(",").filter(Boolean);
+  if (categoryIds.length === 0) return [];
+  return [{
+    $match: {
+      category: {
+        $in: categoryIds.map((id) => new ObjectId(id))
+      }
+    }
+  }];
+}
+function getDeliveryFilterStage(delivery) {
+  if (!delivery) return [];
+  const deliveryOptions = delivery.split(",").filter(Boolean);
+  if (deliveryOptions.length === 0) return [];
+  return [{
+    $match: {
+      delivery: { $in: deliveryOptions }
+    }
+  }];
+}
+function getAttributeFiltersStage(filtersString) {
+  if (!filtersString) return [];
+  try {
+    const filters = JSON.parse(filtersString);
+    if (!Array.isArray(filters) || filters.length === 0) return [];
+    const filterConditions = [];
+    filters.forEach((filter) => {
+      const { parameter, values, caseSensitive = false } = filter;
+      if (!values || values.length === 0) return;
+      const conditions = values.map((value) => {
+        const valueCondition = caseSensitive ? value : { $regex: `^${escapeRegex(value)}$`, $options: "i" };
+        return {
+          attributes: {
+            $elemMatch: {
+              name: parameter,
+              value: valueCondition
+            }
+          }
+        };
+      });
+      if (conditions.length > 0) {
+        filterConditions.push({ $or: conditions });
+      }
+    });
+    return filterConditions.length > 0 ? [{ $match: { $and: filterConditions } }] : [];
+  } catch (error) {
+    console.error("Error parsing attribute filters:", error);
+    return [];
+  }
+}
+function escapeRegex(string) {
+  return string.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+}
+const queryProcessorProducts = {
+  getAttributeFiltersStage,
+  getCategoriesFilterStage,
+  getDeliveryFilterStage
+};
+const productLookupConfigs = {
+  // NEW: Лукап для availability продуктов из inventory модуля
+  inventory: {
+    lookup: {
+      from: "stockavailabilities",
+      let: { productId: "$_id" },
+      pipeline: [
+        {
+          $match: {
+            $expr: { $eq: ["$product", "$$productId"] }
+          }
+        },
+        {
+          $lookup: {
+            from: "spots",
+            localField: "storage",
+            foreignField: "_id",
+            as: "storageInfo"
+          }
+        },
+        {
+          $unwind: { path: "$storageInfo", preserveNullAndEmptyArrays: true }
+        },
+        {
+          $project: {
+            _id: 1,
+            storage: 1,
+            storageName: "$storageInfo.profile.name",
+            available: 1
+          }
+        }
+      ],
+      as: "availability"
+    },
+    additionalStages: [
+      // Этап для расчета общего доступного количества
+      {
+        $addFields: {
+          availabilityDetails: "$availability",
+          available: {
+            $sum: "$availability.available"
+          },
+          totalStock: {
+            $sum: "$availability.quantity"
+          },
+          storageCount: {
+            $size: { $ifNull: ["$availability", []] }
+          }
+        }
+      }
+    ]
+  },
+  variants: {
+    lookup: {
+      from: "variants",
+      localField: "_id",
+      foreignField: "product",
+      as: "variants",
+      pipeline: [
+        {
+          $lookup: {
+            from: "stockavailabilities",
+            localField: "_id",
+            foreignField: "variant",
+            as: "availability"
+          }
+        },
+        {
+          $addFields: {
+            available: {
+              $sum: "$availability.available"
+            }
+          }
+        }
+      ]
+    }
+  },
+  recommended: {
+    lookup: {
+      from: "products",
+      localField: "recommended",
+      foreignField: "_id",
+      as: "recommended"
+    }
+  },
+  // Лукап для категорий продукта
+  categories: {
+    lookup: {
+      from: "categories",
+      localField: "category",
+      foreignField: "_id",
+      as: "category"
+    },
+    additionalStages: [{
+      $addFields: {
+        category: {
+          $map: {
+            input: "$category",
+            as: "cat",
+            in: {
+              _id: "$$cat._id",
+              name: "$$cat.name",
+              description: "$$cat.description",
+              url: "$$cat.url"
+            }
+          }
+        }
+      }
+    }]
+  }
+};
+const controllerFactory = (db) => {
+  const Product = db.product;
+  const Create = async (req, res) => {
+    try {
+      const productData = {
+        ...req.body,
+        category: req.body.category?.map((cat) => cat._id) || []
+      };
+      const product = await new Product(productData).save();
+      return res.status(201).json(product);
+    } catch (err) {
+      console.log(err);
+      return res.status(500).json({ message: err.message });
+    }
+  };
+  const Read = async (req, res) => {
+    try {
+      const requestedLookups = queryProcessorGlobals.getRequestedLookups(req.query);
+      const stages = [
+        ...queryProcessorGlobals.getBasicOptions(req.query),
+        ...queryProcessorGlobals.getSearchOptions(req.query.search, {
+          fields: ["name", "description"]
+        }),
+        ...queryProcessorGlobals.getFilterDate(req.query.dateStart, req.query.dateEnd, {
+          start: "startDate",
+          end: "endDate"
+        }),
+        ...queryProcessorGlobals.getPriceConditions(req.query.prices),
+        ...queryProcessorProducts.getCategoriesFilterStage(req.query.categories),
+        ...queryProcessorProducts.getDeliveryFilterStage(req.query.delivery),
+        ...queryProcessorProducts.getAttributeFiltersStage(req.query.filters),
+        ...queryProcessorGlobals.getLookupStages(requestedLookups, productLookupConfigs),
+        queryProcessorGlobals.getCreatorUserLookupStage(),
+        queryProcessorGlobals.getCreatorOrganizationLookupStage(),
+        queryProcessorGlobals.getOwnerUserLookupStage(),
+        queryProcessorGlobals.getOwnerOrganizationLookupStage(),
+        queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
+        ...queryProcessorGlobals.getSortingOptions(req.query.sortParam, req.query.sortOrder),
+        ...queryProcessorGlobals.getPaginationOptions(req.query.skip, req.query.limit),
+        // Удаление временных полей
+        queryProcessorGlobals.removeTempPropeties(),
+        // Дополнительные очистки для lookup-ов
+        ...requestedLookups.includes("inventory") ? [{ $project: { availability: 0 } }] : []
+      ].filter(Boolean);
+      const products = await Product.aggregate(stages);
+      if (req.query.count) {
+        return res.status(200).json({ count: products.length });
+      }
+      res.status(200).json(products);
+    } catch (err) {
+      console.error("Error in products Read controller:", err);
+      return res.status(500).json({ message: err.message });
+    }
+  };
+  const Update = async (req, res) => {
+    try {
+      const { _id } = req.params;
+      const updateData = {
+        name: req.body.name,
+        status: req.body.status,
+        listing: req.body.listing,
+        description: req.body.description,
+        category: req.body.category?.map((cat) => cat._id) || [],
+        images: req.body.images,
+        attributes: req.body.attributes,
+        recommended: req.body.recommended,
+        localization: req.body.translations,
+        discounts: req.body.discounts,
+        included: req.body.included
+      };
+      const updatedProduct = await Product.findOneAndUpdate({ _id }, updateData, { 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.attributes || [];
+        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 attributes 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.
+      `;
+      const result = await openaiGlobal.createChatCompletion(prompt, {
+        model: "gpt-4",
+        temperature: 0.8,
+        systemPrompt: "You are a product recommendation specialist with expertise in matching customer needs to product attributes."
+      });
+      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 });
+    }
+  };
+  return {
+    Create,
+    Read,
+    Update,
+    Delete,
+    getProductRecommendation
+  };
+};
+const CategoryModel = (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() }
+    }
+  );
+  applyCommonSchema(CategorySchema);
+  applyOwnershipSchema(CategorySchema, db);
+  applyMetadataSchema(CategorySchema);
+  applyEngagementSchema(CategorySchema);
+  CategorySchema.index({ name: 1 });
+  CategorySchema.index({ name: "text", description: "text" });
+  CategorySchema.index({ "owner.type": 1, "owner.target": 1, status: 1, parent: 1 });
+  CategorySchema.index({ "owner.type": 1, "owner.target": 1, order: 1 });
+  CategorySchema.index({ parent: 1, status: 1, order: 1 });
+  CategorySchema.index({ parent: 1, status: 1, "owner.type": 1 });
+  CategorySchema.index({ parent: 1, name: 1 });
+  CategorySchema.index({ parent: 1, createdAt: -1 });
+  CategorySchema.index({ parent: 1, updatedAt: -1 });
+  CategorySchema.index({ status: 1, order: 1 });
+  CategorySchema.index({ status: 1, name: 1 });
+  CategorySchema.index({ status: 1, createdAt: -1 });
+  CategorySchema.index({ status: 1, updatedAt: -1 });
+  CategorySchema.index({ _id: 1, parent: 1 });
+  CategorySchema.index({ order: 1 });
+  CategorySchema.index({ createdAt: -1 });
+  CategorySchema.index({ updatedAt: -1 });
+  const Category = db.mongoose.model("Category", CategorySchema, "categories");
+  return Category;
+};
+const discountschema = (db) => {
+  const DiscountSchema = new db.mongoose.Schema(
+    {
+      type: {
+        type: String,
+        enum: ["discount", "special_price"],
+        default: "discount",
+        required: true
+      },
+      value: {
+        type: Number,
+        required: true,
+        min: 0
+      },
+      quantity: {
+        type: Number,
+        min: 1
+      },
+      date: {
+        start: Date,
+        end: Date
+      },
+      time: {
+        start: String,
+        // 'HH:mm' формат
+        end: String
+      },
+      name: String,
+      description: String
+    },
+    { _id: false }
+  );
+  return DiscountSchema;
+};
+const ProductModel = (db) => {
+  const DiscountSchema = discountschema(db);
+  const ProductSchema = new db.mongoose.Schema({
+    listing: {
+      type: String,
+      enum: ["sale", "rent"]
+    },
+    sku: {
+      type: String,
+      trim: true
+    },
+    category: [{
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Category"
+    }],
+    images: {
+      type: Array
+    },
+    name: {
+      type: String
+    },
+    description: {
+      type: String
+    },
+    included: {
+      type: String
+    },
+    attributes: [{
+      name: { type: String },
+      value: { type: String }
+    }],
+    recommended: [{
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Product"
+    }],
+    translations: {
+      type: Array
+    },
+    discounts: [DiscountSchema]
+  }, {
+    timestamps: {
+      currentTime: () => Date.now()
+    }
+  });
+  applyCommonSchema(ProductSchema);
+  applyOwnershipSchema(ProductSchema, db);
+  ProductSchema.index({ name: "text", description: "text" });
+  ProductSchema.index({ "owner.type": 1, "owner.target": 1, status: 1, category: 1 });
+  ProductSchema.index({ category: 1, status: 1, delivery: 1, price: 1 });
+  ProductSchema.index({ category: 1, status: 1, price: -1 });
+  ProductSchema.index({ category: 1, status: 1, views: -1 });
+  ProductSchema.index({ category: 1, status: 1, createdAt: -1 });
+  ProductSchema.index({ category: 1, status: 1, updatedAt: -1 });
+  ProductSchema.index({ category: 1, delivery: 1, price: 1 });
+  ProductSchema.index({ "attributes.name": 1, "attributes.value": 1 });
+  ProductSchema.index({ status: 1, delivery: 1, price: 1 });
+  ProductSchema.index({ status: 1, price: -1 });
+  ProductSchema.index({ status: 1, views: -1 });
+  ProductSchema.index({ status: 1, createdAt: -1 });
+  ProductSchema.index({ status: 1, updatedAt: -1 });
+  ProductSchema.index({ status: 1, name: 1 });
+  ProductSchema.index({ status: 1, "attributes.name": 1, "attributes.value": 1 });
+  ProductSchema.index({ listing: 1 });
+  ProductSchema.index({ recommended: 1 });
+  ProductSchema.index({ price: 1 });
+  ProductSchema.index({ views: -1 });
+  ProductSchema.index({ createdAt: -1 });
+  ProductSchema.index({ updatedAt: -1 });
+  const Product = db.mongoose.model("Product", ProductSchema);
+  return Product;
+};
+const ingredientSchema = (db) => {
+  const IngredientSchema = new db.mongoose.Schema({
+    _id: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Product"
+    },
+    price: {
+      type: Number,
+      required: true,
+      default: 0,
+      min: [0, "Price cannot be less than 0"]
+    },
+    cost: {
+      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"]
+    },
+    unit: {
+      type: String,
+      required: true,
+      default: "g"
+    },
+    optional: {
+      type: Boolean,
+      default: false,
+      description: "Является ли ингредиент опциональным"
+    },
+    replaceable: {
+      type: Boolean,
+      default: false,
+      description: "Можно ли заменить ингредиент"
+    },
+    alternatives: [{
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Product",
+      description: "Альтернативные продукты для замены"
+    }]
+  });
+  return IngredientSchema;
+};
+const VariantModel = (db) => {
+  const IngredientSchema = ingredientSchema(db);
+  const VariantSchema = new db.mongoose.Schema({
+    _id: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      auto: true
+    },
+    product: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Product",
+      required: true
+    },
+    sku: {
+      type: String,
+      trim: true
+    },
+    images: {
+      type: Array
+    },
+    name: {
+      type: String
+    },
+    price: {
+      type: Number
+    },
+    cost: {
+      type: Number,
+      default: 0
+    },
+    quantity: {
+      type: Number,
+      default: 1
+    },
+    unit: {
+      type: String,
+      default: "pcs",
+      enum: ["pcs", "g", "kg", "ml", "l", "oz"]
+    },
+    ingredients: [
+      IngredientSchema
+    ],
+    attributes: [{
+      name: { type: String },
+      value: { type: String }
+    }]
+  }, {
+    timestamps: {
+      currentTime: () => Date.now()
+    }
+  });
+  applyCommonSchema(VariantSchema);
+  applyOwnershipSchema(VariantSchema, db);
+  VariantSchema.index({ Variant: 1, name: 1 });
+  VariantSchema.index({ name: "text", sku: "text" });
+  VariantSchema.index({ "owner.type": 1, "owner.target": 1, product: 1, status: 1 });
+  VariantSchema.index({ product: 1, status: 1, price: 1 });
+  VariantSchema.index({ product: 1, status: 1, quantity: 1 });
+  VariantSchema.index({ product: 1, sku: 1 });
+  VariantSchema.index({ product: 1, "ingredients._id": 1 });
+  VariantSchema.index({ "attributes.name": 1, "attributes.value": 1 });
+  VariantSchema.index({ status: 1, price: 1 });
+  VariantSchema.index({ status: 1, price: -1 });
+  VariantSchema.index({ status: 1, quantity: 1 });
+  VariantSchema.index({ status: 1, quantity: -1 });
+  VariantSchema.index({ status: 1, createdAt: -1 });
+  VariantSchema.index({ status: 1, updatedAt: -1 });
+  VariantSchema.index({ status: 1, quantity: 1, product: 1 });
+  VariantSchema.index({ "ingredients._id": 1 });
+  VariantSchema.index({ "ingredients.quantity": 1 });
+  VariantSchema.index({ sku: 1 });
+  VariantSchema.index({ name: 1 });
+  VariantSchema.index({ price: 1 });
+  VariantSchema.index({ quantity: 1 });
+  VariantSchema.index({ createdAt: -1 });
+  VariantSchema.index({ updatedAt: -1 });
+  const Variant = db.mongoose.model("Variant", VariantSchema);
+  return Variant;
+};
+const verifierFactory$1 = function(db) {
+  const queryValidatorConfig = {
+    parent: { rule: "optional", validator: Validator.schema().string() },
+    url: { rule: "optional", validator: Validator.schema().string() },
+    search: { rule: "optional", validator: Validator.schema().string() },
+    sortParam: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["order", "name", "createdAt", "updatedAt"]),
+      default: "order"
+    },
+    sortOrder: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["asc", "desc"]),
+      default: "asc"
+    },
+    skip: { rule: "optional", validator: Validator.schema().number().integer().min(0), default: 0 },
+    limit: {
+      rule: "optional",
+      validator: Validator.schema().number().integer().min(1).max(100),
+      default: 10
+    },
+    excludeChildren: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["true", "false"]),
+      default: "true"
+    },
+    rootOnly: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["true", "false"]),
+      default: "false"
+    },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["draft", "internal", "published", "removed"])
+    },
+    type: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["platform", "organization", "all"]),
+      default: "all"
+    },
+    organizationId: { rule: "optional", validator: Validator.schema().string() }
+  };
+  const bodyValidatorConfig = {
+    _id: { rule: "optional", validator: Validator.schema().string() },
+    name: { rule: "optional", validator: Validator.schema().string().required() },
+    description: { rule: "optional", validator: Validator.schema().string() },
+    photo: { rule: "optional", validator: Validator.schema().string() },
+    status: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["draft", "internal", "published", "removed"]),
+      default: "draft"
+    },
+    url: { rule: "optional", validator: Validator.schema().string().required() },
+    parent: { rule: "optional", validator: Validator.schema().oneOfTypes(["string", "null"]) },
+    localization: { rule: "optional" },
+    filters: { rule: "optional" },
+    owner: {
+      rule: "optional",
+      validator: Validator.schema().object({
+        type: Validator.schema().string().oneOf(["platform", "organization"]).required(),
+        target: Validator.schema().string()
+      })
+    },
+    creator: {
+      rule: "optional",
+      validator: Validator.schema().object({
+        type: Validator.schema().string().oneOf(["user", "organization"]).required(),
+        target: Validator.schema().string()
+      })
+    },
+    children: { rule: "optional", validator: Validator.schema().array() },
+    order: { rule: "optional", validator: Validator.schema().number() }
+  };
+  const orderBodyValidatorConfig = {
+    categories: {
+      rule: "optional",
+      validator: Validator.schema().array().required(),
+      default: []
+    }
+  };
+  const deleteBodyValidatorConfig = {
+    url: {
+      rule: "optional",
+      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);
+      console.log("verification is", verification);
+      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 });
+      }
+    }
+  };
+};
+const { getInstance: getInstance$1 } = globalsabac;
+const categoriesRoutes = function(app, db) {
+  const jwt = middlewareFactory(db);
+  const verifier = verifierFactory$1(db);
+  const abac = getInstance$1(db);
+  const controller = controllerFactory$1(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);
+};
+const productsRoutes = 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);
+};
+const verifierFactory = function(db) {
+  const createVerifier = new Verifier({
+    name: {
+      rule: "required",
+      validator: Validator.schema().string().required("Variant name is required").min(2, "Name must be at least 2 characters").max(100, "Name must not exceed 100 characters")
+    },
+    sku: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[A-Za-z0-9-_]+$/, "SKU can only contain letters, numbers, hyphens and underscores").max(50)
+    },
+    price: {
+      rule: "required",
+      validator: Validator.schema().number().required("Price is required").min(0, "Price cannot be negative")
+    },
+    cost: {
+      rule: "optional",
+      default: 0,
+      validator: Validator.schema().number().min(0, "Cost cannot be negative")
+    },
+    quantity: {
+      rule: "optional",
+      default: 1,
+      validator: Validator.schema().number().min(0, "Quantity cannot be negative")
+    },
+    unit: {
+      rule: "optional",
+      default: "pcs",
+      validator: Validator.schema().string().oneOf(["pcs", "g", "kg", "ml", "l", "oz"], "Invalid unit")
+    },
+    images: {
+      rule: "optional",
+      validator: Validator.schema().array().items(Validator.schema().string())
+    },
+    ingredients: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().object({
+          name: Validator.schema().string().required(),
+          quantity: Validator.schema().number().min(0),
+          unit: Validator.schema().string()
+        })
+      )
+    },
+    attributes: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().object({
+          name: Validator.schema().string().required(),
+          value: Validator.schema().string().required()
+        })
+      )
+    },
+    owner: {
+      rule: "required",
+      validator: Validator.schema().object({
+        type: Validator.schema().string().oneOf(["user", "organization"]),
+        target: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
+      })
+    }
+  });
+  const updateVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Variant ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid ID format")
+    },
+    name: {
+      rule: "optional",
+      validator: Validator.schema().string().min(2, "Name must be at least 2 characters").max(100, "Name must not exceed 100 characters")
+    },
+    sku: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[A-Za-z0-9-_]+$/, "SKU can only contain letters, numbers, hyphens and underscores").max(50)
+    },
+    price: {
+      rule: "optional",
+      validator: Validator.schema().number().min(0, "Price cannot be negative")
+    },
+    cost: {
+      rule: "optional",
+      validator: Validator.schema().number().min(0, "Cost cannot be negative")
+    },
+    quantity: {
+      rule: "optional",
+      validator: Validator.schema().integer().min(0, "Quantity cannot be negative")
+    },
+    unit: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["pcs", "g", "kg", "ml", "l", "oz"], "Invalid unit")
+    },
+    images: {
+      rule: "optional",
+      validator: Validator.schema().array().items(Validator.schema().string())
+    },
+    ingredients: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().object({
+          name: Validator.schema().string().required(),
+          quantity: Validator.schema().number().min(0),
+          unit: Validator.schema().string()
+        })
+      )
+    },
+    attributes: {
+      rule: "optional",
+      validator: Validator.schema().array().items(
+        Validator.schema().object({
+          name: Validator.schema().string().required(),
+          value: Validator.schema().string().required()
+        })
+      )
+    }
+  });
+  const readVerifier = new Verifier({
+    _id: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
+    },
+    owner: {
+      rule: "optional",
+      validator: Validator.schema().string()
+    },
+    skip: {
+      rule: "optional",
+      default: 0,
+      validator: Validator.schema().integer().min(0)
+    },
+    limit: {
+      rule: "optional",
+      default: 20,
+      validator: Validator.schema().integer().min(1).max(100)
+    },
+    sortParam: {
+      rule: "optional",
+      validator: Validator.schema().string().oneOf(["name", "price", "quantity", "createdAt", "updatedAt"])
+    },
+    sortOrder: {
+      rule: "optional",
+      default: "desc",
+      validator: Validator.schema().string().oneOf(["asc", "desc"])
+    }
+  });
+  const deleteVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Variant ID is required").pattern(/^[0-9a-fA-F]{24}$/)
+    }
+  });
+  return {
+    createVerifier,
+    readVerifier,
+    updateVerifier,
+    deleteVerifier
+  };
+};
+const { getInstance } = ABAC;
+function setupVariantsRoutes(app, db) {
+  const abac = getInstance(db);
+  const verifier = verifierFactory();
+  const variantsCRUD = new CRUD({
+    app,
+    db,
+    model: db.variant,
+    modelName: "variant",
+    basePath: "/api/variants",
+    auth: true,
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+    abac,
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ["variant", "inventory"]
+    },
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+  return variantsCRUD;
+}
+function initializeProduct(app, db, origins, publicPath) {
+  db.product = ProductModel(db);
+  db.variant = VariantModel(db);
+  db.category = CategoryModel(db);
+  if (app) {
+    productsRoutes(app, db);
+    categoriesRoutes(app, db);
+    setupVariantsRoutes(app, db);
+  }
+}
+const models = {
+  ProductModel,
+  CategoryModel
+};
+const routes = {
+  productsRoutes,
+  categoriesRoutes
+};
+const controllers = {
+  ProductController: controllerFactory,
+  CategoryController: controllerFactory$1
+};
+const products_server = {
+  initialize: initializeProduct,
+  models,
+  routes,
+  controllers
+};
+export {
+  controllers,
+  products_server as default,
+  initializeProduct as initialize,
+  models,
+  routes
+};