@ozdao/prometheus-framework 0.1.36 → 0.1.37

package/dist/community.server.js

@@ -1,217 +1,245 @@
 "use strict";
 const _commonjsHelpers = require("./_commonjsHelpers-3b53548e.js");
-require("uuid");
 const require$$0 = require("mongoose");
+const metadata_schema = require("./metadata.schema-e4fe5c57.js");
+require("util");
+require("uuid");
 const index = require("./index-21dfdbd9.js");
-const metadata_schema = require("./metadata.schema-4f856191.js");
 require("jsonwebtoken");
 require("mongodb");
-async function getBlockedMembers$1(Membership, userId) {
+function getPeriodConditions(period) {
+  const date = /* @__PURE__ */ new Date();
+  switch (period) {
+    case "today":
+      date.setDate(date.getDate() - 1);
+      break;
+    case "week":
+      date.setDate(date.getDate() - 7);
+      break;
+    case "month":
+      date.setMonth(date.getMonth() - 1);
+      break;
+    case "year":
+      date.setFullYear(date.getFullYear() - 1);
+      break;
+    default:
+      date.setFullYear(date.getFullYear() - 1);
+  }
+  if (date) {
+    return [{ $match: { createdAt: { $gte: date } } }];
+  } else {
+    return [];
+  }
+}
+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;
+    }
+  }
+  console.log(aggregationStages);
+  return aggregationStages;
+}
+var queryProcessor$2 = {
+  getPeriodConditions,
+  getCategoryConditions
+  // ... other functions that you might want to export
+};
+const ObjectId$2 = require$$0.Types.ObjectId;
+function getCommentsLookupStage() {
+  return {
+    $lookup: {
+      from: "comments",
+      localField: "_id",
+      foreignField: "target",
+      as: "comments"
+    }
+  };
+}
+function getReactionsLookupStage() {
+  return {
+    $lookup: {
+      from: "reactions",
+      localField: "_id",
+      foreignField: "target",
+      as: "reactions"
+    }
+  };
+}
+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
+            ]
+          }
+        }
+      }
+    }
+  };
+}
+var queryProcessorReactions$1 = {
+  getCommentsLookupStage,
+  getReactionsLookupStage,
+  getReactionsCommentsFields
+};
+const ObjectId$1 = require$$0.Types.ObjectId;
+async function getBlockedMembers(Membership, userId) {
   const memberships = await Membership.find({ user: userId });
   return memberships.filter((membership) => membership.role === "blocked").map((membership) => membership.target);
 }
-function addConditionsForBlocked$1(matchStage, field, blockedMembers) {
+function addConditionsForBlocked(matchStage, field, blockedMembers) {
   const conditionsForBlocked = { "$nin": blockedMembers };
   if (matchStage[field]) {
     matchStage[field] = { "$eq": matchStage[field], ...conditionsForBlocked };
   } else {
     matchStage[field] = conditionsForBlocked;
   }
+  return matchStage;
 }
-var excludeBlockedMembers = { getBlockedMembers: getBlockedMembers$1, addConditionsForBlocked: addConditionsForBlocked$1 };
-const { getBlockedMembers, addConditionsForBlocked } = excludeBlockedMembers;
-const controllerFactory$3 = (db) => {
-  const Blogpost = db.blogpost;
-  db.organization;
-  const Membership = db.membership;
-  const read = async (req, res) => {
-    let query = [];
-    let matchStage = {};
-    const options = {
-      skip: parseInt(req.query.skip) || 0,
-      limit: parseInt(req.query.limit) || 20
-    };
-    if (req.query.url) {
-      matchStage["url"] = req.query.url;
-      await Blogpost.findOneAndUpdate({ url: req.query.url }, { $inc: { views: 1 } }, { new: true });
-    }
-    if (req.query.status) {
-      matchStage["status"] = req.query.status;
-    }
-    if (req.query.owner) {
-      matchStage["owner.target"] = new db.mongoose.Types.ObjectId(req.query.owner);
+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 [];
     }
-    if (req.query.creator) {
-      matchStage["creator.target"] = new db.mongoose.Types.ObjectId(req.query.creator);
+    const members = await AggregationProcessor.getMembersByRole(Membership, userOrFollowing, role);
+    if (members.length === 0) {
+      return [];
     }
-    if (req.query.user) {
-      const blockedMembers = await getBlockedMembers(Membership, req.query.user);
+    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) {
-        addConditionsForBlocked(matchStage, "owner.target", blockedMembers);
-        addConditionsForBlocked(matchStage, "creator.target", blockedMembers);
+        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 [];
     }
-    if (req.query.tags) {
-      matchStage["tags"] = { $in: req.query.tags.split(",") };
-    }
-    if (req.query.period) {
-      const date = /* @__PURE__ */ new Date();
-      switch (req.query.period) {
-        case "today":
-          date.setDate(date.getDate() - 1);
-          break;
-        case "week":
-          date.setDate(date.getDate() - 7);
-          break;
-        case "month":
-          date.setMonth(date.getMonth() - 1);
-          break;
-        case "year":
-          date.setFullYear(date.getFullYear() - 1);
-          break;
-      }
-      matchStage["createdAt"] = { $gte: date };
-    }
-    if (req.query.category) {
-      switch (req.query.category) {
-        case "featured":
-          matchStage["tags"] = { $in: ["Featured"] };
-          break;
-        case "popular":
-          query.push({ $sort: { views: -1, likes: -1 } });
-          break;
-        case "new":
-          query.push({ $sort: { createdAt: -1 } });
-          break;
-        case "following":
-          if (req.query.user) {
-            const memberships = await Membership.find({ user: req.query.user });
-            const followedOrganizations = memberships.filter((membership) => membership.type === "organization").map((membership) => membership.target);
-            const followedAuthors = memberships.filter((membership) => membership.type === "user").map((membership) => membership.target);
-            matchStage["$or"] = [
-              { "owner.target": { $in: followedOrganizations } },
-              { "owner.target": { $in: followedAuthors } }
-            ];
-          }
-          break;
-      }
-    }
-    query.push({ $match: matchStage });
-    query.push({
-      $lookup: {
-        from: "comments",
-        localField: "_id",
-        foreignField: "target",
-        as: "comments"
-      }
-    });
-    query.push({
-      $lookup: {
-        from: "reactions",
-        localField: "_id",
-        foreignField: "target",
-        as: "reactions"
-      }
-    });
-    query.push({
-      $addFields: {
-        numberOfComments: { $size: "$comments" },
-        numberOfReactions: { $size: "$reactions" },
-        isReacted: {
-          $in: [
-            new db.mongoose.Types.ObjectId(req.query.user),
-            "$reactions.user"
-          ]
-        },
-        reactionId: {
-          $let: {
-            vars: {
-              reactionIndex: {
-                $indexOfArray: [
-                  "$reactions.user",
-                  new db.mongoose.Types.ObjectId(req.query.user)
-                ]
-              }
-            },
-            in: {
-              $cond: [
-                { $gte: ["$$reactionIndex", 0] },
-                { $arrayElemAt: ["$reactions._id", "$$reactionIndex"] },
-                null
-              ]
-            }
-          }
-        }
-      }
-    });
-    query.push(
-      {
-        $lookup: {
-          from: "users",
-          localField: "creator.target",
-          foreignField: "_id",
-          as: "creatorUser"
-        }
-      },
-      {
-        $lookup: {
-          from: "organizations",
-          localField: "creator.target",
-          foreignField: "_id",
-          as: "creatorOrganization"
-        }
-      },
-      // Для owner
-      {
-        $lookup: {
-          from: "users",
-          localField: "owner.target",
-          foreignField: "_id",
-          as: "ownerUser"
-        }
-      },
-      {
-        $lookup: {
-          from: "organizations",
-          localField: "owner.target",
-          foreignField: "_id",
-          as: "ownerOrganization"
-        }
-      },
-      {
-        $addFields: {
-          "creator.target": {
-            $cond: [
-              { $eq: ["$creator.type", "user"] },
-              { $arrayElemAt: ["$creatorUser", 0] },
-              { $arrayElemAt: ["$creatorOrganization", 0] }
-            ]
-          },
-          "owner.target": {
-            $cond: [
-              { $eq: ["$owner.type", "user"] },
-              { $arrayElemAt: ["$ownerUser", 0] },
-              { $arrayElemAt: ["$ownerOrganization", 0] }
-            ]
-          }
-        }
-      }
-    );
-    query.push({
-      $project: {
-        comments: 0,
-        reactions: 0
-      }
-    });
-    query.push({ $skip: options.skip });
-    query.push({ $limit: options.limit });
+  },
+  getFollowingStage: async (Membership, following) => {
+    return await AggregationProcessor.generateMatchStage(Membership, following, "subscriber", "$in");
+  }
+};
+var queryProcessor$1 = AggregationProcessor;
+const queryProcessor = queryProcessor$2;
+const queryProcessorReactions = queryProcessorReactions$1;
+const queryProcessorOrganizations = queryProcessor$1;
+const queryProcessorGlobals = metadata_schema.queryProcessor;
+const controllerFactory$3 = (db) => {
+  const Blogpost = db.blogpost;
+  db.organization;
+  const Membership = db.membership;
+  const read = async (req, res) => {
+    let stages = [];
+    stages = [
+      ...queryProcessorGlobals.getBasicOptions(
+        req.query
+      ),
+      ...queryProcessorGlobals.getTagsOptions(
+        req.query.tags
+      ),
+      ...queryProcessor.getPeriodConditions(
+        req.query.period
+      ),
+      ...await queryProcessor.getCategoryConditions(
+        req.query.category
+      ),
+      // Following
+      ...await queryProcessorOrganizations.getFollowingStage(
+        Membership,
+        req.query.following
+      ),
+      // Blocking
+      ...await queryProcessorOrganizations.getBlockedStage(
+        Membership,
+        req.query.user
+      ),
+      queryProcessorReactions.getCommentsLookupStage(),
+      queryProcessorReactions.getReactionsLookupStage(),
+      queryProcessorReactions.getReactionsCommentsFields(
+        req.query.user
+      ),
+      // Sorting and Pagination
+      ...queryProcessorGlobals.getSortingOptions(
+        req.query.sortParam,
+        req.query.sortOrder
+      ),
+      ...queryProcessorGlobals.getPaginationOptions(
+        req.query.skip,
+        req.query.limit
+      ),
+      // For creator
+      queryProcessorGlobals.getCreatorUserLookupStage(),
+      queryProcessorGlobals.getCreatorOrganizationLookupStage(),
+      // For owner
+      queryProcessorGlobals.getOwnerUserLookupStage(),
+      queryProcessorGlobals.getOwnerOrganizationLookupStage(),
+      queryProcessorGlobals.getAddFieldsCreatorOwnerStage()
+    ];
     try {
-      const posts = await Blogpost.aggregate(query).exec();
+      console.log(stages);
+      const posts = await Blogpost.aggregate(stages).exec();
       if (posts.length === 0) {
         return res.status(200).send([]);
       }
-      console.log(posts);
       res.status(200).send(posts);
     } catch (err) {
       console.log(err);
@@ -601,7 +629,7 @@ var blogpost_model = (db) => {
     strict: false
   });
   applyCommonSchema(BlogpostSchema);
-  applyEngagementSchema(BlogpostSchema, db);
+  applyEngagementSchema(BlogpostSchema);
   applyOwnershipSchema(BlogpostSchema, db);
   applyMetadataSchema(BlogpostSchema);
   const Blogpost = db.mongoose.model("Blogpost", BlogpostSchema);