@ozdao/martyrs 0.2.584 → 0.2.586

package/dist/core.server.js

@@ -1,4 +1,6 @@
 import { c as coreabac } from "./abac-BPl9Bmf9.js";
+import { i as initSessionsService } from "./sessions.service-COcwjd0f.js";
+import { g as getVisitorsService, i as initVisitorsService } from "./visitors.service-B1dhhuSo.js";
 const initCorePolicies = (function initializeDefaultPolicies(abacAccessControl) {
   abacAccessControl.registerGlobalPolicy("AdminModeratorAccessPolicy", async (context) => {
     const { user, req } = context;
@@ -101,17 +103,181 @@ const initCorePolicies = (function initializeDefaultPolicies(abacAccessControl)
   });
   return abacAccessControl;
 });
+const SessionModel = (db) => {
+  const SessionSchema = new db.mongoose.Schema(
+    {
+      target: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "User",
+        required: true
+      },
+      visitor: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Visitor",
+        default: null
+      },
+      isActive: {
+        type: Boolean,
+        default: true
+      },
+      ip: String,
+      userAgent: String,
+      lastSeenAt: {
+        type: Date,
+        default: Date.now
+      },
+      revokedAt: {
+        type: Date,
+        default: null
+      },
+      expiresAt: {
+        type: Date,
+        required: true
+      }
+    },
+    {
+      timestamps: true
+    }
+  );
+  SessionSchema.index({ target: 1, isActive: 1 });
+  SessionSchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+  const Session = db.mongoose.models.Session || db.mongoose.model("Session", SessionSchema);
+  return Session;
+};
+const VisitorModel = (db) => {
+  const VisitorSchema = new db.mongoose.Schema(
+    {
+      ip: String,
+      userAgent: String,
+      acceptLanguage: String,
+      fingerprint: { type: String, unique: true },
+      target: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "User",
+        default: null
+      },
+      linkedAt: {
+        type: Date,
+        default: null
+      }
+    },
+    {
+      timestamps: true
+    }
+  );
+  VisitorSchema.index({ target: 1 }, { sparse: true });
+  const Visitor = db.mongoose.models.Visitor || db.mongoose.model("Visitor", VisitorSchema);
+  return Visitor;
+};
+const RequestModel = (db) => {
+  const RequestSchema = new db.mongoose.Schema({
+    visitor: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Visitor"
+    },
+    target: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      default: null
+    },
+    session: {
+      type: db.mongoose.Schema.Types.ObjectId,
+      ref: "Session",
+      default: null
+    },
+    path: String,
+    method: String,
+    referer: String,
+    query: String,
+    timestamp: { type: Date, default: Date.now }
+  });
+  RequestSchema.index({ visitor: 1 });
+  RequestSchema.index({ target: 1 }, { sparse: true });
+  RequestSchema.index({ timestamp: -1 });
+  const Request = db.mongoose.models.Request || db.mongoose.model("Request", RequestSchema);
+  return Request;
+};
+let instance = null;
+function initRequestsService(db) {
+  const Request = db.request;
+  async function logRequest({ visitorId, req, userId = null, sessionId = null }) {
+    const request = await Request.create({
+      visitor: visitorId ? new db.mongoose.Types.ObjectId(visitorId) : null,
+      target: userId ? new db.mongoose.Types.ObjectId(userId) : null,
+      session: sessionId ? new db.mongoose.Types.ObjectId(sessionId) : null,
+      path: req.path,
+      method: req.method,
+      referer: req.headers["referer"] || null,
+      query: req.query ? JSON.stringify(req.query) : null
+    });
+    return request;
+  }
+  async function getJourney(visitorId, { limit = 50, skip = 0 } = {}) {
+    const requests = await Request.find({ visitor: new db.mongoose.Types.ObjectId(visitorId) }).sort({ timestamp: -1 }).skip(skip).limit(limit).lean();
+    return requests;
+  }
+  async function getUserJourney(userId, { limit = 50, skip = 0 } = {}) {
+    const requests = await Request.find({ target: new db.mongoose.Types.ObjectId(userId) }).sort({ timestamp: -1 }).skip(skip).limit(limit).lean();
+    return requests;
+  }
+  instance = {
+    logRequest,
+    getJourney,
+    getUserJourney
+  };
+  return instance;
+}
+function getRequestsService() {
+  if (!instance) {
+    throw new Error("Requests service not initialized. Call initRequestsService(db) first.");
+  }
+  return instance;
+}
+const VISITOR_COOKIE_NAME = "visitorId";
+const VISITOR_COOKIE_MAX_AGE = 365 * 24 * 60 * 60 * 1e3;
+const createVisitorLogger = () => {
+  const visitorLogger = async (req, res, next) => {
+    try {
+      const visitorsService = getVisitorsService();
+      const requestsService = getRequestsService();
+      const visitor = await visitorsService.findOrCreateVisitor(req);
+      const cookieVisitorId = req.cookies?.visitorId;
+      if (!cookieVisitorId || cookieVisitorId !== visitor._id.toString()) {
+        res.cookie(VISITOR_COOKIE_NAME, visitor._id.toString(), {
+          maxAge: VISITOR_COOKIE_MAX_AGE,
+          httpOnly: true,
+          sameSite: "lax"
+        });
+      }
+      req.visitor = visitor;
+      req.visitorId = visitor._id;
+      res.on("finish", () => {
+        requestsService.logRequest({
+          visitorId: visitor._id,
+          req,
+          userId: req.userId || null,
+          sessionId: req.sessionId || null
+        }).catch((err) => console.error("Error logging request:", err));
+      });
+      next();
+    } catch (error) {
+      console.error("Error processing visitor:", error);
+      next();
+    }
+  };
+  return { visitorLogger };
+};
 const { getInstance } = coreabac;
 let _WebSocketManagerClass = null;
 async function createWebSocketManager(...args) {
   if (!_WebSocketManagerClass) {
-    const module = await import("./core.websocket-C2FxNmZ1.js");
+    const module = await import("./core.websocket-Cl76z2wT.js");
     _WebSocketManagerClass = module.default;
   }
   return new _WebSocketManagerClass(...args);
 }
 const WebSocketManager = createWebSocketManager;
-function initializeCore(app, db, origins, publicPath) {
+function initializeCore(app, db, origins, publicPath, wss = null) {
   db.log = db.mongoose.models.Log || db.mongoose.model(
     "Log",
     new db.mongoose.Schema(
@@ -123,8 +289,31 @@ function initializeCore(app, db, origins, publicPath) {
       { versionKey: false }
     )
   );
+  db.session = SessionModel(db);
+  db.visitor = VisitorModel(db);
+  db.request = RequestModel(db);
+  initSessionsService(db);
+  initVisitorsService(db);
+  initRequestsService(db);
   const abac = getInstance(db);
   initCorePolicies(abac);
+  if (app) {
+    const { visitorLogger } = createVisitorLogger();
+    app.use(visitorLogger);
+  }
+  if (wss) {
+    wss.registerRpcMethod("core", "getOnlineStatus", async ({ userId }) => {
+      if (!userId) return { isOnline: false, lastSeenAt: null };
+      const isOnline = wss.userConnections.has(userId.toString());
+      if (isOnline) return { isOnline: true, lastSeenAt: /* @__PURE__ */ new Date() };
+      const session = await db.session.findOne(
+        { target: new db.mongoose.Types.ObjectId(userId), isActive: true },
+        { lastSeenAt: 1 },
+        { sort: { lastSeenAt: -1 } }
+      ).lean();
+      return { isOnline: false, lastSeenAt: session?.lastSeenAt || null };
+    }, { requireAuth: false });
+  }
 }
 const core_server = {
   initialize: initializeCore,

package/dist/{core.websocket-C2FxNmZ1.js → core.websocket-Cl76z2wT.js}

@@ -1,6 +1,7 @@
 import * as cookie from "cookie";
 import jwt from "jsonwebtoken";
 import uWS from "uWebSockets.js";
+import { g as getSessionsService } from "./sessions.service-COcwjd0f.js";
 class WebSocketManager {
   constructor(options = {}) {
     if (options.ssl) {
@@ -24,9 +25,14 @@ class WebSocketManager {
       idleTimeout: 120,
       compression: uWS.SHARED_COMPRESSOR,
       maxBackpressure: 1024 * 1024,
-      // Обработчик аутентификации и апгрейда соединения
+      // Обработчик аутентификации и апгрейда соединения (синхронный - uWS требует)
       upgrade: (res, req, context) => {
         let userId = null;
+        let sessionId = null;
+        let aborted = false;
+        res.onAborted(() => {
+          aborted = true;
+        });
         const headers = {};
         req.forEach((key, value) => {
           headers[key.toLowerCase()] = value;
@@ -41,22 +47,47 @@ class WebSocketManager {
               const token = JSON.parse(decodeURIComponent(cookies.user));
               const decoded = jwt.verify(token.accessToken, process.env.SECRET_KEY);
               userId = decoded._id;
+              sessionId = decoded.session_id;
             }
           }
         } catch (err) {
           console.error("Invalid token:", err);
         }
+        if (aborted) return;
         if (process.env.REQUIRE_AUTH === "true" && !userId) {
           res.writeStatus("401 Unauthorized").end("Authentication required");
           return;
         }
-        const userData = { userId };
+        const userData = { userId, sessionId, needsSessionValidation: !!sessionId };
         res.upgrade(userData, secWebSocketKey, secWebSocketProtocol, secWebSocketExtensions, context);
       },
-      // Обработчик открытия соединения
-      open: (ws) => {
-        ws.userId = ws.getUserData().userId;
+      // Обработчик открытия соединения (async безопасен здесь)
+      open: async (ws) => {
+        const userData = ws.getUserData();
+        ws.userId = userData.userId;
+        ws.sessionId = userData.sessionId;
         ws.subscriptions = /* @__PURE__ */ new Set();
+        ws.lastSeenAt = Date.now();
+        if (userData.needsSessionValidation) {
+          try {
+            const sessionsService = getSessionsService();
+            const session = await sessionsService.validateSession({
+              sessionId: userData.sessionId,
+              userId: userData.userId
+            });
+            if (!session) {
+              ws.end(4001, "Session expired or revoked");
+              return;
+            }
+            sessionsService.touchSession(userData.sessionId).catch((err) => {
+              console.error("Error updating session lastSeenAt:", err);
+            });
+          } catch (err) {
+            console.error("Session validation error:", err);
+            ws.end(4002, "Session validation failed");
+            return;
+          }
+        }
         if (ws.userId) {
           this._trackUserConnection(ws.userId, ws);
         } else {
@@ -82,6 +113,11 @@ class WebSocketManager {
               await this._handleRpcCall(ws, msg);
               return;
             }
+            if (msg.type === "ping") {
+              ws.lastSeenAt = Date.now();
+              ws.send(JSON.stringify({ type: "pong" }), false);
+              return;
+            }
             const moduleName = msg.module;
             console.log(`[WebSocket Server] Message from ${ws.userId || "anonymous"}, module: ${moduleName}, type: ${msg.type}, subscriptions:`, Array.from(ws.subscriptions));
             if (moduleName && this.modules.has(moduleName)) {

package/dist/{crud-q1ye5IhV.js → crud-DpOXTZep.js}

@@ -1,4 +1,4 @@
-import { m as middlewareFactory } from "./authJwt-J1csaMWA.js";
+import { m as middlewareFactory } from "./authJwt-DKbMMjw0.js";
 import { q as queryProcessorCore } from "./queryProcessor-C_5Iipam.js";
 import { O as ObserverNamespaced } from "./core.observer-MZsqaE6F.js";
 import { L as LoggerNamespaced } from "./abac-BPl9Bmf9.js";

package/dist/events.server.js

@@ -2,11 +2,11 @@ import { q as queryProcessorCore } from "./queryProcessor-C_5Iipam.js";
 import { c as createFriendlyURL, a as applyMetadataSchema } from "./metadata.schema-CIRR_WQ-.js";
 import Stripe from "stripe";
 import { Types } from "mongoose";
-import { c as controllerFactory } from "./tickets.controller-B7r0mK-5.js";
+import { c as controllerFactory } from "./tickets.controller-DdF85W-i.js";
 import { a as applyCommonSchema } from "./common.schema-DswiUXKB.js";
 import { a as applyEngagementSchema } from "./engagement.schema-fh6W1fb_.js";
 import { a as applyOwnershipSchema } from "./ownership.schema-fwwDf_e5.js";
-import { m as middlewareIndexFactory$1 } from "./index-_Edcmck_.js";
+import { m as middlewareIndexFactory$1 } from "./index-kvBwwb0w.js";
 import { c as coreabac } from "./abac-BPl9Bmf9.js";
 class serviceIntegrations {
   async createProduct(event) {

package/dist/files.server.js

@@ -1,4 +1,4 @@
-import { m as middlewareIndexFactory$1 } from "./index-_Edcmck_.js";
+import { m as middlewareIndexFactory$1 } from "./index-kvBwwb0w.js";
 import busboy from "busboy";
 import * as fs from "node:fs";
 import * as fsp from "node:fs/promises";

package/dist/gallery.server.js

@@ -3,7 +3,7 @@ import path from "path";
 import { a as applyCommonSchema } from "./common.schema-DswiUXKB.js";
 import { a as applyEngagementSchema } from "./engagement.schema-fh6W1fb_.js";
 import { a as applyOwnershipSchema } from "./ownership.schema-fwwDf_e5.js";
-import { m as middlewareIndexFactory } from "./index-_Edcmck_.js";
+import { m as middlewareIndexFactory } from "./index-kvBwwb0w.js";
 const controllerFactory = (db) => {
   const Photo = db.photo;
   const read = async (req, res) => {