@ozdao/martyrs 0.2.491 → 0.2.492

package/dist/inventory.server.js

@@ -0,0 +1,1170 @@
+import { a as applyOwnershipSchema } from "./ownership.schema-BqH4v5vH.js";
+import { m as middlewareFactory } from "./authJwt-J1csaMWA.js";
+import { g as globalsabac } from "./globals.abac-DNdtSYop.js";
+import { C as Cache, L as Logger } from "./globals.logger-Bf6rRU7j.js";
+import { O as Observer } from "./globals.observer-CDqUjVU5.js";
+import { q as queryProcessorGlobals } from "./queryProcessor-CVcLPEnv.js";
+import { a as Validator, V as Verifier } from "./globals.verifier-CWFz5Gh2.js";
+import { C as CRUD } from "./crud-Cwx5VlSm.js";
+import { A as ABAC } from "./abac-Cf_9lCSh.js";
+const StockAdjustmentModel = (db) => {
+  const StockAdjustmentSchema = new db.mongoose.Schema({
+    product: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Product",
+      required: true
+    },
+    variant: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Variant",
+      required: true
+    },
+    storage: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Spot",
+      required: true
+    },
+    source: {
+      type: {
+        type: String,
+        required: true,
+        enum: ["User", "Order", "Inventory"]
+      },
+      target: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        refPath: "source.type"
+      }
+    },
+    reason: {
+      type: String,
+      enum: ["restock", "sale", "return", "damage", "transfer", "custom"],
+      required: true
+    },
+    comment: {
+      type: String
+    },
+    quantity: {
+      type: Number,
+      required: true
+    },
+    cost: {
+      type: Number
+    }
+  }, {
+    timestamps: {
+      currentTime: () => Date.now()
+    }
+  });
+  applyOwnershipSchema(StockAdjustmentSchema, db);
+  StockAdjustmentSchema.index({ product: 1, variant: 1, storage: 1 });
+  StockAdjustmentSchema.index({ storage: 1 });
+  StockAdjustmentSchema.index({ storage: 1, createdAt: -1 });
+  StockAdjustmentSchema.index({ product: 1, createdAt: -1 });
+  StockAdjustmentSchema.index({ reason: 1, createdAt: -1 });
+  const StockAdjustment = db.mongoose.model("StockAdjustment", StockAdjustmentSchema);
+  return StockAdjustment;
+};
+const StockBalanceModel = (db) => {
+  const StockBalanceSchema = new db.mongoose.Schema({
+    product: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Product",
+      required: true
+    },
+    variant: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Variant"
+    },
+    storage: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Spot",
+      required: true
+    },
+    quantity: {
+      type: Number,
+      default: 0
+    }
+  }, {
+    timestamps: {
+      currentTime: () => Date.now()
+    }
+  });
+  applyOwnershipSchema(StockBalanceSchema, db);
+  StockBalanceSchema.index({ product: 1, variant: 1, storage: 1 }, { unique: true });
+  StockBalanceSchema.index({ updatedAt: -1 });
+  StockBalanceSchema.index({ storage: 1, variant: 1 });
+  StockBalanceSchema.index({ storage: 1, product: 1 });
+  StockBalanceSchema.index({ quantity: -1 });
+  const StockBalance = db.mongoose.model("StockBalance", StockBalanceSchema);
+  return StockBalance;
+};
+const StockAvailabilityModel = (db) => {
+  const StockAvailabilitySchema = new db.mongoose.Schema({
+    product: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Product",
+      required: true
+    },
+    variant: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Variant",
+      required: true
+    },
+    storage: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Spot",
+      required: true
+    },
+    // Computed availability
+    quantity: {
+      type: Number,
+      default: 0
+    },
+    available: {
+      type: Number,
+      default: 0
+    },
+    reservations: {
+      type: Number,
+      default: 0
+    },
+    constraints: [{
+      ingredient: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Product"
+      },
+      stock: Number,
+      required: Number,
+      available: Number
+    }]
+  }, {
+    timestamps: {
+      currentTime: () => Date.now()
+    }
+  });
+  StockAvailabilitySchema.index(
+    { product: 1, variant: 1, storage: 1 },
+    { unique: true }
+  );
+  StockAvailabilitySchema.index({ storage: 1 });
+  StockAvailabilitySchema.index({ available: -1 });
+  const StockAvailability = db.mongoose.model("StockAvailability", StockAvailabilitySchema);
+  return StockAvailability;
+};
+const StockAuditModel = (db) => {
+  const StockAuditSchema = new db.mongoose.Schema({
+    storage: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Spot",
+      required: true
+    },
+    status: {
+      type: String,
+      enum: ["draft", "published", "cancelled"],
+      default: "draft"
+    },
+    positions: [{
+      product: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Product",
+        required: true
+      },
+      variant: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Variant"
+      },
+      quantity: {
+        type: Number,
+        required: true
+      },
+      reason: {
+        type: String,
+        enum: ["restock", "sale", "return", "damage", "transfer", "custom"],
+        default: "custom"
+      },
+      comment: {
+        type: String
+      },
+      cost: {
+        type: Number,
+        min: 0
+      }
+    }],
+    comment: {
+      type: String
+    }
+  }, {
+    timestamps: {
+      currentTime: () => Date.now()
+    }
+  });
+  applyOwnershipSchema(StockAuditSchema, db);
+  StockAuditSchema.index({ storage: 1 });
+  StockAuditSchema.index({ status: 1, createdAt: -1 });
+  const StockAudit = db.mongoose.model("StockAudit", StockAuditSchema);
+  return StockAudit;
+};
+const StockAlertModel = (db) => {
+  const StockAlertSchema = new db.mongoose.Schema({
+    product: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Product",
+      required: true
+    },
+    variant: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Variant",
+      default: null
+      // null = все варианты
+    },
+    storage: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Spot",
+      default: null
+      // null = все склады
+    },
+    threshold: {
+      type: Number,
+      required: true,
+      min: 0
+    },
+    enabled: {
+      type: Boolean,
+      default: true
+    }
+  }, {
+    timestamps: {
+      currentTime: () => Date.now()
+    }
+  });
+  applyOwnershipSchema(StockAlertSchema, db);
+  StockAlertSchema.index({ product: 1, enabled: 1 });
+  StockAlertSchema.index({ product: 1, variant: 1, storage: 1 });
+  StockAlertSchema.index({ "owner.target": 1 });
+  const StockAlert = db.mongoose.model("StockAlert", StockAlertSchema);
+  return StockAlert;
+};
+const controllerFactory = (db) => {
+  const cache = new Cache({ ttlSeconds: 300 });
+  const logger = new Logger(db);
+  const observer = new Observer();
+  async function recalculateAvailability(variantIds, storage, session) {
+    const variants = await db.variant.find({
+      _id: { $in: variantIds }
+    }).session(session).lean();
+    if (!variants.length) return;
+    const allIngredientIds = /* @__PURE__ */ new Set();
+    const variantMap = /* @__PURE__ */ new Map();
+    variants.forEach((v) => {
+      variantMap.set(v._id.toString(), v);
+      v.ingredients?.forEach((ing) => {
+        allIngredientIds.add(ing._id.toString());
+      });
+    });
+    const balances = await db.stockBalance.find({
+      storage,
+      $or: [
+        { variant: { $in: variantIds } },
+        { product: { $in: Array.from(allIngredientIds) } }
+      ]
+    }).session(session).lean();
+    const balanceByVariant = /* @__PURE__ */ new Map();
+    const balanceByProduct = /* @__PURE__ */ new Map();
+    balances.forEach((b) => {
+      if (b.variant) {
+        balanceByVariant.set(b.variant.toString(), b.quantity);
+      } else if (b.product) {
+        balanceByProduct.set(b.product.toString(), b.quantity);
+      }
+    });
+    const bulkOps = [];
+    variants.forEach((variant) => {
+      const variantId = variant._id.toString();
+      const directStock = balanceByVariant.get(variantId) || 0;
+      let available = directStock > 0 ? directStock : Infinity;
+      const constraints = [];
+      if (variant.ingredients?.length) {
+        for (const ing of variant.ingredients) {
+          if (ing.optional) continue;
+          const stock = balanceByProduct.get(ing._id.toString()) || 0;
+          const canMake = Math.floor(stock / (ing.quantity || 1));
+          if (directStock === 0 || canMake < available) {
+            available = canMake;
+          }
+          constraints.push({
+            ingredient: ing._id,
+            stock,
+            required: ing.quantity,
+            available: canMake
+          });
+        }
+      }
+      if (available === Infinity) {
+        available = directStock;
+      }
+      bulkOps.push({
+        updateOne: {
+          filter: { variant: variant._id, storage },
+          update: {
+            $set: {
+              product: variant.product,
+              quantity: directStock,
+              available,
+              constraints,
+              calculatedAt: /* @__PURE__ */ new Date()
+            },
+            $setOnInsert: {
+              owner: variant.owner,
+              creator: variant.creator
+            }
+          },
+          upsert: true
+        }
+      });
+    });
+    if (bulkOps.length) {
+      await db.stockAvailability.bulkWrite(bulkOps, { session });
+      for (const variant of variants) {
+        const variantId = variant._id.toString();
+        const available = balanceByVariant.get(variantId) || 0;
+        const alerts = await db.stockAlert.find({
+          product: variant.product,
+          enabled: true,
+          $or: [
+            { variant: null, storage: null },
+            { variant: null, storage },
+            { variant: variant._id, storage: null },
+            { variant: variant._id, storage }
+          ]
+        }).session(session);
+        for (const alert of alerts) {
+          if (available < alert.threshold) {
+            try {
+              await fetch(`${process.env.API_URL || ""}/api/notifications`, {
+                method: "POST",
+                headers: {
+                  "Content-Type": "application/json",
+                  "X-Service-Key": process.env.SERVICE_KEY
+                },
+                body: JSON.stringify({
+                  title: "Low Stock Alert",
+                  body: `Stock is low: ${available} units (threshold: ${alert.threshold})`,
+                  type: "stock_alert",
+                  metadata: {
+                    alertId: alert._id,
+                    productId: variant.product,
+                    variantId: variant._id,
+                    storageId: storage,
+                    currentStock: available,
+                    threshold: alert.threshold
+                  },
+                  userId: alert.creator.target
+                })
+              });
+            } catch (notificationError) {
+              logger.error("Error sending stock alert notification:", notificationError);
+            }
+          }
+        }
+      }
+    }
+  }
+  function invalidateCache(tags) {
+    setImmediate(() => {
+      cache.delByTags(tags).catch(
+        (err) => logger.error("Cache invalidation error", err)
+      );
+    });
+  }
+  function initChangeStreams() {
+    const variantStream = db.variant.watch([], { fullDocument: "updateLookup" });
+    variantStream.on("change", async (change) => {
+      if (change.operationType === "update" && change.updateDescription?.updatedFields?.ingredients) {
+        const variantId = change.documentKey._id;
+        const storages = await db.stockBalance.distinct("storage", {
+          variant: variantId
+        });
+        for (const storage of storages) {
+          await recalculateAvailability([variantId], storage);
+        }
+        invalidateCache(["availability"]);
+      }
+    });
+    variantStream.on("error", (err) => {
+      logger.error("Variant change stream error", err);
+    });
+  }
+  initChangeStreams();
+  const adjustments = {
+    async read(req, res) {
+      try {
+        const cacheKey = JSON.stringify({ type: "adjustments", ...req.verifiedQuery });
+        let data = await cache.get(cacheKey);
+        if (!data) {
+          const stages = [
+            ...queryProcessorGlobals.getBasicOptions(req.verifiedQuery),
+            ...queryProcessorGlobals.getFilterDate(req.verifiedQuery.dateStart, req.verifiedQuery.dateEnd),
+            {
+              $lookup: {
+                from: "products",
+                let: { productId: "$product" },
+                pipeline: [
+                  { $match: { $expr: { $eq: ["$_id", "$$productId"] } } },
+                  { $project: { name: 1, sku: 1 } }
+                ],
+                as: "productData"
+              }
+            },
+            { $unwind: { path: "$productData", preserveNullAndEmptyArrays: true } },
+            ...queryProcessorGlobals.getSortingOptions("createdAt", "desc"),
+            ...queryProcessorGlobals.getPaginationOptions(req.verifiedQuery.skip, req.verifiedQuery.limit)
+          ];
+          data = await db.stockAdjustment.aggregate(stages).exec();
+          await cache.setWithTags(cacheKey, data, ["adjustments"]);
+        }
+        res.json(data);
+      } catch (error) {
+        logger.error("Error reading adjustments", error);
+        res.status(500).json({ message: error.message });
+      }
+    },
+    async create(req, res) {
+      const session = await db.mongoose.startSession();
+      session.startTransaction();
+      try {
+        const adjustmentData = {
+          ...req.verifiedBody,
+          creator: req.verifiedBody.creator || { type: "user", target: req.userId },
+          owner: req.verifiedBody.owner
+        };
+        const [adjustment] = await db.stockAdjustment.create([adjustmentData], { session });
+        const balance2 = await db.stockBalance.findOneAndUpdate(
+          {
+            product: adjustmentData.product,
+            variant: adjustmentData.variant,
+            storage: adjustmentData.storage
+          },
+          {
+            $inc: { quantity: adjustmentData.quantity },
+            $setOnInsert: {
+              owner: adjustmentData.owner,
+              creator: adjustmentData.creator
+            }
+          },
+          { upsert: true, new: true, session }
+        );
+        const affectedVariants = /* @__PURE__ */ new Set();
+        if (adjustmentData.variant) {
+          affectedVariants.add(adjustmentData.variant.toString());
+        }
+        const dependentVariants = await db.variant.find({
+          "ingredients._id": adjustmentData.product,
+          "ingredients.optional": { $ne: true }
+        }).distinct("_id").session(session);
+        dependentVariants.forEach((v) => affectedVariants.add(v.toString()));
+        if (affectedVariants.size) {
+          await recalculateAvailability(
+            Array.from(affectedVariants),
+            adjustmentData.storage,
+            session
+          );
+        }
+        await session.commitTransaction();
+        invalidateCache(["adjustments", "balance", "availability"]);
+        setImmediate(() => {
+          observer.notify("stock.adjusted", {
+            adjustment,
+            balance: balance2,
+            affectedVariants: Array.from(affectedVariants)
+          });
+        });
+        res.status(201).json(adjustment);
+      } catch (error) {
+        console.log(error);
+        await session.abortTransaction();
+        logger.error("Error creating adjustment", error);
+        res.status(500).json({ message: error.message });
+      } finally {
+        session.endSession();
+      }
+    }
+  };
+  const balance = {
+    async read(req, res) {
+      try {
+        const cacheKey = JSON.stringify({ type: "balance", ...req.verifiedQuery });
+        let data = await cache.get(cacheKey);
+        if (!data) {
+          const pipeline = [
+            {
+              $match: {
+                ...req.verifiedQuery.storage && { storage: new db.mongoose.Types.ObjectId(req.verifiedQuery.storage) },
+                ...req.verifiedQuery.product && { product: new db.mongoose.Types.ObjectId(req.verifiedQuery.product) },
+                quantity: { $gt: 0 }
+              }
+            },
+            {
+              $lookup: {
+                from: "products",
+                let: { pid: "$product" },
+                pipeline: [
+                  { $match: { $expr: { $eq: ["$_id", "$$pid"] } } },
+                  { $project: { name: 1, sku: 1 } }
+                ],
+                as: "product"
+              }
+            },
+            { $unwind: { path: "$product", preserveNullAndEmptyArrays: true } },
+            {
+              $lookup: {
+                from: "spots",
+                let: { sid: "$storage" },
+                pipeline: [
+                  { $match: { $expr: { $eq: ["$_id", "$$sid"] } } },
+                  { $project: { name: 1, location: 1 } }
+                ],
+                as: "storage"
+              }
+            },
+            { $unwind: { path: "$storage", preserveNullAndEmptyArrays: true } },
+            { $limit: req.verifiedQuery.limit },
+            { $skip: req.verifiedQuery.skip }
+          ];
+          data = await db.stockBalance.aggregate(pipeline).exec();
+          await cache.setWithTags(cacheKey, data, ["balance"]);
+        }
+        res.json(data);
+      } catch (error) {
+        logger.error("Error reading balance", error);
+        res.status(500).json({ message: error.message });
+      }
+    }
+  };
+  const availability = {
+    async read(req, res) {
+      try {
+        console.log("=== AVAILABILITY DEBUG ===");
+        console.log("req.query:", req.query);
+        console.log("req.verifiedQuery:", req.verifiedQuery);
+        console.log("req.verifiedQuery?.details:", req.verifiedQuery?.details);
+        if (!req.verifiedQuery) {
+          console.log("WARNING: req.verifiedQuery is undefined, converting from req.query");
+          req.verifiedQuery = {
+            ...req.query,
+            skip: parseInt(req.query.skip) || 0,
+            limit: parseInt(req.query.limit) || 20
+          };
+        }
+        const cacheKey = JSON.stringify({ type: "availability", ...req.verifiedQuery });
+        let data = await cache.get(cacheKey);
+        if (!data) {
+          const needsDetails = req.verifiedQuery?.details === "true";
+          const matchConditions = {};
+          if (req.verifiedQuery?.owner) {
+            matchConditions["owner.target"] = new db.mongoose.Types.ObjectId(req.verifiedQuery.owner);
+          }
+          if (req.verifiedQuery?.product) {
+            matchConditions._id = new db.mongoose.Types.ObjectId(req.verifiedQuery.product);
+          }
+          if (req.verifiedQuery?.search) {
+            matchConditions.name = { $regex: req.verifiedQuery.search, $options: "i" };
+          }
+          const pipeline = [
+            { $match: matchConditions },
+            {
+              $lookup: {
+                from: "stockavailabilities",
+                let: { productId: "$_id" },
+                pipeline: [
+                  {
+                    $match: {
+                      $expr: { $eq: ["$product", "$$productId"] },
+                      ...req.verifiedQuery?.storage && { storage: new db.mongoose.Types.ObjectId(req.verifiedQuery.storage) }
+                    }
+                  }
+                ],
+                as: "availability"
+              }
+            },
+            {
+              $addFields: {
+                available: { $sum: "$availability.available" },
+                totalStock: { $sum: "$availability.quantity" },
+                storageCount: { $size: "$availability" }
+              }
+            }
+          ];
+          if (needsDetails) {
+            pipeline.push(
+              {
+                $lookup: {
+                  from: "products",
+                  let: { pid: "$product" },
+                  pipeline: [
+                    { $match: { $expr: { $eq: ["$_id", "$$pid"] } } },
+                    { $project: { name: 1, sku: 1, price: 1, images: { $slice: ["$images", 1] } } }
+                  ],
+                  as: "product"
+                }
+              },
+              { $unwind: { path: "$product", preserveNullAndEmptyArrays: true } },
+              {
+                $lookup: {
+                  from: "variants",
+                  let: { vid: "$variant" },
+                  pipeline: [
+                    { $match: { $expr: { $eq: ["$_id", "$$vid"] } } },
+                    { $project: { name: 1, attributes: 1, price: 1 } }
+                  ],
+                  as: "variant"
+                }
+              },
+              { $unwind: { path: "$variant", preserveNullAndEmptyArrays: true } }
+            );
+          }
+          pipeline.push(
+            { $sort: { available: -1 } },
+            { $limit: req.verifiedQuery?.limit || 20 },
+            { $skip: req.verifiedQuery?.skip || 0 }
+          );
+          data = await db.stockAvailability.aggregate(pipeline).allowDiskUse(true).exec();
+          await cache.setWithTags(cacheKey, data, ["availability"]);
+        }
+        res.json(data);
+      } catch (error) {
+        logger.error("Error reading availability", error);
+        res.status(500).json({ message: error.message });
+      }
+    }
+  };
+  const inventory = {
+    async read(req, res) {
+      try {
+        const stages = [
+          ...queryProcessorGlobals.getBasicOptions(req.verifiedQuery),
+          queryProcessorGlobals.getCreatorUserLookupStage(),
+          queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
+          ...queryProcessorGlobals.getSortingOptions("createdAt", "desc"),
+          ...queryProcessorGlobals.getPaginationOptions(req.verifiedQuery.skip, req.verifiedQuery.limit)
+        ];
+        const data = await db.stockAudit.aggregate(stages).exec();
+        res.json(data);
+      } catch (error) {
+        logger.error("Error reading inventories", error);
+        res.status(500).json({ message: error.message });
+      }
+    },
+    async create(req, res) {
+      const session = await db.mongoose.startSession();
+      session.startTransaction();
+      try {
+        const inventoryData = {
+          ...req.verifiedBody,
+          creator: { type: "user", target: req.userId },
+          owner: req.verifiedBody.owner
+        };
+        const audit = await db.stockAudit.create([inventoryData], { session });
+        if (req.verifiedBody.status === "published") {
+          const auditDoc = audit[0];
+          const adjustmentPromises = auditDoc.positions.map((position) => {
+            return db.stockAdjustment.create([{
+              product: position.product,
+              variant: position.variant,
+              storage: auditDoc.storage,
+              source: { type: "Inventory", target: auditDoc._id },
+              reason: position.reason || "custom",
+              comment: position.comment,
+              quantity: position.quantity,
+              cost: position.cost,
+              creator: auditDoc.creator,
+              owner: auditDoc.owner
+            }], { session });
+          });
+          await Promise.all(adjustmentPromises);
+          const balanceOps = auditDoc.positions.map((p) => ({
+            updateOne: {
+              filter: {
+                product: p.product,
+                variant: p.variant || null,
+                storage: auditDoc.storage
+              },
+              update: {
+                $inc: { quantity: p.quantity },
+                $setOnInsert: {
+                  owner: auditDoc.owner,
+                  creator: auditDoc.creator
+                }
+              },
+              upsert: true
+            }
+          }));
+          await db.stockBalance.bulkWrite(balanceOps, { session });
+          const affectedVariants = /* @__PURE__ */ new Set();
+          const affectedProducts = /* @__PURE__ */ new Set();
+          auditDoc.positions.forEach((p) => {
+            if (p.variant) affectedVariants.add(p.variant.toString());
+            affectedProducts.add(p.product.toString());
+          });
+          const dependentVariants = await db.variant.find({
+            "ingredients._id": { $in: Array.from(affectedProducts) },
+            "ingredients.optional": { $ne: true }
+          }).distinct("_id").session(session);
+          dependentVariants.forEach((v) => affectedVariants.add(v.toString()));
+          if (affectedVariants.size) {
+            await recalculateAvailability(Array.from(affectedVariants), auditDoc.storage, session);
+          }
+        }
+        await session.commitTransaction();
+        invalidateCache(["inventories", "balances", "availability"]);
+        res.status(201).json(audit[0]);
+      } catch (error) {
+        await session.abortTransaction();
+        logger.error("Error creating inventory", error);
+        res.status(500).json({ message: error.message });
+      } finally {
+        session.endSession();
+      }
+    },
+    async complete(req, res) {
+      const session = await db.mongoose.startSession();
+      session.startTransaction();
+      try {
+        const inventory2 = await db.stockAudit.findById(req.verifiedBody._id).session(session);
+        if (!inventory2 || inventory2.status !== "draft") {
+          throw new Error("Invalid inventory status");
+        }
+        const adjustmentPromises = inventory2.positions.map((position) => {
+          return db.stockAdjustment.create([{
+            product: position.product,
+            variant: position.variant,
+            storage: inventory2.storage,
+            source: { type: "Inventory", target: inventory2._id },
+            reason: position.reason || "custom",
+            comment: position.comment,
+            quantity: position.quantity,
+            cost: position.cost,
+            creator: inventory2.creator,
+            owner: inventory2.owner
+          }], { session });
+        });
+        await Promise.all(adjustmentPromises);
+        const bulkOps = inventory2.positions.map((p) => ({
+          updateOne: {
+            filter: {
+              product: p.product,
+              variant: p.variant || null,
+              storage: inventory2.storage
+            },
+            update: {
+              $inc: { quantity: p.quantity },
+              $setOnInsert: {
+                owner: inventory2.owner,
+                creator: inventory2.creator
+              }
+            },
+            upsert: true
+          }
+        }));
+        await db.stockBalance.bulkWrite(bulkOps, { session });
+        const affectedVariants = /* @__PURE__ */ new Set();
+        const affectedProducts = /* @__PURE__ */ new Set();
+        inventory2.positions.forEach((p) => {
+          if (p.variant) affectedVariants.add(p.variant.toString());
+          affectedProducts.add(p.product.toString());
+        });
+        const dependentVariants = await db.variant.find({
+          "ingredients._id": { $in: Array.from(affectedProducts) },
+          "ingredients.optional": { $ne: true }
+        }).distinct("_id").session(session);
+        dependentVariants.forEach((v) => affectedVariants.add(v.toString()));
+        if (affectedVariants.size) {
+          await recalculateAvailability(
+            Array.from(affectedVariants),
+            inventory2.storage,
+            session
+          );
+        }
+        inventory2.status = "published";
+        await inventory2.save({ session });
+        await session.commitTransaction();
+        invalidateCache(["adjustments", "balance", "availability", "inventories"]);
+        setImmediate(() => {
+          observer.notify("inventory.completed", {
+            inventory: inventory2,
+            affectedVariants: Array.from(affectedVariants)
+          });
+        });
+        res.json(inventory2);
+      } catch (error) {
+        await session.abortTransaction();
+        logger.error("Error completing inventory", error);
+        res.status(500).json({ message: error.message });
+      } finally {
+        session.endSession();
+      }
+    }
+  };
+  return { adjustments, balance, availability, inventory };
+};
+function verifierFactory(db) {
+  const adjustmentQueryConfig = {
+    product: { rule: "optional", validator: Validator.schema().string() },
+    variant: { rule: "optional", validator: Validator.schema().string() },
+    storage: { rule: "optional", validator: Validator.schema().string() },
+    reason: { rule: "optional", validator: Validator.schema().string() },
+    dateStart: { rule: "optional", validator: Validator.schema().date() },
+    dateEnd: { rule: "optional", validator: Validator.schema().date() },
+    skip: { rule: "optional", validator: Validator.schema().integer().min(0), default: 0 },
+    limit: { rule: "optional", validator: Validator.schema().integer().min(1).max(100), default: 20 }
+  };
+  const adjustmentBodyConfig = {
+    product: { rule: "required", validator: Validator.schema().string() },
+    variant: { rule: "optional", validator: Validator.schema().string() },
+    storage: { rule: "required", validator: Validator.schema().string() },
+    source: {
+      rule: "required",
+      validator: Validator.schema().object({
+        type: Validator.schema().string().oneOf(["User", "Order", "Inventory"]).required(),
+        target: Validator.schema().string().required()
+      })
+    },
+    reason: {
+      rule: "required",
+      validator: Validator.schema().string().oneOf(["restock", "sale", "return", "damage", "transfer", "custom"])
+    },
+    quantity: { rule: "required", validator: Validator.schema().integer() },
+    cost: { rule: "optional", validator: Validator.schema().number().min(0) },
+    comment: { rule: "optional", validator: Validator.schema().string() }
+  };
+  const balanceQueryConfig = {
+    product: { rule: "optional", validator: Validator.schema().string() },
+    storage: { rule: "optional", validator: Validator.schema().string() },
+    skip: { rule: "optional", validator: Validator.schema().integer().min(0), default: 0 },
+    limit: { rule: "optional", validator: Validator.schema().integer().min(1).max(100), default: 50 },
+    details: { rule: "optional", validator: Validator.schema().string() },
+    search: { rule: "optional", validator: Validator.schema().string() },
+    sortParam: { rule: "optional", validator: Validator.schema().string() },
+    sortOrder: { rule: "optional", validator: Validator.schema().string().oneOf(["asc", "desc"]) }
+  };
+  const inventoryBodyConfig = {
+    storage: { rule: "required", validator: Validator.schema().string() },
+    comment: { rule: "optional", validator: Validator.schema().string() },
+    status: { rule: "optional", validator: Validator.schema().string().oneOf(["draft", "published"]), default: "draft" },
+    positions: {
+      rule: "required",
+      validator: Validator.schema().array().items(
+        Validator.schema().object({
+          product: Validator.schema().string().required(),
+          variant: Validator.schema().string(),
+          quantity: Validator.schema().number().integer().required()
+        })
+      )
+    }
+  };
+  const adjustmentQueryVerifier = new Verifier(adjustmentQueryConfig);
+  const adjustmentBodyVerifier = new Verifier(adjustmentBodyConfig);
+  const balanceQueryVerifier = new Verifier(balanceQueryConfig);
+  const inventoryBodyVerifier = new Verifier(inventoryBodyConfig);
+  return {
+    verifyAdjustmentQuery: (req, res, next) => {
+      const verification = adjustmentQueryVerifier.verify(req.query);
+      if (!verification.isValid) {
+        return res.status(400).json({ errors: verification.verificationErrors });
+      }
+      req.verifiedQuery = verification.verifiedData;
+      next();
+    },
+    verifyAdjustmentBody: (req, res, next) => {
+      const verification = adjustmentBodyVerifier.verify(req.body);
+      if (!verification.isValid) {
+        return res.status(400).json({ errors: verification.verificationErrors });
+      }
+      req.verifiedBody = verification.verifiedData;
+      next();
+    },
+    verifyBalanceQuery: (req, res, next) => {
+      const verification = balanceQueryVerifier.verify(req.query);
+      if (!verification.isValid) {
+        return res.status(400).json({ errors: verification.verificationErrors });
+      }
+      verification.verifiedData.skip = parseInt(verification.verifiedData.skip) || 0;
+      verification.verifiedData.limit = parseInt(verification.verifiedData.limit) || 50;
+      req.verifiedQuery = verification.verifiedData;
+      next();
+    },
+    verifyAvailabilityQuery: (req, res, next) => {
+      const verification = balanceQueryVerifier.verify(req.query);
+      if (!verification.isValid) {
+        return res.status(400).json({ errors: verification.verificationErrors });
+      }
+      verification.verifiedData.skip = parseInt(verification.verifiedData.skip) || 0;
+      verification.verifiedData.limit = parseInt(verification.verifiedData.limit) || 50;
+      req.verifiedQuery = verification.verifiedData;
+      next();
+    },
+    verifyInventoryQuery: (req, res, next) => {
+      const verification = balanceQueryVerifier.verify(req.query);
+      if (!verification.isValid) {
+        return res.status(400).json({ errors: verification.verificationErrors });
+      }
+      verification.verifiedData.skip = parseInt(verification.verifiedData.skip) || 0;
+      verification.verifiedData.limit = parseInt(verification.verifiedData.limit) || 50;
+      req.verifiedQuery = verification.verifiedData;
+      next();
+    },
+    verifyInventoryBody: (req, res, next) => {
+      const verification = inventoryBodyVerifier.verify(req.body);
+      if (!verification.isValid) {
+        return res.status(400).json({ errors: verification.verificationErrors });
+      }
+      req.verifiedBody = verification.verifiedData;
+      next();
+    },
+    verifyInventoryComplete: (req, res, next) => {
+      if (!req.body._id) {
+        return res.status(400).json({ message: "Inventory ID required" });
+      }
+      req.verifiedBody = { _id: req.body._id };
+      next();
+    }
+  };
+}
+function stockAlertsVerifierFactory(db) {
+  const createVerifier = new Verifier({
+    product: {
+      rule: "required",
+      validator: Validator.schema().string().required("Product ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid product ID format")
+    },
+    variant: {
+      rule: "optional",
+      default: null,
+      validator: Validator.schema().oneOfTypes(["string", "null"], "Variant must be a valid ID or null").custom((value) => {
+        if (value === null) return true;
+        return /^[0-9a-fA-F]{24}$/.test(value);
+      }, "Invalid variant ID format")
+    },
+    storage: {
+      rule: "optional",
+      default: null,
+      validator: Validator.schema().oneOfTypes(["string", "null"], "Storage must be a valid ID or null").custom((value) => {
+        if (value === null) return true;
+        return /^[0-9a-fA-F]{24}$/.test(value);
+      }, "Invalid storage ID format")
+    },
+    threshold: {
+      rule: "required",
+      validator: Validator.schema().number().required("Threshold is required").min(0, "Threshold cannot be negative")
+    },
+    enabled: {
+      rule: "optional",
+      default: true,
+      validator: Validator.schema().boolean()
+    },
+    owner: {
+      rule: "required",
+      validator: Validator.schema().object({
+        type: Validator.schema().string().oneOf(["organization"]),
+        target: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
+      })
+    },
+    creator: {
+      rule: "required",
+      validator: Validator.schema().object({
+        type: Validator.schema().string().oneOf(["user"]),
+        target: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
+      })
+    }
+  });
+  const updateVerifier = new Verifier({
+    _id: {
+      rule: "required",
+      validator: Validator.schema().string().required("Alert ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid alert ID format")
+    },
+    product: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid product ID format")
+    },
+    variant: {
+      rule: "optional",
+      validator: Validator.schema().oneOfTypes(["string", "null"], "Variant must be a valid ID or null").custom((value) => {
+        if (value === null) return true;
+        return /^[0-9a-fA-F]{24}$/.test(value);
+      }, "Invalid variant ID format")
+    },
+    storage: {
+      rule: "optional",
+      validator: Validator.schema().oneOfTypes(["string", "null"], "Storage must be a valid ID or null").custom((value) => {
+        if (value === null) return true;
+        return /^[0-9a-fA-F]{24}$/.test(value);
+      }, "Invalid storage ID format")
+    },
+    threshold: {
+      rule: "optional",
+      validator: Validator.schema().number().min(0, "Threshold cannot be negative")
+    },
+    enabled: {
+      rule: "optional",
+      validator: Validator.schema().boolean()
+    }
+  });
+  const readVerifier = new Verifier({
+    _id: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid alert ID format")
+    },
+    product: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid product ID format")
+    },
+    variant: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid variant ID format")
+    },
+    storage: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid storage ID format")
+    },
+    owner: {
+      rule: "optional",
+      validator: Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid owner ID format")
+    },
+    enabled: {
+      rule: "optional",
+      validator: Validator.schema().boolean()
+    },
+    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(["threshold", "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("Alert ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid alert ID format")
+    }
+  });
+  return {
+    createVerifier,
+    readVerifier,
+    updateVerifier,
+    deleteVerifier
+  };
+}
+const { getInstance: getInstance$2 } = ABAC;
+function setupStockAlertsRoutes(app, db) {
+  const abac = getInstance$2(db);
+  const verifier = stockAlertsVerifierFactory();
+  const stockAlertsCRUD = new CRUD({
+    app,
+    db,
+    model: db.stockAlert,
+    modelName: "stockAlert",
+    basePath: "/api/inventory/alerts",
+    auth: true,
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+    abac,
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ["stockAlerts", "inventory"]
+    },
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+  return stockAlertsCRUD;
+}
+const { getInstance: getInstance$1 } = globalsabac;
+function inventoryRoutes(app, db) {
+  const jwt = middlewareFactory(db);
+  const verifier = verifierFactory();
+  const abac = getInstance$1(db);
+  const controller = controllerFactory(db);
+  app.get(
+    "/api/inventory/adjustments",
+    jwt.verifyToken(true),
+    verifier.verifyAdjustmentQuery,
+    controller.adjustments.read
+  );
+  app.post(
+    "/api/inventory/adjustments/create",
+    jwt.verifyToken(),
+    verifier.verifyAdjustmentBody,
+    abac.middleware("stockAdjustment", "create"),
+    controller.adjustments.create
+  );
+  app.get(
+    "/api/inventory/balance",
+    jwt.verifyToken(true),
+    verifier.verifyBalanceQuery,
+    controller.balance.read
+  );
+  app.get(
+    "/api/inventory/availability",
+    verifier.verifyAvailabilityQuery,
+    controller.availability.read
+  );
+  app.get(
+    "/api/inventory/audits",
+    jwt.verifyToken(),
+    verifier.verifyInventoryQuery,
+    controller.inventory.read
+  );
+  app.post(
+    "/api/inventory/audits/create",
+    jwt.verifyToken(),
+    verifier.verifyInventoryBody,
+    abac.middleware("stockAudit", "create"),
+    controller.inventory.create
+  );
+  app.post(
+    "/api/inventory/audits/complete",
+    jwt.verifyToken(),
+    verifier.verifyInventoryComplete,
+    abac.middleware("stockAudit", "edit"),
+    controller.inventory.complete
+  );
+  setupStockAlertsRoutes(app, db);
+}
+const { getInstance } = globalsabac;
+function inventoryPolicies(db) {
+  const abac = getInstance(db);
+  return abac;
+}
+function initializeInventory(app, db, origins, publicPath) {
+  db.stockAdjustment = StockAdjustmentModel(db);
+  db.stockBalance = StockBalanceModel(db);
+  db.stockAvailability = StockAvailabilityModel(db);
+  db.stockAudit = StockAuditModel(db);
+  db.stockAlert = StockAlertModel(db);
+  if (app) {
+    inventoryRoutes(app, db);
+    inventoryPolicies(db);
+  }
+}
+const inventory_server = { initialize: initializeInventory };
+export {
+  inventory_server as default,
+  initializeInventory as initialize
+};