@ozdao/prometheus-framework 0.2.330 → 0.2.332

package/dist/community.server.mjs

@@ -1,605 +1,648 @@
 import { g as getDefaultExportFromCjs } from "./_commonjsHelpers-CUmg6egw.mjs";
 import require$$0 from "mongoose";
-import { q as queryProcessor$3 } from "./queryProcessor-CyQch65j.mjs";
+import { r as requireQueryProcessor$2 } from "./queryProcessor-C_l-zkrM.mjs";
 import "util";
-import "uuid";
-import { m as middlewares } from "./index-CW2mOwo8.mjs";
-import { g as globals_abac } from "./globals.abac-CWAEpvzq.mjs";
-import { c as common_schema } from "./common.schema-ChBVARrs.mjs";
-import { e as engagement_schema } from "./engagement.schema-CCdSLKd4.mjs";
-import { o as ownership_schema } from "./ownership.schema-oyx6eNkZ.mjs";
-import { m as metadata_schema } from "./metadata.schema-CK5e2O3f.mjs";
-function getPeriodConditions(period) {
-  const currentDate = /* @__PURE__ */ new Date();
-  const startDate = /* @__PURE__ */ new Date();
-  switch (period) {
-    case "today":
-      startDate.setDate(currentDate.getDate() - 1);
-      break;
-    case "week":
-      startDate.setDate(currentDate.getDate() - 7);
-      break;
-    case "month":
-      startDate.setMonth(currentDate.getMonth() - 1);
-      break;
-    case "year":
-      startDate.setFullYear(currentDate.getFullYear() - 1);
-      break;
-    default:
-      startDate.setFullYear(currentDate.getFullYear() - 1);
-  }
-  return [{
-    $match: {
-      createdAt: {
-        $gte: startDate,
-        $lte: currentDate
-        // Добавлено условие, чтобы исключить будущие записи
-      }
-    }
-  }];
-}
-async function getCategoryConditions(category, user) {
-  const aggregationStages = [];
-  if (category) {
-    switch (category) {
-      case "featured":
-        aggregationStages.push({ $match: { tags: { $in: ["Featured"] } } });
+import require$$0$1 from "uuid";
+import { r as requireMiddlewares } from "./index-Ctf6Y61O.mjs";
+import { r as requireGlobals_abac } from "./globals.abac-dtpS1dd-.mjs";
+import { r as requireCommon_schema } from "./common.schema-C2m3O1XY.mjs";
+import { r as requireEngagement_schema } from "./engagement.schema-DnDD7Bn3.mjs";
+import { r as requireOwnership_schema } from "./ownership.schema-C0w02Vw1.mjs";
+import { r as requireMetadata_schema } from "./metadata.schema-DrLHoyi8.mjs";
+var queryProcessor$1;
+var hasRequiredQueryProcessor$1;
+function requireQueryProcessor$1() {
+  if (hasRequiredQueryProcessor$1) return queryProcessor$1;
+  hasRequiredQueryProcessor$1 = 1;
+  function getPeriodConditions(period) {
+    const currentDate = /* @__PURE__ */ new Date();
+    const startDate = /* @__PURE__ */ new Date();
+    switch (period) {
+      case "today":
+        startDate.setDate(currentDate.getDate() - 1);
+        break;
+      case "week":
+        startDate.setDate(currentDate.getDate() - 7);
         break;
-      case "popular":
-        aggregationStages.push({ $sort: { views: -1, likes: -1 } });
+      case "month":
+        startDate.setMonth(currentDate.getMonth() - 1);
         break;
-      case "new":
-        aggregationStages.push({ $sort: { createdAt: 1 } });
+      case "year":
+        startDate.setFullYear(currentDate.getFullYear() - 1);
         break;
+      default:
+        startDate.setFullYear(currentDate.getFullYear() - 1);
     }
+    return [{
+      $match: {
+        createdAt: {
+          $gte: startDate,
+          $lte: currentDate
+          // Добавлено условие, чтобы исключить будущие записи
+        }
+      }
+    }];
   }
-  return aggregationStages;
-}
-var queryProcessor$2 = {
-  getPeriodConditions,
-  getCategoryConditions
-};
-const ObjectId$2 = require$$0.Types.ObjectId;
-function getCommentsLookupStage() {
-  return {
-    $lookup: {
-      from: "comments",
-      localField: "_id",
-      foreignField: "target",
-      as: "comments"
-    }
-  };
-}
-function getReactionsLookupStage() {
-  return {
-    $lookup: {
-      from: "reactions",
-      localField: "_id",
-      foreignField: "target",
-      as: "reactions"
+  async function getCategoryConditions(category, user) {
+    const aggregationStages = [];
+    if (category) {
+      switch (category) {
+        case "featured":
+          aggregationStages.push({ $match: { tags: { $in: ["Featured"] } } });
+          break;
+        case "popular":
+          aggregationStages.push({ $sort: { views: -1, likes: -1 } });
+          break;
+        case "new":
+          aggregationStages.push({ $sort: { createdAt: 1 } });
+          break;
+      }
     }
+    return aggregationStages;
+  }
+  queryProcessor$1 = {
+    getPeriodConditions,
+    getCategoryConditions
   };
+  return queryProcessor$1;
 }
-function getReactionsCommentsFields(user) {
-  return {
-    $addFields: {
-      numberOfComments: { $size: "$comments" },
-      numberOfReactions: { $size: "$reactions" },
-      isReacted: {
-        $in: [
-          new ObjectId$2(user),
-          // make sure db is accessible or pass as param
-          "$reactions.user"
-        ]
-      },
-      reactionId: {
-        $let: {
-          vars: {
-            reactionIndex: {
-              $indexOfArray: [
-                "$reactions.user",
-                new ObjectId$2(user)
-                // same here for db accessibility
+var queryProcessorReactions;
+var hasRequiredQueryProcessorReactions;
+function requireQueryProcessorReactions() {
+  if (hasRequiredQueryProcessorReactions) return queryProcessorReactions;
+  hasRequiredQueryProcessorReactions = 1;
+  const ObjectId = require$$0.Types.ObjectId;
+  function getCommentsLookupStage() {
+    return {
+      $lookup: {
+        from: "comments",
+        localField: "_id",
+        foreignField: "target",
+        as: "comments"
+      }
+    };
+  }
+  function getReactionsLookupStage() {
+    return {
+      $lookup: {
+        from: "reactions",
+        localField: "_id",
+        foreignField: "target",
+        as: "reactions"
+      }
+    };
+  }
+  function getReactionsCommentsFields(user) {
+    return {
+      $addFields: {
+        numberOfComments: { $size: "$comments" },
+        numberOfReactions: { $size: "$reactions" },
+        isReacted: {
+          $in: [
+            new ObjectId(user),
+            // make sure db is accessible or pass as param
+            "$reactions.user"
+          ]
+        },
+        reactionId: {
+          $let: {
+            vars: {
+              reactionIndex: {
+                $indexOfArray: [
+                  "$reactions.user",
+                  new ObjectId(user)
+                  // same here for db accessibility
+                ]
+              }
+            },
+            in: {
+              $cond: [
+                { $gte: ["$$reactionIndex", 0] },
+                { $arrayElemAt: ["$reactions._id", "$$reactionIndex"] },
+                null
               ]
             }
-          },
-          in: {
-            $cond: [
-              { $gte: ["$$reactionIndex", 0] },
-              { $arrayElemAt: ["$reactions._id", "$$reactionIndex"] },
-              null
-            ]
           }
         }
       }
-    }
+    };
+  }
+  queryProcessorReactions = {
+    getCommentsLookupStage,
+    getReactionsLookupStage,
+    getReactionsCommentsFields
   };
+  return queryProcessorReactions;
 }
-var queryProcessorReactions$1 = {
-  getCommentsLookupStage,
-  getReactionsLookupStage,
-  getReactionsCommentsFields
-};
-const ObjectId$1 = require$$0.Types.ObjectId;
-async function getBlockedMembers(Membership, userId) {
-  const memberships = await Membership.find({ user: userId });
-  return memberships.filter((membership) => membership.role === "blocked").map((membership) => membership.target);
-}
-function addConditionsForBlocked(matchStage, field, blockedMembers) {
-  const conditionsForBlocked = { "$nin": blockedMembers };
-  if (matchStage[field]) {
-    matchStage[field] = { "$eq": matchStage[field], ...conditionsForBlocked };
-  } else {
-    matchStage[field] = conditionsForBlocked;
+var queryProcessor;
+var hasRequiredQueryProcessor;
+function requireQueryProcessor() {
+  if (hasRequiredQueryProcessor) return queryProcessor;
+  hasRequiredQueryProcessor = 1;
+  const ObjectId = require$$0.Types.ObjectId;
+  async function getBlockedMembers(Membership, userId) {
+    const memberships = await Membership.find({ user: userId });
+    return memberships.filter((membership) => membership.role === "blocked").map((membership) => membership.target);
   }
-  return matchStage;
-}
-const AggregationProcessor = {
-  getMembersByRole: async (Membership, userId, role) => {
-    const memberships = await Membership.find({ user: userId, role });
-    return memberships.map((membership) => new ObjectId$1(membership.target));
-  },
-  generateMatchStage: async (Membership, userOrFollowing, role, operation = "$in") => {
-    if (!userOrFollowing) {
-      return [];
-    }
-    const members = await AggregationProcessor.getMembersByRole(Membership, userOrFollowing, role);
-    if (members.length === 0) {
-      return [];
-    }
-    const typeMap = {
-      "owner.target": "organization",
-      "creator.target": "user"
-    };
-    const matchConditions = Object.keys(typeMap).map((key) => ({
-      [key]: { [operation]: members }
-    }));
-    return [{
-      $match: { $or: matchConditions }
-    }];
-  },
-  getBlockedStage: async (Membership, user) => {
-    if (user) {
-      const blockedMembers = await getBlockedMembers(Membership, user);
-      console.log(blockedMembers);
-      if (blockedMembers.length > 0) {
-        let stage = {};
-        addConditionsForBlocked(stage, "owner.target", blockedMembers);
-        addConditionsForBlocked(stage, "creator.target", blockedMembers);
-        console.log("Maths is" + [{
-          $match: stage
-        }]);
-        return [{
-          $match: stage
-        }];
-      } else {
-        return [];
-      }
+  function addConditionsForBlocked(matchStage, field, blockedMembers) {
+    const conditionsForBlocked = { "$nin": blockedMembers };
+    if (matchStage[field]) {
+      matchStage[field] = { "$eq": matchStage[field], ...conditionsForBlocked };
     } else {
-      return [];
+      matchStage[field] = conditionsForBlocked;
     }
-  },
-  getFollowingStage: async (Membership, following) => {
-    return await AggregationProcessor.generateMatchStage(Membership, following, "subscriber", "$in");
+    return matchStage;
   }
-};
-var queryProcessor$1 = AggregationProcessor;
-const queryProcessor = queryProcessor$2;
-const queryProcessorReactions = queryProcessorReactions$1;
-const queryProcessorOrganizations = queryProcessor$1;
-const queryProcessorGlobals = queryProcessor$3;
-const controllerFactory$3 = (db) => {
-  const Blogpost = db.blogpost;
-  db.organization;
-  const Membership = db.membership;
-  const read = async (req, res) => {
-    console.log(req.query);
-    let stages = [];
-    stages = [
-      ...queryProcessorGlobals.getTagsOptions(
-        req.query.tags
-      ),
-      ...queryProcessor.getPeriodConditions(
-        req.query.period
-      ),
-      ...await queryProcessor.getCategoryConditions(
-        req.query.category
-      ),
-      // Following
-      ...await queryProcessorOrganizations.getFollowingStage(
-        Membership,
-        req.query.following
-      ),
-      // Blocking
-      ...await queryProcessorOrganizations.getBlockedStage(
-        Membership,
-        req.query.user
-      ),
-      queryProcessorReactions.getCommentsLookupStage(),
-      queryProcessorReactions.getReactionsLookupStage(),
-      queryProcessorReactions.getReactionsCommentsFields(
-        req.query.user
-      ),
-      // Sorting and Pagination
-      ...queryProcessorGlobals.getSortingOptions(
-        req.query.sortParam,
-        req.query.sortOrder
-      ),
-      ...queryProcessorGlobals.getPaginationOptions(
-        req.query.skip,
-        req.query.limit
-      ),
-      // For creator
-      queryProcessorGlobals.getCreatorUserLookupStage(),
-      queryProcessorGlobals.getCreatorOrganizationLookupStage(),
-      // For owner
-      queryProcessorGlobals.getOwnerUserLookupStage(),
-      queryProcessorGlobals.getOwnerOrganizationLookupStage(),
-      queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
-      // Basic
-      ...queryProcessorGlobals.getBasicOptions(
-        req.query
-      )
-      // { $sample: { size: Number(req.query.limit) } },
-    ];
-    try {
-      const posts = await Blogpost.aggregate(stages).exec();
-      if (posts.length === 0) {
-        return res.status(200).send([]);
+  const AggregationProcessor = {
+    getMembersByRole: async (Membership, userId, role) => {
+      const memberships = await Membership.find({ user: userId, role });
+      return memberships.map((membership) => new ObjectId(membership.target));
+    },
+    generateMatchStage: async (Membership, userOrFollowing, role, operation = "$in") => {
+      if (!userOrFollowing) {
+        return [];
       }
-      res.status(200).send(posts);
-    } catch (err) {
-      console.log(err);
-      res.status(500).send({ err });
-    }
-  };
-  const create = (req, res) => {
-    const newBlogpost = {
-      url: req.body.name.toLowerCase().replace(/ /g, "-").replace(/[^\w-]+/g, ""),
-      name: req.body.name,
-      status: req.body.status,
-      tags: req.body.tags ? req.body.tags : ["All"],
-      owner: req.body.owner,
-      source: req.body.source,
-      creator: req.body.creator,
-      content: req.body.content,
-      views: 1
-    };
-    Blogpost.create(newBlogpost).then((post) => {
-      res.status(200).send(post);
-    }).catch((err) => {
-      res.status(500).send({ message: err.message || "Some error occurred while creating the blogpost." });
-    });
-  };
-  const update = (req, res) => {
-    Blogpost.findOneAndUpdate({ _id: req.body._id }, { $set: req.body }, { new: true }).exec().then((post) => {
-      if (!post) {
-        return res.status(404).send({ message: "Something wrong when updating the blogpost." });
+      const members = await AggregationProcessor.getMembersByRole(Membership, userOrFollowing, role);
+      if (members.length === 0) {
+        return [];
       }
-      res.status(200).send(post);
-    }).catch((err) => {
-      res.status(500).send({ message: err.message || "Some error occurred while updating the blogpost." });
-    });
-  };
-  const del = (req, res) => {
-    Blogpost.findOneAndDelete({ _id: req.params._id }).exec().then((post) => {
-      if (!post) {
-        return res.status(404).send({ message: "The blogpost is not deleted." });
+      const typeMap = {
+        "owner.target": "organization",
+        "creator.target": "user"
+      };
+      const matchConditions = Object.keys(typeMap).map((key) => ({
+        [key]: { [operation]: members }
+      }));
+      return [{
+        $match: { $or: matchConditions }
+      }];
+    },
+    getBlockedStage: async (Membership, user) => {
+      if (user) {
+        const blockedMembers = await getBlockedMembers(Membership, user);
+        console.log(blockedMembers);
+        if (blockedMembers.length > 0) {
+          let stage = {};
+          addConditionsForBlocked(stage, "owner.target", blockedMembers);
+          addConditionsForBlocked(stage, "creator.target", blockedMembers);
+          console.log("Maths is" + [{
+            $match: stage
+          }]);
+          return [{
+            $match: stage
+          }];
+        } else {
+          return [];
+        }
+      } else {
+        return [];
       }
-      res.status(200).send(post);
-    }).catch((err) => {
-      res.status(500).send({ message: err.message || "Some error occurred while deleting the blogpost." });
-    });
+    },
+    getFollowingStage: async (Membership, following) => {
+      return await AggregationProcessor.generateMatchStage(Membership, following, "subscriber", "$in");
+    }
   };
-  return {
-    read,
-    create,
-    update,
-    delete: del
+  queryProcessor = AggregationProcessor;
+  return queryProcessor;
+}
+var blog_controller;
+var hasRequiredBlog_controller;
+function requireBlog_controller() {
+  if (hasRequiredBlog_controller) return blog_controller;
+  hasRequiredBlog_controller = 1;
+  const queryProcessor2 = requireQueryProcessor$1();
+  const queryProcessorReactions2 = requireQueryProcessorReactions();
+  const queryProcessorOrganizations = requireQueryProcessor();
+  const queryProcessorGlobals = requireQueryProcessor$2();
+  const controllerFactory = (db) => {
+    const Blogpost = db.blogpost;
+    db.organization;
+    const Membership = db.membership;
+    const read = async (req, res) => {
+      console.log(req.query);
+      let stages = [];
+      stages = [
+        ...queryProcessorGlobals.getTagsOptions(
+          req.query.tags
+        ),
+        ...queryProcessor2.getPeriodConditions(
+          req.query.period
+        ),
+        ...await queryProcessor2.getCategoryConditions(
+          req.query.category
+        ),
+        // Following
+        ...await queryProcessorOrganizations.getFollowingStage(
+          Membership,
+          req.query.following
+        ),
+        // Blocking
+        ...await queryProcessorOrganizations.getBlockedStage(
+          Membership,
+          req.query.user
+        ),
+        queryProcessorReactions2.getCommentsLookupStage(),
+        queryProcessorReactions2.getReactionsLookupStage(),
+        queryProcessorReactions2.getReactionsCommentsFields(
+          req.query.user
+        ),
+        // Sorting and Pagination
+        ...queryProcessorGlobals.getSortingOptions(
+          req.query.sortParam,
+          req.query.sortOrder
+        ),
+        ...queryProcessorGlobals.getPaginationOptions(
+          req.query.skip,
+          req.query.limit
+        ),
+        // For creator
+        queryProcessorGlobals.getCreatorUserLookupStage(),
+        queryProcessorGlobals.getCreatorOrganizationLookupStage(),
+        // For owner
+        queryProcessorGlobals.getOwnerUserLookupStage(),
+        queryProcessorGlobals.getOwnerOrganizationLookupStage(),
+        queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
+        // Basic
+        ...queryProcessorGlobals.getBasicOptions(
+          req.query
+        )
+        // { $sample: { size: Number(req.query.limit) } },
+      ];
+      try {
+        const posts = await Blogpost.aggregate(stages).exec();
+        if (posts.length === 0) {
+          return res.status(200).send([]);
+        }
+        res.status(200).send(posts);
+      } catch (err) {
+        console.log(err);
+        res.status(500).send({ err });
+      }
+    };
+    const create = (req, res) => {
+      const newBlogpost = {
+        url: req.body.name.toLowerCase().replace(/ /g, "-").replace(/[^\w-]+/g, ""),
+        name: req.body.name,
+        status: req.body.status,
+        tags: req.body.tags ? req.body.tags : ["All"],
+        owner: req.body.owner,
+        source: req.body.source,
+        creator: req.body.creator,
+        content: req.body.content,
+        views: 1
+      };
+      Blogpost.create(newBlogpost).then((post) => {
+        res.status(200).send(post);
+      }).catch((err) => {
+        res.status(500).send({ message: err.message || "Some error occurred while creating the blogpost." });
+      });
+    };
+    const update = (req, res) => {
+      Blogpost.findOneAndUpdate({ _id: req.body._id }, { $set: req.body }, { new: true }).exec().then((post) => {
+        if (!post) {
+          return res.status(404).send({ message: "Something wrong when updating the blogpost." });
+        }
+        res.status(200).send(post);
+      }).catch((err) => {
+        res.status(500).send({ message: err.message || "Some error occurred while updating the blogpost." });
+      });
+    };
+    const del = (req, res) => {
+      Blogpost.findOneAndDelete({ _id: req.params._id }).exec().then((post) => {
+        if (!post) {
+          return res.status(404).send({ message: "The blogpost is not deleted." });
+        }
+        res.status(200).send(post);
+      }).catch((err) => {
+        res.status(500).send({ message: err.message || "Some error occurred while deleting the blogpost." });
+      });
+    };
+    return {
+      read,
+      create,
+      update,
+      delete: del
+    };
   };
-};
-var blog_controller = controllerFactory$3;
-const commentControllerFactory = (db) => {
-  const Comment = db.comment;
-  const Membership = db.membership;
-  const read = async (req, res) => {
-    try {
-      let buildCommentTree = function(comments2) {
-        const commentMap = /* @__PURE__ */ new Map();
-        const objectIdToString = (id) => id.toString();
-        function addToMap(comment) {
-          const commentId = objectIdToString(comment._id);
-          if (!commentMap.has(commentId)) {
-            commentMap.set(commentId, { ...comment, children: [] });
-            if (comment.children && comment.children.length > 0) {
-              comment.children.forEach(addToMap);
+  blog_controller = controllerFactory;
+  return blog_controller;
+}
+var comments_controller;
+var hasRequiredComments_controller;
+function requireComments_controller() {
+  if (hasRequiredComments_controller) return comments_controller;
+  hasRequiredComments_controller = 1;
+  const commentControllerFactory = (db) => {
+    const Comment = db.comment;
+    const Membership = db.membership;
+    const read = async (req, res) => {
+      try {
+        let buildCommentTree = function(comments2) {
+          const commentMap = /* @__PURE__ */ new Map();
+          const objectIdToString = (id) => id.toString();
+          function addToMap(comment) {
+            const commentId = objectIdToString(comment._id);
+            if (!commentMap.has(commentId)) {
+              commentMap.set(commentId, { ...comment, children: [] });
+              if (comment.children && comment.children.length > 0) {
+                comment.children.forEach(addToMap);
+              }
             }
           }
-        }
-        comments2.forEach(addToMap);
-        commentMap.forEach((comment) => {
-          if (comment.parent) {
-            const parentId2 = objectIdToString(comment.parent);
-            const parent = commentMap.get(parentId2);
-            if (parent) {
-              parent.children.push(comment);
+          comments2.forEach(addToMap);
+          commentMap.forEach((comment) => {
+            if (comment.parent) {
+              const parentId2 = objectIdToString(comment.parent);
+              const parent = commentMap.get(parentId2);
+              if (parent) {
+                parent.children.push(comment);
+              }
+            }
+          });
+          function sortChildren(comment) {
+            if (comment.children.length > 0) {
+              comment.children.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
+              comment.children.forEach(sortChildren);
             }
           }
-        });
-        function sortChildren(comment) {
-          if (comment.children.length > 0) {
-            comment.children.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
-            comment.children.forEach(sortChildren);
-          }
+          const rootComments = comments2.map((comment) => {
+            const commentId = objectIdToString(comment._id);
+            return commentMap.get(commentId);
+          }).filter((comment) => !comment.parent);
+          rootComments.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
+          rootComments.forEach(sortChildren);
+          return rootComments;
+        };
+        const { target, type, user, maxDepth = 4, parentId = null } = req.query;
+        let conditions = {
+          target: new db.mongoose.Types.ObjectId(target),
+          type
+        };
+        if (parentId) {
+          conditions.parent = new db.mongoose.Types.ObjectId(parentId);
+        } else {
+          conditions.parent = null;
         }
-        const rootComments = comments2.map((comment) => {
-          const commentId = objectIdToString(comment._id);
-          return commentMap.get(commentId);
-        }).filter((comment) => !comment.parent);
-        rootComments.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
-        rootComments.forEach(sortChildren);
-        return rootComments;
-      };
-      const { target, type, user, maxDepth = 4, parentId = null } = req.query;
-      let conditions = {
-        target: new db.mongoose.Types.ObjectId(target),
-        type
-      };
-      if (parentId) {
-        conditions.parent = new db.mongoose.Types.ObjectId(parentId);
-      } else {
-        conditions.parent = null;
-      }
-      let blockedMembers = [];
-      if (user) {
-        const memberships = await Membership.find({ user, role: "blocked" });
-        blockedMembers = memberships.map((membership) => membership.target);
-      }
-      const pipeline = [
-        { $match: conditions },
-        { $sort: { createdAt: 1 } },
-        {
-          $graphLookup: {
-            from: "comments",
-            startWith: "$_id",
-            connectFromField: "_id",
-            connectToField: "parent",
-            as: "children",
-            depthField: "childDepth"
-          }
-        },
-        {
-          $lookup: {
-            from: "users",
-            localField: "owner.target",
-            foreignField: "_id",
-            as: "owner"
-          }
-        },
-        { $unwind: "$owner" },
-        {
-          $lookup: {
-            from: "users",
-            localField: "children.owner.target",
-            foreignField: "_id",
-            as: "childUsers"
-          }
-        },
-        {
-          $project: {
-            _id: 1,
-            content: 1,
-            type: 1,
-            target: 1,
-            "owner.username": 1,
-            "owner.profile.photo": 1,
-            "owner.profile.name": 1,
-            "owner._id": 1,
-            depth: 1,
-            createdAt: 1,
-            childrenCount: { $size: "$children" },
-            children: {
-              $map: {
-                input: "$children",
-                as: "child",
-                in: {
-                  _id: "$$child._id",
-                  content: "$$child.content",
-                  type: "$$child.type",
-                  parent: "$$child.parent",
-                  target: "$$child.target",
-                  owner: {
-                    $arrayElemAt: [
-                      {
-                        $filter: {
-                          input: "$childUsers",
-                          as: "childUser",
-                          cond: { $eq: ["$$childUser._id", "$$child.owner.target"] }
-                        }
-                      },
-                      0
-                    ]
-                  },
-                  depth: "$$child.depth",
-                  createdAt: "$$child.createdAt",
-                  childrenCount: { $size: "$$child.children" }
+        let blockedMembers = [];
+        if (user) {
+          const memberships = await Membership.find({ user, role: "blocked" });
+          blockedMembers = memberships.map((membership) => membership.target);
+        }
+        const pipeline = [
+          { $match: conditions },
+          { $sort: { createdAt: 1 } },
+          {
+            $graphLookup: {
+              from: "comments",
+              startWith: "$_id",
+              connectFromField: "_id",
+              connectToField: "parent",
+              as: "children",
+              depthField: "childDepth"
+            }
+          },
+          {
+            $lookup: {
+              from: "users",
+              localField: "owner.target",
+              foreignField: "_id",
+              as: "owner"
+            }
+          },
+          { $unwind: "$owner" },
+          {
+            $lookup: {
+              from: "users",
+              localField: "children.owner.target",
+              foreignField: "_id",
+              as: "childUsers"
+            }
+          },
+          {
+            $project: {
+              _id: 1,
+              content: 1,
+              type: 1,
+              target: 1,
+              "owner.username": 1,
+              "owner.profile.photo": 1,
+              "owner.profile.name": 1,
+              "owner._id": 1,
+              depth: 1,
+              createdAt: 1,
+              childrenCount: { $size: "$children" },
+              children: {
+                $map: {
+                  input: "$children",
+                  as: "child",
+                  in: {
+                    _id: "$$child._id",
+                    content: "$$child.content",
+                    type: "$$child.type",
+                    parent: "$$child.parent",
+                    target: "$$child.target",
+                    owner: {
+                      $arrayElemAt: [
+                        {
+                          $filter: {
+                            input: "$childUsers",
+                            as: "childUser",
+                            cond: { $eq: ["$$childUser._id", "$$child.owner.target"] }
+                          }
+                        },
+                        0
+                      ]
+                    },
+                    depth: "$$child.depth",
+                    createdAt: "$$child.createdAt",
+                    childrenCount: { $size: "$$child.children" }
+                  }
                 }
               }
             }
           }
+        ];
+        if (blockedMembers.length > 0) {
+          pipeline.unshift({ $match: { user: { $nin: blockedMembers } } });
         }
-      ];
-      if (blockedMembers.length > 0) {
-        pipeline.unshift({ $match: { user: { $nin: blockedMembers } } });
+        const comments = await Comment.aggregate(pipeline);
+        let commentsTree = buildCommentTree(comments);
+        console.log(commentsTree);
+        res.status(200).json(commentsTree);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ message: error.message });
       }
-      const comments = await Comment.aggregate(pipeline);
-      let commentsTree = buildCommentTree(comments);
-      console.log(commentsTree);
-      res.status(200).json(commentsTree);
-    } catch (error) {
-      console.error(error);
-      res.status(500).json({ message: error.message });
-    }
-  };
-  const create = async (req, res) => {
-    try {
-      const { user, type, target, content, parent, creator, owner } = req.body;
-      let depth = 0;
-      if (parent) {
-        const parentComment = await Comment.findById(parent);
-        if (!parentComment) {
-          return res.status(404).send({ message: "Parent comment not found." });
+    };
+    const create = async (req, res) => {
+      try {
+        const { user, type, target, content, parent, creator, owner } = req.body;
+        let depth = 0;
+        if (parent) {
+          const parentComment = await Comment.findById(parent);
+          if (!parentComment) {
+            return res.status(404).send({ message: "Parent comment not found." });
+          }
+          depth = parentComment.depth + 1;
+        }
+        const comment = new Comment({
+          user,
+          type,
+          target,
+          content,
+          parent,
+          creator,
+          owner,
+          depth
+        });
+        const savedComment = await comment.save();
+        if (parent) {
+          await Comment.findByIdAndUpdate(parent, {
+            $push: { children: savedComment._id }
+          });
         }
-        depth = parentComment.depth + 1;
+        const populatedComment = await Comment.findById(savedComment._id).populate({
+          path: "owner.target",
+          select: "username profile.photo profile.name _id"
+        }).populate({
+          path: "creator.target",
+          select: "username profile.photo profile.name _id"
+        });
+        res.status(201).send(populatedComment);
+      } catch (err) {
+        console.error(err);
+        res.status(500).send({
+          message: err.message || "Some error occurred while creating the comment."
+        });
       }
-      const comment = new Comment({
-        user,
-        type,
-        target,
-        content,
-        parent,
-        creator,
-        owner,
-        depth
-      });
-      const savedComment = await comment.save();
-      if (parent) {
-        await Comment.findByIdAndUpdate(parent, {
-          $push: { children: savedComment._id }
+    };
+    const update = async (req, res) => {
+      try {
+        const comment = await Comment.findByIdAndUpdate(req.params._id, req.body, { new: true }).populate({
+          path: "creator.target",
+          select: "username profile.photo profile.name _id"
+        }).populate({
+          path: "owner.target",
+          select: "username profile.photo profile.name _id"
         });
+        if (!comment) {
+          return res.status(404).send({ message: "Comment not found." });
+        }
+        res.status(200).send(comment);
+      } catch (err) {
+        res.status(500).send({ message: err.message });
       }
-      const populatedComment = await Comment.findById(savedComment._id).populate({
-        path: "owner.target",
-        select: "username profile.photo profile.name _id"
-      }).populate({
-        path: "creator.target",
-        select: "username profile.photo profile.name _id"
-      });
-      res.status(201).send(populatedComment);
-    } catch (err) {
-      console.error(err);
-      res.status(500).send({
-        message: err.message || "Some error occurred while creating the comment."
-      });
-    }
-  };
-  const update = async (req, res) => {
-    try {
-      const comment = await Comment.findByIdAndUpdate(req.params._id, req.body, { new: true }).populate({
-        path: "creator.target",
-        select: "username profile.photo profile.name _id"
-      }).populate({
-        path: "owner.target",
-        select: "username profile.photo profile.name _id"
-      });
-      if (!comment) {
-        return res.status(404).send({ message: "Comment not found." });
+    };
+    const deleteComment = async (req, res) => {
+      try {
+        const comment = await Comment.findByIdAndRemove(req.params._id);
+        if (!comment) {
+          return res.status(404).send({ message: "Comment is not deleted." });
+        }
+        res.status(200).send(comment);
+      } catch (err) {
+        res.status(500).send({ message: err.message });
       }
-      res.status(200).send(comment);
-    } catch (err) {
-      res.status(500).send({ message: err.message });
-    }
+    };
+    return {
+      read,
+      create,
+      update,
+      delete: deleteComment
+    };
   };
-  const deleteComment = async (req, res) => {
-    try {
-      const comment = await Comment.findByIdAndRemove(req.params._id);
-      if (!comment) {
-        return res.status(404).send({ message: "Comment is not deleted." });
+  comments_controller = commentControllerFactory;
+  return comments_controller;
+}
+var reactions_controller;
+var hasRequiredReactions_controller;
+function requireReactions_controller() {
+  if (hasRequiredReactions_controller) return reactions_controller;
+  hasRequiredReactions_controller = 1;
+  const { v1: uuidv1, v4: uuidv4 } = require$$0$1;
+  const ObjectId = require$$0.Types.ObjectId;
+  const reactionControllerFactory = (db) => {
+    const Reaction = db.reaction;
+    const read = async (req, res) => {
+      let query = {};
+      if (req.query.user) {
+        query.user = new ObjectId(req.query.user);
       }
-      res.status(200).send(comment);
-    } catch (err) {
-      res.status(500).send({ message: err.message });
-    }
-  };
-  return {
-    read,
-    create,
-    update,
-    delete: deleteComment
-  };
-};
-var comments_controller = commentControllerFactory;
-const ObjectId = require$$0.Types.ObjectId;
-const reactionControllerFactory = (db) => {
-  const Reaction = db.reaction;
-  const read = async (req, res) => {
-    let query = {};
-    if (req.query.user) {
-      query.user = new ObjectId(req.query.user);
-    }
-    if (req.query.type) {
-      query.type = req.query.type;
-    }
-    if (req.query.target) {
-      query.target = req.query.target;
-    }
-    if (req.query.targetString) {
-      query.targetString = req.query.targetString;
-    }
-    try {
-      const reactions = await Reaction.find(query).populate("user");
-      if (!reactions) {
-        return res.status(404).send({ errorCode: "REACTIONS_NOT_FOUND" });
+      if (req.query.type) {
+        query.type = req.query.type;
       }
-      res.send(reactions);
-    } catch (err) {
-      res.status(500).send({ errorCode: "SERVER_ERROR" });
-    }
-  };
-  const create = async (req, res) => {
-    try {
-      const reaction = new Reaction(req.body);
-      const savedReaction = await reaction.save();
-      res.status(200).send({ reaction: savedReaction });
-    } catch (err) {
-      console.error(err);
-      res.status(500).send({ message: err });
-    }
-  };
-  const update = async (req, res) => {
-    try {
-      let query = { _id: new ObjectId(req.params._id) };
-      if (req.body.targetString && !req.body.target) {
-        query.targetString = req.body.targetString;
+      if (req.query.target) {
+        query.target = req.query.target;
       }
-      const updatedReaction = await Reaction.findOneAndUpdate(
-        query,
-        { $set: req.body },
-        { new: true }
-      );
-      if (!updatedReaction) {
-        return res.status(404).send({ message: "Something wrong when updating reaction." });
+      if (req.query.targetString) {
+        query.targetString = req.query.targetString;
       }
-      res.status(200).send(updatedReaction);
-    } catch (err) {
-      console.error(err);
-      res.status(500).send({ message: err });
-    }
-  };
-  const deleteReaction = async (req, res) => {
-    try {
-      let query = { _id: new ObjectId(req.body._id) };
-      if (req.body.targetString && !req.body.target) {
-        query.targetString = req.body.targetString;
+      try {
+        const reactions = await Reaction.find(query).populate("user");
+        if (!reactions) {
+          return res.status(404).send({ errorCode: "REACTIONS_NOT_FOUND" });
+        }
+        res.send(reactions);
+      } catch (err) {
+        res.status(500).send({ errorCode: "SERVER_ERROR" });
       }
-      const deletedReaction = await Reaction.findOneAndDelete(query);
-      if (!deletedReaction) {
-        return res.status(404).send({ message: "Reaction is not deleted." });
+    };
+    const create = async (req, res) => {
+      try {
+        const reaction = new Reaction(req.body);
+        const savedReaction = await reaction.save();
+        res.status(200).send({ reaction: savedReaction });
+      } catch (err) {
+        console.error(err);
+        res.status(500).send({ message: err });
       }
-      res.status(200).send(deletedReaction);
-    } catch (err) {
-      console.error(err);
-      res.status(500).send({ message: err });
-    }
-  };
-  return {
-    read,
-    create,
-    update,
-    delete: deleteReaction
+    };
+    const update = async (req, res) => {
+      try {
+        let query = { _id: new ObjectId(req.params._id) };
+        if (req.body.targetString && !req.body.target) {
+          query.targetString = req.body.targetString;
+        }
+        const updatedReaction = await Reaction.findOneAndUpdate(
+          query,
+          { $set: req.body },
+          { new: true }
+        );
+        if (!updatedReaction) {
+          return res.status(404).send({ message: "Something wrong when updating reaction." });
+        }
+        res.status(200).send(updatedReaction);
+      } catch (err) {
+        console.error(err);
+        res.status(500).send({ message: err });
+      }
+    };
+    const deleteReaction = async (req, res) => {
+      try {
+        let query = { _id: new ObjectId(req.body._id) };
+        if (req.body.targetString && !req.body.target) {
+          query.targetString = req.body.targetString;
+        }
+        const deletedReaction = await Reaction.findOneAndDelete(query);
+        if (!deletedReaction) {
+          return res.status(404).send({ message: "Reaction is not deleted." });
+        }
+        res.status(200).send(deletedReaction);
+      } catch (err) {
+        console.error(err);
+        res.status(500).send({ message: err });
+      }
+    };
+    return {
+      read,
+      create,
+      update,
+      delete: deleteReaction
+    };
   };
-};
-var reactions_controller = reactionControllerFactory;
+  reactions_controller = reactionControllerFactory;
+  return reactions_controller;
+}
 var verifyBlogpost;
 var hasRequiredVerifyBlogpost;
 function requireVerifyBlogpost() {
@@ -653,302 +696,359 @@ function requireVerifyBlogpost() {
   verifyBlogpost = middlewareFactory;
   return verifyBlogpost;
 }
-const middlewareIndexFactory = (db) => {
-  const verifyBlogpost2 = requireVerifyBlogpost()(db);
-  return {
-    verifyBlogpost: verifyBlogpost2
+var server;
+var hasRequiredServer;
+function requireServer() {
+  if (hasRequiredServer) return server;
+  hasRequiredServer = 1;
+  const middlewareIndexFactory = (db) => {
+    const verifyBlogpost2 = requireVerifyBlogpost()(db);
+    return {
+      verifyBlogpost: verifyBlogpost2
+    };
+  };
+  server = middlewareIndexFactory;
+  return server;
+}
+var blog_routes;
+var hasRequiredBlog_routes;
+function requireBlog_routes() {
+  if (hasRequiredBlog_routes) return blog_routes;
+  hasRequiredBlog_routes = 1;
+  const controllerFactory = requireBlog_controller();
+  const middlewareFactoryAuth = requireMiddlewares();
+  const middlewareFactoryCommunity = requireServer();
+  const { getInstance } = requireGlobals_abac();
+  blog_routes = function(app, db, origins) {
+    const controller = controllerFactory(db);
+    const abac = getInstance(db);
+    const { authJwt } = middlewareFactoryAuth(db);
+    const { verifyBlogpost: verifyBlogpost2 } = middlewareFactoryCommunity(db);
+    app.get(
+      "/api/blog/read",
+      [
+        authJwt.verifyToken(true),
+        abac.middleware("blogposts", "read", {
+          allowPublished: true,
+          allowUnauthenticated: true
+        })
+      ],
+      controller.read
+    );
+    app.post(
+      "/api/blog/create",
+      [
+        authJwt.verifyToken(),
+        abac.middleware("blogposts", "create"),
+        verifyBlogpost2.checkNameNotEmpty,
+        verifyBlogpost2.checkBlogpostExistOrNot
+      ],
+      controller.create
+    );
+    app.post(
+      "/api/blog/update",
+      [
+        authJwt.verifyToken(),
+        abac.middleware("blogposts", "edit"),
+        verifyBlogpost2.checkNameNotEmpty,
+        verifyBlogpost2.checkBlogpostExistOrNot
+      ],
+      controller.update
+    );
+    app.delete(
+      "/api/blog/delete/:_id",
+      [
+        authJwt.verifyToken(),
+        abac.middleware("blogposts", "delete")
+      ],
+      controller.delete
+    );
   };
-};
-var server = middlewareIndexFactory;
-const controllerFactory$2 = blog_controller;
-const middlewareFactoryAuth$2 = middlewares;
-const middlewareFactoryCommunity = server;
-const { getInstance: getInstance$2 } = globals_abac;
-var blog_routes = function(app, db, origins) {
-  const controller = controllerFactory$2(db);
-  const abac = getInstance$2(db);
-  const { authJwt } = middlewareFactoryAuth$2(db);
-  const { verifyBlogpost: verifyBlogpost2 } = middlewareFactoryCommunity(db);
-  app.get(
-    "/api/blog/read",
-    [
-      authJwt.verifyToken(true),
-      abac.middleware("blogposts", "read", {
-        allowPublished: true,
-        allowUnauthenticated: true
-      })
-    ],
-    controller.read
-  );
-  app.post(
-    "/api/blog/create",
-    [
-      authJwt.verifyToken(),
-      abac.middleware("blogposts", "create"),
-      verifyBlogpost2.checkNameNotEmpty,
-      verifyBlogpost2.checkBlogpostExistOrNot
-    ],
-    controller.create
-  );
-  app.post(
-    "/api/blog/update",
-    [
-      authJwt.verifyToken(),
-      abac.middleware("blogposts", "edit"),
-      verifyBlogpost2.checkNameNotEmpty,
-      verifyBlogpost2.checkBlogpostExistOrNot
-    ],
-    controller.update
-  );
-  app.delete(
-    "/api/blog/delete/:_id",
-    [
-      authJwt.verifyToken(),
-      abac.middleware("blogposts", "delete")
-    ],
-    controller.delete
-  );
-};
-const controllerFactory$1 = comments_controller;
-const middlewareFactoryAuth$1 = middlewares;
-const { getInstance: getInstance$1 } = globals_abac;
-var comments_routes = function(app, db) {
-  const controller = controllerFactory$1(db);
-  const abac = getInstance$1(db);
-  const { authJwt } = middlewareFactoryAuth$1(db);
-  app.get(
-    "/comments/read",
-    [
-      authJwt.verifyToken(true),
-      abac.middleware("comments", "read", {
-        allowPublished: true,
-        allowUnauthenticated: true
-      })
-    ],
-    controller.read
-  );
-  app.post(
-    "/comments/create",
-    [
-      authJwt.verifyToken(),
-      abac.middleware("comments", "create")
-    ],
-    controller.create
-  );
-  app.post(
-    "/comments/update/:url",
-    [
-      authJwt.verifyToken(),
-      abac.middleware("comments", "edit")
-    ],
-    controller.update
-  );
-  app.delete(
-    "/comments/delete/:url",
-    [
-      authJwt.verifyToken(),
-      abac.middleware("comments", "delete")
-    ],
-    controller.delete
-  );
-};
-const controllerFactory = reactions_controller;
-const middlewareFactoryAuth = middlewares;
-const { getInstance } = globals_abac;
-var reactions_routes = function(app, db) {
-  const controller = controllerFactory(db);
-  getInstance(db);
-  const { authJwt } = middlewareFactoryAuth(db);
-  app.get(
-    "/api/reactions/read",
-    [
-      authJwt.verifyToken(true)
-    ],
-    controller.read
-  );
-  app.post(
-    "/api/reactions/create",
-    [
-      authJwt.verifyToken()
-    ],
-    controller.create
-  );
-  app.post(
-    "/api/reactions/update",
-    [
-      authJwt.verifyToken()
-    ],
-    controller.update
-  );
-  app.post(
-    "/api/reactions/delete",
-    [
-      authJwt.verifyToken()
-    ],
-    controller.delete
-  );
-};
-const applyCommonSchema = common_schema;
-const applyEngagementSchema = engagement_schema;
-const applyOwnershipSchema$1 = ownership_schema;
-const applyMetadataSchema = metadata_schema;
-var blogpost_model = (db) => {
-  const BlogpostSchema = new db.mongoose.Schema({
-    name: {
-      type: String,
-      required: true
-    },
-    content: {
-      type: Array
-    },
-    source: {
-      type: String
-    },
-    createdAt: {
-      type: Date,
-      default: Date.now
-    }
-  }, {
-    strict: true
-  });
-  applyCommonSchema(BlogpostSchema);
-  applyEngagementSchema(BlogpostSchema);
-  applyOwnershipSchema$1(BlogpostSchema, db);
-  applyMetadataSchema(BlogpostSchema);
-  const Blogpost = db.mongoose.model("Blogpost", BlogpostSchema);
-  return Blogpost;
-};
-const applyOwnershipSchema = ownership_schema;
-var comment_model = (db) => {
-  const CommentSchema = new db.mongoose.Schema({
-    type: {
-      type: String,
-      enum: ["blogpost", "comment", "photo", "event"],
-      default: "post",
-      required: true
-    },
-    target: {
-      // заменяем 'organization' на 'target', так как это может быть или User, или Organization
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: function(value) {
-        if (this.type === "blogpost") return "Blogpost";
-        if (this.type === "comment") return "Comment";
-        if (this.type === "event") return "Event";
-        if (this.type === "photo") return "Photo";
+  return blog_routes;
+}
+var comments_routes;
+var hasRequiredComments_routes;
+function requireComments_routes() {
+  if (hasRequiredComments_routes) return comments_routes;
+  hasRequiredComments_routes = 1;
+  const controllerFactory = requireComments_controller();
+  const middlewareFactoryAuth = requireMiddlewares();
+  const { getInstance } = requireGlobals_abac();
+  comments_routes = function(app, db) {
+    const controller = controllerFactory(db);
+    const abac = getInstance(db);
+    const { authJwt } = middlewareFactoryAuth(db);
+    app.get(
+      "/comments/read",
+      [
+        authJwt.verifyToken(true),
+        abac.middleware("comments", "read", {
+          allowPublished: true,
+          allowUnauthenticated: true
+        })
+      ],
+      controller.read
+    );
+    app.post(
+      "/comments/create",
+      [
+        authJwt.verifyToken(),
+        abac.middleware("comments", "create")
+      ],
+      controller.create
+    );
+    app.post(
+      "/comments/update/:url",
+      [
+        authJwt.verifyToken(),
+        abac.middleware("comments", "edit")
+      ],
+      controller.update
+    );
+    app.delete(
+      "/comments/delete/:url",
+      [
+        authJwt.verifyToken(),
+        abac.middleware("comments", "delete")
+      ],
+      controller.delete
+    );
+  };
+  return comments_routes;
+}
+var reactions_routes;
+var hasRequiredReactions_routes;
+function requireReactions_routes() {
+  if (hasRequiredReactions_routes) return reactions_routes;
+  hasRequiredReactions_routes = 1;
+  const controllerFactory = requireReactions_controller();
+  const middlewareFactoryAuth = requireMiddlewares();
+  const { getInstance } = requireGlobals_abac();
+  reactions_routes = function(app, db) {
+    const controller = controllerFactory(db);
+    getInstance(db);
+    const { authJwt } = middlewareFactoryAuth(db);
+    app.get(
+      "/api/reactions/read",
+      [
+        authJwt.verifyToken(true)
+      ],
+      controller.read
+    );
+    app.post(
+      "/api/reactions/create",
+      [
+        authJwt.verifyToken()
+      ],
+      controller.create
+    );
+    app.post(
+      "/api/reactions/update",
+      [
+        authJwt.verifyToken()
+      ],
+      controller.update
+    );
+    app.post(
+      "/api/reactions/delete",
+      [
+        authJwt.verifyToken()
+      ],
+      controller.delete
+    );
+  };
+  return reactions_routes;
+}
+var blogpost_model;
+var hasRequiredBlogpost_model;
+function requireBlogpost_model() {
+  if (hasRequiredBlogpost_model) return blogpost_model;
+  hasRequiredBlogpost_model = 1;
+  const applyCommonSchema = requireCommon_schema();
+  const applyEngagementSchema = requireEngagement_schema();
+  const applyOwnershipSchema = requireOwnership_schema();
+  const applyMetadataSchema = requireMetadata_schema();
+  blogpost_model = (db) => {
+    const BlogpostSchema = new db.mongoose.Schema({
+      name: {
+        type: String,
+        required: true
       },
-      required: true
-    },
-    parent: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: "Comment",
-      default: null
-    },
-    children: [{
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: "Comment"
-    }],
-    depth: {
-      type: Number,
-      default: 0
-    },
-    content: {
-      type: String,
-      required: true
-    },
-    createdAt: {
-      type: Date,
-      default: Date.now
-    }
-  });
-  applyOwnershipSchema(CommentSchema, db);
-  CommentSchema.index({ target: 1, parent: 1, depth: 1 });
-  const Comment = db.mongoose.model("Comment", CommentSchema);
-  return Comment;
-};
-var reaction_model = (db) => {
-  const ReactionSchema = new db.mongoose.Schema({
-    user: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: function(value) {
-        if (this.owner.type === "user") return "User";
-        if (this.owner.type === "organization") return "Organization";
+      content: {
+        type: Array
       },
-      required: true
-    },
-    type: {
-      type: String,
-      enum: ["event", "comment", "blogpost", "mix"],
-      default: "blogpost",
-      required: true
-    },
-    target: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: function(value) {
-        if (this.owner.type === "event") return "Event";
-        if (this.owner.type === "comment") return "Comment";
-        if (this.owner.blogpost === "blogpost") return "Blogpost";
+      source: {
+        type: String
+      },
+      createdAt: {
+        type: Date,
+        default: Date.now
       }
+    }, {
+      strict: true
+    });
+    applyCommonSchema(BlogpostSchema, db);
+    applyEngagementSchema(BlogpostSchema, db);
+    applyOwnershipSchema(BlogpostSchema, db);
+    applyMetadataSchema(BlogpostSchema, db);
+    const Blogpost = db.mongoose.model("Blogpost", BlogpostSchema);
+    return Blogpost;
+  };
+  return blogpost_model;
+}
+var comment_model;
+var hasRequiredComment_model;
+function requireComment_model() {
+  if (hasRequiredComment_model) return comment_model;
+  hasRequiredComment_model = 1;
+  const applyOwnershipSchema = requireOwnership_schema();
+  comment_model = (db) => {
+    const CommentSchema = new db.mongoose.Schema({
+      type: {
+        type: String,
+        enum: ["blogpost", "comment", "photo", "event"],
+        default: "post",
+        required: true
+      },
+      target: {
+        // заменяем 'organization' на 'target', так как это может быть или User, или Organization
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: function(value) {
+          if (this.type === "blogpost") return "Blogpost";
+          if (this.type === "comment") return "Comment";
+          if (this.type === "event") return "Event";
+          if (this.type === "photo") return "Photo";
+        },
+        required: true
+      },
+      parent: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Comment",
+        default: null
+      },
+      children: [{
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Comment"
+      }],
+      depth: {
+        type: Number,
+        default: 0
+      },
+      content: {
+        type: String,
+        required: true
+      },
+      createdAt: {
+        type: Date,
+        default: Date.now
+      }
+    });
+    applyOwnershipSchema(CommentSchema, db);
+    CommentSchema.index({ target: 1, parent: 1, depth: 1 });
+    const Comment = db.mongoose.model("Comment", CommentSchema);
+    return Comment;
+  };
+  return comment_model;
+}
+var reaction_model;
+var hasRequiredReaction_model;
+function requireReaction_model() {
+  if (hasRequiredReaction_model) return reaction_model;
+  hasRequiredReaction_model = 1;
+  reaction_model = (db) => {
+    const ReactionSchema = new db.mongoose.Schema({
+      user: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: function(value) {
+          if (this.owner.type === "user") return "User";
+          if (this.owner.type === "organization") return "Organization";
+        },
+        required: true
+      },
+      type: {
+        type: String,
+        enum: ["event", "comment", "blogpost", "mix"],
+        default: "blogpost",
+        required: true
+      },
+      target: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: function(value) {
+          if (this.owner.type === "event") return "Event";
+          if (this.owner.type === "comment") return "Comment";
+          if (this.owner.blogpost === "blogpost") return "Blogpost";
+        }
+      },
+      targetString: {
+        type: String
+      },
+      class: {
+        type: String,
+        enum: ["like", "dislike", "emoji"],
+        default: "like",
+        required: true
+      },
+      content: {
+        type: String
+      }
+    }, {
+      timestamps: {
+        currentTime: () => Date.now()
+      }
+    }, {
+      strict: false
+    });
+    const Reaction = db.mongoose.model("Reaction", ReactionSchema);
+    return Reaction;
+  };
+  return reaction_model;
+}
+var community_server$1;
+var hasRequiredCommunity_server;
+function requireCommunity_server() {
+  if (hasRequiredCommunity_server) return community_server$1;
+  hasRequiredCommunity_server = 1;
+  const BlogController = requireBlog_controller();
+  const CommentsController = requireComments_controller();
+  const ReactionsController = requireReactions_controller();
+  const blogRoutes = requireBlog_routes();
+  const commentsRoutes = requireComments_routes();
+  const reactionsRoutes = requireReactions_routes();
+  const BlogpostModel = requireBlogpost_model();
+  const CommentModel = requireComment_model();
+  const ReactionModel = requireReaction_model();
+  function initializeCommunity(app, db, origins, publicPath) {
+    db.blogpost = BlogpostModel(db);
+    db.comment = CommentModel(db);
+    db.reaction = ReactionModel(db);
+    if (app) {
+      blogRoutes(app, db, origins, publicPath);
+      commentsRoutes(app, db, origins, publicPath);
+      reactionsRoutes(app, db, origins, publicPath);
+    }
+  }
+  community_server$1 = {
+    initialize: initializeCommunity,
+    models: {
+      BlogpostModel,
+      CommentModel,
+      ReactionModel
     },
-    targetString: {
-      type: String
-    },
-    class: {
-      type: String,
-      enum: ["like", "dislike", "emoji"],
-      default: "like",
-      required: true
+    routes: {
+      blogRoutes,
+      commentsRoutes,
+      reactionsRoutes
     },
-    content: {
-      type: String
-    }
-  }, {
-    timestamps: {
-      currentTime: () => Date.now()
+    controllers: {
+      BlogController,
+      CommentsController,
+      ReactionsController
     }
-  }, {
-    strict: false
-  });
-  const Reaction = db.mongoose.model("Reaction", ReactionSchema);
-  return Reaction;
-};
-const BlogController = blog_controller;
-const CommentsController = comments_controller;
-const ReactionsController = reactions_controller;
-const blogRoutes = blog_routes;
-const commentsRoutes = comments_routes;
-const reactionsRoutes = reactions_routes;
-const BlogpostModel = blogpost_model;
-const CommentModel = comment_model;
-const ReactionModel = reaction_model;
-function initializeCommunity(app, db, origins, publicPath) {
-  db.blogpost = BlogpostModel(db);
-  db.comment = CommentModel(db);
-  db.reaction = ReactionModel(db);
-  if (app) {
-    blogRoutes(app, db);
-    commentsRoutes(app, db);
-    reactionsRoutes(app, db);
-  }
+  };
+  return community_server$1;
 }
-var community_server = {
-  initialize: initializeCommunity,
-  models: {
-    BlogpostModel,
-    CommentModel,
-    ReactionModel
-  },
-  routes: {
-    blogRoutes,
-    commentsRoutes,
-    reactionsRoutes
-  },
-  controllers: {
-    BlogController,
-    CommentsController,
-    ReactionsController
-  }
-};
-const community_server$1 = /* @__PURE__ */ getDefaultExportFromCjs(community_server);
+var community_serverExports = requireCommunity_server();
+const community_server = /* @__PURE__ */ getDefaultExportFromCjs(community_serverExports);
 export {
-  community_server$1 as default
+  community_server as default
 };