@ozdao/martyrs 0.2.551 → 0.2.553

package/dist/inventory.server.cjs

@@ -1,1069 +0,0 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const ownership_schema = require("./ownership.schema-CRYdbemm.cjs");
-const authJwt = require("./authJwt-BIZ2GIfT.cjs");
-const core_abac = require("./core.abac-DqDvtkHR.cjs");
-const queryProcessor = require("./queryProcessor-DJUTwCLN.cjs");
-const core_logger = require("./core.logger-BuW7JHMY.cjs");
-const crud = require("./crud-CQ3ICbm7.cjs");
-const core_verifier = require("./core.verifier-Bi-XLEi9.cjs");
-const abac = require("./abac-gNSxNkX1.cjs");
-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()
-    }
-  });
-  ownership_schema.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 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"
-    },
-    storage: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: "Spot",
-      required: true
-    },
-    // Physical stock quantity (was in StockBalance)
-    quantity: {
-      type: Number,
-      default: 0
-    },
-    // Computed availability for sale
-    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
-    }],
-    calculatedAt: {
-      type: Date,
-      default: Date.now
-    }
-  }, {
-    timestamps: {
-      currentTime: () => Date.now()
-    }
-  });
-  ownership_schema.applyOwnershipSchema(StockAvailabilitySchema, db);
-  StockAvailabilitySchema.index({ product: 1, variant: 1, storage: 1 }, { unique: true });
-  StockAvailabilitySchema.index({ updatedAt: -1 });
-  StockAvailabilitySchema.index({ storage: 1, variant: 1 });
-  StockAvailabilitySchema.index({ storage: 1, product: 1 });
-  StockAvailabilitySchema.index({ quantity: -1 });
-  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()
-    }
-  });
-  ownership_schema.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()
-    }
-  });
-  ownership_schema.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 availabilityServiceFactory = (db) => {
-  const cache = new core_logger.CacheNamespaced({ ttlSeconds: 300 });
-  const logger = new core_logger.LoggerNamespaced(db);
-  const collectAffectedVariants = async (products, variants, session) => {
-    const affectedVariants = /* @__PURE__ */ new Set();
-    variants?.forEach((v) => {
-      if (v) affectedVariants.add(v.toString());
-    });
-    if (products?.length) {
-      const dependentVariants = await db.variant.find({
-        "ingredients._id": { $in: products },
-        "ingredients.optional": { $ne: true }
-      }).distinct("_id").session(session);
-      dependentVariants.forEach((v) => affectedVariants.add(v.toString()));
-    }
-    return Array.from(affectedVariants);
-  };
-  const recalculateAvailability = async (variantIds, storage, session) => {
-    const variants = await db.variant.find({
-      _id: { $in: variantIds }
-    }).session(session).lean();
-    if (!variants.length) return;
-    const allIngredientIds = /* @__PURE__ */ new Set();
-    variants.forEach((v) => {
-      v.ingredients?.forEach((ing) => {
-        allIngredientIds.add(ing._id.toString());
-      });
-    });
-    const availabilities = await db.stockAvailability.find({
-      storage,
-      $or: [
-        { variant: { $in: variantIds } },
-        { product: { $in: Array.from(allIngredientIds) } }
-      ]
-    }).session(session).lean();
-    const quantityByVariant = /* @__PURE__ */ new Map();
-    const quantityByProduct = /* @__PURE__ */ new Map();
-    availabilities.forEach((a) => {
-      if (a.variant) {
-        quantityByVariant.set(a.variant.toString(), a.quantity);
-      } else if (a.product) {
-        quantityByProduct.set(a.product.toString(), a.quantity);
-      }
-    });
-    const bulkOps = [];
-    variants.forEach((variant) => {
-      const variantId = variant._id.toString();
-      const directStock = quantityByVariant.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 = quantityByProduct.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,
-              available,
-              constraints,
-              calculatedAt: /* @__PURE__ */ new Date()
-            },
-            $setOnInsert: {
-              quantity: directStock,
-              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 = quantityByVariant.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 for ${variant.name || "Product"} is low: ${available} units remaining (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);
-            }
-          }
-        }
-      }
-    }
-  };
-  const invalidateCache = (tags) => {
-    setImmediate(() => {
-      cache.delByTags(tags).catch(
-        (err) => logger.error("Cache invalidation error", err)
-      );
-    });
-  };
-  const 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.stockAvailability.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);
-    });
-  };
-  return {
-    // Public API for reading 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: { pid: "$_id" },
-                pipeline: [
-                  {
-                    $match: {
-                      $expr: { $eq: ["$product", "$$pid"] },
-                      ...req.verifiedQuery?.storage && {
-                        storage: new db.mongoose.Types.ObjectId(req.verifiedQuery.storage)
-                      }
-                    }
-                  }
-                ],
-                as: "availability"
-              }
-            },
-            { $skip: req.verifiedQuery?.skip || 0 },
-            { $limit: req.verifiedQuery?.limit || 20 },
-            {
-              $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,
-                        unit: 1
-                      }
-                    }
-                  ],
-                  as: "productInfo"
-                }
-              },
-              {
-                $unwind: {
-                  path: "$productInfo",
-                  preserveNullAndEmptyArrays: true
-                }
-              }
-            );
-          }
-          data = await db.product.aggregate(pipeline).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 });
-      }
-    },
-    // Internal methods for other services
-    recalculateAvailability,
-    collectAffectedVariants,
-    invalidateCache,
-    initChangeStreams,
-    cache,
-    logger
-  };
-};
-const adjustmentServiceFactory = (db) => {
-  const cache = new core_logger.CacheNamespaced({ ttlSeconds: 300 });
-  const logger = new core_logger.LoggerNamespaced(db);
-  const observer = new crud.ObserverNamespaced();
-  const availabilityService = availabilityServiceFactory(db);
-  const updateStockQuantity = async (product, variant, storage, quantity, owner, creator, session) => {
-    return await db.stockAvailability.findOneAndUpdate(
-      { product, variant, storage },
-      {
-        $inc: { quantity },
-        $setOnInsert: {
-          owner,
-          creator,
-          available: 0,
-          constraints: []
-        }
-      },
-      { upsert: true, new: true, session }
-    );
-  };
-  return {
-    async read(req, res) {
-      try {
-        const cacheKey = JSON.stringify({ type: "adjustments", ...req.verifiedQuery });
-        let data = await cache.get(cacheKey);
-        if (!data) {
-          const stages = [
-            ...queryProcessor.queryProcessorCore.getBasicOptions(req.verifiedQuery),
-            {
-              $lookup: {
-                from: "products",
-                let: { pid: "$product" },
-                pipeline: [
-                  { $match: { $expr: { $eq: ["$_id", "$$pid"] } } },
-                  {
-                    $project: {
-                      name: 1,
-                      sku: 1,
-                      unit: 1
-                    }
-                  }
-                ],
-                as: "productData"
-              }
-            },
-            {
-              $unwind: {
-                path: "$productData",
-                preserveNullAndEmptyArrays: true
-              }
-            },
-            queryProcessor.queryProcessorCore.getCreatorUserLookupStage(),
-            queryProcessor.queryProcessorCore.getAddFieldsCreatorOwnerStage(),
-            ...queryProcessor.queryProcessorCore.getSortingOptions("createdAt", "desc"),
-            ...queryProcessor.queryProcessorCore.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 availability = await updateStockQuantity(
-          adjustmentData.product,
-          adjustmentData.variant,
-          adjustmentData.storage,
-          adjustmentData.quantity,
-          adjustmentData.owner,
-          adjustmentData.creator,
-          session
-        );
-        const affectedVariants = await availabilityService.collectAffectedVariants(
-          [adjustmentData.product],
-          adjustmentData.variant ? [adjustmentData.variant] : [],
-          session
-        );
-        if (affectedVariants.length) {
-          await availabilityService.recalculateAvailability(affectedVariants, adjustmentData.storage, session);
-        }
-        await session.commitTransaction();
-        availabilityService.invalidateCache(["adjustments", "availability"]);
-        setImmediate(() => {
-          observer.notify("stock.adjusted", {
-            adjustment,
-            availability,
-            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 auditServiceFactory = (db) => {
-  new core_logger.CacheNamespaced({ ttlSeconds: 300 });
-  const logger = new core_logger.LoggerNamespaced(db);
-  const observer = new crud.ObserverNamespaced();
-  const availabilityService = availabilityServiceFactory(db);
-  async function processInventoryPositions(audit, session) {
-    await Promise.all(
-      audit.positions.map(
-        (position) => db.stockAdjustment.create([{
-          product: position.product,
-          variant: position.variant,
-          storage: audit.storage,
-          source: { type: "Inventory", target: audit._id },
-          reason: position.reason || "custom",
-          comment: position.comment,
-          quantity: position.quantity,
-          cost: position.cost,
-          creator: audit.creator,
-          owner: audit.owner
-        }], { session })
-      )
-    );
-    await db.stockAvailability.bulkWrite(
-      audit.positions.map((p) => ({
-        updateOne: {
-          filter: {
-            product: p.product,
-            variant: p.variant || null,
-            storage: audit.storage
-          },
-          update: {
-            $inc: { quantity: p.quantity },
-            $setOnInsert: {
-              owner: audit.owner,
-              creator: audit.creator,
-              available: 0,
-              constraints: []
-            }
-          },
-          upsert: true
-        }
-      })),
-      { session }
-    );
-    const products = audit.positions.map((p) => p.product);
-    const variants = audit.positions.filter((p) => p.variant).map((p) => p.variant);
-    return await availabilityService.collectAffectedVariants(products, variants, session);
-  }
-  return {
-    async read(req, res) {
-      try {
-        const stages = [
-          ...queryProcessor.queryProcessorCore.getBasicOptions(req.verifiedQuery),
-          queryProcessor.queryProcessorCore.getCreatorUserLookupStage(),
-          queryProcessor.queryProcessorCore.getAddFieldsCreatorOwnerStage(),
-          ...queryProcessor.queryProcessorCore.getSortingOptions("createdAt", "desc"),
-          ...queryProcessor.queryProcessorCore.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 affectedVariants = await processInventoryPositions(audit[0], session);
-          if (affectedVariants.length) {
-            await availabilityService.recalculateAvailability(affectedVariants, audit[0].storage, session);
-          }
-        }
-        await session.commitTransaction();
-        availabilityService.invalidateCache(["inventories", "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 inventory = await db.stockAudit.findById(req.verifiedBody._id).session(session);
-        if (!inventory || inventory.status !== "draft") {
-          throw new Error("Invalid inventory status");
-        }
-        const affectedVariants = await processInventoryPositions(inventory, session);
-        if (affectedVariants.length) {
-          await availabilityService.recalculateAvailability(affectedVariants, inventory.storage, session);
-        }
-        inventory.status = "published";
-        await inventory.save({ session });
-        await session.commitTransaction();
-        availabilityService.invalidateCache(["adjustments", "availability", "inventories"]);
-        setImmediate(() => {
-          observer.notify("inventory.completed", {
-            inventory,
-            affectedVariants
-          });
-        });
-        res.json(inventory);
-      } catch (error) {
-        await session.abortTransaction();
-        logger.error("Error completing inventory", error);
-        res.status(500).json({ message: error.message });
-      } finally {
-        session.endSession();
-      }
-    }
-  };
-};
-function verifierFactory(db) {
-  const adjustmentQueryConfig = {
-    product: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    variant: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    storage: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    reason: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    dateStart: { rule: "optional", validator: core_verifier.Validator.schema().date() },
-    dateEnd: { rule: "optional", validator: core_verifier.Validator.schema().date() },
-    skip: { rule: "optional", validator: core_verifier.Validator.schema().integer().min(0), default: 0 },
-    limit: { rule: "optional", validator: core_verifier.Validator.schema().integer().min(1).max(100), default: 20 }
-  };
-  const adjustmentBodyConfig = {
-    product: { rule: "required", validator: core_verifier.Validator.schema().string() },
-    variant: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    storage: { rule: "required", validator: core_verifier.Validator.schema().string() },
-    source: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().object({
-        type: core_verifier.Validator.schema().string().oneOf(["User", "Order", "Inventory"]).required(),
-        target: core_verifier.Validator.schema().string().required()
-      })
-    },
-    reason: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().oneOf(["restock", "sale", "return", "damage", "transfer", "custom"])
-    },
-    quantity: { rule: "required", validator: core_verifier.Validator.schema().integer() },
-    cost: { rule: "optional", validator: core_verifier.Validator.schema().number().min(0) },
-    comment: { rule: "optional", validator: core_verifier.Validator.schema().string() }
-  };
-  const queryConfig = {
-    product: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    storage: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    skip: { rule: "optional", validator: core_verifier.Validator.schema().integer().min(0), default: 0 },
-    limit: { rule: "optional", validator: core_verifier.Validator.schema().integer().min(1).max(100), default: 50 },
-    details: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    search: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    sortParam: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    sortOrder: { rule: "optional", validator: core_verifier.Validator.schema().string().oneOf(["asc", "desc"]) }
-  };
-  const inventoryBodyConfig = {
-    storage: { rule: "required", validator: core_verifier.Validator.schema().string() },
-    comment: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-    status: { rule: "optional", validator: core_verifier.Validator.schema().string().oneOf(["draft", "published"]), default: "draft" },
-    positions: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().array().items(
-        core_verifier.Validator.schema().object({
-          product: core_verifier.Validator.schema().string().required(),
-          variant: core_verifier.Validator.schema().string(),
-          quantity: core_verifier.Validator.schema().number().integer().required()
-        })
-      )
-    }
-  };
-  const adjustmentQueryVerifier = new core_verifier.Verifier(adjustmentQueryConfig);
-  const adjustmentBodyVerifier = new core_verifier.Verifier(adjustmentBodyConfig);
-  const queryVerifier = new core_verifier.Verifier(queryConfig);
-  const inventoryBodyVerifier = new core_verifier.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();
-    },
-    verifyAvailabilityQuery: (req, res, next) => {
-      const verification = queryVerifier.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 = queryVerifier.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 core_verifier.Verifier({
-    product: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Product ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid product ID format")
-    },
-    variant: {
-      rule: "optional",
-      default: null,
-      validator: core_verifier.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: core_verifier.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: core_verifier.Validator.schema().number().required("Threshold is required").min(0, "Threshold cannot be negative")
-    },
-    enabled: {
-      rule: "optional",
-      default: true,
-      validator: core_verifier.Validator.schema().boolean()
-    },
-    owner: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().object({
-        type: core_verifier.Validator.schema().string().oneOf(["organization"]),
-        target: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
-      })
-    },
-    creator: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().object({
-        type: core_verifier.Validator.schema().string().oneOf(["user"]),
-        target: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/)
-      })
-    }
-  });
-  const updateVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Alert ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid alert ID format")
-    },
-    product: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid product ID format")
-    },
-    variant: {
-      rule: "optional",
-      validator: core_verifier.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: core_verifier.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: core_verifier.Validator.schema().number().min(0, "Threshold cannot be negative")
-    },
-    enabled: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().boolean()
-    }
-  });
-  const readVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid alert ID format")
-    },
-    product: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid product ID format")
-    },
-    variant: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid variant ID format")
-    },
-    storage: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid storage ID format")
-    },
-    owner: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().pattern(/^[0-9a-fA-F]{24}$/, "Invalid owner ID format")
-    },
-    enabled: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().boolean()
-    },
-    skip: {
-      rule: "optional",
-      default: 0,
-      validator: core_verifier.Validator.schema().integer().min(0)
-    },
-    limit: {
-      rule: "optional",
-      default: 20,
-      validator: core_verifier.Validator.schema().integer().min(1).max(100)
-    },
-    sortParam: {
-      rule: "optional",
-      validator: core_verifier.Validator.schema().string().oneOf(["threshold", "createdAt", "updatedAt"])
-    },
-    sortOrder: {
-      rule: "optional",
-      default: "desc",
-      validator: core_verifier.Validator.schema().string().oneOf(["asc", "desc"])
-    }
-  });
-  const deleteVerifier = new core_verifier.Verifier({
-    _id: {
-      rule: "required",
-      validator: core_verifier.Validator.schema().string().required("Alert ID is required").pattern(/^[0-9a-fA-F]{24}$/, "Invalid alert ID format")
-    }
-  });
-  return {
-    createVerifier,
-    readVerifier,
-    updateVerifier,
-    deleteVerifier
-  };
-}
-const { getInstance: getInstance$2 } = abac.ABAC;
-function setupStockAlertsRoutes(app, db) {
-  const abac2 = getInstance$2(db);
-  const verifier = stockAlertsVerifierFactory();
-  const stockAlertsCRUD = new crud.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: abac2,
-    cache: {
-      enabled: true,
-      ttl: 300,
-      tags: ["stockAlerts", "inventory"]
-    },
-    events: {
-      enabled: true,
-      logReads: false
-    }
-  });
-  return stockAlertsCRUD;
-}
-const { getInstance: getInstance$1 } = core_abac.coreabac;
-function inventoryRoutes(app, db) {
-  const jwt = authJwt.middlewareFactory(db);
-  const verifier = verifierFactory();
-  const abac2 = getInstance$1(db);
-  const adjustmentService = adjustmentServiceFactory(db);
-  const availabilityService = availabilityServiceFactory(db);
-  const auditService = auditServiceFactory(db);
-  app.get(
-    "/api/inventory/adjustments",
-    jwt.verifyToken(true),
-    verifier.verifyAdjustmentQuery,
-    adjustmentService.read
-  );
-  app.post(
-    "/api/inventory/adjustments/create",
-    jwt.verifyToken(),
-    verifier.verifyAdjustmentBody,
-    abac2.middleware("stockAdjustment", "create"),
-    adjustmentService.create
-  );
-  app.get(
-    "/api/inventory/availability",
-    verifier.verifyAvailabilityQuery,
-    availabilityService.read
-  );
-  app.get(
-    "/api/inventory/audits",
-    jwt.verifyToken(),
-    verifier.verifyInventoryQuery,
-    auditService.read
-  );
-  app.post(
-    "/api/inventory/audits/create",
-    jwt.verifyToken(),
-    verifier.verifyInventoryBody,
-    abac2.middleware("stockAudit", "create"),
-    auditService.create
-  );
-  app.post(
-    "/api/inventory/audits/complete",
-    jwt.verifyToken(),
-    verifier.verifyInventoryComplete,
-    abac2.middleware("stockAudit", "edit"),
-    auditService.complete
-  );
-  setupStockAlertsRoutes(app, db);
-}
-const { getInstance } = core_abac.coreabac;
-function inventoryPolicies(db) {
-  const abac2 = getInstance(db);
-  return abac2;
-}
-function initializeInventory(app, db, origins, publicPath) {
-  db.stockAdjustment = StockAdjustmentModel(db);
-  db.stockAvailability = StockAvailabilityModel(db);
-  db.stockAudit = StockAuditModel(db);
-  db.stockAlert = StockAlertModel(db);
-  if (app) {
-    inventoryRoutes(app, db);
-    inventoryPolicies(db);
-    const availabilityService = availabilityServiceFactory(db);
-    availabilityService.initChangeStreams();
-  }
-}
-const inventory_server = { initialize: initializeInventory };
-exports.default = inventory_server;
-exports.initialize = initializeInventory;