@ozdao/martyrs 0.2.477 → 0.2.478

package/dist/community.server.js

@@ -1,406 +1,338 @@
-"use strict";
-const _commonjsHelpers = require("./_commonjsHelpers-DHfMLFPC.js");
-const require$$0 = require("mongoose");
-const queryProcessor$2 = require("./queryProcessor-DSUqSk3I.js");
-require("util");
-const require$$0$1 = require("uuid");
-const index = require("./index-BOmxJQ5W.js");
-const globals_abac = require("./globals.abac-Bn-4tbX8.js");
-const common_schema = require("./common.schema-O0w_rDyC.js");
-const engagement_schema = require("./engagement.schema-DAiXsvh1.js");
-const ownership_schema = require("./ownership.schema-MxfJlPtq.js");
-const metadata_schema = require("./metadata.schema-CUkLXZ2f.js");
-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 "month":
-        startDate.setMonth(currentDate.getMonth() - 1);
-        break;
-      case "year":
-        startDate.setFullYear(currentDate.getFullYear() - 1);
-        break;
-      default:
-        return [];
+import { Types } from "mongoose";
+import { q as queryProcessorGlobals } from "./queryProcessor-CVcLPEnv.js";
+import { a as applyCommonSchema } from "./common.schema-Bw1O5_2Q.js";
+import { a as applyEngagementSchema } from "./engagement.schema-Dh1adRsn.js";
+import { a as applyMetadataSchema } from "./metadata.schema-CWmcDJN7.js";
+import { a as applyOwnershipSchema } from "./ownership.schema-CCZX5vfw.js";
+import { m as middlewareIndexFactory$1 } from "./index-CsJwdsBW.js";
+import { g as globalsabac } from "./globals.abac-DBV_kaOq.js";
+const ObjectId$2 = { Types }.Types.ObjectId;
+function getCommentsLookupStage() {
+  return {
+    $lookup: {
+      from: "comments",
+      localField: "_id",
+      foreignField: "target",
+      as: "comments"
     }
-    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"] } } });
-          break;
-        case "popular":
-          aggregationStages.push({ $sort: { views: -1, likes: -1 } });
-          break;
-        case "new":
-          aggregationStages.push({ $sort: { createdAt: 1 } });
-          break;
-      }
+  };
+}
+function getReactionsLookupStage() {
+  return {
+    $lookup: {
+      from: "reactions",
+      localField: "_id",
+      foreignField: "target",
+      as: "reactions"
     }
-    return aggregationStages;
-  }
-  queryProcessor$1 = {
-    getPeriodConditions,
-    getCategoryConditions
   };
-  return queryProcessor$1;
 }
-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
+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
               ]
             }
+          },
+          in: {
+            $cond: [{ $gte: ["$$reactionIndex", 0] }, { $arrayElemAt: ["$reactions._id", "$$reactionIndex"] }, null]
           }
         }
       }
-    };
-  }
-  queryProcessorReactions = {
-    getCommentsLookupStage,
-    getReactionsLookupStage,
-    getReactionsCommentsFields
+    }
   };
-  return queryProcessorReactions;
 }
-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);
+const queryProcessorReactions = {
+  getCommentsLookupStage,
+  getReactionsLookupStage,
+  getReactionsCommentsFields
+};
+const ObjectId$1 = { Types }.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;
   }
-  function addConditionsForBlocked(matchStage, field, blockedMembers) {
-    const conditionsForBlocked = { "$nin": blockedMembers };
-    if (matchStage[field]) {
-      matchStage[field] = { "$eq": matchStage[field], ...conditionsForBlocked };
-    } else {
-      matchStage[field] = conditionsForBlocked;
+  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 [];
     }
-    return matchStage;
-  }
-  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 [];
-      }
-      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 [{
+    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 [{
+      }
+    ];
+  },
+  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 [];
       }
-    },
-    getFollowingStage: async (Membership, following) => {
-      return await AggregationProcessor.generateMatchStage(Membership, following, "subscriber", "$in");
+    } else {
+      return [];
     }
-  };
-  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 = queryProcessor$2.requireQueryProcessor();
-  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 = [
-        // Basic
-        ...queryProcessorGlobals.getBasicOptions(
-          req.query
-        ),
-        ...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
-        ),
-        queryProcessorGlobals.getCreatorUserLookupStage(),
-        queryProcessorGlobals.getCreatorOrganizationLookupStage(),
-        // For owner
-        queryProcessorGlobals.getOwnerUserLookupStage(),
-        queryProcessorGlobals.getOwnerOrganizationLookupStage(),
-        queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
-        // Sorting and Pagination
-        ...queryProcessorGlobals.getSortingOptions(
-          req.query.sortParam,
-          req.query.sortOrder
-        ),
-        ...queryProcessorGlobals.getPaginationOptions(
-          req.query.skip,
-          req.query.limit
-        )
-        // For creator
-        // { $sample: { size: Number(req.query.limit) } },
-      ];
-      try {
-        const posts = await Blogpost.aggregate(stages).exec();
-        if (posts.length === 0) {
-          return res.status(200).send([]);
+  },
+  getFollowingStage: async (Membership, following) => {
+    return await AggregationProcessor.generateMatchStage(Membership, following, "subscriber", "$in");
+  }
+};
+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:
+      return [];
+  }
+  return [
+    {
+      $match: {
+        createdAt: {
+          $gte: startDate,
+          $lte: currentDate
+          // Добавлено условие, чтобы исключить будущие записи
         }
-        res.status(200).send(posts);
-      } catch (err) {
-        console.log(err);
-        res.status(500).send({ err });
       }
+    }
+  ];
+}
+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;
+}
+const queryProcessor = {
+  getPeriodConditions,
+  getCategoryConditions
+};
+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 = [
+      // Basic
+      ...queryProcessorGlobals.getBasicOptions(req.query),
+      ...queryProcessorGlobals.getTagsOptions(req.query.tags),
+      ...queryProcessor.getPeriodConditions(req.query.period),
+      ...await queryProcessor.getCategoryConditions(req.query.category),
+      // Following
+      ...await AggregationProcessor.getFollowingStage(Membership, req.query.following),
+      // Blocking
+      ...await AggregationProcessor.getBlockedStage(Membership, req.query.user),
+      queryProcessorReactions.getCommentsLookupStage(),
+      queryProcessorReactions.getReactionsLookupStage(),
+      queryProcessorReactions.getReactionsCommentsFields(req.query.user),
+      queryProcessorGlobals.getCreatorUserLookupStage(),
+      queryProcessorGlobals.getCreatorOrganizationLookupStage(),
+      // For owner
+      queryProcessorGlobals.getOwnerUserLookupStage(),
+      queryProcessorGlobals.getOwnerOrganizationLookupStage(),
+      queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
+      // Sorting and Pagination
+      ...queryProcessorGlobals.getSortingOptions(req.query.sortParam, req.query.sortOrder),
+      ...queryProcessorGlobals.getPaginationOptions(req.query.skip, req.query.limit)
+      // For creator
+      // { $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
     };
-    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
-    };
+    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." });
+    });
   };
-  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 queryProcessorGlobals = queryProcessor$2.requireQueryProcessor();
-  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);
-              }
+  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
+  };
+};
+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);
-              }
-            }
-          });
-          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);
+        }
+        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);
             }
           }
-          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,
-          format = "tree",
-          sortParam = "createdAt",
-          sortOrder = "desc"
-        } = req.query;
-        let conditions = {};
-        if (target) conditions.target = new db.mongoose.Types.ObjectId(target);
-        if (type) conditions.type = 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);
+        });
+        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 pipeline = [
-          { $match: conditions },
-          ...format === "tree" ? [{
+        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, format = "tree", sortParam = "createdAt", sortOrder = "desc" } = req.query;
+      let conditions = {};
+      if (target) conditions.target = new db.mongoose.Types.ObjectId(target);
+      if (type) conditions.type = 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 },
+        ...format === "tree" ? [
+          {
             $graphLookup: {
               from: "comments",
               startWith: "$_id",
@@ -410,481 +342,239 @@ function requireComments_controller() {
               maxDepth: Number(req.query.maxDepth),
               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"
-            }
-          },
-          ...queryProcessorGlobals.getSortingOptions(
-            sortParam,
-            sortOrder
-          ),
-          {
-            $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,
-              ...format === "tree" ? {
-                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" }
-                    }
+          }
+        ] : [],
+        {
+          $lookup: {
+            from: "users",
+            localField: "owner.target",
+            foreignField: "_id",
+            as: "owner"
+          }
+        },
+        { $unwind: "$owner" },
+        {
+          $lookup: {
+            from: "users",
+            localField: "children.owner.target",
+            foreignField: "_id",
+            as: "childUsers"
+          }
+        },
+        ...queryProcessorGlobals.getSortingOptions(sortParam, sortOrder),
+        {
+          $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,
+            ...format === "tree" ? {
+              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 } } });
         }
-        const comments = await Comment.aggregate(pipeline);
-        let commentsTree = format === "tree" ? buildCommentTree(comments) : comments;
-        res.status(200).json(commentsTree);
-      } catch (error) {
-        console.error(error);
-        res.status(500).json({ message: error.message });
+      ];
+      if (blockedMembers.length > 0) {
+        pipeline.unshift({ $match: { user: { $nin: blockedMembers } } });
       }
-    };
-    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 }
-          });
+      const comments = await Comment.aggregate(pipeline);
+      let commentsTree = format === "tree" ? buildCommentTree(comments) : comments;
+      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 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."
-        });
+        depth = parentComment.depth + 1;
       }
-    };
-    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"
+      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 }
         });
-        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 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 });
-      }
-    };
-    return {
-      read,
-      create,
-      update,
-      delete: deleteComment
-    };
+      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."
+      });
+    }
   };
-  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);
-      }
-      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;
+  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." });
       }
-      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" });
+      res.status(200).send(comment);
+    } catch (err) {
+      res.status(500).send({ message: err.message });
+    }
+  };
+  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." });
       }
-    };
-    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(comment);
+    } catch (err) {
+      res.status(500).send({ message: err.message });
+    }
+  };
+  return {
+    read,
+    create,
+    update,
+    delete: deleteComment
+  };
+};
+const ObjectId = { Types }.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" });
       }
-    };
-    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 });
+      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;
       }
-    };
-    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 });
+      const updatedReaction = await Reaction.findOneAndUpdate(query, { $set: req.body }, { new: true });
+      if (!updatedReaction) {
+        return res.status(404).send({ message: "Something wrong when updating reaction." });
       }
-    };
-    return {
-      read,
-      create,
-      update,
-      delete: deleteReaction
-    };
+      res.status(200).send(updatedReaction);
+    } catch (err) {
+      console.error(err);
+      res.status(500).send({ message: err });
+    }
   };
-  reactions_controller = reactionControllerFactory;
-  return reactions_controller;
-}
-var verifyBlogpost;
-var hasRequiredVerifyBlogpost;
-function requireVerifyBlogpost() {
-  if (hasRequiredVerifyBlogpost) return verifyBlogpost;
-  hasRequiredVerifyBlogpost = 1;
-  const middlewareFactory = (db) => {
-    const Blogpost = db.blogpost;
-    const checkBlogpostExistOrNot = async (req, res, next) => {
-      try {
-        const url = req.body.url ? req.body.url : req.body.name.toLowerCase().replace(/ /g, "-").replace(/[^\w-]+/g, "");
-        if (!req.body._id) {
-          const blogpost = await Blogpost.findOne({ url });
-          if (blogpost) {
-            res.status(400).send({ errorCode: "POST_URL_ALREADY_IN_USE", accessToken: null });
-            return;
-          }
-          next();
-          return;
-        }
-        const updatingBlogpostId = req.body._id;
-        const existingBlogpost = await Blogpost.findById(updatingBlogpostId);
-        if (!existingBlogpost) {
-          res.status(404).send({ errorCode: "BLOGPOST_NOT_FOUND", accessToken: null });
-          return;
-        }
-        if (existingBlogpost.url !== url) {
-          const blogpost = await Blogpost.findOne({ url });
-          if (blogpost) {
-            res.status(400).send({ errorCode: "POST_URL_ALREADY_IN_USE", accessToken: null });
-            return;
-          }
-        }
-        next();
-      } catch (err) {
-        console.log(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 checkNameNotEmpty = (req, res, next) => {
-      if (!req.body.name || req.body.name.trim() === "") {
-        res.status(400).send({ errorCode: "NAME_CANNOT_BE_EMPTY", accessToken: null });
-        return;
+      const deletedReaction = await Reaction.findOneAndDelete(query);
+      if (!deletedReaction) {
+        return res.status(404).send({ message: "Reaction is not deleted." });
       }
-      next();
-    };
-    return {
-      checkBlogpostExistOrNot,
-      checkNameNotEmpty
-    };
-  };
-  verifyBlogpost = middlewareFactory;
-  return verifyBlogpost;
-}
-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 = index.requireMiddlewares();
-  const middlewareFactoryCommunity = requireServer();
-  const { getInstance } = globals_abac.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
-    );
-  };
-  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 = index.requireMiddlewares();
-  const { getInstance } = globals_abac.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
-    );
+      res.status(200).send(deletedReaction);
+    } catch (err) {
+      console.error(err);
+      res.status(500).send({ message: err });
+    }
   };
-  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 = index.requireMiddlewares();
-  const { getInstance } = globals_abac.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 {
+    read,
+    create,
+    update,
+    delete: deleteReaction
   };
-  return reactions_routes;
-}
-var blogpost_model;
-var hasRequiredBlogpost_model;
-function requireBlogpost_model() {
-  if (hasRequiredBlogpost_model) return blogpost_model;
-  hasRequiredBlogpost_model = 1;
-  const applyCommonSchema = common_schema.requireCommon_schema();
-  const applyEngagementSchema = engagement_schema.requireEngagement_schema();
-  const applyOwnershipSchema = ownership_schema.requireOwnership_schema();
-  const applyMetadataSchema = metadata_schema.requireMetadata_schema();
-  blogpost_model = (db) => {
-    const BlogpostSchema = new db.mongoose.Schema({
+};
+const BlogpostModel = (db) => {
+  const BlogpostSchema = new db.mongoose.Schema(
+    {
       name: {
         type: String,
         required: true
@@ -899,79 +589,68 @@ function requireBlogpost_model() {
         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 = ownership_schema.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
+    }
+  );
+  applyCommonSchema(BlogpostSchema);
+  applyEngagementSchema(BlogpostSchema);
+  applyOwnershipSchema(BlogpostSchema, db);
+  applyMetadataSchema(BlogpostSchema);
+  const Blogpost = db.mongoose.model("Blogpost", BlogpostSchema);
+  return Blogpost;
+};
+const CommentModel = (db) => {
+  const CommentSchema = new db.mongoose.Schema({
+    type: {
+      type: String,
+      enum: ["blogpost", "comment", "photo", "event"],
+      default: "post",
+      required: true
+    },
+    target: {
+      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";
       },
-      children: [{
+      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({
+    ],
+    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;
+};
+const ReactionModel = (db) => {
+  const ReactionSchema = new db.mongoose.Schema(
+    {
       user: {
         type: db.mongoose.Schema.Types.ObjectId,
         ref: function(value) {
@@ -1006,62 +685,156 @@ function requireReaction_model() {
       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
-    },
-    routes: {
-      blogRoutes,
-      commentsRoutes,
-      reactionsRoutes
-    },
-    controllers: {
-      BlogController,
-      CommentsController,
-      ReactionsController
+  );
+  const Reaction = db.mongoose.model("Reaction", ReactionSchema);
+  return Reaction;
+};
+const middlewareFactory = (db) => {
+  const Blogpost = db.blogpost;
+  const checkBlogpostExistOrNot = async (req, res, next) => {
+    try {
+      const url = req.body.url ? req.body.url : req.body.name.toLowerCase().replace(/ /g, "-").replace(/[^\w-]+/g, "");
+      if (!req.body._id) {
+        const blogpost = await Blogpost.findOne({ url });
+        if (blogpost) {
+          res.status(400).send({ errorCode: "POST_URL_ALREADY_IN_USE", accessToken: null });
+          return;
+        }
+        next();
+        return;
+      }
+      const updatingBlogpostId = req.body._id;
+      const existingBlogpost = await Blogpost.findById(updatingBlogpostId);
+      if (!existingBlogpost) {
+        res.status(404).send({ errorCode: "BLOGPOST_NOT_FOUND", accessToken: null });
+        return;
+      }
+      if (existingBlogpost.url !== url) {
+        const blogpost = await Blogpost.findOne({ url });
+        if (blogpost) {
+          res.status(400).send({ errorCode: "POST_URL_ALREADY_IN_USE", accessToken: null });
+          return;
+        }
+      }
+      next();
+    } catch (err) {
+      console.log(err);
+      res.status(500).send({ message: err });
+    }
+  };
+  const checkNameNotEmpty = (req, res, next) => {
+    if (!req.body.name || req.body.name.trim() === "") {
+      res.status(400).send({ errorCode: "NAME_CANNOT_BE_EMPTY", accessToken: null });
+      return;
     }
+    next();
   };
-  return community_server$1;
+  return {
+    checkBlogpostExistOrNot,
+    checkNameNotEmpty
+  };
+};
+const middlewareIndexFactory = (db) => {
+  const verifyBlogpost = middlewareFactory(db);
+  return {
+    verifyBlogpost
+  };
+};
+const { getInstance: getInstance$2 } = globalsabac;
+const blogRoutes = function(app, db, origins) {
+  const controller = controllerFactory(db);
+  const abac = getInstance$2(db);
+  const { authJwt } = middlewareIndexFactory$1(db);
+  const { verifyBlogpost } = middlewareIndexFactory(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"), verifyBlogpost.checkNameNotEmpty, verifyBlogpost.checkBlogpostExistOrNot], controller.create);
+  app.post("/api/blog/update", [authJwt.verifyToken(), abac.middleware("blogposts", "edit"), verifyBlogpost.checkNameNotEmpty, verifyBlogpost.checkBlogpostExistOrNot], controller.update);
+  app.delete("/api/blog/delete/:_id", [authJwt.verifyToken(), abac.middleware("blogposts", "delete")], controller.delete);
+};
+const { getInstance: getInstance$1 } = globalsabac;
+const commentsRoutes = function(app, db) {
+  const controller = commentControllerFactory(db);
+  const abac = getInstance$1(db);
+  const { authJwt } = middlewareIndexFactory$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 { getInstance } = globalsabac;
+const reactionsRoutes = function(app, db) {
+  const controller = reactionControllerFactory(db);
+  getInstance(db);
+  const { authJwt } = middlewareIndexFactory$1(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);
+};
+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);
+  }
 }
-var community_serverExports = requireCommunity_server();
-const community_server = /* @__PURE__ */ _commonjsHelpers.getDefaultExportFromCjs(community_serverExports);
-module.exports = community_server;
+const models = {
+  BlogpostModel,
+  CommentModel,
+  ReactionModel
+};
+const routes = {
+  blogRoutes,
+  commentsRoutes,
+  reactionsRoutes
+};
+const controllers = {
+  BlogController: controllerFactory,
+  CommentsController: commentControllerFactory,
+  ReactionsController: reactionControllerFactory
+};
+const community_server = {
+  initialize: initializeCommunity,
+  models,
+  routes,
+  controllers
+};
+export {
+  controllers,
+  community_server as default,
+  initializeCommunity as initialize,
+  models,
+  routes
+};