@ozdao/martyrs 0.2.518 → 0.2.520

package/dist/_virtual/index.cjs

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const _commonjsHelpers = require("./_commonjsHelpers.cjs");
-const index = require("../node_modules/fast-deep-equal/index.cjs");
-var fastDeepEqualExports = index.__require();
-const equal = /* @__PURE__ */ _commonjsHelpers.getDefaultExportFromCjs(fastDeepEqualExports);
-exports.default = equal;
+const index = require("../node_modules/lodash.merge/index.cjs");
+var lodash_mergeExports = index.__require();
+const merge = /* @__PURE__ */ _commonjsHelpers.getDefaultExportFromCjs(lodash_mergeExports);
+exports.default = merge;
 //# sourceMappingURL=index.cjs.map

package/dist/_virtual/index.js

@@ -1,8 +1,8 @@
 import { getDefaultExportFromCjs } from "./_commonjsHelpers.js";
-import { __require as requireFastDeepEqual } from "../node_modules/fast-deep-equal/index.js";
-var fastDeepEqualExports = requireFastDeepEqual();
-const equal = /* @__PURE__ */ getDefaultExportFromCjs(fastDeepEqualExports);
+import { __require as requireLodash_merge } from "../node_modules/lodash.merge/index.js";
+var lodash_mergeExports = requireLodash_merge();
+const merge = /* @__PURE__ */ getDefaultExportFromCjs(lodash_mergeExports);
 export {
-  equal as default
+  merge as default
 };
 //# sourceMappingURL=index.js.map

package/dist/_virtual/index2.cjs

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const _commonjsHelpers = require("./_commonjsHelpers.cjs");
-const index = require("../node_modules/lodash.merge/index.cjs");
-var lodash_mergeExports = index.__require();
-const merge = /* @__PURE__ */ _commonjsHelpers.getDefaultExportFromCjs(lodash_mergeExports);
-exports.default = merge;
+const index = require("../node_modules/fast-deep-equal/index.cjs");
+var fastDeepEqualExports = index.__require();
+const equal = /* @__PURE__ */ _commonjsHelpers.getDefaultExportFromCjs(fastDeepEqualExports);
+exports.default = equal;
 //# sourceMappingURL=index2.cjs.map

package/dist/_virtual/index2.js

@@ -1,8 +1,8 @@
 import { getDefaultExportFromCjs } from "./_commonjsHelpers.js";
-import { __require as requireLodash_merge } from "../node_modules/lodash.merge/index.js";
-var lodash_mergeExports = requireLodash_merge();
-const merge = /* @__PURE__ */ getDefaultExportFromCjs(lodash_mergeExports);
+import { __require as requireFastDeepEqual } from "../node_modules/fast-deep-equal/index.js";
+var fastDeepEqualExports = requireFastDeepEqual();
+const equal = /* @__PURE__ */ getDefaultExportFromCjs(fastDeepEqualExports);
 export {
-  merge as default
+  equal as default
 };
 //# sourceMappingURL=index2.js.map

package/dist/{abac-Cf_9lCSh.js → abac-CnJsrv8S.js}

@@ -1,4 +1,4 @@
-import { C as Cache, L as Logger } from "./globals.logger-Bf6rRU7j.js";
+import { C as CacheNamespaced, L as LoggerNamespaced } from "./globals.logger-VRHh-WUW.js";
 class ABACCore {
   constructor(abac) {
     this.abac = abac;
@@ -966,8 +966,8 @@ class GlobalABAC {
       concurrencyLimit: 10,
       ...options
     };
-    this.cache = new Cache({ ttlSeconds: this.options.cacheTTL });
-    this.logger = options.auditLogger || new Logger(db);
+    this.cache = new CacheNamespaced({ ttlSeconds: this.options.cacheTTL });
+    this.logger = options.auditLogger || new LoggerNamespaced(db);
     this.core = new ABACCore(this);
     this.policies = new ABACPolicies(this);
     this.fields = new ABACFields(this);

package/dist/{abac-6LjoG9u-.cjs → abac-DOyUjhee.cjs}

@@ -1,5 +1,5 @@
 "use strict";
-const globals_logger = require("./globals.logger-CZMgIMlM.cjs");
+const globals_logger = require("./globals.logger-BuW7JHMY.cjs");
 class ABACCore {
   constructor(abac) {
     this.abac = abac;
@@ -967,8 +967,8 @@ class GlobalABAC {
       concurrencyLimit: 10,
       ...options
     };
-    this.cache = new globals_logger.Cache({ ttlSeconds: this.options.cacheTTL });
-    this.logger = options.auditLogger || new globals_logger.Logger(db);
+    this.cache = new globals_logger.CacheNamespaced({ ttlSeconds: this.options.cacheTTL });
+    this.logger = options.auditLogger || new globals_logger.LoggerNamespaced(db);
     this.core = new ABACCore(this);
     this.policies = new ABACPolicies(this);
     this.fields = new ABACFields(this);

package/dist/builder.cjs

@@ -595,19 +595,18 @@ function createSsrDevServer(projectRoot, { clientConfig: clientConfig2, apiConfi
           }
           const jsonStats = stats.toJson();
           if (stats.hasErrors()) {
-            console.error(chalk.red("Client compilation error"));
-            jsonStats.errors.forEach((err) => {
-              if (err.details) {
-                console.error(err.details);
-              } else if (typeof err === "object") {
-                try {
-                  console.error(JSON.stringify(err, null, 2));
-                } catch (e) {
-                  console.error(e);
-                }
-              } else {
-                console.error(chalk.red(err.slice()));
+            console.error(chalk.red("❌ Ошибка компиляции"));
+            jsonStats.errors.forEach((err, index) => {
+              console.error(chalk.red(`
+=== ОШИБКА ${index + 1} ===`));
+              if (err.message) {
+                let message = err.message.replace(/\u001b\[[0-9;]*m/g, "");
+                console.error(chalk.red(message));
+              }
+              if (err.moduleName) {
+                console.error(chalk.yellow(`📄 ФАЙЛ: ${err.moduleName}`));
               }
+              console.error("");
             });
             return;
           }
@@ -667,6 +666,8 @@ function createSsrDevServer(projectRoot, { clientConfig: clientConfig2, apiConfi
   const clientDevMiddleware = devMiddleware(clientCompiler, {
     publicPath: clientConfig2.output.publicPath,
     serverSideRender: true,
+    stats: "minimal",
+    // или 'errors-only'
     stats: {
       children: true
     }
@@ -1019,21 +1020,22 @@ const baseConfig$2 = (projectRoot) => {
       level: "verbose"
     },
     stats: {
-      colors: true,
-      hash: true,
-      version: true,
-      timings: true,
-      assets: true,
-      chunks: true,
-      modules: true,
-      reasons: true,
-      children: true,
-      source: true,
+      // Минимальный вывод
+      preset: "minimal",
+      // Или более детальная настройка:
+      modules: false,
+      chunks: false,
+      chunkModules: false,
+      chunkOrigins: false,
+      entrypoints: false,
+      assets: false,
+      moduleTrace: false,
+      errorDetails: false,
+      // Показывать только ошибки и предупреждения
       errors: true,
-      errorDetails: true,
-      errorStack: true,
       warnings: true,
-      publicPath: true
+      // Цвета в терминале
+      colors: true
     }
   };
 };

package/dist/builder.js

@@ -554,19 +554,18 @@ function createSsrDevServer(projectRoot, { clientConfig: clientConfig2, apiConfi
           }
           const jsonStats = stats.toJson();
           if (stats.hasErrors()) {
-            console.error(chalk.red("Client compilation error"));
-            jsonStats.errors.forEach((err) => {
-              if (err.details) {
-                console.error(err.details);
-              } else if (typeof err === "object") {
-                try {
-                  console.error(JSON.stringify(err, null, 2));
-                } catch (e) {
-                  console.error(e);
-                }
-              } else {
-                console.error(chalk.red(err.slice()));
+            console.error(chalk.red("❌ Ошибка компиляции"));
+            jsonStats.errors.forEach((err, index) => {
+              console.error(chalk.red(`
+=== ОШИБКА ${index + 1} ===`));
+              if (err.message) {
+                let message = err.message.replace(/\u001b\[[0-9;]*m/g, "");
+                console.error(chalk.red(message));
+              }
+              if (err.moduleName) {
+                console.error(chalk.yellow(`📄 ФАЙЛ: ${err.moduleName}`));
               }
+              console.error("");
             });
             return;
           }
@@ -626,6 +625,8 @@ function createSsrDevServer(projectRoot, { clientConfig: clientConfig2, apiConfi
   const clientDevMiddleware = devMiddleware(clientCompiler, {
     publicPath: clientConfig2.output.publicPath,
     serverSideRender: true,
+    stats: "minimal",
+    // или 'errors-only'
     stats: {
       children: true
     }
@@ -978,21 +979,22 @@ const baseConfig$2 = (projectRoot) => {
       level: "verbose"
     },
     stats: {
-      colors: true,
-      hash: true,
-      version: true,
-      timings: true,
-      assets: true,
-      chunks: true,
-      modules: true,
-      reasons: true,
-      children: true,
-      source: true,
+      // Минимальный вывод
+      preset: "minimal",
+      // Или более детальная настройка:
+      modules: false,
+      chunks: false,
+      chunkModules: false,
+      chunkOrigins: false,
+      entrypoints: false,
+      assets: false,
+      moduleTrace: false,
+      errorDetails: false,
+      // Показывать только ошибки и предупреждения
       errors: true,
-      errorDetails: true,
-      errorStack: true,
       warnings: true,
-      publicPath: true
+      // Цвета в терминале
+      colors: true
     }
   };
 };

package/dist/chats.server.cjs

@@ -4,10 +4,15 @@ require("./mailing-Bs9ThyVZ.cjs");
 const index = require("./index-BFxqqmgh.cjs");
 const controllerFactory = (db) => {
   const ChatMessage = db.chat;
+  const Department = db.department;
+  const Order = db.order;
+  const notificationTimers = /* @__PURE__ */ new Map();
+  const NOTIFICATION_DELAY = 3e3;
   const saveMessage = async (msg) => {
     try {
       const message = new ChatMessage(msg);
       await message.save();
+      console.log("[CHAT CONTROLLER] Saved message with userId:", msg.userId);
       return message;
     } catch (error) {
       console.error("Error saving message to database:", error);
@@ -21,9 +26,149 @@ const controllerFactory = (db) => {
       console.error("Error retrieving messages from database:", error);
     }
   };
+  const markMessagesAsRead = async (messageIds, userId) => {
+    try {
+      console.log("[CHAT CONTROLLER] markMessagesAsRead called:", { messageIds, userId });
+      const messages = await ChatMessage.find({ _id: { $in: messageIds } });
+      console.log("[CHAT CONTROLLER] Found messages to mark:", messages.map((m) => ({
+        id: m._id,
+        userId: m.userId,
+        isOwnMessage: m.userId?.toString() === userId.toString(),
+        alreadyRead: m.readBy?.some((r) => r.userId.toString() === userId.toString())
+      })));
+      const result = await ChatMessage.updateMany(
+        {
+          _id: { $in: messageIds },
+          userId: { $ne: userId },
+          // НЕ свои сообщения
+          "readBy.userId": { $ne: userId }
+          // еще не прочитанные
+        },
+        {
+          $push: {
+            readBy: {
+              userId,
+              readAt: /* @__PURE__ */ new Date()
+            }
+          }
+        }
+      );
+      console.log("[CHAT CONTROLLER] Mark as read result:", result);
+      return result;
+    } catch (error) {
+      console.error("Error marking messages as read:", error);
+    }
+  };
+  const getUsersWithOrdersConfirmAccess = async (organizationId) => {
+    const pipeline = [
+      { $match: {
+        organization: new db.mongoose.Types.ObjectId(organizationId),
+        "accesses.orders.confirm": true
+      } },
+      { $unwind: "$members" },
+      { $group: {
+        _id: "$members.user"
+      } },
+      { $project: { userId: "$_id" } }
+    ];
+    const result = await Department.aggregate(pipeline);
+    return result.map((item) => item.userId);
+  };
+  const sendChatNotifications = async (message, recipientIds) => {
+    if (!recipientIds || recipientIds.length === 0) return;
+    const notifications = recipientIds.map((userId) => ({
+      title: "New Message",
+      body: `${message.username}: ${message.text.substring(0, 100)}`,
+      type: "chat_message",
+      metadata: {
+        type: "chat_message",
+        chatId: message.chatId,
+        messageId: message._id,
+        context: "chat"
+      },
+      userId
+    }));
+    try {
+      const response = await fetch(`${process.env.API_URL || ""}/api/notifications/batch`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Service-Key": process.env.SERVICE_KEY
+        },
+        body: JSON.stringify({ notifications })
+      });
+      if (!response.ok) {
+        const errorData = await response.text();
+        throw new Error(`Notification API failed: ${response.status} - ${errorData}`);
+      }
+      const result = await response.json();
+      console.log("Chat notifications sent:", result);
+      return result;
+    } catch (error) {
+      console.error("Failed to send chat notifications:", error);
+    }
+  };
+  const scheduleNotifications = async (message, wss, senderUserId) => {
+    console.log("[CHAT CONTROLLER] scheduleNotifications called for message:", message);
+    console.log("[CHAT CONTROLLER] Sender userId:", senderUserId);
+    console.log("[CHAT CONTROLLER] Chat type:", message.chatType);
+    console.log("[CHAT CONTROLLER] Chat ID:", message.chatId);
+    let recipientIds = [];
+    if (message.chatType === "order") {
+      try {
+        const order = await Order.findById(message.chatId);
+        console.log("[CHAT CONTROLLER] Found order:", order?._id, "Owner:", order?.owner);
+        const organizationId = order?.owner?.target?._id || order?.owner?.target;
+        if (order && organizationId) {
+          console.log("[CHAT CONTROLLER] Looking for users with orders.confirm access in org:", organizationId);
+          recipientIds = await getUsersWithOrdersConfirmAccess(organizationId);
+          console.log("[CHAT CONTROLLER] Found recipient IDs:", recipientIds);
+        } else {
+          console.log("[CHAT CONTROLLER] Order not found or has no organization");
+        }
+      } catch (error) {
+        console.error("[CHAT CONTROLLER] Error fetching order:", error);
+      }
+    } else if (message.chatType === "group") {
+      console.log("[CHAT CONTROLLER] Group notifications are mocked for now");
+      return;
+    } else {
+      console.log("[CHAT CONTROLLER] Unknown chat type:", message.chatType);
+      return;
+    }
+    const filteredRecipientIds = recipientIds.filter(
+      (userId) => userId.toString() !== senderUserId?.toString()
+    );
+    console.log("[CHAT CONTROLLER] Recipients after filtering out sender:", filteredRecipientIds);
+    if (filteredRecipientIds.length === 0) {
+      console.log("[CHAT CONTROLLER] No recipients after filtering, skipping notifications");
+      return;
+    }
+    filteredRecipientIds.forEach((userId) => {
+      const timerKey = `${message._id}_${userId}`;
+      console.log(`[CHAT CONTROLLER] Setting timer for user ${userId}, key: ${timerKey}`);
+      const timer = setTimeout(async () => {
+        console.log(`[CHAT CONTROLLER] Timer fired for user ${userId}, checking if message is read`);
+        const currentMessage = await ChatMessage.findById(message._id);
+        const isRead = currentMessage.readBy.some((r) => r.userId.toString() === userId.toString());
+        console.log(`[CHAT CONTROLLER] Message read status for user ${userId}:`, isRead);
+        if (!isRead) {
+          console.log(`[CHAT CONTROLLER] Sending notification to user ${userId}`);
+          await sendChatNotifications(message, [userId]);
+        } else {
+          console.log(`[CHAT CONTROLLER] Message already read by user ${userId}, skipping notification`);
+        }
+        notificationTimers.delete(timerKey);
+      }, NOTIFICATION_DELAY);
+      notificationTimers.set(timerKey, timer);
+    });
+  };
   return {
     saveMessage,
-    getMessages
+    getMessages,
+    markMessagesAsRead,
+    scheduleNotifications,
+    notificationTimers
   };
 };
 const ChatModel = (db) => {
@@ -32,14 +177,35 @@ const ChatModel = (db) => {
       type: String,
       required: true
     },
+    userId: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      required: true
+    },
     chatId: {
       type: String,
       required: true
     },
+    chatType: {
+      type: String,
+      required: true,
+      enum: ["order", "group", "support", "private"],
+      default: "private"
+    },
     text: {
       type: String,
       required: true
     },
+    readBy: [{
+      userId: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "User"
+      },
+      readAt: {
+        type: Date,
+        default: Date.now
+      }
+    }],
     createdAt: {
       type: Date,
       default: Date.now
@@ -58,7 +224,9 @@ const chatsRoutes = function(app, db, wss) {
       ws.activeChats.add(msg.chatId);
     }
     if (msg.type === "message") {
+      console.log("[CHAT] Received message:", msg);
       const savedMessage = await controller.saveMessage(msg);
+      console.log("[CHAT] Saved message:", savedMessage);
       wss.broadcastToModuleWithFilter(
         "chat",
         (client) => {
@@ -66,6 +234,35 @@ const chatsRoutes = function(app, db, wss) {
         },
         savedMessage
       );
+      console.log("[CHAT] Scheduling notifications for message:", savedMessage._id, "from user:", ws.userId);
+      controller.scheduleNotifications(savedMessage, wss, ws.userId);
+    }
+    if (msg.type === "markAsRead") {
+      console.log("[CHAT] markAsRead request:", { messageIds: msg.messageIds, userId: ws.userId });
+      if (!msg.messageIds || !msg.chatId || !ws.userId) {
+        console.log("[CHAT] markAsRead missing params:", { hasMessageIds: !!msg.messageIds, hasChatId: !!msg.chatId, hasUserId: !!ws.userId });
+        return;
+      }
+      await controller.markMessagesAsRead(msg.messageIds, ws.userId);
+      msg.messageIds.forEach((messageId) => {
+        const timerKey = `${messageId}_${ws.userId}`;
+        if (controller.notificationTimers.has(timerKey)) {
+          clearTimeout(controller.notificationTimers.get(timerKey));
+          controller.notificationTimers.delete(timerKey);
+        }
+      });
+      wss.broadcastToModuleWithFilter(
+        "chat",
+        (client) => {
+          return client.activeChats?.has(msg.chatId) && client.userId !== ws.userId;
+        },
+        {
+          type: "readReceipt",
+          messageIds: msg.messageIds,
+          userId: ws.userId,
+          readAt: /* @__PURE__ */ new Date()
+        }
+      );
     }
   });
   app.get("/messages/:chatId", async (req, res) => {