@ozdao/martyrs 0.2.518 → 0.2.520

package/src/modules/inventory/inventory.server.js

@@ -1,16 +1,15 @@
 import StockAdjustmentModel from './models/stock.adjustment.model.js';
-import StockBalanceModel from './models/stock.balance.model.js';
 import StockAvailabilityModel from './models/stock.availability.model.js';
 import StockAuditModel from './models/stock.audit.model.js';
 import StockAlertModel from './models/stock.alerts.model.js';
 
 import inventoryRoutes from './routes/inventory.routes.js';
 import inventoryPolicies from './policies/inventory.policies.js';
+import availabilityServiceFactory from './services/availability.service.js';
 
 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);
@@ -19,6 +18,11 @@ function initializeInventory(app, db, origins, publicPath) {
   if (app) {
     inventoryRoutes(app, db, origins, publicPath);
     inventoryPolicies(db);
+    
+    // Инициализация availability service с change streams
+    const availabilityService = availabilityServiceFactory(db);
+    
+    availabilityService.initChangeStreams();
   }
 }
 

package/src/modules/inventory/{services → middlewares}/inventory.verifier.js

@@ -34,8 +34,8 @@ export default function(db) {
     comment: { rule: 'optional', validator: Validator.schema().string() }
   };
   
-  // Balance & Availability verifiers
-  const balanceQueryConfig = {
+  // Availability & Inventory query verifiers
+  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 },
@@ -65,7 +65,7 @@ export default function(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 {
@@ -85,19 +85,8 @@ export default function(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 });
       }
@@ -108,7 +97,7 @@ export default function(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 });
       }

package/src/modules/inventory/models/stock.availability.model.js

@@ -1,3 +1,5 @@
+import applyOwnershipSchema from '@martyrs/src/modules/globals/models/schemas/ownership.schema.js';
+
 export default db => {
   const StockAvailabilitySchema = new db.mongoose.Schema({
     product: {
@@ -8,18 +10,18 @@ export default db => {
     variant: {
       type: db.mongoose.Schema.Types.ObjectId,
       ref: 'Variant',
-      required: true,
     },
     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,
@@ -37,17 +39,28 @@ export default db => {
       required: Number,
       available: Number,
     }],
+    calculatedAt: {
+      type: Date,
+      default: Date.now,
+    }
   }, {
     timestamps: {
       currentTime: () => Date.now(),
     },
   });
 
-  // Create indexes for efficient querying
-  StockAvailabilitySchema.index(
-    { product: 1, variant: 1, storage: 1 },
-    { unique: true }
-  );
+  applyOwnershipSchema(StockAvailabilitySchema, db);
+
+  // Add proper composite index for lookups (from StockBalance)
+  StockAvailabilitySchema.index({product: 1, variant: 1, storage: 1}, {unique: true});
+  
+  // Add individual indexes for common lookups (from StockBalance)
+  StockAvailabilitySchema.index({updatedAt: -1});
+  StockAvailabilitySchema.index({ storage: 1, variant: 1 });
+  StockAvailabilitySchema.index({ storage: 1, product: 1 });
+  StockAvailabilitySchema.index({ quantity: -1 });
+  
+  // Original availability indexes
   StockAvailabilitySchema.index({ storage: 1 });
   StockAvailabilitySchema.index({ available: -1 }); 
   

package/src/modules/inventory/routes/inventory.routes.js

@@ -1,7 +1,9 @@
 import jwtFactory from '@martyrs/src/modules/auth/controllers/middlewares/authJwt.js';
 import globalsabac from '@martyrs/src/modules/globals/controllers/classes/globals.abac.js';
-import controllerFactory from '../services/inventory.crud.js';
-import verifierFactory from '../services/inventory.verifier.js';
+import adjustmentServiceFactory from '../services/adjustment.service.js';
+import availabilityServiceFactory from '../services/availability.service.js';
+import auditServiceFactory from '../services/audit.service.js';
+import verifierFactory from '../middlewares/inventory.verifier.js';
 import setupStockAlertsRoutes from './stock.alerts.routes.js';
 
 const { getInstance } = globalsabac;
@@ -10,54 +12,49 @@ export default function(app, db) {
   const jwt = jwtFactory(db);
   const verifier = verifierFactory(db);
   const abac = getInstance(db);
-  const controller = controllerFactory(db);
+  const adjustmentService = adjustmentServiceFactory(db);
+  const availabilityService = availabilityServiceFactory(db);
+  const auditService = auditServiceFactory(db);
   
   // StockAdjustment routes
   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
-  );
-  
-  // StockBalance routes
-  app.get('/api/inventory/balance', 
-    jwt.verifyToken(true), 
-    verifier.verifyBalanceQuery, 
-    controller.balance.read
+    adjustmentService.create
   );
   
   // StockAvailability routes
   app.get('/api/inventory/availability', 
     verifier.verifyAvailabilityQuery, 
-    controller.availability.read
+    availabilityService.read
   );
   
-  // StockInventory routes
+  // StockAudit routes
   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
   );
   
   // Initialize stock alerts routes

package/src/modules/inventory/services/adjustment.service.js

@@ -0,0 +1,137 @@
+import queryProcessor from '@martyrs/src/modules/globals/controllers/utils/queryProcessor.js';
+import Cache from '@martyrs/src/modules/globals/controllers/classes/globals.cache.js';
+import Logger from '@martyrs/src/modules/globals/controllers/classes/globals.logger.js';
+import Observer from '@martyrs/src/modules/globals/controllers/classes/globals.observer.js';
+import availabilityServiceFactory from './availability.service.js';
+
+const adjustmentServiceFactory = db => {
+  const cache = new Cache({ ttlSeconds: 300 });
+  const logger = new Logger(db);
+  const observer = new Observer();
+  const availabilityService = availabilityServiceFactory(db);
+  
+  // Update quantity in stockAvailability - local function
+  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.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.getCreatorUserLookupStage(),
+            queryProcessor.getAddFieldsCreatorOwnerStage(),
+            ...queryProcessor.getSortingOptions('createdAt', 'desc'),
+            ...queryProcessor.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();
+      }
+    }
+  };
+};
+
+export default adjustmentServiceFactory;

package/src/modules/inventory/services/audit.service.js

@@ -0,0 +1,160 @@
+import queryProcessor from '@martyrs/src/modules/globals/controllers/utils/queryProcessor.js';
+import Cache from '@martyrs/src/modules/globals/controllers/classes/globals.cache.js';
+import Logger from '@martyrs/src/modules/globals/controllers/classes/globals.logger.js';
+import Observer from '@martyrs/src/modules/globals/controllers/classes/globals.observer.js';
+import availabilityServiceFactory from './availability.service.js';
+
+const auditServiceFactory = db => {
+  const cache = new Cache({ ttlSeconds: 300 });
+  const logger = new Logger(db);
+  const observer = new Observer();
+  const availabilityService = availabilityServiceFactory(db);
+  
+  // Process inventory positions
+  async function processInventoryPositions(audit, session) {
+    // Create adjustments
+    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 })
+      )
+    );
+    
+    // Update quantities
+    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 }
+    );
+    
+    // Collect affected items
+    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.getBasicOptions(req.verifiedQuery),
+          queryProcessor.getCreatorUserLookupStage(),
+          queryProcessor.getAddFieldsCreatorOwnerStage(),
+          ...queryProcessor.getSortingOptions('createdAt', 'desc'),
+          ...queryProcessor.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();
+      }
+    }
+  };
+};
+
+export default auditServiceFactory;