@ozdao/martyrs 0.2.486 → 0.2.488

package/dist/community.server.js

@@ -1,840 +0,0 @@
-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"
-    }
-  };
-}
-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 }.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
-      ...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
-    };
-    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"
-          }
-        },
-        ...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 }.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
-    }
-  );
-  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";
-      },
-      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;
-};
-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 } = 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);
-  }
-}
-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
-};