@ozdao/martyrs 0.2.477 → 0.2.479

package/dist/products.server.js

@@ -1,142 +1,832 @@
-"use strict";
-const _commonjsHelpers = require("./_commonjsHelpers-DHfMLFPC.js");
-const ownership_schema = require("./ownership.schema-MxfJlPtq.js");
-const common_schema = require("./common.schema-O0w_rDyC.js");
-const metadata_schema = require("./metadata.schema-CUkLXZ2f.js");
-const engagement_schema = require("./engagement.schema-DAiXsvh1.js");
-const require$$0 = require("uuid");
-const require$$0$1 = require("mongoose");
-require("path");
-const require$$3 = require("openai");
-const queryProcessor = require("./queryProcessor-DSUqSk3I.js");
-const globals_logger = require("./globals.logger-BdjooLaD.js");
-const globals_cache = require("./globals.cache-CwWvNGFQ.js");
-const globals_verifier = require("./globals.verifier-CKYpYfQl.js");
-const authJwt = require("./authJwt-CELQKF2s.js");
-const globals_abac = require("./globals.abac-Bn-4tbX8.js");
-var product_model;
-var hasRequiredProduct_model;
-function requireProduct_model() {
-  if (hasRequiredProduct_model) return product_model;
-  hasRequiredProduct_model = 1;
-  const applyOwnershipSchema = ownership_schema.requireOwnership_schema();
-  product_model = (db) => {
-    const ProductSchema = new db.mongoose.Schema({
-      status: {
-        type: String
-      },
-      listing: {
-        type: String,
-        enum: ["sale", "rent"]
-      },
+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-CCZX5vfw.js";
+import { m as middlewareFactory } from "./authJwt-DcYNNwcr.js";
+import { g as globalsabac } from "./globals.abac-DBV_kaOq.js";
+import { a as Validator, V as Verifier } from "./globals.verifier-CWFz5Gh2.js";
+import { O as Observer } from "./globals.observer-CDqUjVU5.js";
+import { A as ABAC } from "./abac-BuL5pUZ4.js";
+const controllerFactory$2 = (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);
+  }
+};
+const controllerFactory$1 = (db) => {
+  const Leftover = db.leftover;
+  const read = async (req, res) => {
+    try {
+      let stages = [
+        ...queryProcessorGlobals.getSearchOptions(req.query.search, {
+          fields: ["positions.name"]
+        }),
+        ...queryProcessorGlobals.getBasicOptions(req.query),
+        // For creator
+        queryProcessorGlobals.getCreatorUserLookupStage(),
+        queryProcessorGlobals.getCreatorOrganizationLookupStage(),
+        // For owner
+        queryProcessorGlobals.getOwnerUserLookupStage(),
+        queryProcessorGlobals.getOwnerOrganizationLookupStage(),
+        queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
+        // Pagination
+        ...queryProcessorGlobals.getSortingOptions(req.query.sortParam, req.query.sortOrder),
+        ...queryProcessorGlobals.getPaginationOptions(req.query.skip, req.query.limit)
+      ];
+      const leftoveres = await Leftover.aggregate(stages).exec();
+      if (!leftoveres) {
+        return res.status(404).send({ message: "LEFTOVERES_NOT_FOUND" });
+      }
+      res.status(200).send(leftoveres);
+    } catch (err) {
+      console.error(err);
+      res.status(500).send({ message: "ERROR_GET_ALL_LEFTOVERES" });
+    }
+  };
+  const create = async (req, res) => {
+    try {
+      const leftover = await Leftover.create({
+        organization: req.body.organization,
+        type: req.body.type,
+        order: req.body.order,
+        comment: req.body.comment,
+        positions: req.body.positions,
+        creator: req.body.creator,
+        owner: req.body.owner
+      });
+      if (!leftover) {
+        return res.status(404).send({ message: "ERROR_CREATING_LEFTOVER" });
+      }
+      res.status(200).send(leftover);
+    } catch (err) {
+      console.log(err);
+      res.status(500).send({ message: "ERROR_CREATE_LEFTOVER" });
+    }
+  };
+  const get = async (req, res) => {
+    try {
+      const leftover = await Leftover.findOne({ _id: req.params._id }).exec();
+      if (!leftover) {
+        return res.status(404).send({ message: "LEFTOVER_NOT_FOUND" });
+      }
+      res.status(200).send(leftover);
+    } catch (err) {
+      res.status(500).send({ message: "ERROR_GET_LEFTOVER" });
+    }
+  };
+  const update = async (req, res) => {
+    try {
+      const leftover = await Leftover.findOneAndUpdate({ _id: req.params._id }, req.body, {
+        new: true,
+        upsert: true
+      }).exec();
+      if (!leftover) {
+        return res.status(404).send({ message: "LEFTOVER_NOT_FOUND" });
+      }
+      res.status(200).send(leftover);
+    } catch (err) {
+      console.log(err);
+      res.status(500).send({ message: "ERROR_UPDATING_LEFTOVER" });
+    }
+  };
+  const deleteLeftover = async (req, res) => {
+    try {
+      const leftover = await Leftover.findOneAndDelete({ _id: req.params._id });
+      if (!leftover) {
+        return res.status(404).send({ message: "ERROR_DELETING_LEFTOVER" });
+      }
+      res.status(200).send(leftover);
+    } catch (err) {
+      res.status(500).send({ message: "ERROR_DELETE_LEFTOVER" });
+    }
+  };
+  return {
+    read,
+    create,
+    get,
+    update,
+    delete: deleteLeftover
+  };
+};
+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: {
-        type: Array
-      },
-      name: {
-        type: String
-      },
-      description: {
-        type: String
-      },
-      information: [{
-        name: { type: String },
-        value: { type: String }
-      }],
-      images: {
-        type: Array
-      },
-      localization: {
-        type: Array
-      },
-      // ЗАДАЧА: Нужно отрефачить price, перенести его в default variant
-      price: {
-        type: Number,
-        required: true
-      },
-      price_cost: {
-        type: Number,
-        default: 0
-      },
-      price_currency: {
-        type: String,
-        default: "$"
-      },
-      quantity: {
-        type: Number,
-        default: 1
-      },
-      unit: {
-        type: String,
-        required: true,
-        default: "pcs"
-      },
-      prices: { type: Array },
-      // 
-      variants: [{
-        _id: { type: db.mongoose.Schema.Types.ObjectId, auto: true },
-        name: { type: String },
-        price: { type: Number },
-        options: [{
-          name: { type: String },
-          value: { type: String }
-        }],
-        default: { type: Boolean }
-      }],
-      ingredients: [{
-        _id: {
-          type: db.mongoose.Schema.Types.ObjectId,
-          ref: "Product"
-        },
-        price: {
-          type: Number,
-          required: true,
-          default: 0,
-          min: [0, "Price cannot be less than 0"]
+        $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 = {
+  // Лукап для leftover-ов продукта
+  leftovers: {
+    lookup: {
+      from: "leftovers",
+      let: { productId: "$_id", ingredientsIds: "$ingredients._id" },
+      pipeline: [
+        { $unwind: "$positions" },
+        {
+          $match: {
+            $expr: {
+              $or: [
+                { $eq: ["$positions._id", "$$productId"] },
+                { $in: ["$positions._id", { $ifNull: ["$$ingredientsIds", []] }] }
+              ]
+            }
+          }
         },
-        quantity: {
-          type: Number,
-          required: true,
-          min: [1, "Quantity cannot be less than 1"]
+        {
+          $addFields: {
+            "positions.quantity": {
+              $cond: {
+                if: { $eq: ["$type", "stock-in"] },
+                then: "$positions.quantity",
+                else: { $multiply: ["$positions.quantity", -1] }
+              }
+            }
+          }
         },
-        type: {
-          type: String,
-          required: true,
-          default: "g"
+        {
+          $project: {
+            _id: "$positions._id",
+            quantity: "$positions.quantity",
+            name: "$positions.name"
+          }
         }
-      }],
-      quantityDiscount: [{
-        quantity: {
-          type: Number,
-          required: true,
-          min: [1, "Quantity cannot be less than 1"]
-        },
-        discount: {
-          type: Number,
-          required: true,
-          min: [0, "Quantity-based discount cannot be less than 0"],
-          max: [100, "Quantity-based discount cannot be more than 100"]
+      ],
+      as: "leftovers"
+    },
+    additionalStages: [
+      // Этап для расчета количеств по ингредиентам
+      {
+        $addFields: {
+          ingredientsQuantities: {
+            $cond: {
+              if: { $isArray: "$ingredients" },
+              then: {
+                $map: {
+                  input: "$ingredients",
+                  as: "ingredient",
+                  in: {
+                    $let: {
+                      vars: {
+                        ingredientId: "$$ingredient._id",
+                        ingredientQuantity: { $ifNull: ["$$ingredient.quantity", 0] }
+                      },
+                      in: {
+                        $divide: [
+                          {
+                            $sum: {
+                              $map: {
+                                input: "$leftovers",
+                                as: "leftover",
+                                in: {
+                                  $cond: {
+                                    if: { $eq: ["$$leftover._id", "$$ingredientId"] },
+                                    then: "$$leftover.quantity",
+                                    else: 0
+                                  }
+                                }
+                              }
+                            }
+                          },
+                          {
+                            $cond: {
+                              if: { $eq: ["$$ingredientQuantity", 0] },
+                              then: 1,
+                              else: "$$ingredientQuantity"
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                }
+              },
+              else: []
+            }
+          }
         }
-      }]
-    }, {
-      timestamps: {
-        currentTime: () => Date.now()
+      },
+      // Этап для расчета доступного количества
+      {
+        $set: {
+          available: {
+            $cond: {
+              if: { $gt: [{ $size: { $ifNull: ["$ingredients", []] } }, 0] },
+              then: { $floor: { $min: "$ingredientsQuantities" } },
+              else: { $sum: "$leftovers.quantity" }
+            }
+          }
+        }
+      }
+    ]
+  },
+  // Лукап для категорий продукта
+  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.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(),
+        // Дополнительные очистки для leftovers (если был запрошен)
+        ...requestedLookups.includes("leftovers") ? [{ $project: { ingredientsQuantities: 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,
+        localization: req.body.translations,
+        discounts: req.body.discounts
+      };
+      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 });
+    }
+  };
+  const getProductsPopular = (req, res) => {
+    Product.find({
+      status: "published",
+      views: { $gt: 10 }
+    }).limit(10).exec((err, products) => {
+      if (err) {
+        return res.status(500).send({ message: err });
+      }
+      if (!products) {
+        return res.status(404).send({ message: "Products not found." });
       }
+      res.status(200).send(products);
     });
-    applyOwnershipSchema(ProductSchema, db);
-    ProductSchema.index({ category: 1 });
-    ProductSchema.index({ price: 1 });
-    const Product = db.mongoose.model("Product", ProductSchema);
-    return Product;
   };
-  return product_model;
-}
-var category_model;
-var hasRequiredCategory_model;
-function requireCategory_model() {
-  if (hasRequiredCategory_model) return category_model;
-  hasRequiredCategory_model = 1;
-  category_model = (db) => {
-    const CategorySchema = new db.mongoose.Schema({
+  return {
+    Create,
+    Read,
+    Update,
+    Delete,
+    getProductsPopular,
+    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 },
@@ -145,32 +835,23 @@ function requireCategory_model() {
       parent: { type: db.mongoose.Schema.Types.ObjectId, ref: "Category" },
       localization: { type: Array },
       filters: { type: Array }
-    }, {
+    },
+    {
       timestamps: { currentTime: () => Date.now() }
-    });
-    common_schema.requireCommon_schema()(CategorySchema, db);
-    ownership_schema.requireOwnership_schema()(CategorySchema, db);
-    metadata_schema.requireMetadata_schema()(CategorySchema, db);
-    engagement_schema.requireEngagement_schema()(CategorySchema, db);
-    CategorySchema.index({ parent: 1 });
-    CategorySchema.index({ name: 1 });
-    const Category = db.mongoose.model("Category", CategorySchema, "categories");
-    return Category;
-  };
-  return category_model;
-}
-var leftover_model;
-var hasRequiredLeftover_model;
-function requireLeftover_model() {
-  if (hasRequiredLeftover_model) return leftover_model;
-  hasRequiredLeftover_model = 1;
-  const applyOwnershipSchema = ownership_schema.requireOwnership_schema();
-  leftover_model = (db) => {
-    const LeftoverSchema = new db.mongoose.Schema({
-      organization: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: "Organization"
-      },
+    }
+  );
+  applyCommonSchema(CategorySchema);
+  applyOwnershipSchema(CategorySchema, db);
+  applyMetadataSchema(CategorySchema);
+  applyEngagementSchema(CategorySchema);
+  CategorySchema.index({ parent: 1 });
+  CategorySchema.index({ name: 1 });
+  const Category = db.mongoose.model("Category", CategorySchema, "categories");
+  return Category;
+};
+const LeftoverModel = (db) => {
+  const LeftoverSchema = new db.mongoose.Schema(
+    {
       type: {
         type: String,
         enum: ["stock-in", "stock-out", "write-off"],
@@ -178,1203 +859,1777 @@ function requireLeftover_model() {
         required: true
       },
       order: {
-        type: String
-      },
-      comment: {
-        type: String
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Order"
       },
-      store: {
-        type: Object
+      storage: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Spot"
       },
       positions: [{
         _id: {
+          type: db.mongoose.Schema.Types.ObjectId
+        },
+        product: {
           type: db.mongoose.Schema.Types.ObjectId,
           ref: "Product"
         },
+        variant: {
+          _id: {
+            type: db.mongoose.Schema.Types.ObjectId
+          },
+          name: {
+            type: String
+          },
+          attributes: {
+            type: Array
+          }
+        },
+        image: {
+          type: String
+        },
         name: {
           type: String
         },
         quantity: {
           type: Number
         },
-        price: {
+        cost: {
           type: Number
         },
-        type: {
+        unit: {
           type: String
         }
-      }]
-    }, {
+      }],
+      comment: {
+        type: String
+      }
+    },
+    {
       timestamps: {
         currentTime: () => Date.now()
       }
-    });
-    applyOwnershipSchema(LeftoverSchema, db);
-    LeftoverSchema.index({ user: 1, type: 1, target: 1 });
-    const Leftover = db.mongoose.model("Leftover", LeftoverSchema);
-    return Leftover;
-  };
-  return leftover_model;
-}
-var products_controller;
-var hasRequiredProducts_controller;
-function requireProducts_controller() {
-  if (hasRequiredProducts_controller) return products_controller;
-  hasRequiredProducts_controller = 1;
-  const { v1: uuidv1, v4: uuidv4 } = require$$0;
-  const ObjectId = require$$0$1.Types.ObjectId;
-  const OpenAI = require$$3;
-  const openai = new OpenAI({
-    organization: process.env.OPENAI_ORG_KEY,
-    apiKey: process.env.OPENAI_API_KEY
-  });
-  const queryProcessorGlobals = queryProcessor.requireQueryProcessor();
-  const controllerFactory = (db) => {
-    const Product = db.product;
-    db.modification;
-    db.leftover;
-    const Create = async (req, res) => {
-      try {
-        const newProduct = new Product(req.body);
-        const data = await newProduct.save();
-        res.send(data);
-      } catch (err) {
-        console.log(err);
-        res.status(500).send({ message: err.message });
+    }
+  );
+  applyOwnershipSchema(LeftoverSchema, db);
+  LeftoverSchema.index({ storage: 1, order: 1, type: 1 });
+  const Leftover = db.mongoose.model("Leftover", LeftoverSchema);
+  return Leftover;
+};
+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
+    },
+    attributes: [{
+      name: { type: String },
+      value: { type: String }
+    }],
+    translations: {
+      type: Array
+    },
+    discounts: [DiscountSchema]
+  }, {
+    timestamps: {
+      currentTime: () => Date.now()
+    }
+  });
+  applyCommonSchema(ProductSchema);
+  applyOwnershipSchema(ProductSchema, db);
+  ProductSchema.index({ category: 1 });
+  ProductSchema.index({ name: "text", description: "text" });
+  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 });
+  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"
+        });
       }
-    };
-    const Read = async (req, res) => {
-      console.log(req.query);
+      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 {
-        const query = {};
-        if (req.query.owner) {
-          query["owner.target"] = new ObjectId(req.query.owner);
-        }
-        if (req.query._id) {
-          query._id = new ObjectId(req.query._id);
-        }
-        if (req.query.status) {
-          query.status = req.query.status;
-        }
-        const categories = req.query.categories?.split(",") || [];
-        if (categories.length) {
-          query.category = { $in: categories };
+        if (!req.verifiedBody.url) {
+          return res.status(400).json({ message: "URL is required" });
         }
-        const deliveryOptions = req.query.delivery?.split(",") || [];
-        if (deliveryOptions.length) {
-          query.delivery = { $in: deliveryOptions };
-        }
-        const search = req.query.search;
-        if (search) {
-          const parts = search.split(".");
-          let regexPattern = "";
-          if (parts.length === 2) {
-            regexPattern = parts.map((part) => part.substr(0, part.length - 1) + ".{1}").join("\\.");
-          } else {
-            regexPattern = search.substr(0, search.length - 1) + ".{1}";
-          }
-          query.name = { $regex: regexPattern, $options: "i" };
-        }
-        const prices = req.query.prices?.split(",") || [];
-        if (prices.length) {
-          const priceConditions = prices.map((priceRange) => {
-            if (priceRange.startsWith("<")) {
-              return { price: { $lt: parseInt(priceRange.slice(1)) } };
-            }
-            if (priceRange.startsWith(">")) {
-              return { price: { $gt: parseInt(priceRange.slice(1)) } };
-            }
-            const [min, max] = priceRange.split("-").map(Number);
-            return { price: { $gte: min, $lte: max } };
+        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
           });
-          if (priceConditions.length) {
-            query.$or = priceConditions;
-          }
         }
-        if (req.query.filters) {
-          let escapeRegex = function(string) {
-            return string.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
-          };
-          try {
-            const filters = JSON.parse(req.query.filters);
-            filters.forEach((filter) => {
-              const { parameter, values, caseSensitive = false } = filter;
-              const conditions = values.map((value) => {
-                if (caseSensitive) {
-                  return {
-                    "information": {
-                      $elemMatch: {
-                        "name": parameter,
-                        "value": value
-                      }
-                    }
-                  };
-                } else {
-                  return {
-                    "information": {
-                      $elemMatch: {
-                        "name": parameter,
-                        "value": { $regex: `^${escapeRegex(value)}$`, $options: "i" }
-                      }
-                    }
-                  };
-                }
-              });
-              if (conditions.length > 0) {
-                if (query.$or) {
-                  if (!query.$and) {
-                    query.$and = [];
-                  }
-                  query.$and.push({ $or: query.$or });
-                  query.$and.push({ $or: conditions });
-                  delete query.$or;
-                } else {
-                  query.$or = conditions;
-                }
-              }
-            });
-          } catch (error) {
-            console.error("Error parsing filters:", error);
-          }
-        }
-        const options = {
-          skip: parseInt(req.query.skip) || 0,
-          limit: parseInt(req.query.limit) || 10,
-          sort: { createdAt: -1 }
-        };
-        const aggregationPipeline = [
-          { $match: query },
-          { $sort: options.sort },
-          { $skip: options.skip },
-          { $limit: options.limit },
-          {
-            $lookup: {
-              from: "leftovers",
-              let: { productId: "$_id", ingredientsIds: "$ingredients._id" },
-              pipeline: [
-                { $unwind: "$positions" },
-                {
-                  $match: {
-                    $expr: {
-                      $or: [
-                        { $eq: ["$positions._id", "$$productId"] },
-                        { $in: ["$positions._id", { $ifNull: ["$$ingredientsIds", []] }] }
-                      ]
-                    }
-                  }
-                },
-                {
-                  "$addFields": {
-                    "positions.quantity": {
-                      $cond: {
-                        if: { $eq: ["$type", "stock-in"] },
-                        then: "$positions.quantity",
-                        else: { $multiply: ["$positions.quantity", -1] }
-                      }
-                    }
-                  }
-                },
-                {
-                  "$project": {
-                    _id: "$positions._id",
-                    quantity: "$positions.quantity",
-                    name: "$positions.name"
-                  }
-                }
-              ],
-              as: "leftovers"
-            }
-          },
-          {
-            $addFields: {
-              ingredientsQuantities: {
-                $cond: {
-                  if: { $isArray: "$ingredients" },
-                  then: {
-                    $map: {
-                      input: "$ingredients",
-                      as: "ingredient",
-                      in: {
-                        $let: {
-                          vars: {
-                            ingredientId: "$$ingredient._id",
-                            ingredientQuantity: { $ifNull: ["$$ingredient.quantity", 0] }
-                          },
-                          in: {
-                            $divide: [
-                              {
-                                $sum: {
-                                  $map: {
-                                    input: "$leftovers",
-                                    as: "leftover",
-                                    in: {
-                                      $cond: {
-                                        if: { $eq: ["$$leftover._id", "$$ingredientId"] },
-                                        then: "$$leftover.quantity",
-                                        else: 0
-                                      }
-                                    }
-                                  }
-                                }
-                              },
-                              {
-                                $cond: {
-                                  if: { $eq: ["$$ingredientQuantity", 0] },
-                                  then: 1,
-                                  else: "$$ingredientQuantity"
-                                }
-                              }
-                            ]
-                          }
-                        }
-                      }
-                    }
-                  },
-                  else: []
-                }
-              }
-            }
-          },
-          // For owner
-          queryProcessorGlobals.getOwnerUserLookupStage(),
-          queryProcessorGlobals.getOwnerOrganizationLookupStage(),
-          queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
-          {
-            $set: {
-              available: {
-                $cond: {
-                  if: { $eq: ["$listing", "rent"] },
-                  then: "$quantity",
-                  else: {
-                    $cond: {
-                      if: { $gt: [{ $size: { $ifNull: ["$ingredients", []] } }, 0] },
-                      then: { $floor: { $min: "$ingredientsQuantities" } },
-                      else: { $sum: "$leftovers.quantity" }
-                    }
-                  }
-                }
-              }
-            }
-          },
-          { $unset: ["leftovers", "ingredientsQuantities"] }
-        ];
-        const products = await Product.aggregate(aggregationPipeline);
-        if (req.query.count) {
-          const count = products.length;
-          return res.status(200).json({ count });
-        }
-        res.status(200).json(products);
-      } catch (err) {
-        return res.status(500).json({ message: err.message });
+        next();
+      } catch (error) {
+        res.status(500).json({ message: error.message });
       }
-    };
-    const Update = async (req, res) => {
+    },
+    // Загрузка категории для проверки ABAC (для обновления и удаления)
+    async loadCategoryForUpdate(req, res, next) {
       try {
-        const { _id } = req.params;
-        console.log(req.body.ingredients);
-        const updatedProduct = await Product.findOneAndUpdate(
-          { _id },
-          {
-            name: req.body.name,
-            status: req.body.status,
-            listing: req.body.listing,
-            description: req.body.description,
-            price: req.body.price,
-            price_currency: req.body.price_currency,
-            price_cost: req.body.price_cost,
-            unit: req.body.unit,
-            category: req.body.category,
-            images: req.body.images,
-            information: req.body.information,
-            localization: req.body.localization,
-            quantity: req.body.quantity,
-            quantityDiscount: req.body.quantityDiscount,
-            ingredients: req.body.ingredients
-          },
-          { new: true }
-        );
-        if (!updatedProduct) {
-          return res.status(404).send({ message: "Something wrong when updating product." });
+        const categoryId = req.verifiedBody._id;
+        if (!categoryId) {
+          return res.status(400).json({ message: "Category ID is required" });
         }
-        res.status(200).send(updatedProduct);
-      } catch (err) {
-        res.status(500).send({ message: err.message });
-      }
-    };
-    const Delete = async (req, res) => {
-      try {
-        const { _id } = req.params;
-        const deletedProduct = await Product.findOneAndDelete({ _id });
-        if (!deletedProduct) {
-          return res.status(404).send({ message: "Product not found for deletion." });
+        const category = await db.category.findById(categoryId).lean();
+        if (!category) {
+          return res.status(404).json({ message: "Category not found" });
         }
-        res.status(200).send(deletedProduct);
-      } catch (err) {
-        res.status(500).send({ message: err.message });
+        req.currentResource = category;
+        next();
+      } catch (error) {
+        res.status(500).json({ message: error.message });
       }
-    };
-    const getProductRecommendation = async (req, res) => {
-      const { mood } = req.body;
+    },
+    // Загрузка категории по URL для удаления
+    async loadCategoryForDelete(req, res, next) {
       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 url = req.verifiedBody.url;
+        if (!url) {
+          return res.status(400).json({ message: "Category URL is required" });
         }
-        const productsList = products.map((p) => {
-          const info = p.information || [];
-          const value0 = info[0] ? info[0].value : "";
-          const value1 = info[1] ? `(${info[1].value}%)` : "";
-          const value2 = info[2] ? `(${info[2].value})` : "";
-          return `${p._id}: ${p.name} (${value0}) ${value1} ${value2}`;
-        }).join(", ");
-        const prompt = `
-        1. When asked how the client wants to feel, they responded "${mood}". 
-        2. Here is a list of products in our store: ${productsList}. 
-        3. Based on the information about the products (strain, THC content) and the user's desires, choose 1 product to recommend to the user.
-        4. The response should be in the language that the user used in mood (${mood}).
-        5. Please format your response as a JSON object '{"_id": "ID of the recommended product (it must correspond to one of the product IDs I sent)", "recommendationText": "Text explaining why this particular product"'. Write only the JSON object without any other text outside of it.
-      `;
-        console.log(prompt);
-        let response;
-        let result;
-        while (true) {
-          try {
-            response = await openai.chat.completions.create({
-              model: "gpt-3.5-turbo",
-              messages: [{ role: "user", content: prompt }]
-            });
-            console.log(response);
-            result = JSON.parse(response.choices[0].message.content);
-            break;
-          } catch (err) {
-            if (err instanceof SyntaxError) {
-              console.log("Received invalid JSON, retrying...");
-            } else {
-              console.log(err);
-              res.status(500).send({ message: err });
-              return;
-            }
-          }
+        const category = await db.category.findOne({ url }).lean();
+        if (!category) {
+          return res.status(404).json({ message: "Category not found" });
         }
-        console.log(result._id);
-        console.log(result.recommendationText);
-        const recommendedProduct = await Product.findById(result._id);
-        if (!recommendedProduct) {
-          console.log(`No product found with _id: ${result._id}`);
-          return res.status(404).send({ message: "Recommended product not found." });
-        }
-        res.status(200).json({ product: recommendedProduct, recommendationText: result.recommendationText });
-      } catch (err) {
-        console.log(err);
-        res.status(500).send({ message: err });
+        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$2(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 leftoversRoutes = function(app, db) {
+  const controller = controllerFactory$1(db);
+  app.get("/leftovers", controller.read);
+  app.get("/leftovers/:_id", controller.get);
+  app.post("/leftovers/:_id", controller.update);
+  app.post("/leftovers", controller.create);
+  app.delete("/leftovers/:_id", controller.delete);
+};
+const 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);
+};
+class CRUDCore {
+  constructor(crud) {
+    this.crud = crud;
+    this.verifiers = {};
+    this.hooks = {};
+    this.aggregateExtensions = {};
+    this.cacheOptions = {
+      ttl: 300,
+      // 5 минут по умолчанию
+      tags: [crud.modelName],
+      enabled: true
     };
-    const getProductsPopular = (req, res) => {
-      Product.find({
-        status: "published",
-        views: { $gt: 10 }
-      }).populate("modifications").limit(10).exec((err, products) => {
-        if (err) {
-          return res.status(500).send({ message: err });
-        }
-        if (!products) {
-          return res.status(404).send({ message: "Products not found." });
-        }
-        res.status(200).send(products);
-      });
+    this.auth = {
+      read: false,
+      // Публичный доступ к чтению
+      create: true,
+      // Требует авторизацию
+      update: true,
+      // Требует авторизацию
+      delete: true
+      // Требует авторизацию
     };
-    return {
-      Create,
-      Read,
-      Update,
-      Delete,
-      getProductsPopular,
-      getProductRecommendation
+    this.options = {
+      enableEvents: true,
+      enableAudit: false,
+      enableMetrics: false,
+      strictMode: false,
+      serviceKey: process.env.SERVICE_KEY
     };
-  };
-  products_controller = controllerFactory;
-  return products_controller;
-}
-var products_routes;
-var hasRequiredProducts_routes;
-function requireProducts_routes() {
-  if (hasRequiredProducts_routes) return products_routes;
-  hasRequiredProducts_routes = 1;
-  const controllerFactory = requireProducts_controller();
-  products_routes = function(app, db, allowedOrigins) {
-    const controller = controllerFactory(db);
-    app.post(
-      "/api/products/create",
-      controller.Create
-    );
-    app.get(
-      "/api/products/read",
-      controller.Read
-    );
-    app.post(
-      "/api/products/:_id",
-      controller.Update
-    );
-    app.delete(
-      "/api/products/:_id",
-      controller.Delete
-    );
-    app.post(
-      "/api/product/recommended",
-      controller.getProductRecommendation
-    );
-  };
-  return products_routes;
+  }
+  // Инициализация с опциями
+  init(options = {}) {
+    if (options.auth !== void 0) {
+      if (options.auth === false) {
+        this.auth = false;
+      } else if (options.auth === true) {
+        this.auth = {
+          read: false,
+          create: true,
+          update: true,
+          delete: true
+        };
+      } else if (typeof options.auth === "object") {
+        this.auth = {
+          read: false,
+          create: true,
+          update: true,
+          delete: true,
+          ...options.auth
+        };
+      }
+    }
+    if (options.cache !== void 0) {
+      if (options.cache === false) {
+        this.cacheOptions.enabled = false;
+      } else if (typeof options.cache === "object") {
+        this.setCacheOptions(options.cache);
+      }
+    }
+    if (options.events !== void 0) {
+      if (options.events === false) {
+        this.options.enableEvents = false;
+      } else if (typeof options.events === "object") {
+        Object.assign(this.options, options.events);
+      }
+    }
+    if (options.verifiers) this.initVerifiers(options.verifiers);
+    if (options.hooks) this.initHooks(options.hooks);
+    if (options.middlewares) this.initMiddlewares(options.middlewares);
+    if (options.aggregateExtensions) this.initAggregateExtensions(options.aggregateExtensions);
+    if (options.abac) this.initABAC(options.abac, options.policies, options.fieldsPolicies);
+    if (options.serviceKey !== void 0) {
+      this.options.serviceKey = options.serviceKey;
+    }
+    this.crud.events.init(this.options);
+    if (options.abac) {
+      this.crud.policies.init(options.abac, options.policies, options.fieldsPolicies);
+    }
+  }
+  // Управление auth
+  setAuth(action, required) {
+    if (this.auth === false) {
+      this.auth = {};
+    }
+    this.auth[action] = required;
+  }
+  getAuth(action) {
+    if (this.auth === false) return false;
+    return this.auth[action] ?? true;
+  }
+  isAuthEnabled() {
+    return this.auth !== false;
+  }
+  // Управление верификаторами
+  setVerifier(action, verifier) {
+    this.verifiers[action] = verifier;
+  }
+  getVerifier(action) {
+    return this.verifiers[action];
+  }
+  initVerifiers(verifiers) {
+    Object.entries(verifiers).forEach(([action, verifier]) => {
+      this.setVerifier(action, verifier);
+    });
+  }
+  // Управление хуками
+  addHook(name, handler) {
+    this.hooks[name] = handler;
+  }
+  getHook(name) {
+    return this.hooks[name];
+  }
+  async executeHook(name, ...args) {
+    const hook = this.getHook(name);
+    if (hook) {
+      return await hook(...args);
+    }
+  }
+  initHooks(hooks) {
+    Object.entries(hooks).forEach(([name, handler]) => {
+      this.addHook(name, handler);
+    });
+  }
+  // Управление расширениями агрегации
+  addAggregateExtension(phase, extension) {
+    this.aggregateExtensions[phase] = extension;
+  }
+  getAggregateExtensions() {
+    return this.aggregateExtensions;
+  }
+  initAggregateExtensions(extensions) {
+    Object.entries(extensions).forEach(([phase, extension]) => {
+      this.addAggregateExtension(phase, extension);
+    });
+  }
+  // Управление middleware (делегирует в controller)
+  initMiddlewares(middlewares) {
+    Object.entries(middlewares).forEach(([phase, actions]) => {
+      if (typeof actions === "object") {
+        Object.entries(actions).forEach(([action, mws]) => {
+          const middlewareArray = Array.isArray(mws) ? mws : [mws];
+          middlewareArray.forEach((mw) => {
+            this.crud.controller.addMiddleware(phase, action, mw);
+          });
+        });
+      }
+    });
+  }
+  // Управление ABAC (делегирует в policies)
+  initABAC(abac, policies = {}, fieldsPolicies = null) {
+    if (fieldsPolicies && typeof fieldsPolicies === "function" && abac) {
+      abac.registerFieldsPolicy(this.crud.modelName, fieldsPolicies);
+    }
+  }
+  // Управление кешем
+  getCacheOptions() {
+    return { ...this.cacheOptions };
+  }
+  setCacheOptions(options) {
+    Object.assign(this.cacheOptions, options);
+    if (!this.cacheOptions.tags.includes(this.crud.modelName)) {
+      this.cacheOptions.tags.unshift(this.crud.modelName);
+    }
+  }
+  // Получение опций
+  getOptions() {
+    return { ...this.options };
+  }
+  setOption(key, value) {
+    this.options[key] = value;
+  }
+  // Проверка включенности функций
+  isEventsEnabled() {
+    return this.options.enableEvents;
+  }
+  isCacheEnabled() {
+    return this.cacheOptions.enabled && this.crud.cache !== null;
+  }
+  isAuditEnabled() {
+    return this.options.enableAudit;
+  }
+  isMetricsEnabled() {
+    return this.options.enableMetrics;
+  }
 }
-var categories_routes = { exports: {} };
-var categories_controller;
-var hasRequiredCategories_controller;
-function requireCategories_controller() {
-  if (hasRequiredCategories_controller) return categories_controller;
-  hasRequiredCategories_controller = 1;
-  const globalsQuery = queryProcessor.requireQueryProcessor();
-  const Logger = globals_logger.requireGlobals_logger();
-  const Cache = globals_cache.requireGlobals_cache();
-  const controllerFactory = (db) => {
-    const Category = db.category;
-    const logger = new Logger(db);
-    const cache = new Cache();
-    return {
-      async read(req, res) {
-        try {
-          const {
-            parent,
-            url,
-            search,
-            sortParam,
-            sortOrder,
-            skip,
-            limit,
-            excludeChildren,
-            rootOnly,
-            type
-          } = req.verifiedQuery;
-          const cacheKey = JSON.stringify(req.verifiedQuery);
-          let cachedResult = await cache.get(cacheKey);
-          if (cachedResult) {
-            return res.status(200).json(cachedResult);
-          }
-          const matchStage = {
-            ...req.query.status && { status: req.query.status },
-            ...url && { url },
-            ...search && { name: { $regex: search, $options: "i" } },
-            ...parent ? { parent: new db.mongoose.Types.ObjectId(parent) } : {},
-            ...rootOnly === "true" && !search ? { parent: null } : {}
-          };
-          if (type === "platform") {
-            matchStage["owner.type"] = "platform";
-          } else if (type === "organization" && req.query.organizationId) {
-            matchStage["owner.type"] = "organization";
-            matchStage["owner.target"] = new db.mongoose.Types.ObjectId(req.query.organizationId);
-          }
-          if (search) {
-            excludeChildren = "true";
-          }
-          const pipeline = [
-            { $match: matchStage },
-            globalsQuery.getCreatorUserLookupStage(),
-            globalsQuery.getCreatorOrganizationLookupStage(),
-            // For owner
-            globalsQuery.getOwnerUserLookupStage(),
-            globalsQuery.getOwnerOrganizationLookupStage(),
-            globalsQuery.getAddFieldsCreatorOwnerStage(),
-            { $sort: { [sortParam]: sortOrder === "asc" ? 1 : -1 } },
-            { $skip: Number(skip) },
-            { $limit: Number(limit) },
-            globalsQuery.removeTempPropeties()
-          ];
-          if (excludeChildren !== "true") {
-            pipeline.push({
-              $graphLookup: {
-                from: "categories",
-                startWith: "$_id",
-                connectFromField: "_id",
-                connectToField: "parent",
-                as: "allDescendants",
-                maxDepth: 10
-              }
-            });
+class CRUDController {
+  constructor(crud) {
+    this.crud = crud;
+    this.routes = /* @__PURE__ */ new Map();
+    this.middlewares = {
+      before: {},
+      after: {}
+    };
+    this.jwt = middlewareFactory(crud.db);
+  }
+  // Добавление middleware
+  addMiddleware(phase, action, middleware) {
+    if (!["before", "after"].includes(phase)) {
+      throw new Error(`Invalid middleware phase: ${phase}`);
+    }
+    if (!this.middlewares[phase][action]) {
+      this.middlewares[phase][action] = [];
+    }
+    this.middlewares[phase][action].push(middleware);
+  }
+  // Получение middleware для действия
+  getMiddlewares(phase, action) {
+    return this.middlewares[phase][action] || [];
+  }
+  // Регистрация роута
+  registerRoute(method, path, actionName) {
+    const fullPath = `${this.crud.basePath}${path}`;
+    const middlewareStack = [];
+    if (this.crud.core.isAuthEnabled()) {
+      const authRequired = this.crud.core.getAuth(actionName);
+      middlewareStack.push(this.jwt.verifyToken(!authRequired));
+    }
+    const verifierMiddleware = this._createVerifierMiddleware(method, actionName);
+    if (verifierMiddleware) {
+      middlewareStack.push(verifierMiddleware);
+    }
+    middlewareStack.push(...this.getMiddlewares("before", actionName));
+    const abacMiddleware = this.crud.policies.getPoliciesMiddleware(actionName);
+    if (abacMiddleware) {
+      middlewareStack.push(abacMiddleware);
+    }
+    if (["create", "update"].includes(actionName)) {
+      const fieldsMiddleware = this.crud.policies.getFieldsMiddleware(actionName);
+      if (fieldsMiddleware) {
+        middlewareStack.push(fieldsMiddleware);
+      }
+    }
+    const handler = this._createHandler(actionName);
+    const wrappedHandler = this._wrapHandler(handler, actionName);
+    this.crud.app[method](fullPath, ...middlewareStack, wrappedHandler);
+    this.routes.set(`${method.toUpperCase()} ${fullPath}`, {
+      method,
+      path: fullPath,
+      actionName,
+      middlewareStack
+    });
+    return this;
+  }
+  // Регистрация кастомного роута
+  registerCustomRoute(method, path, actionName, handler) {
+    this.crud.service.registerCustomHandler(actionName, handler);
+    return this.registerRoute(method, path, actionName);
+  }
+  // Создание handler для стандартных CRUD операций
+  _createHandler(actionName) {
+    switch (actionName) {
+      case "create":
+        return async (req, res) => {
+          try {
+            const data = req.verified || req.body;
+            const context = this._buildContext(req);
+            const created = await this.crud.service.create(data, context);
+            res.status(201).json(created);
+          } catch (error) {
+            this._handleError(error, res);
           }
-          const results = await Category.aggregate(pipeline);
-          let response;
-          if (excludeChildren === "true") {
-            response = results;
-          } else {
-            const allCategories = [];
-            results.forEach((doc) => {
-              const category = { ...doc };
-              delete category.allDescendants;
-              allCategories.push(category);
-              if (doc.allDescendants && doc.allDescendants.length > 0) {
-                allCategories.push(...doc.allDescendants);
-              }
-            });
-            const uniqueCategories = Array.from(
-              new Map(allCategories.map((item) => [item._id.toString(), item])).values()
-            );
-            const tree = buildAdjacencyTree(uniqueCategories, sortParam, sortOrder);
-            if (rootOnly === "true") {
-              response = tree;
-            } else {
-              const requestedCategoryIds = results.map((r) => r._id.toString());
-              response = tree.filter(
-                (category) => requestedCategoryIds.includes(category._id.toString())
-              );
+        };
+      case "read":
+        return async (req, res) => {
+          try {
+            const query = req.verified || req.query;
+            const context = this._buildContext(req);
+            let data = await this.crud.service.read(query, context);
+            if (this.crud.policies.hasAbac()) {
+              data = await this.crud.policies.filterFieldsForRead(req, data);
             }
+            res.json(data);
+          } catch (error) {
+            this._handleError(error, res);
           }
-          const tags = ["categories"];
-          if (type === "organization" && req.query.organizationId) {
-            tags.push(`organization_${req.query.organizationId}`);
-          }
-          for (const cat of response) {
-            if (cat._id) {
-              tags.push(`category_${cat._id}`);
+        };
+      case "update":
+        return async (req, res) => {
+          try {
+            const data = req.verified || req.body;
+            const { _id, ...updateData } = data;
+            if (!_id) {
+              return res.status(400).json({ error: "ID_REQUIRED" });
             }
+            const context = this._buildContext(req);
+            const updated = await this.crud.service.update(_id, updateData, context);
+            res.json(updated);
+          } catch (error) {
+            this._handleError(error, res);
           }
-          await cache.setWithTags(cacheKey, response, tags);
-          res.status(200).json(response);
-        } catch (err) {
-          logger.error(`Error reading categories: ${err.message}`);
-          res.status(500).json({ message: err.message });
-        }
-      },
-      async create(req, res) {
-        try {
-          const categoryData = req.verifiedBody;
-          if (!categoryData.creator && req.userId) {
-            categoryData.creator = {
-              type: "user",
-              target: req.userId
-            };
-          }
-          if (!categoryData.owner) {
-            if (req.query.organizationId) {
-              categoryData.owner = {
-                type: "organization",
-                target: req.query.organizationId
-              };
-            } else {
-              categoryData.owner = {
-                type: "platform",
-                target: null
-              };
+        };
+      case "delete":
+        return async (req, res) => {
+          try {
+            const data = req.verified || req.query || req.body;
+            const { _id } = data;
+            if (!_id) {
+              return res.status(400).json({ error: "ID_REQUIRED" });
             }
+            const context = this._buildContext(req);
+            await this.crud.service.delete(_id, context);
+            res.status(204).send();
+          } catch (error) {
+            this._handleError(error, res);
           }
-          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());
+        };
+      default:
+        return async (req, res) => {
+          try {
+            const customHandler = this.crud.service.getCustomHandler(actionName);
+            if (!customHandler) {
+              return res.status(404).json({ error: "ACTION_NOT_FOUND" });
             }
-          });
-          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;
+            await customHandler.call(this.crud, req, res);
+          } catch (error) {
+            this._handleError(error, res);
           }
-          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}`);
+        };
+    }
+  }
+  // Создание контекста из request
+  _buildContext(req) {
+    return {
+      userId: req.userId,
+      user: req.user,
+      organizationId: req.organizationId,
+      roles: req.roles || [],
+      permissions: req.permissions || [],
+      abacContext: req.abacContext || {},
+      ip: req.ip,
+      userAgent: req.get("user-agent"),
+      isServiceRequest: req.isServiceRequest || false,
+      ...req.context
+      // Дополнительный контекст
+    };
+  }
+  // Обработка ошибок
+  _handleError(error, res) {
+    if (res.headersSent) return;
+    const statusCode = error.statusCode || error.code === "NOT_FOUND" ? 404 : 500;
+    const message = error.message || "Internal Server Error";
+    res.status(statusCode).json({
+      error: message,
+      code: error.code
+    });
+  }
+  // Создание middleware для верификации
+  _createVerifierMiddleware(method, actionName) {
+    const verifier = this.crud.core.getVerifier(actionName);
+    if (!verifier) return null;
+    const verifyTarget = this._getVerificationTarget(method, actionName);
+    if (!verifyTarget) return null;
+    return (req, res, next) => {
+      const data = verifyTarget === "query" ? req.query : req.body;
+      const result = verifier.verify ? verifier.verify(data) : verifier.validate(data);
+      if (!result.isValid) {
+        return res.status(400).json({
+          error: "VALIDATION_ERROR",
+          field: verifyTarget,
+          errors: result.verificationErrors || result.errors
+        });
+      }
+      console.log("verified result", result);
+      req.verified = result.verifiedData || data;
+      next();
+    };
+  }
+  // Определение цели верификации
+  _getVerificationTarget(method, actionName) {
+    if (["create", "update"].includes(actionName)) {
+      return "body";
+    }
+    if (["read", "delete"].includes(actionName)) {
+      return "query";
+    }
+    if (["post", "put", "patch"].includes(method)) {
+      return "body";
+    }
+    if (["get", "delete"].includes(method)) {
+      return "query";
+    }
+    return null;
+  }
+  // Обертка handler для after middleware
+  _wrapHandler(handler, actionName) {
+    return async (req, res, next) => {
+      try {
+        await handler(req, res, next);
+        if (!res.headersSent) {
+          const afterMiddlewares = this.getMiddlewares("after", actionName);
+          for (const mw of afterMiddlewares) {
+            await new Promise((resolve, reject) => {
+              mw(req, res, (err) => err ? reject(err) : resolve());
+            });
           }
-          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" });
         }
+      } catch (error) {
+        next(error);
       }
     };
-    function buildAdjacencyTree(categories, sortParam, sortOrder) {
-      const categoryMap = /* @__PURE__ */ new Map();
-      categories.forEach((category) => {
-        categoryMap.set(category._id.toString(), {
-          ...category,
-          children: []
+  }
+  // Получение информации о роутах
+  getRoutes() {
+    return Array.from(this.routes.entries()).map(([key, value]) => ({
+      key,
+      ...value
+    }));
+  }
+  // Удаление роута
+  removeRoute(method, path) {
+    const key = `${method.toUpperCase()} ${this.crud.basePath}${path}`;
+    return this.routes.delete(key);
+  }
+  // Проверка существования роута
+  hasRoute(method, path) {
+    const key = `${method.toUpperCase()} ${this.crud.basePath}${path}`;
+    return this.routes.has(key);
+  }
+}
+class CRUDService {
+  constructor(crud) {
+    this.crud = crud;
+    this.customHandlers = /* @__PURE__ */ new Map();
+  }
+  // Регистрация кастомного handler
+  registerCustomHandler(name, handler) {
+    this.customHandlers.set(name, handler);
+  }
+  // CREATE операция
+  async create(data, context = {}) {
+    try {
+      const hookData = await this.crud.core.executeHook("beforeCreate", data, context);
+      const finalData = hookData || data;
+      const created = await this.crud.model.create(finalData);
+      if (this.crud.core.isCacheEnabled()) {
+        await this.invalidateCache("create", created);
+      }
+      if (this.crud.core.isEventsEnabled()) {
+        await this.crud.events.emit("created", {
+          document: created,
+          user: context.userId
         });
-      });
-      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;
+      }
+      await this.crud.core.executeHook("afterCreate", created, context);
+      return created;
+    } catch (error) {
+      console.log(error);
+      await this.crud.events.logError("create", error);
+      throw error;
+    }
+  }
+  // READ операция
+  async read(query = {}, context = {}) {
+    try {
+      await this.crud.core.executeHook("beforeRead", query, context);
+      let data = null;
+      let cacheKey = null;
+      if (this.crud.core.isCacheEnabled()) {
+        cacheKey = this.generateCacheKey("read", query);
+        data = await this.crud.cache.get(cacheKey);
+      }
+      if (!data) {
+        const pipeline = await this.buildAggregationPipeline(query, context);
+        data = await this.crud.model.aggregate(pipeline).exec();
+        if (this.crud.core.isCacheEnabled() && cacheKey) {
+          const cacheOptions = this.crud.core.getCacheOptions();
+          await this.crud.cache.setWithTags(
+            cacheKey,
+            data,
+            [...cacheOptions.tags, `${this.crud.modelName}_list`],
+            cacheOptions.ttl
+          );
         }
-        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);
-          }
+      }
+      if (this.crud.core.isEventsEnabled()) {
+        await this.crud.events.emitRead(query, data, context.userId);
+      }
+      const hookResult = await this.crud.core.executeHook("afterRead", data, context);
+      return hookResult || data;
+    } catch (error) {
+      console.log(error);
+      await this.crud.events.logError("read", error);
+      throw error;
+    }
+  }
+  // UPDATE операция
+  async update(id, updateData, context = {}) {
+    try {
+      const current = await this.crud.model.findById(id);
+      if (!current) {
+        const error = new Error("NOT_FOUND");
+        error.code = "NOT_FOUND";
+        error.statusCode = 404;
+        throw error;
+      }
+      const hookData = await this.crud.core.executeHook("beforeUpdate", updateData, context, current);
+      const finalData = hookData || updateData;
+      const updated = await this.crud.model.findByIdAndUpdate(
+        id,
+        finalData,
+        { new: true, runValidators: true }
+      );
+      if (this.crud.core.isCacheEnabled()) {
+        await this.invalidateCache("update", updated);
+      }
+      if (this.crud.core.isEventsEnabled()) {
+        await this.crud.events.emit("updated", {
+          document: updated,
+          previousDocument: current,
+          user: context.userId
         });
-        nodes.forEach((node) => {
-          if (node.children && node.children.length > 0) {
-            sortCategories(node.children);
-          }
+      }
+      await this.crud.core.executeHook("afterUpdate", updated, context, current);
+      return updated;
+    } catch (error) {
+      await this.crud.events.logError("update", error);
+      throw error;
+    }
+  }
+  // DELETE операция
+  async delete(id, context = {}) {
+    try {
+      const document = await this.crud.model.findById(id);
+      if (!document) {
+        const error = new Error("NOT_FOUND");
+        error.code = "NOT_FOUND";
+        error.statusCode = 404;
+        throw error;
+      }
+      await this.crud.core.executeHook("beforeDelete", document, context);
+      await this.crud.model.findByIdAndDelete(id);
+      if (this.crud.core.isCacheEnabled()) {
+        await this.invalidateCache("delete", document);
+      }
+      if (this.crud.core.isEventsEnabled()) {
+        await this.crud.events.emit("deleted", {
+          document,
+          user: context.userId
         });
-        return nodes;
       }
-      return sortCategories(rootCategories);
+      await this.crud.core.executeHook("afterDelete", document, context);
+      return document;
+    } catch (error) {
+      await this.crud.events.logError("delete", error);
+      throw error;
     }
-  };
-  categories_controller = controllerFactory;
-  return categories_controller;
-}
-var categories_verifier;
-var hasRequiredCategories_verifier;
-function requireCategories_verifier() {
-  if (hasRequiredCategories_verifier) return categories_verifier;
-  hasRequiredCategories_verifier = 1;
-  const Verifier = globals_verifier.requireGlobals_verifier();
-  const Validator = globals_verifier.requireGlobals_validator();
-  categories_verifier = function(db) {
-    const queryValidatorConfig = {
-      parent: { allowed: true, validator: Validator.schema().string() },
-      url: { allowed: true, validator: Validator.schema().string() },
-      search: { allowed: true, validator: Validator.schema().string() },
-      sortParam: { allowed: true, validator: Validator.schema().string().oneOf(["order", "name", "createdAt", "updatedAt"]), default: "order" },
-      sortOrder: { allowed: true, validator: Validator.schema().string().oneOf(["asc", "desc"]), default: "asc" },
-      skip: { allowed: true, validator: Validator.schema().number().integer().min(0), default: 0 },
-      limit: { allowed: true, validator: Validator.schema().number().integer().min(1).max(100), default: 10 },
-      excludeChildren: { allowed: true, validator: Validator.schema().string().oneOf(["true", "false"]), default: "true" },
-      rootOnly: { allowed: true, validator: Validator.schema().string().oneOf(["true", "false"]), default: "false" },
-      status: { allowed: true, validator: Validator.schema().string().oneOf(["draft", "internal", "published", "removed"]) },
-      type: { allowed: true, validator: Validator.schema().string().oneOf(["platform", "organization", "all"]), default: "all" },
-      organizationId: { allowed: true, validator: Validator.schema().string() }
-    };
-    const bodyValidatorConfig = {
-      _id: { allowed: true, validator: Validator.schema().string() },
-      name: { allowed: true, validator: Validator.schema().string().required() },
-      description: { allowed: true, validator: Validator.schema().string() },
-      photo: { allowed: true, validator: Validator.schema().string() },
-      status: { allowed: true, validator: Validator.schema().string().oneOf(["draft", "internal", "published", "removed"]), default: "draft" },
-      url: { allowed: true, validator: Validator.schema().string().required() },
-      parent: { allowed: true, validator: Validator.schema().oneOfTypes(["string", "null"]) },
-      localization: { allowed: true },
-      filters: { allowed: true },
-      owner: { allowed: true, validator: Validator.schema().object({
-        type: Validator.schema().string().oneOf(["platform", "organization"]).required(),
-        target: Validator.schema().string()
-      }) },
-      creator: { allowed: true, validator: Validator.schema().object({
-        type: Validator.schema().string().oneOf(["user", "organization"]).required(),
-        target: Validator.schema().string()
-      }) },
-      children: { allowed: true, validator: Validator.schema().array() },
-      order: { allowed: true, validator: Validator.schema().number() }
-    };
-    const orderBodyValidatorConfig = {
-      categories: {
-        allowed: true,
-        validator: Validator.schema().array().required(),
-        default: []
+  }
+  // Получение кастомного handler
+  getCustomHandler(name) {
+    return this.customHandlers.get(name);
+  }
+  // Построение aggregation pipeline
+  async buildAggregationPipeline(query, context) {
+    const stages = [];
+    const extensions = this.crud.core.getAggregateExtensions();
+    if (extensions.before) {
+      stages.push(...await extensions.before(query, context));
+    }
+    stages.push(...queryProcessorGlobals.getBasicOptions(query));
+    if (extensions.middle) {
+      stages.push(...await extensions.middle(query, context));
+    }
+    stages.push(
+      queryProcessorGlobals.getCreatorUserLookupStage(),
+      queryProcessorGlobals.getCreatorOrganizationLookupStage(),
+      queryProcessorGlobals.getOwnerUserLookupStage(),
+      queryProcessorGlobals.getOwnerOrganizationLookupStage(),
+      queryProcessorGlobals.getAddFieldsCreatorOwnerStage()
+    );
+    if (extensions.beforePagination) {
+      stages.push(...await extensions.beforePagination(query, context));
+    }
+    stages.push(
+      ...queryProcessorGlobals.getSortingOptions(query.sortParam, query.sortOrder),
+      ...queryProcessorGlobals.getPaginationOptions(query.skip, query.limit),
+      queryProcessorGlobals.removeTempPropeties()
+    );
+    if (extensions.after) {
+      stages.push(...await extensions.after(query, context));
+    }
+    return stages;
+  }
+  // Управление кешем
+  generateCacheKey(operation, data) {
+    const prefix = `${this.crud.modelName}:${operation}`;
+    if (operation === "read") {
+      return `${prefix}:${JSON.stringify(this._normalizeQuery(data))}`;
+    }
+    return `${prefix}:${Date.now()}`;
+  }
+  _normalizeQuery(query) {
+    const normalized = {};
+    const keys = Object.keys(query).sort();
+    for (const key of keys) {
+      if (query[key] !== void 0 && query[key] !== null && query[key] !== "") {
+        normalized[key] = query[key];
       }
-    };
-    const deleteBodyValidatorConfig = {
-      url: {
-        allowed: true,
-        validator: Validator.schema().string().required()
+    }
+    return normalized;
+  }
+  async invalidateCache(operation, document) {
+    const cacheOptions = this.crud.core.getCacheOptions();
+    const tags = [...cacheOptions.tags];
+    if (["create", "update", "delete"].includes(operation)) {
+      tags.push(`${this.crud.modelName}_list`);
+      if (document && document._id) {
+        tags.push(`${this.crud.modelName}_${document._id}`);
       }
+    }
+    for (const tag of tags) {
+      await this.crud.cache.delByTags([tag]);
+    }
+  }
+}
+class CRUDPolicies {
+  constructor(crud) {
+    this.crud = crud;
+    this.abac = null;
+    this.policyOptions = {};
+    this.defaultPolicies = {};
+  }
+  // Инициализация с ABAC
+  init(abac, policies = {}, fieldPolicies = null) {
+    this.abac = abac;
+    this.defaultPolicies = policies;
+  }
+  // Установка опций для конкретного действия
+  setOptions(action, options) {
+    this.policyOptions[action] = {
+      enabled: options.enabled !== false,
+      policies: options.policies || [],
+      customPolicies: options.customPolicies || {},
+      skipDefaultPolicies: options.skipDefaultPolicies || false,
+      ...options
     };
-    const queryVerifier = new Verifier(queryValidatorConfig);
-    const bodyVerifier = new Verifier(bodyValidatorConfig);
-    const orderBodyVerifier = new Verifier(orderBodyValidatorConfig);
-    const deleteBodyVerifier = new Verifier(deleteBodyValidatorConfig);
-    return {
-      // Верификация параметров запроса
-      verifyQuery(req, res, next) {
-        const verification = queryVerifier.verify(req.query);
-        if (!verification.isValid) {
-          return res.status(400).json({
-            errors: verification.verificationErrors,
-            message: "Invalid query parameters"
-          });
+  }
+  // Получение опций для действия
+  getOptions(action) {
+    return this.policyOptions[action] || this.defaultPolicies[action] || {};
+  }
+  // Получение ABAC middleware для действия
+  getPoliciesMiddleware(action) {
+    if (!this.abac) return null;
+    const options = this.getOptions(action);
+    if (options.enabled === false) {
+      return null;
+    }
+    if (options.policies && options.policies.length > 0) {
+      return this.abac.policyMiddleware(
+        options.policies,
+        options.customPolicies || {},
+        {
+          resource: this.crud.modelName,
+          action,
+          skipDefaultPolicies: options.skipDefaultPolicies
         }
-        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"
-          });
+      );
+    }
+    return this.abac.middleware(this.crud.modelName, action, options);
+  }
+  // Получение middleware для проверки доступа к полям
+  getFieldsMiddleware(action) {
+    if (!this.abac) return null;
+    return async (req, res, next) => {
+      try {
+        const data = req.verified || req.body;
+        const context = {
+          user: req.userId,
+          resource: this.crud.modelName,
+          action,
+          req,
+          data: {
+            ...req.body,
+            ...req.query,
+            params: req.params
+          },
+          params: req.params
+        };
+        if (req.skipFieldPolicies) {
+          console.log("Skipping field policies for admin/moderator");
+          req.verified = data;
+          return next();
         }
-        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"
+        if (action === "update" && data._id) {
+          try {
+            const current = await this.crud.model.findById(data._id);
+            if (current) {
+              context.currentResource = current;
+            }
+          } catch (err) {
+          }
+        }
+        const fieldsResult = await this.abac.checkFields(
+          context,
+          data,
+          action
+        );
+        if (fieldsResult.denied && fieldsResult.denied.length > 0) {
+          return res.status(403).json({
+            error: "FIELD_ACCESS_DENIED",
+            deniedFields: fieldsResult.denied.map((d) => d.path)
           });
         }
-        req.verifiedBody = verification.verifiedData;
-        next();
-      },
-      // Верификация тела запроса для удаления категории
-      verifyDeleteBody(req, res, next) {
-        const verification = deleteBodyVerifier.verify(req.body);
-        if (!verification.isValid) {
+        if (fieldsResult.errors && fieldsResult.errors.length > 0) {
           return res.status(400).json({
-            errors: verification.verificationErrors,
-            message: "Invalid request data"
+            error: "FIELD_VALIDATION_ERROR",
+            fields: fieldsResult.errors
           });
         }
-        req.verifiedBody = verification.verifiedData;
+        req.verified = fieldsResult.transformed || fieldsResult.allowed;
         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 });
-        }
+      } catch (error) {
+        next(error);
       }
     };
-  };
-  return categories_verifier;
-}
-var hasRequiredCategories_routes;
-function requireCategories_routes() {
-  if (hasRequiredCategories_routes) return categories_routes.exports;
-  hasRequiredCategories_routes = 1;
-  const controllerFactory = requireCategories_controller();
-  const verifierFactory = requireCategories_verifier();
-  const jwtFactory = authJwt.requireAuthJwt();
-  const { getInstance } = globals_abac.requireGlobals_abac();
-  categories_routes.exports = function(app, db) {
-    const jwt = jwtFactory(db);
-    const verifier = verifierFactory(db);
-    const abac = getInstance(db);
-    const controller = controllerFactory(db);
-    app.get(
-      "/api/categories",
-      jwt.verifyToken(true),
-      verifier.verifyQuery,
-      controller.read
-    );
-    app.post(
-      "/api/categories/create",
-      jwt.verifyToken(),
-      verifier.verifyBody,
-      verifier.checkCategoryExistOrNot,
-      abac.middleware("category", "create"),
-      controller.create
-    );
-    app.post(
-      "/api/categories/update",
-      jwt.verifyToken(),
-      verifier.verifyBody,
-      verifier.loadCategoryForUpdate,
-      abac.middleware("category", "edit"),
-      controller.update
-    );
-    app.post(
-      "/api/categories/updateOrder",
-      jwt.verifyToken(),
-      verifier.verifyOrderBody,
-      abac.middleware("category", "edit"),
-      controller.updateOrder
-    );
-    app.post(
-      "/api/categories/delete",
-      jwt.verifyToken(),
-      verifier.verifyDeleteBody,
-      verifier.loadCategoryForDelete,
-      abac.middleware("category", "delete"),
-      controller.delete
-    );
-  };
-  categories_routes.exports.controllerFactory = controllerFactory;
-  return categories_routes.exports;
-}
-var leftovers_controller;
-var hasRequiredLeftovers_controller;
-function requireLeftovers_controller() {
-  if (hasRequiredLeftovers_controller) return leftovers_controller;
-  hasRequiredLeftovers_controller = 1;
-  const queryProcessorGlobals = queryProcessor.requireQueryProcessor();
-  const controllerFactory = (db) => {
-    const Leftover = db.leftover;
-    const read = async (req, res) => {
-      try {
-        let matchConditions = [];
-        const search = req.query.search;
-        if (search) {
-          const parts = search.split(".");
-          let regexPattern = "";
-          if (parts.length === 2) {
-            regexPattern = parts.map((part) => part.substr(0, part.length - 1) + ".{1}").join("\\.");
-          } else {
-            regexPattern = search.substr(0, search.length - 1) + ".{1}";
-          }
-          matchConditions.push({
-            $or: [
-              { "comment": { $regex: regexPattern, $options: "i" } },
-              { "positions.name": { $regex: regexPattern, $options: "i" } }
-            ]
-          });
-        }
-        const matchStage = matchConditions.length > 0 ? { $match: { $and: matchConditions } } : null;
-        let stages = [
-          ...queryProcessorGlobals.getBasicOptions(
-            req.query
-          ),
-          // For creator
-          queryProcessorGlobals.getCreatorUserLookupStage(),
-          queryProcessorGlobals.getCreatorOrganizationLookupStage(),
-          // For owner
-          queryProcessorGlobals.getOwnerUserLookupStage(),
-          queryProcessorGlobals.getOwnerOrganizationLookupStage(),
-          queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
-          ...matchStage != null ? [matchStage] : [],
-          // Pagination
-          ...queryProcessorGlobals.getSortingOptions(
-            req.query.sortParam,
-            req.query.sortOrder
-          ),
-          ...queryProcessorGlobals.getPaginationOptions(
-            req.query.skip,
-            req.query.limit
-          )
-        ];
-        const leftoveres = await Leftover.aggregate(stages).exec();
-        if (!leftoveres) {
-          return res.status(404).send({ message: "LEFTOVERES_NOT_FOUND" });
-        }
-        res.status(200).send(leftoveres);
-      } catch (err) {
-        console.error(err);
-        res.status(500).send({ message: "ERROR_GET_ALL_LEFTOVERES" });
-      }
+  }
+  // Фильтрация полей для чтения (вызывается из controller после получения данных)
+  async filterFieldsForRead(req, data) {
+    if (!this.abac) {
+      return data;
+    }
+    const context = {
+      user: req.userId,
+      resource: this.crud.modelName,
+      action: "read",
+      req,
+      data: {
+        ...req.query,
+        params: req.params
+      },
+      params: req.params
     };
-    const create = async (req, res) => {
-      try {
-        console.log("order is", req.body.order);
-        const leftover = await Leftover.create({
-          organization: req.body.organization,
-          type: req.body.type,
-          order: req.body.order,
-          comment: req.body.comment,
-          positions: req.body.positions,
-          creator: req.body.creator,
-          owner: req.body.owner
-        });
-        if (!leftover) {
-          return res.status(404).send({ message: "ERROR_CREATING_LEFTOVER" });
-        }
-        res.status(200).send(leftover);
-      } catch (err) {
-        console.log(err);
-        res.status(500).send({ message: "ERROR_CREATE_LEFTOVER" });
+    if (Array.isArray(data)) {
+      const results = [];
+      for (const doc of data) {
+        const fieldsResult2 = await this.abac.checkFields(
+          { ...context, currentResource: doc },
+          doc,
+          "read"
+        );
+        results.push(fieldsResult2.transformed || fieldsResult2.allowed);
       }
+      return results;
+    }
+    const fieldsResult = await this.abac.checkFields(
+      { ...context, currentResource: data },
+      data,
+      "read"
+    );
+    return fieldsResult.transformed || fieldsResult.allowed;
+  }
+  // Добавление кастомной политики
+  addPolicy(action, policyName, policyFn = null) {
+    if (!this.policyOptions[action]) {
+      this.policyOptions[action] = {
+        enabled: true,
+        policies: [],
+        customPolicies: {}
+      };
+    }
+    if (policyFn) {
+      this.policyOptions[action].customPolicies[policyName] = policyFn;
+    }
+    if (!this.policyOptions[action].policies.includes(policyName)) {
+      this.policyOptions[action].policies.push(policyName);
+    }
+  }
+  // Удаление политики
+  removePolicy(action, policyName) {
+    if (!this.policyOptions[action]) return;
+    const policies = this.policyOptions[action].policies;
+    const index = policies.indexOf(policyName);
+    if (index > -1) {
+      policies.splice(index, 1);
+    }
+    delete this.policyOptions[action].customPolicies[policyName];
+  }
+  // Проверка наличия ABAC
+  hasAbac() {
+    return !!this.abac;
+  }
+  // Получение всех политик для действия
+  getPolicies(action) {
+    const options = this.getOptions(action);
+    return {
+      enabled: options.enabled !== false,
+      policies: options.policies || [],
+      customPolicies: options.customPolicies || {},
+      defaultPolicies: this.defaultPolicies[action] || {}
     };
-    const get = async (req, res) => {
-      try {
-        const leftover = await Leftover.findOne({ _id: req.params._id }).exec();
-        if (!leftover) {
-          return res.status(404).send({ message: "LEFTOVER_NOT_FOUND" });
-        }
-        res.status(200).send(leftover);
-      } catch (err) {
-        res.status(500).send({ message: "ERROR_GET_LEFTOVER" });
+  }
+  // Временное отключение ABAC для действия
+  disableForAction(action) {
+    if (!this.policyOptions[action]) {
+      this.policyOptions[action] = {};
+    }
+    this.policyOptions[action].enabled = false;
+  }
+  // Включение ABAC для действия
+  enableForAction(action) {
+    if (!this.policyOptions[action]) {
+      this.policyOptions[action] = {};
+    }
+    this.policyOptions[action].enabled = true;
+  }
+  // Установка политик по умолчанию для всех действий
+  setDefaultPolicies(policies) {
+    ["create", "read", "update", "delete"].forEach((action) => {
+      if (!this.policyOptions[action]) {
+        this.policyOptions[action] = {};
       }
-    };
-    const update = async (req, res) => {
-      try {
-        const leftover = await Leftover.findOneAndUpdate({ _id: req.params._id }, req.body, { new: true, upsert: true }).exec();
-        if (!leftover) {
-          return res.status(404).send({ message: "LEFTOVER_NOT_FOUND" });
-        }
-        res.status(200).send(leftover);
-      } catch (err) {
-        console.log(err);
-        res.status(500).send({ message: "ERROR_UPDATING_LEFTOVER" });
+      this.policyOptions[action].policies = [...policies];
+    });
+  }
+}
+class CRUDEvents {
+  constructor(crud) {
+    this.crud = crud;
+    this.observer = null;
+    this.logger = null;
+    this.enabled = false;
+    this.options = {};
+  }
+  init(options = {}) {
+    this.enabled = options.enabled !== false;
+    this.options = options;
+    if (this.enabled) {
+      this.observer = options.observer || new Observer();
+      this.logger = options.logger || new Logger(this.crud.db);
+    }
+  }
+  // Отправка события
+  async emit(eventName, data) {
+    if (!this.enabled || !this.observer) return;
+    const fullEventName = `${this.crud.modelName}:${eventName}`;
+    try {
+      await this.observer.notify(fullEventName, {
+        ...data,
+        timestamp: /* @__PURE__ */ new Date(),
+        model: this.crud.modelName
+      });
+      await this.log("info", `Event emitted: ${fullEventName}`, data);
+    } catch (error) {
+      console.error(`Error emitting event ${fullEventName}:`, error);
+    }
+  }
+  // Подписка на событие
+  subscribe(eventName, handler) {
+    if (!this.observer) return null;
+    const fullEventName = `${this.crud.modelName}:${eventName}`;
+    return this.observer.subscribe(fullEventName, handler);
+  }
+  // Отписка от события
+  unsubscribe(eventName, handler) {
+    if (!this.observer) return;
+    const fullEventName = `${this.crud.modelName}:${eventName}`;
+    this.observer.unsubscribe(fullEventName, handler);
+  }
+  // Логирование
+  async log(level, message, data = {}) {
+    if (!this.enabled || !this.logger) return;
+    try {
+      const logData = {
+        model: this.crud.modelName,
+        ...data
+      };
+      switch (level) {
+        case "info":
+          await this.logger.info(message, logData);
+          break;
+        case "warning":
+          await this.logger.warning(message, logData);
+          break;
+        case "error":
+          await this.logger.error(message, logData);
+          break;
+        default:
+          await this.logger.info(message, logData);
       }
-    };
-    const deleteLeftover = async (req, res) => {
-      try {
-        const leftover = await Leftover.findOneAndDelete({ _id: req.params._id });
-        if (!leftover) {
-          return res.status(404).send({ message: "ERROR_DELETING_LEFTOVER" });
+    } catch (error) {
+      console.error("Logging error:", error);
+    }
+  }
+  // Логирование ошибок
+  async logError(operation, error) {
+    await this.log("error", `Error in ${operation} operation`, {
+      operation,
+      error: error.message,
+      stack: error.stack
+    });
+  }
+  // Специализированные методы событий
+  async emitCreate(document, userId) {
+    await this.emit("created", {
+      document,
+      user: userId,
+      action: "create"
+    });
+  }
+  async emitUpdate(document, previousDocument, userId) {
+    await this.emit("updated", {
+      document,
+      previousDocument,
+      user: userId,
+      action: "update",
+      changes: this._getChanges(previousDocument, document)
+    });
+  }
+  async emitDelete(document, userId) {
+    await this.emit("deleted", {
+      document,
+      user: userId,
+      action: "delete"
+    });
+  }
+  async emitRead(query, results, userId) {
+    if (this.options.logReads !== false) {
+      await this.emit("read", {
+        query,
+        resultCount: Array.isArray(results) ? results.length : 1,
+        user: userId,
+        action: "read"
+      });
+    }
+  }
+  // Вспомогательные методы
+  _getChanges(oldDoc, newDoc) {
+    const changes = {};
+    if (!oldDoc || !newDoc) return changes;
+    for (const key in newDoc) {
+      if (newDoc.hasOwnProperty(key)) {
+        const oldVal = oldDoc[key];
+        const newVal = newDoc[key];
+        if (["_id", "__v", "updatedAt"].includes(key)) continue;
+        if (JSON.stringify(oldVal) !== JSON.stringify(newVal)) {
+          changes[key] = {
+            old: oldVal,
+            new: newVal
+          };
         }
-        res.status(200).send(leftover);
-      } catch (err) {
-        res.status(500).send({ message: "ERROR_DELETE_LEFTOVER" });
       }
+    }
+    return changes;
+  }
+  // Аудит действий
+  async audit(action, data) {
+    if (!this.options.enableAudit) return;
+    const auditData = {
+      action,
+      model: this.crud.modelName,
+      timestamp: /* @__PURE__ */ new Date(),
+      ...data
     };
-    return {
-      read,
-      create,
-      get,
-      update,
-      delete: deleteLeftover
-    };
-  };
-  leftovers_controller = controllerFactory;
-  return leftovers_controller;
+    await this.emit("audit", auditData);
+    await this.log("info", `Audit: ${action}`, auditData);
+  }
+  // Метрики
+  async recordMetric(metric, value = 1) {
+    if (!this.options.enableMetrics) return;
+    await this.emit("metric", {
+      metric,
+      value,
+      model: this.crud.modelName,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  // Проверка включены ли события
+  isEnabled() {
+    return this.enabled;
+  }
+  // Временное отключение событий
+  disable() {
+    this.enabled = false;
+  }
+  // Включение событий
+  enable() {
+    if (this.observer && this.logger) {
+      this.enabled = true;
+    }
+  }
 }
-var leftovers_routes;
-var hasRequiredLeftovers_routes;
-function requireLeftovers_routes() {
-  if (hasRequiredLeftovers_routes) return leftovers_routes;
-  hasRequiredLeftovers_routes = 1;
-  const controllerFactory = requireLeftovers_controller();
-  leftovers_routes = function(app, db) {
-    const controller = controllerFactory(db);
-    app.get(
-      "/leftovers",
-      controller.read
-    );
-    app.get(
-      "/leftovers/:_id",
-      controller.get
-    );
-    app.post(
-      "/leftovers/:_id",
-      controller.update
-    );
-    app.post(
-      "/leftovers",
-      controller.create
-    );
-    app.delete(
-      "/leftovers/:_id",
-      controller.delete
-    );
-  };
-  return leftovers_routes;
+class CRUD {
+  constructor(options = {}) {
+    const {
+      app,
+      db,
+      model,
+      basePath,
+      modelName = model?.modelName || "resource",
+      cache,
+      logger,
+      ...otherOptions
+    } = options;
+    this.app = app;
+    this.db = db;
+    this.model = model;
+    this.basePath = basePath;
+    this.modelName = modelName;
+    this.cache = cache !== false ? cache instanceof Cache ? cache : new Cache() : null;
+    this.logger = logger || new Logger(db);
+    this.initModules(otherOptions);
+    this.core.init(otherOptions);
+    if (!otherOptions.disableDefaultRoutes) {
+      this.registerDefaultRoutes();
+    }
+  }
+  initModules(options) {
+    this.core = new CRUDCore(this);
+    this.service = new CRUDService(this);
+    this.controller = new CRUDController(this);
+    this.policies = new CRUDPolicies(this);
+    this.events = new CRUDEvents(this);
+  }
+  // Регистрация дефолтных CRUD роутов
+  registerDefaultRoutes() {
+    this.controller.registerRoute("post", "/create", "create");
+    this.controller.registerRoute("get", "/read", "read");
+    this.controller.registerRoute("put", "/update", "update");
+    this.controller.registerRoute("delete", "/delete", "delete");
+  }
+  // API методы для конфигурации
+  setVerifier(action, verifier) {
+    this.core.setVerifier(action, verifier);
+    return this;
+  }
+  addHook(name, handler) {
+    this.core.addHook(name, handler);
+    return this;
+  }
+  addMiddleware(phase, action, middleware) {
+    this.controller.addMiddleware(phase, action, middleware);
+    return this;
+  }
+  addAbac(action, options = {}) {
+    this.policies.setOptions(action, options);
+    return this;
+  }
+  addAggregateExtension(phase, extension) {
+    this.core.addAggregateExtension(phase, extension);
+    return this;
+  }
+  // Управление авторизацией
+  setAuth(action, required) {
+    this.core.setAuth(action, required);
+    return this;
+  }
+  // Добавление кастомного действия
+  addAction(name, config) {
+    const {
+      method = "post",
+      path = `/${name}`,
+      handler,
+      verifier,
+      middlewares = { before: [], after: [] },
+      abac = {},
+      hooks = {},
+      auth = true
+      // По умолчанию требует авторизацию
+    } = config;
+    if (verifier) this.setVerifier(name, verifier);
+    if (abac) this.addAbac(name, abac);
+    if (auth !== void 0) this.setAuth(name, auth);
+    if (middlewares.before) {
+      const beforeMiddlewares = Array.isArray(middlewares.before) ? middlewares.before : [middlewares.before];
+      beforeMiddlewares.forEach((mw) => this.addMiddleware("before", name, mw));
+    }
+    if (middlewares.after) {
+      const afterMiddlewares = Array.isArray(middlewares.after) ? middlewares.after : [middlewares.after];
+      afterMiddlewares.forEach((mw) => this.addMiddleware("after", name, mw));
+    }
+    Object.entries(hooks).forEach(([hookName, hookFn]) => {
+      this.addHook(hookName, hookFn);
+    });
+    if (handler) {
+      this.controller.registerCustomRoute(method, path, name, handler);
+    } else {
+      this.controller.registerRoute(method, path, name);
+    }
+    return this;
+  }
+  // Получение конфигурации кеша
+  getCacheOptions() {
+    return this.core.getCacheOptions();
+  }
+  // Установка опций кеша
+  setCacheOptions(options) {
+    this.core.setCacheOptions(options);
+    return this;
+  }
 }
-var products_server$1;
-var hasRequiredProducts_server;
-function requireProducts_server() {
-  if (hasRequiredProducts_server) return products_server$1;
-  hasRequiredProducts_server = 1;
-  const ProductModel = requireProduct_model();
-  const CategoryModel = requireCategory_model();
-  const LeftoverModel = requireLeftover_model();
-  const productsRoutes = requireProducts_routes();
-  const categoriesRoutes = requireCategories_routes();
-  const leftoversRoutes = requireLeftovers_routes();
-  const ProductController = requireProducts_controller();
-  const CategoryController = requireCategories_controller();
-  const LeftoverController = requireLeftovers_controller();
-  function initializeProduct(app, db, origins, publicPath) {
-    db.product = ProductModel(db);
-    db.category = CategoryModel(db);
-    db.leftover = LeftoverModel(db);
-    if (app) {
-      productsRoutes(app, db, origins, publicPath);
-      categoriesRoutes(app, db, origins, publicPath);
-      leftoversRoutes(app, db, origins, publicPath);
-    }
-  }
-  products_server$1 = {
-    initialize: initializeProduct,
-    models: {
-      ProductModel,
-      CategoryModel,
-      LeftoverModel
-    },
-    routes: {
-      productsRoutes,
-      categoriesRoutes,
-      leftoversRoutes
-    },
-    controllers: {
-      ProductController,
-      CategoryController,
-      LeftoverController
+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().integer().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
   };
-  return products_server$1;
+};
+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);
+  db.leftover = LeftoverModel(db);
+  if (app) {
+    productsRoutes(app, db);
+    categoriesRoutes(app, db);
+    leftoversRoutes(app, db);
+    setupVariantsRoutes(app, db);
+  }
 }
-var products_serverExports = requireProducts_server();
-const products_server = /* @__PURE__ */ _commonjsHelpers.getDefaultExportFromCjs(products_serverExports);
-module.exports = products_server;
+const models = {
+  ProductModel,
+  CategoryModel,
+  LeftoverModel
+};
+const routes = {
+  productsRoutes,
+  categoriesRoutes,
+  leftoversRoutes
+};
+const controllers = {
+  ProductController: controllerFactory,
+  CategoryController: controllerFactory$2,
+  LeftoverController: controllerFactory$1
+};
+const products_server = {
+  initialize: initializeProduct,
+  models,
+  routes,
+  controllers
+};
+export {
+  controllers,
+  products_server as default,
+  initializeProduct as initialize,
+  models,
+  routes
+};