@ozdao/martyrs 0.2.518 → 0.2.520

package/dist/inventory.server.js

@@ -1,12 +1,12 @@
 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 { C as CacheNamespaced, L as LoggerNamespaced } from "./globals.logger-VRHh-WUW.js";
+import { O as ObserverNamespaced } from "./globals.observer-MZsqaE6F.js";
 import { a as Validator, V as Verifier } from "./globals.verifier-DFqKQ7hK.js";
-import { C as CRUD } from "./crud-sE7GLPbj.js";
-import { A as ABAC } from "./abac-Cf_9lCSh.js";
+import { C as CRUD } from "./crud-BIFl1W1i.js";
+import { A as ABAC } from "./abac-CnJsrv8S.js";
 const StockAdjustmentModel = (db) => {
   const StockAdjustmentSchema = new db.mongoose.Schema({
     product: {
@@ -64,40 +64,6 @@ const StockAdjustmentModel = (db) => {
   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: {
@@ -107,19 +73,19 @@ const StockAvailabilityModel = (db) => {
     },
     variant: {
       type: db.mongoose.Schema.Types.ObjectId,
-      ref: "Variant",
-      required: true
+      ref: "Variant"
     },
     storage: {
       type: db.mongoose.Schema.Types.ObjectId,
       ref: "Spot",
       required: true
     },
-    // Computed availability
+    // Physical stock quantity (was in StockBalance)
     quantity: {
       type: Number,
       default: 0
     },
+    // Computed availability for sale
     available: {
       type: Number,
       default: 0
@@ -136,16 +102,22 @@ const StockAvailabilityModel = (db) => {
       stock: Number,
       required: Number,
       available: Number
-    }]
+    }],
+    calculatedAt: {
+      type: Date,
+      default: Date.now
+    }
   }, {
     timestamps: {
       currentTime: () => Date.now()
     }
   });
-  StockAvailabilitySchema.index(
-    { product: 1, variant: 1, storage: 1 },
-    { unique: true }
-  );
+  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);
@@ -244,49 +216,60 @@ const StockAlertModel = (db) => {
   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 availabilityServiceFactory = (db) => {
+  const cache = new CacheNamespaced({ ttlSeconds: 300 });
+  const logger = new 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();
-    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({
+    const availabilities = await db.stockAvailability.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 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 = balanceByVariant.get(variantId) || 0;
+      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 = balanceByProduct.get(ing._id.toString()) || 0;
+          const stock = quantityByProduct.get(ing._id.toString()) || 0;
           const canMake = Math.floor(stock / (ing.quantity || 1));
           if (directStock === 0 || canMake < available) {
             available = canMake;
@@ -308,12 +291,12 @@ const controllerFactory = (db) => {
           update: {
             $set: {
               product: variant.product,
-              quantity: directStock,
               available,
               constraints,
               calculatedAt: /* @__PURE__ */ new Date()
             },
             $setOnInsert: {
+              quantity: directStock,
               owner: variant.owner,
               creator: variant.creator
             }
@@ -326,7 +309,7 @@ const controllerFactory = (db) => {
       await db.stockAvailability.bulkWrite(bulkOps, { session });
       for (const variant of variants) {
         const variantId = variant._id.toString();
-        const available = balanceByVariant.get(variantId) || 0;
+        const available = quantityByVariant.get(variantId) || 0;
         const alerts = await db.stockAlert.find({
           product: variant.product,
           enabled: true,
@@ -348,7 +331,7 @@ const controllerFactory = (db) => {
                 },
                 body: JSON.stringify({
                   title: "Low Stock Alert",
-                  body: `Stock is low: ${available} units (threshold: ${alert.threshold})`,
+                  body: `Stock for ${variant.name || "Product"} is low: ${available} units remaining (threshold: ${alert.threshold})`,
                   type: "stock_alert",
                   metadata: {
                     alertId: alert._id,
@@ -368,20 +351,20 @@ const controllerFactory = (db) => {
         }
       }
     }
-  }
-  function invalidateCache(tags) {
+  };
+  const invalidateCache = (tags) => {
     setImmediate(() => {
       cache.delByTags(tags).catch(
         (err) => logger.error("Cache invalidation error", err)
       );
     });
-  }
-  function initChangeStreams() {
+  };
+  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.stockBalance.distinct("storage", {
+        const storages = await db.stockAvailability.distinct("storage", {
           variant: variantId
         });
         for (const storage of storages) {
@@ -393,154 +376,9 @@ const controllerFactory = (db) => {
     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 = {
+  return {
+    // Public API for reading availability
     async read(req, res) {
       try {
         console.log("=== AVAILABILITY DEBUG ===");
@@ -574,18 +412,22 @@ const controllerFactory = (db) => {
             {
               $lookup: {
                 from: "stockavailabilities",
-                let: { productId: "$_id" },
+                let: { pid: "$_id" },
                 pipeline: [
                   {
                     $match: {
-                      $expr: { $eq: ["$product", "$$productId"] },
-                      ...req.verifiedQuery?.storage && { storage: new db.mongoose.Types.ObjectId(req.verifiedQuery.storage) }
+                      $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" },
@@ -602,32 +444,26 @@ const controllerFactory = (db) => {
                   let: { pid: "$product" },
                   pipeline: [
                     { $match: { $expr: { $eq: ["$_id", "$$pid"] } } },
-                    { $project: { name: 1, sku: 1, price: 1, images: { $slice: ["$images", 1] } } }
+                    {
+                      $project: {
+                        name: 1,
+                        sku: 1,
+                        unit: 1
+                      }
+                    }
                   ],
-                  as: "product"
+                  as: "productInfo"
                 }
               },
-              { $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: "$productInfo",
+                  preserveNullAndEmptyArrays: true
                 }
-              },
-              { $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();
+          data = await db.product.aggregate(pipeline).exec();
           await cache.setWithTags(cacheKey, data, ["availability"]);
         }
         res.json(data);
@@ -635,9 +471,178 @@ const controllerFactory = (db) => {
         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 CacheNamespaced({ ttlSeconds: 300 });
+  const logger = new LoggerNamespaced(db);
+  const observer = new 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 = [
+            ...queryProcessorGlobals.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
+              }
+            },
+            queryProcessorGlobals.getCreatorUserLookupStage(),
+            queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
+            ...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 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 inventory = {
+};
+const auditServiceFactory = (db) => {
+  new CacheNamespaced({ ttlSeconds: 300 });
+  const logger = new LoggerNamespaced(db);
+  const observer = new 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 = [
@@ -665,57 +670,13 @@ const controllerFactory = (db) => {
         };
         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);
+          const affectedVariants = await processInventoryPositions(audit[0], session);
+          if (affectedVariants.length) {
+            await availabilityService.recalculateAvailability(affectedVariants, audit[0].storage, session);
           }
         }
         await session.commitTransaction();
-        invalidateCache(["inventories", "balances", "availability"]);
+        availabilityService.invalidateCache(["inventories", "availability"]);
         res.status(201).json(audit[0]);
       } catch (error) {
         await session.abortTransaction();
@@ -729,72 +690,25 @@ const controllerFactory = (db) => {
       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") {
+        const inventory = await db.stockAudit.findById(req.verifiedBody._id).session(session);
+        if (!inventory || inventory.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
-          );
+        const affectedVariants = await processInventoryPositions(inventory, session);
+        if (affectedVariants.length) {
+          await availabilityService.recalculateAvailability(affectedVariants, inventory.storage, session);
         }
-        inventory2.status = "published";
-        await inventory2.save({ session });
+        inventory.status = "published";
+        await inventory.save({ session });
         await session.commitTransaction();
-        invalidateCache(["adjustments", "balance", "availability", "inventories"]);
+        availabilityService.invalidateCache(["adjustments", "availability", "inventories"]);
         setImmediate(() => {
           observer.notify("inventory.completed", {
-            inventory: inventory2,
-            affectedVariants: Array.from(affectedVariants)
+            inventory,
+            affectedVariants
           });
         });
-        res.json(inventory2);
+        res.json(inventory);
       } catch (error) {
         await session.abortTransaction();
         logger.error("Error completing inventory", error);
@@ -804,7 +718,6 @@ const controllerFactory = (db) => {
       }
     }
   };
-  return { adjustments, balance, availability, inventory };
 };
 function verifierFactory(db) {
   const adjustmentQueryConfig = {
@@ -836,7 +749,7 @@ function verifierFactory(db) {
     cost: { rule: "optional", validator: Validator.schema().number().min(0) },
     comment: { rule: "optional", validator: Validator.schema().string() }
   };
-  const balanceQueryConfig = {
+  const queryConfig = {
     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 },
@@ -863,7 +776,7 @@ function verifierFactory(db) {
   };
   const adjustmentQueryVerifier = new Verifier(adjustmentQueryConfig);
   const adjustmentBodyVerifier = new Verifier(adjustmentBodyConfig);
-  const balanceQueryVerifier = new Verifier(balanceQueryConfig);
+  const queryVerifier = new Verifier(queryConfig);
   const inventoryBodyVerifier = new Verifier(inventoryBodyConfig);
   return {
     verifyAdjustmentQuery: (req, res, next) => {
@@ -882,18 +795,8 @@ function verifierFactory(db) {
       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);
+      const verification = queryVerifier.verify(req.query);
       if (!verification.isValid) {
         return res.status(400).json({ errors: verification.verificationErrors });
       }
@@ -903,7 +806,7 @@ function verifierFactory(db) {
       next();
     },
     verifyInventoryQuery: (req, res, next) => {
-      const verification = balanceQueryVerifier.verify(req.query);
+      const verification = queryVerifier.verify(req.query);
       if (!verification.isValid) {
         return res.status(400).json({ errors: verification.verificationErrors });
       }
@@ -1100,50 +1003,46 @@ function inventoryRoutes(app, db) {
   const jwt = middlewareFactory(db);
   const verifier = verifierFactory();
   const abac = getInstance$1(db);
-  const controller = controllerFactory(db);
+  const adjustmentService = adjustmentServiceFactory(db);
+  const availabilityService = availabilityServiceFactory(db);
+  const auditService = auditServiceFactory(db);
   app.get(
     "/api/inventory/adjustments",
     jwt.verifyToken(true),
     verifier.verifyAdjustmentQuery,
-    controller.adjustments.read
+    adjustmentService.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
+    adjustmentService.create
   );
   app.get(
     "/api/inventory/availability",
     verifier.verifyAvailabilityQuery,
-    controller.availability.read
+    availabilityService.read
   );
   app.get(
     "/api/inventory/audits",
     jwt.verifyToken(),
     verifier.verifyInventoryQuery,
-    controller.inventory.read
+    auditService.read
   );
   app.post(
     "/api/inventory/audits/create",
     jwt.verifyToken(),
     verifier.verifyInventoryBody,
     abac.middleware("stockAudit", "create"),
-    controller.inventory.create
+    auditService.create
   );
   app.post(
     "/api/inventory/audits/complete",
     jwt.verifyToken(),
     verifier.verifyInventoryComplete,
     abac.middleware("stockAudit", "edit"),
-    controller.inventory.complete
+    auditService.complete
   );
   setupStockAlertsRoutes(app, db);
 }
@@ -1154,13 +1053,14 @@ function inventoryPolicies(db) {
 }
 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 availabilityService = availabilityServiceFactory(db);
+    availabilityService.initChangeStreams();
   }
 }
 const inventory_server = { initialize: initializeInventory };