@ozdao/martyrs 0.2.488 → 0.2.491

package/dist/community.server.cjs

@@ -0,0 +1,840 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const mongoose = require("mongoose");
+const queryProcessor$1 = require("./queryProcessor-B_X680wC.cjs");
+const common_schema = require("./common.schema-BzFEVNn3.cjs");
+const engagement_schema = require("./engagement.schema-JADHu8pj.cjs");
+const metadata_schema = require("./metadata.schema-RlxNv46L.cjs");
+const ownership_schema = require("./ownership.schema-D1p5XSpt.cjs");
+const index = require("./index-BFxqqmgh.cjs");
+const globals_abac = require("./globals.abac-CPXLas7N.cjs");
+const ObjectId$2 = { Types: mongoose.Types }.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$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]
+          }
+        }
+      }
+    }
+  };
+}
+const queryProcessorReactions = {
+  getCommentsLookupStage,
+  getReactionsLookupStage,
+  getReactionsCommentsFields
+};
+const ObjectId$1 = { Types: mongoose.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;
+  }
+  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 [];
+      }
+    } else {
+      return [];
+    }
+  },
+  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
+          // Добавлено условие, чтобы исключить будущие записи
+        }
+      }
+    }
+  ];
+}
+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
+      ...queryProcessor$1.queryProcessorGlobals.getBasicOptions(req.query),
+      ...queryProcessor$1.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),
+      queryProcessor$1.queryProcessorGlobals.getCreatorUserLookupStage(),
+      queryProcessor$1.queryProcessorGlobals.getCreatorOrganizationLookupStage(),
+      // For owner
+      queryProcessor$1.queryProcessorGlobals.getOwnerUserLookupStage(),
+      queryProcessor$1.queryProcessorGlobals.getOwnerOrganizationLookupStage(),
+      queryProcessor$1.queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
+      // Sorting and Pagination
+      ...queryProcessor$1.queryProcessorGlobals.getSortingOptions(req.query.sortParam, req.query.sortOrder),
+      ...queryProcessor$1.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
+    };
+    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
+  };
+};
+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);
+          }
+        }
+        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",
+              connectFromField: "_id",
+              connectToField: "parent",
+              as: "children",
+              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"
+          }
+        },
+        ...queryProcessor$1.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 });
+    }
+  };
+  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 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." });
+      }
+      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 ObjectId = { Types: mongoose.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" });
+      }
+      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 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
+  };
+};
+const BlogpostModel = (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
+    }
+  );
+  common_schema.applyCommonSchema(BlogpostSchema);
+  engagement_schema.applyEngagementSchema(BlogpostSchema);
+  ownership_schema.applyOwnershipSchema(BlogpostSchema, db);
+  metadata_schema.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";
+      },
+      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
+    }
+  });
+  ownership_schema.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) {
+          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;
+};
+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 {
+    checkBlogpostExistOrNot,
+    checkNameNotEmpty
+  };
+};
+const middlewareIndexFactory = (db) => {
+  const verifyBlogpost = middlewareFactory(db);
+  return {
+    verifyBlogpost
+  };
+};
+const { getInstance: getInstance$2 } = globals_abac.globalsabac;
+const blogRoutes = function(app, db, origins) {
+  const controller = controllerFactory(db);
+  const abac = getInstance$2(db);
+  const { authJwt } = index.middlewareIndexFactory(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 } = globals_abac.globalsabac;
+const commentsRoutes = function(app, db) {
+  const controller = commentControllerFactory(db);
+  const abac = getInstance$1(db);
+  const { authJwt } = index.middlewareIndexFactory(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 } = globals_abac.globalsabac;
+const reactionsRoutes = function(app, db) {
+  const controller = reactionControllerFactory(db);
+  getInstance(db);
+  const { authJwt } = index.middlewareIndexFactory(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);
+  }
+}
+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
+};
+exports.controllers = controllers;
+exports.default = community_server;
+exports.initialize = initializeCommunity;
+exports.models = models;
+exports.routes = routes;