@ozdao/martyrs 0.2.551 → 0.2.553

package/dist/products.server.cjs

@@ -1,1677 +0,0 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const core_logger = require("./core.logger-BuW7JHMY.cjs");
-const queryProcessor = require("./queryProcessor-DJUTwCLN.cjs");
-const OpenAI = require("openai");
-const mongoose = require("mongoose");
-const common_schema = require("./common.schema-BtXLULba.cjs");
-const engagement_schema = require("./engagement.schema-DHw4iY_W.cjs");
-const metadata_schema = require("./metadata.schema-BGykn-_r.cjs");
-const ownership_schema = require("./ownership.schema-CRYdbemm.cjs");
-const authJwt = require("./authJwt-BIZ2GIfT.cjs");
-const core_abac = require("./core.abac-DqDvtkHR.cjs");
-const core_verifier = require("./core.verifier-Bi-XLEi9.cjs");
-const crud = require("./crud-CQ3ICbm7.cjs");
-const abac = require("./abac-gNSxNkX1.cjs");
-const controllerFactory$1 = (db) => {
-  const Category = db.category;
-  const logger = new core_logger.LoggerNamespaced(db);
-  const cache = new core_logger.CacheNamespaced();
-  const generateSlug = async (name, parentId = null) => {
-    const baseSlug = name.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").trim("-");
-    let slug = baseSlug;
-    let counter = 1;
-    while (await Category.exists({ slug, parent: parentId })) {
-      slug = `${baseSlug}-${counter++}`;
-    }
-    return slug;
-  };
-  const buildTreeFromUrl = (categories, sortParam = "order", sortOrder = "asc") => {
-    categories.sort((a, b) => a.url.localeCompare(b.url));
-    const tree = [];
-    const nodeMap = /* @__PURE__ */ new Map();
-    categories.forEach((cat) => {
-      const node = { ...cat, children: [] };
-      nodeMap.set(cat.url, node);
-      const parentUrl = cat.url.substring(0, cat.url.lastIndexOf("/"));
-      if (parentUrl && nodeMap.has(parentUrl)) {
-        nodeMap.get(parentUrl).children.push(node);
-      } else if (cat.level === 0) {
-        tree.push(node);
-      }
-    });
-    const sortNodes = (nodes) => {
-      nodes.sort((a, b) => {
-        const va = a[sortParam] ?? Number.MAX_SAFE_INTEGER;
-        const vb = b[sortParam] ?? Number.MAX_SAFE_INTEGER;
-        const diff = typeof va === "number" ? va - vb : String(va).localeCompare(String(vb));
-        return sortOrder === "asc" ? diff : -diff;
-      });
-      nodes.forEach((n) => n.children?.length && sortNodes(n.children));
-    };
-    sortNodes(tree);
-    return tree;
-  };
-  const updateCategoryPaths = async (categoryId, newParentId = null) => {
-    const [category, parent] = await Promise.all([
-      Category.findById(categoryId).lean(),
-      newParentId ? Category.findById(newParentId).lean() : null
-    ]);
-    if (!category) {
-      console.log("Category not found");
-      return;
-    }
-    const oldUrl = category.url;
-    const oldLevel = category.level;
-    const oldParent = category.parent ? category.parent.toString() : null;
-    const newParentStr = newParentId ? newParentId.toString() : null;
-    if (oldParent === newParentStr) {
-      console.log("Parent not changed, skipping path update");
-      return;
-    }
-    let newLevel = 0;
-    let newUrl = `/${category.slug}`;
-    if (parent) {
-      newLevel = parent.level + 1;
-      newUrl = `${parent.url}/${category.slug}`;
-    }
-    if (oldUrl === newUrl) {
-      console.log("URL not changed, skipping update");
-      return;
-    }
-    console.log(`URL change: "${oldUrl}" -> "${newUrl}"`);
-    const bulkOps = [];
-    bulkOps.push({
-      updateOne: {
-        filter: { _id: categoryId },
-        update: {
-          $set: {
-            level: newLevel,
-            url: newUrl,
-            parent: newParentId
-          }
-        }
-      }
-    });
-    const levelDiff = newLevel - oldLevel;
-    const oldUrlLength = oldUrl.length;
-    bulkOps.push({
-      updateMany: {
-        filter: { url: { $regex: `^${oldUrl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/` } },
-        update: [
-          {
-            $set: {
-              url: {
-                $concat: [
-                  newUrl,
-                  { $substr: ["$url", oldUrlLength, -1] }
-                ]
-              },
-              level: { $add: ["$level", levelDiff] }
-            }
-          }
-        ]
-      }
-    });
-    const result = await Category.bulkWrite(bulkOps, { ordered: false });
-    console.log(`Updated ${result.modifiedCount} documents`);
-  };
-  return {
-    async read(req, res) {
-      try {
-        const {
-          _id,
-          parent,
-          url,
-          status,
-          search,
-          sortParam = "order",
-          sortOrder = "asc",
-          skip,
-          limit,
-          root = false,
-          owner,
-          type,
-          tree,
-          depth = -1
-        } = req.query;
-        const depthNum = parseInt(depth, 10);
-        const isTree = tree === "true" || tree === true;
-        const isRoot = root === "true" || root === true;
-        console.log("🚀 Read categories params:", { url, depth: depthNum, tree: isTree, root });
-        const cacheKey = JSON.stringify(req.query);
-        const cached = await cache.get(cacheKey);
-        if (cached) return res.json(cached);
-        const match = {
-          ..._id && { _id: new db.mongoose.Types.ObjectId(_id) },
-          ...status && { status },
-          ...search && { name: { $regex: search, $options: "i" } },
-          ...type && { "owner.type": type },
-          ...owner && { "owner.target": new db.mongoose.Types.ObjectId(owner) },
-          ...parent && { parent: new db.mongoose.Types.ObjectId(parent) }
-          // Исправлено: было owner вместо parent
-        };
-        if (url && !_id) {
-          if (depth === 0) {
-            match.url = url;
-          } else if (depth === 1) {
-            match.$or = [
-              { url },
-              { url: { $regex: "^${url}/[^/]+$" } }
-            ];
-          } else {
-            match.$or = [
-              { url },
-              { url: { $regex: `^${url}/` } }
-            ];
-          }
-        } else if (isRoot && !_id) {
-          match.url = { $regex: "^/[^/]+$" };
-        }
-        console.log("🔎 Match object:", JSON.stringify(match, null, 2));
-        const pipeline = [
-          { $match: match },
-          ...queryProcessor.queryProcessorCore.getSortingOptions(sortParam, sortOrder)
-          // ...(skip || limit ? globalsQuery.getPaginationOptions(skip, limit) : []),
-        ];
-        console.log("🔧 Pipeline:", JSON.stringify(pipeline, null, 2));
-        let results = await Category.aggregate(pipeline);
-        console.log("🔍 Aggregate results:", results.length, "categories found");
-        console.log("🔍 Results URLs:", results.map((r) => r.url));
-        if (url && depthNum > 1) {
-          const maxLevel = url.split("/").filter(Boolean).length + depthNum - 1;
-          results = results.filter((cat) => {
-            const catLevel = cat.url.split("/").filter(Boolean).length;
-            return cat.url === url || catLevel <= maxLevel;
-          });
-          console.log("🔍 After depth filter:", results.length, "categories");
-        }
-        if (isTree && results.length > 0) {
-          console.log("🌳 Building tree from results");
-          results = buildTreeFromUrl(results, sortParam, sortOrder);
-        } else if (!isTree && depthNum === 1 && url && results.length > 0) {
-          console.log("📋 Processing tree=false, depth=1");
-          console.log("📋 Looking for main category with url:", url);
-          const mainCategory = results.find((c) => c.url === url);
-          console.log("📋 Main category found:", !!mainCategory, mainCategory?.url);
-          if (mainCategory) {
-            const children = results.filter(
-              (c) => c.url !== url && c.url.startsWith(url + "/")
-            );
-            console.log("📋 Children found:", children.length, children.map((c) => c.url));
-            mainCategory.children = children;
-            results = [mainCategory];
-            console.log("📋 Final result with children:", results[0].url, "children:", results[0].children.length);
-          } else {
-            console.log("❌ Main category not found in results!");
-          }
-        }
-        const tags = ["categories"];
-        if (owner) tags.push(`organization_${owner}`);
-        await cache.setWithTags(cacheKey, results, tags);
-        console.log("✅ Final results count:", results.length);
-        res.json(results);
-      } catch (err) {
-        logger.error(`Error reading categories: ${err.message}`);
-        res.status(500).json({ message: err.message });
-      }
-    },
-    async create(req, res) {
-      try {
-        const data = req.verifiedBody;
-        data.creator ||= { type: "user", target: req.userId };
-        data.owner ||= req.query.owner ? { type: "organization", target: req.query.owner } : { type: "platform", target: null };
-        const slug = await generateSlug(data.name, data.parent);
-        let level = 0;
-        let url = `/${slug}`;
-        if (data.parent) {
-          const parent = await Category.findById(data.parent);
-          if (!parent) throw new Error("Parent category not found");
-          level = parent.level + 1;
-          url = `${parent.url}/${slug}`;
-        }
-        const maxOrder = await Category.findOne({ parent: data.parent || null }).sort("-order").select("order");
-        const order = (maxOrder?.order || 0) + 1;
-        const category = await Category.create({
-          ...data,
-          slug,
-          url,
-          level,
-          order
-        });
-        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.includes("not found") ? 404 : 500).json({ message: err.message });
-      }
-    },
-    async update(req, res) {
-      try {
-        const data = req.verifiedBody;
-        const oldCategory = await Category.findById(data._id);
-        if (!oldCategory) {
-          return res.status(404).json({ message: "Category not found" });
-        }
-        if (data.parent !== void 0 && data.parent != oldCategory.parent) {
-          await updateCategoryPaths(data._id, data.parent);
-        }
-        const updated = await Category.findByIdAndUpdate(
-          data._id,
-          { $set: data },
-          { new: true }
-        ).lean();
-        await cache.delByTags(["categories"]);
-        if (updated.owner?.type === "organization") {
-          await cache.delByTag(`organization_${updated.owner.target}`);
-        }
-        logger.info(`Category updated: ${data._id}`);
-        res.json(updated);
-      } catch (err) {
-        logger.error(`Category update error: ${err.message}`);
-        res.status(500).json({ message: "Failed to update category" });
-      }
-    },
-    async updateOrder(req, res) {
-      const startTime = Date.now();
-      try {
-        console.log("📥 BACKEND RECEIVED:", JSON.stringify(req.body, null, 2));
-        const { movedCategory, affectedCategories } = req.verifiedBody;
-        if (!affectedCategories || affectedCategories.length === 0) {
-          return res.json({ message: "No changes to update" });
-        }
-        const bulkOps = affectedCategories.map((cat) => ({
-          updateOne: {
-            filter: { _id: cat._id },
-            update: { $set: { order: cat.order } }
-          }
-        }));
-        console.log(`Starting bulkWrite with ${bulkOps.length} operations`);
-        const bulkStart = Date.now();
-        await Category.bulkWrite(bulkOps, { ordered: false });
-        console.log(`BulkWrite completed in ${Date.now() - bulkStart}ms`);
-        if (movedCategory) {
-          const pathStart = Date.now();
-          console.log("Starting updateCategoryPaths...");
-          await updateCategoryPaths(movedCategory._id, movedCategory.newParent);
-          console.log(`updateCategoryPaths completed in ${Date.now() - pathStart}ms`);
-        }
-        const cacheStart = Date.now();
-        await cache.delByTags(["categories"]);
-        console.log(`Cache clear completed in ${Date.now() - cacheStart}ms`);
-        const totalTime = Date.now() - startTime;
-        console.log(`=== UPDATE ORDER COMPLETE in ${totalTime}ms ===`);
-        logger.info(`Categories order updated: ${affectedCategories.length} items in ${totalTime}ms`);
-        res.json({ message: "Order updated successfully" });
-      } catch (err) {
-        logger.error(`Category order update error: ${err.message}`);
-        console.error("Full error:", err);
-        res.status(500).json({ message: "Failed to update categories order" });
-      }
-    },
-    async delete(req, res) {
-      try {
-        const category = req.currentResource;
-        await Category.updateMany(
-          { parent: category._id },
-          {
-            $set: { parent: category.parent },
-            $inc: { level: -1 }
-          }
-        );
-        if (category.parent) {
-          const parent = await Category.findById(category.parent);
-          const children = await Category.find({ parent: category.parent });
-          for (const child of children) {
-            await updateCategoryPaths(child._id, category.parent);
-          }
-        }
-        await Category.deleteOne({ _id: category._id });
-        await cache.delByTags(["categories"]);
-        if (category.owner?.type === "organization") {
-          await cache.delByTag(`organization_${category.owner.target}`);
-        }
-        logger.info(`Category deleted: ${category.slug}`);
-        res.json({ message: "Category deleted successfully" });
-      } catch (err) {
-        logger.error(`Error deleting category: ${err.message}`);
-        res.status(500).json({ message: err.message });
-      }
-    }
-  };
-};
-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 = mongoose.Types.ObjectId;
-function getCategoriesFilterStage(categories) {
-  if (!categories) return [];
-  if (typeof categories === "string") {
-    return [
-      {
-        $lookup: {
-          from: "categories",
-          localField: "category",
-          foreignField: "_id",
-          as: "categoryData"
-        }
-      },
-      {
-        $match: {
-          "categoryData.url": {
-            $regex: `^${categories}(/|$)`
-          }
-        }
-      },
-      {
-        $project: {
-          categoryData: 0
-        }
-      }
-    ];
-  }
-  if (Array.isArray(categories)) {
-    const categoryIds = categories.filter(Boolean);
-    if (categoryIds.length === 0) return [];
-    return [{
-      $match: {
-        category: {
-          $in: categoryIds.map((id) => new ObjectId(id))
-        }
-      }
-    }];
-  }
-  return [];
-}
-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 getVariantPriceFilterStage(priceMin, priceMax) {
-  const hasValidMin = priceMin && priceMin.trim() !== "";
-  const hasValidMax = priceMax && priceMax.trim() !== "";
-  if (!hasValidMin && !hasValidMax) return [];
-  try {
-    const priceCondition = {
-      variants: {
-        $elemMatch: {
-          price: {}
-        }
-      }
-    };
-    if (hasValidMin) {
-      const minPrice = parseFloat(priceMin);
-      if (!isNaN(minPrice)) {
-        priceCondition.variants.$elemMatch.price.$gte = minPrice;
-      }
-    }
-    if (hasValidMax) {
-      const maxPrice = parseFloat(priceMax);
-      if (!isNaN(maxPrice)) {
-        priceCondition.variants.$elemMatch.price.$lte = maxPrice;
-      }
-    }
-    return [{ $match: priceCondition }];
-  } catch (error) {
-    console.error("Error parsing price filters:", error);
-    return [];
-  }
-}
-function getAvailabilityFilterStage(dateStart, dateEnd) {
-  if (!dateStart || !dateEnd) return [];
-  const startDate = new Date(dateStart);
-  const endDate = new Date(dateEnd);
-  if (isNaN(startDate.getTime()) || isNaN(endDate.getTime())) {
-    console.warn("Invalid dates provided for availability filter:", { dateStart, dateEnd });
-    return [];
-  }
-  return [
-    {
-      $lookup: {
-        from: "rents",
-        let: {
-          productId: "$_id",
-          dateStart: startDate,
-          dateEnd: endDate
-        },
-        pipeline: [
-          {
-            $match: {
-              $expr: {
-                $and: [
-                  { $eq: ["$product", "$$productId"] },
-                  { $in: ["$status", ["pending", "confirmed", "active"]] },
-                  {
-                    $or: [
-                      {
-                        $and: [
-                          { $gte: ["$startDate", "$$dateStart"] },
-                          { $lte: ["$startDate", "$$dateEnd"] }
-                        ]
-                      },
-                      {
-                        $and: [
-                          { $gte: ["$endDate", "$$dateStart"] },
-                          { $lte: ["$endDate", "$$dateEnd"] }
-                        ]
-                      },
-                      {
-                        $and: [
-                          { $lte: ["$startDate", "$$dateStart"] },
-                          { $gte: ["$endDate", "$$dateEnd"] }
-                        ]
-                      }
-                    ]
-                  }
-                ]
-              }
-            }
-          },
-          {
-            $group: {
-              _id: null,
-              totalRented: { $sum: { $ifNull: ["$available", 1] } }
-            }
-          }
-        ],
-        as: "rentInfo"
-      }
-    },
-    {
-      $addFields: {
-        rentedQuantity: {
-          $ifNull: [{ $arrayElemAt: ["$rentInfo.totalRented", 0] }, 0]
-        },
-        availableQuantity: {
-          $subtract: [
-            { $ifNull: ["$available", 0] },
-            { $ifNull: [{ $arrayElemAt: ["$rentInfo.totalRented", 0] }, 0] }
-          ]
-        }
-      }
-    },
-    {
-      $match: {
-        $or: [
-          { availableQuantity: { $gt: 0 } },
-          { $and: [{ rentedQuantity: 0 }, { $or: [{ available: { $gt: 0 } }, { available: { $exists: false } }] }] }
-        ]
-      }
-    },
-    {
-      $project: {
-        rentInfo: 0,
-        rentedQuantity: 0,
-        availableQuantity: 0
-      }
-    }
-  ];
-}
-function escapeRegex(string) {
-  return string.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
-}
-const queryProcessorProducts = {
-  getAttributeFiltersStage,
-  getCategoriesFilterStage,
-  getDeliveryFilterStage,
-  getVariantPriceFilterStage,
-  getAvailabilityFilterStage
-};
-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",
-      pipeline: [
-        {
-          $lookup: {
-            from: "variants",
-            localField: "_id",
-            foreignField: "product",
-            as: "variants"
-          }
-        }
-      ]
-    }
-  },
-  // Лукап для категорий продукта
-  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 Variant = db.variant;
-  const generateSKU = () => {
-    const timestamp = Date.now().toString(36);
-    const random = Math.random().toString(36).substring(2, 5);
-    return `VAR-${timestamp}-${random}`.toUpperCase();
-  };
-  const Create = async (req, res) => {
-    try {
-      const productData = {
-        ...req.body,
-        category: req.body.category?.map((cat) => cat._id) || []
-      };
-      const { defaultVariant, ...cleanProductData } = productData;
-      const product = await new Product(cleanProductData).save();
-      if (defaultVariant && defaultVariant.price !== null && defaultVariant.price > 0) {
-        const variantData = {
-          product: product._id,
-          name: product.name,
-          price: parseFloat(defaultVariant.price),
-          quantity: parseInt(defaultVariant.quantity) || 1,
-          unit: defaultVariant.unit || "pcs",
-          status: product.status,
-          // используем статус из товара
-          sku: generateSKU(),
-          owner: product.owner,
-          creator: product.creator,
-          images: [],
-          cost: 0,
-          ingredients: [],
-          attributes: []
-        };
-        await new Variant(variantData).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 = queryProcessor.queryProcessorCore.getRequestedLookups(req.query);
-      if (req.query.dateStart || req.query.dateEnd) {
-        console.log("Availability filter params:", {
-          dateStart: req.query.dateStart,
-          dateEnd: req.query.dateEnd,
-          dateStartType: typeof req.query.dateStart,
-          dateEndType: typeof req.query.dateEnd
-        });
-      }
-      const stages = [
-        ...queryProcessor.queryProcessorCore.getBasicOptions(req.query),
-        ...queryProcessor.queryProcessorCore.getSearchOptions(req.query.search, {
-          fields: ["name", "description"]
-        }),
-        ...queryProcessorProducts.getCategoriesFilterStage(req.query.categories),
-        ...queryProcessorProducts.getDeliveryFilterStage(req.query.delivery),
-        ...queryProcessorProducts.getAttributeFiltersStage(req.query.filters),
-        ...queryProcessor.queryProcessorCore.getLookupStages(requestedLookups, productLookupConfigs),
-        ...queryProcessorProducts.getVariantPriceFilterStage(req.query.priceMin, req.query.priceMax),
-        ...queryProcessorProducts.getAvailabilityFilterStage(req.query.dateStart, req.query.dateEnd),
-        queryProcessor.queryProcessorCore.getCreatorUserLookupStage(),
-        queryProcessor.queryProcessorCore.getCreatorOrganizationLookupStage(),
-        queryProcessor.queryProcessorCore.getOwnerUserLookupStage(),
-        queryProcessor.queryProcessorCore.getOwnerOrganizationLookupStage(),
-        queryProcessor.queryProcessorCore.getAddFieldsCreatorOwnerStage(),
-        ...queryProcessor.queryProcessorCore.getSortingOptions(req.query.sortParam, req.query.sortOrder),
-        ...queryProcessor.queryProcessorCore.getPaginationOptions(req.query.skip, req.query.limit),
-        // Удаление временных полей
-        queryProcessor.queryProcessorCore.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 },
-      slug: { type: String, required: true, trim: true },
-      url: { type: String, required: true, trim: true, unique: true },
-      parent: { type: db.mongoose.Schema.Types.ObjectId, ref: "Category" },
-      level: { type: Number, required: true, default: 0 },
-      localization: { type: Array },
-      filters: { type: Array }
-    },
-    {
-      timestamps: { currentTime: () => Date.now() }
-    }
-  );
-  common_schema.applyCommonSchema(CategorySchema);
-  ownership_schema.applyOwnershipSchema(CategorySchema, db);
-  metadata_schema.applyMetadataSchema(CategorySchema);
-  engagement_schema.applyEngagementSchema(CategorySchema);
-  CategorySchema.index({ name: "text", description: "text" });
-  CategorySchema.index({ url: 1, "owner.target": 1, status: 1, level: 1 });
-  CategorySchema.index({ "owner.type": 1, "owner.target": 1, status: 1, level: 1 });
-  CategorySchema.index({ parent: 1, status: 1, order: 1 });
-  CategorySchema.index({ level: 1, status: 1, order: 1 });
-  CategorySchema.index({ status: 1, order: 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()
-    }
-  });
-  common_schema.applyCommonSchema(ProductSchema);
-  ownership_schema.applyOwnershipSchema(ProductSchema, db);
-  engagement_schema.applyEngagementSchema(ProductSchema);
-  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
-    },
-    description: {
-      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()
-    }
-  });
-  common_schema.applyCommonSchema(VariantSchema);
-  ownership_schema.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 generateSlug = (name, existingSlugs = []) => {
-    let baseSlug = name.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").trim("-");
-    let slug = baseSlug;
-    let counter = 1;
-    while (existingSlugs.includes(slug)) {
-      slug = `${baseSlug}-${counter}`;
-      counter++;
-    }
-    return slug;
-  };
-  const queryValidatorConfig = {
-    parent: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    slug: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    url: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    parentUrl: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    search: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    sortParam: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["order", "name", "createdAt", "updatedAt"]),
-      default: "order"
-    },
-    sortOrder: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["asc", "desc"]),
-      default: "asc"
-    },
-    skip: { rule: "optional", validator: core_verifier.Validator.schema().number().integer().min(0), default: 0 },
-    limit: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().number().integer().min(1).max(100),
-      default: 10
-    },
-    excludeChildren: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["true", "false"]),
-      default: "true"
-    },
-    rootOnly: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["true", "false"]),
-      default: "false"
-    },
-    status: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["draft", "internal", "published", "removed"])
-    },
-    type: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["platform", "organization", "all"]),
-      default: "all"
-    },
-    organizationId: { rule: "optional", validator: core_verifier.Validator.schema().string() }
-  };
-  const bodyValidatorConfig = {
-    _id: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    name: { rule: "optional", validator: core_verifier.Validator.schema().string().required() },
-    description: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    photo: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    status: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["draft", "internal", "published", "removed"]),
-      default: "draft"
-    },
-    slug: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    parent: { rule: "optional", validator: core_verifier.Validator.schema().oneOfTypes(["string", "null"]) },
-    localization: { rule: "optional" },
-    filters: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(
-        core_verifier.Validator.schema().object({
-          name: core_verifier.Validator.schema().string(),
-          options: core_verifier.Validator.schema().array().items(core_verifier.Validator.schema().string())
-        })
-      )
-    },
-    owner: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().object({
-        type: core_verifier.Validator.schema().string().oneOf(["platform", "organization"]).required(),
-        target: core_verifier.Validator.schema().string()
-      })
-    },
-    creator: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().object({
-        type: core_verifier.Validator.schema().string().oneOf(["user", "organization"]).required(),
-        target: core_verifier.Validator.schema().string()
-      })
-    },
-    children: { rule: "optional", validator: core_verifier.Validator.schema().array() },
-    order: { rule: "optional", validator: core_verifier.Validator.schema().number() }
-  };
-  const orderBodyValidatorConfig = {
-    movedCategory: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().object({
-        _id: core_verifier.Validator.schema().string().required(),
-        newParent: core_verifier.Validator.schema().oneOfTypes(["string", "null"])
-      })
-    },
-    affectedCategories: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array(),
-      default: []
-    }
-  };
-  const deleteBodyValidatorConfig = {
-    _id: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().required()
-    }
-  };
-  const queryVerifier = new core_verifier.Verifier(queryValidatorConfig);
-  const bodyVerifier = new core_verifier.Verifier(bodyValidatorConfig);
-  const orderBodyVerifier = new core_verifier.Verifier(orderBodyValidatorConfig);
-  const deleteBodyVerifier = new core_verifier.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();
-    },
-    // Проверка на существование категории с тем же slug в рамках parent
-    async checkCategoryExistOrNot(req, res, next) {
-      try {
-        const { name, parent, slug } = req.verifiedBody;
-        if (!name) {
-          return res.status(400).json({ message: "Name is required" });
-        }
-        let categorySlug = slug;
-        if (!categorySlug) {
-          const existingSlugs = await db.category.find({
-            parent: parent || null
-          }).distinct("slug");
-          categorySlug = generateSlug(name, existingSlugs);
-          req.verifiedBody.slug = categorySlug;
-        } else {
-          const existingCategory = await db.category.findOne({
-            slug: categorySlug,
-            parent: parent || null
-          });
-          if (existingCategory) {
-            return res.status(409).json({
-              message: "Category with this slug already exists in this parent",
-              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 });
-      }
-    },
-    // Загрузка категории по _id для удаления
-    async loadCategoryForDelete(req, res, next) {
-      try {
-        const _id = req.verifiedBody._id;
-        if (!_id) {
-          return res.status(400).json({ message: "Category _id is required" });
-        }
-        const category = await db.category.findById(_id).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 } = core_abac.coreabac;
-const categoriesRoutes = (function(app, db) {
-  const jwt = authJwt.middlewareFactory(db);
-  const verifier = verifierFactory$1(db);
-  const abac2 = 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, abac2.middleware("category", "create"), controller.create);
-  app.post("/api/categories/update", jwt.verifyToken(), verifier.verifyBody, verifier.loadCategoryForUpdate, abac2.middleware("category", "edit"), controller.update);
-  app.post("/api/categories/updateOrder", jwt.verifyToken(), verifier.verifyOrderBody, abac2.middleware("category", "edit"), controller.updateOrder);
-  app.post("/api/categories/delete", jwt.verifyToken(), verifier.verifyDeleteBody, verifier.loadCategoryForDelete, abac2.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 core_verifier.Verifier({
-    name: {
-      rule: "required",
-      validator: core_verifier.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")
-    },
-    description: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().length({ max: 5e3 }, "Description must not exceed 5000 characters")
-    },
-    sku: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[A-Za-z0-9-_]+$/, "SKU can only contain letters, numbers, hyphens and underscores").max(50)
-    },
-    price: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().number().required("Price is required").min(0, "Price cannot be negative")
-    },
-    cost: {
-      rule: "optional",
-      default: 0,
-      validator: core_verifier.Validator.schema().number().min(0, "Cost cannot be negative")
-    },
-    quantity: {
-      rule: "optional",
-      default: 1,
-      validator: core_verifier.Validator.schema().number().min(0, "Quantity cannot be negative")
-    },
-    unit: {
-      rule: "optional",
-      default: "pcs",
-      validator: core_verifier.Validator.schema().string().oneOf(["pcs", "g", "kg", "ml", "l", "oz"], "Invalid unit")
-    },
-    images: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(core_verifier.Validator.schema().string())
-    },
-    ingredients: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(
-        core_verifier.Validator.schema().object({
-          name: core_verifier.Validator.schema().string().required(),
-          quantity: core_verifier.Validator.schema().number().min(0),
-          unit: core_verifier.Validator.schema().string()
-        })
-      )
-    },
-    attributes: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(
-        core_verifier.Validator.schema().object({
-          name: core_verifier.Validator.schema().string().required(),
-          value: core_verifier.Validator.schema().string().required()
-        })
-      )
-    },
-    owner: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().object({
-        type: core_verifier.Validator.schema().string().oneOf(["user", "organization"]),
-        target: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
-      })
-    }
-  });
-  const updateVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Variant ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid ID format")
-    },
-    name: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().min(2, "Name must be at least 2 characters").max(100, "Name must not exceed 100 characters")
-    },
-    description: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().length({ max: 5e3 }, "Description must not exceed 5000 characters")
-    },
-    sku: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[A-Za-z0-9-_]+$/, "SKU can only contain letters, numbers, hyphens and underscores").max(50)
-    },
-    price: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().number().min(0, "Price cannot be negative")
-    },
-    cost: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().number().min(0, "Cost cannot be negative")
-    },
-    quantity: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().integer().min(0, "Quantity cannot be negative")
-    },
-    unit: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["pcs", "g", "kg", "ml", "l", "oz"], "Invalid unit")
-    },
-    images: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(core_verifier.Validator.schema().string())
-    },
-    ingredients: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(
-        core_verifier.Validator.schema().object({
-          name: core_verifier.Validator.schema().string().required(),
-          quantity: core_verifier.Validator.schema().number().min(0),
-          unit: core_verifier.Validator.schema().string()
-        })
-      )
-    },
-    attributes: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().array().items(
-        core_verifier.Validator.schema().object({
-          name: core_verifier.Validator.schema().string().required(),
-          value: core_verifier.Validator.schema().string().required()
-        })
-      )
-    }
-  });
-  const readVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
-    },
-    owner: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string()
-    },
-    skip: {
-      rule: "optional",
-      default: 0,
-      validator: core_verifier.Validator.schema().integer().min(0)
-    },
-    limit: {
-      rule: "optional",
-      default: 20,
-      validator: core_verifier.Validator.schema().integer().min(1).max(100)
-    },
-    sortParam: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["name", "price", "quantity", "createdAt", "updatedAt"])
-    },
-    sortOrder: {
-      rule: "optional",
-      default: "desc",
-      validator: core_verifier.Validator.schema().string().oneOf(["asc", "desc"])
-    }
-  });
-  const deleteVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Variant ID is required").pattern(/^[0-9a-fA-F]{24}$/)
-    }
-  });
-  return {
-    createVerifier,
-    readVerifier,
-    updateVerifier,
-    deleteVerifier
-  };
-});
-const { getInstance } = abac.ABAC;
-function setupVariantsRoutes(app, db) {
-  const abac2 = getInstance(db);
-  const verifier = verifierFactory();
-  const variantsCRUD = new crud.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: abac2,
-    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
-};
-exports.controllers = controllers;
-exports.default = products_server;
-exports.initialize = initializeProduct;
-exports.models = models;
-exports.routes = routes;