@drodil/backstage-plugin-qeta-backend 3.47.2 → 3.48.0

package/dist/database/DatabaseQetaStore.cjs.js

@@ -1,84 +1,33 @@
 'use strict';
 
 var backendPluginApi = require('@backstage/backend-plugin-api');
-var backstagePluginQetaCommon = require('@drodil/backstage-plugin-qeta-common');
-var pluginPermissionNode = require('@backstage/plugin-permission-node');
-var lodash = require('lodash');
-var tagDb = require('../tagDb.cjs.js');
+var PostsStore = require('./stores/PostsStore.cjs.js');
+var AnswersStore = require('./stores/AnswersStore.cjs.js');
+var CommentsStore = require('./stores/CommentsStore.cjs.js');
+var CollectionsStore = require('./stores/CollectionsStore.cjs.js');
+var StatsStore = require('./stores/StatsStore.cjs.js');
+var TagsStore = require('./stores/TagsStore.cjs.js');
+var UsersStore = require('./stores/UsersStore.cjs.js');
+var EntitiesStore = require('./stores/EntitiesStore.cjs.js');
+var TemplatesStore = require('./stores/TemplatesStore.cjs.js');
+var AttachmentsStore = require('./stores/AttachmentsStore.cjs.js');
 
 const migrationsDir = backendPluginApi.resolvePackagePath(
   "@drodil/backstage-plugin-qeta-backend",
   "migrations"
 );
-function isQetaFilter(filter) {
-  return filter.hasOwnProperty("property");
-}
-function parseFilter(filter, query, db, type = "post", negate = false) {
-  if (pluginPermissionNode.isNotCriteria(filter)) {
-    return parseFilter(filter.not, query, db, type, !negate);
-  }
-  if (isQetaFilter(filter)) {
-    const values = lodash.compact(filter.values) ?? [];
-    let fk = "posts.id";
-    if (type === "answer") {
-      fk = "answers.postId";
-    } else if (type === "collection") {
-      fk = "collection_posts.postId";
-    }
-    if (filter.property === "tags") {
-      const postIds = db("tags").leftJoin("post_tags", "tags.id", "post_tags.tagId").where("tags.tag", "in", values).select("post_tags.postId");
-      query.whereIn(fk, postIds);
-      return query;
-    }
-    if (filter.property === "tag.experts") {
-      if (type === "post") {
-        const postIds = db("tags").leftJoin("post_tags", "tags.id", "post_tags.tagId").leftJoin("tag_experts", "tag_experts.tagId", "tags.id").where("tag_experts.entityRef", "in", values).select("post_tags.postId");
-        query.whereIn(fk, postIds);
-        return query;
-      } else if (type === "answer") {
-        const answerIds = db("answers").leftJoin("posts", "answers.postId", "posts.id").leftJoin("post_tags", "post_tags.postId", "posts.id").leftJoin("post_tags", "tags.id", "post_tags.tagId").leftJoin("tag_experts", "tag_experts.tagId", "tags.id").where("tag_experts.entityRef", "in", values).select("answers.id");
-        query.whereIn(fk, answerIds);
-        return query;
-      } else if (type === "tags") {
-        const tagIds = db("tag_experts").leftJoin("tags", "tag_experts.tagId", "tags.id").where("tag_experts.entityRef", "in", values).select("tag_experts.tagId");
-        query.whereIn(fk, tagIds);
-        return query;
-      } else if (type === "collection") {
-        const collectionIds = db("collection_posts").leftJoin("posts", "collection_posts.postId", "posts.id").leftJoin("post_tags", "post_tags.postId", "posts.id").leftJoin("post_tags", "tags.id", "post_tags.tagId").leftJoin("tag_experts", "tag_experts.tagId", "tags.id").where("tag_experts.entityRef", "in", values).select("collection_posts.collectionId");
-        query.whereIn(fk, collectionIds);
-        return query;
-      }
-    }
-    if (filter.property === "entityRefs") {
-      const postIds = db("entities").leftJoin("post_entities", "entities.id", "post_entities.entityId").where("entities.entity_ref", "in", values).select("post_entities.postId");
-      query.whereIn(fk, postIds);
-      return query;
-    }
-    if (values.length === 0) {
-      return query.whereNull(filter.property);
-    }
-    return query.whereIn(filter.property, values);
-  }
-  return query[negate ? "andWhereNot" : "andWhere"](function filterFunction() {
-    if (pluginPermissionNode.isOrCriteria(filter)) {
-      for (const subFilter of filter.anyOf ?? []) {
-        this.orWhere(
-          (subQuery) => parseFilter(subFilter, subQuery, db, type, false)
-        );
-      }
-    } else if (pluginPermissionNode.isAndCriteria(filter)) {
-      for (const subFilter of filter.allOf ?? []) {
-        this.andWhere(
-          (subQuery) => parseFilter(subFilter, subQuery, db, type, false)
-        );
-      }
-    }
-  });
-}
 class DatabaseQetaStore {
-  constructor(db, tagDatabase) {
-    this.db = db;
-    this.tagDatabase = tagDatabase;
+  constructor(postsStore, answersStore, commentsStore, collectionsStore, statsStore, tagsStore, usersStore, entitiesStore, templatesStore, attachmentsStore) {
+    this.postsStore = postsStore;
+    this.answersStore = answersStore;
+    this.commentsStore = commentsStore;
+    this.collectionsStore = collectionsStore;
+    this.statsStore = statsStore;
+    this.tagsStore = tagsStore;
+    this.usersStore = usersStore;
+    this.entitiesStore = entitiesStore;
+    this.templatesStore = templatesStore;
+    this.attachmentsStore = attachmentsStore;
   }
   static async create({
     database,
@@ -88,1946 +37,418 @@ class DatabaseQetaStore {
     const client = await database.getClient();
     if (!database.migrations?.skip && !skipMigrations) {
       await client.migrate.latest({
-        // nosonar
         directory: migrationsDir
       });
     }
-    return new DatabaseQetaStore(client, tagDatabase);
+    const commentsStore = new CommentsStore.CommentsStore(client);
+    const tagsStore = new TagsStore.TagsStore(client, tagDatabase);
+    const entitiesStore = new EntitiesStore.EntitiesStore(client);
+    const usersStore = new UsersStore.UsersStore(client);
+    const templatesStore = new TemplatesStore.TemplatesStore(client, tagsStore, entitiesStore);
+    const attachmentsStore = new AttachmentsStore.AttachmentsStore(client);
+    const postsStore = new PostsStore.PostsStore(
+      client,
+      commentsStore,
+      tagsStore,
+      entitiesStore,
+      attachmentsStore,
+      tagDatabase
+    );
+    const answersStore = new AnswersStore.AnswersStore(
+      client,
+      commentsStore,
+      postsStore,
+      attachmentsStore
+    );
+    const collectionsStore = new CollectionsStore.CollectionsStore(
+      client,
+      postsStore,
+      attachmentsStore
+    );
+    const statsStore = new StatsStore.StatsStore(client);
+    postsStore.setAnswersStore(answersStore);
+    return new DatabaseQetaStore(
+      postsStore,
+      answersStore,
+      commentsStore,
+      collectionsStore,
+      statsStore,
+      tagsStore,
+      usersStore,
+      entitiesStore,
+      templatesStore,
+      attachmentsStore
+    );
   }
   async getPosts(user_ref, options, filters, opts) {
-    const { includeTotal = true, includeDraftFilter = true } = opts ?? {};
-    const query = this.getPostsBaseQuery(user_ref);
-    if (options.type) {
-      query.where("posts.type", options.type);
-    }
-    if (options.fromDate && options.toDate) {
-      query.whereBetween("posts.created", [
-        `${options.fromDate} 00:00:00.000+00`,
-        `${options.toDate} 23:59:59.999+00`
-      ]);
-    } else if (options.fromDate) {
-      query.where("posts.created", ">=", `${options.fromDate} 00:00:00.000+00`);
-    } else if (options.toDate) {
-      query.where("posts.created", "<=", `${options.toDate} 23:59:59.999+00`);
-    }
-    if (options.author) {
-      if (Array.isArray(options.author)) {
-        query.whereIn("posts.author", options.author);
-      } else {
-        query.where("posts.author", "=", options.author);
-      }
-    }
-    if (options.excludeAuthors) {
-      query.whereNotIn("posts.author", options.excludeAuthors);
-    }
-    if (options.status) {
-      if (options.status === "draft") {
-        query.where("posts.author", "=", user_ref);
-      }
-      query.where("posts.status", "=", options.status);
-    } else if (includeDraftFilter) {
-      query.where((q) => {
-        q.where("posts.status", "active").orWhere((q2) => {
-          q2.where("posts.status", "draft").where(
-            "posts.author",
-            "=",
-            user_ref
-          );
-        });
-      });
-    }
-    if (filters) {
-      parseFilter(filters, query, this.db);
-    }
-    if (options.searchQuery) {
-      this.applySearchQuery(
-        query,
-        ["posts.title", "posts.content"],
-        options.searchQuery
-      );
-    }
-    if (options.tags) {
-      const tags = backstagePluginQetaCommon.filterTags(options.tags);
-      if (options.tagsRelation === "or") {
-        query.innerJoin("post_tags", "posts.id", "post_tags.postId");
-        query.innerJoin("tags", "post_tags.tagId", "tags.id");
-        query.whereIn("tags.tag", tags);
-      } else {
-        tags.forEach((t, i) => {
-          query.innerJoin(`post_tags AS qt${i}`, "posts.id", `qt${i}.postId`);
-          query.innerJoin(`tags AS t${i}`, `qt${i}.tagId`, `t${i}.id`);
-          query.where(`t${i}.tag`, "=", t);
-        });
-      }
-    }
-    if (options.entities) {
-      const entityValues = Array.isArray(options.entities) ? options.entities : [options.entities];
-      if (options.entitiesRelation === "or") {
-        query.innerJoin("post_entities", "posts.id", "post_entities.postId").innerJoin("entities", "post_entities.entityId", "entities.id").whereIn("entities.entity_ref", entityValues);
-      } else {
-        entityValues.forEach((t, i) => {
-          query.innerJoin(
-            `post_entities AS pe${i}`,
-            "posts.id",
-            `pe${i}.postId`
-          );
-          query.innerJoin(`entities AS e${i}`, `pe${i}.entityId`, `e${i}.id`);
-          query.where(`e${i}.entity_ref`, "=", t);
-        });
-      }
-    }
-    if (options.collectionId) {
-      query.innerJoin(
-        "collection_posts",
-        "posts.id",
-        "collection_posts.postId"
-      );
-      query.where("collection_posts.collectionId", options.collectionId);
-    } else if (options.orderBy === "rank") {
-      query.innerJoin(
-        "collection_posts",
-        "posts.id",
-        "collection_posts.postId"
-      );
-    }
-    if (options.orderBy === "rank") {
-      query.groupBy("rank");
-    }
-    if (options.noAnswers) {
-      query.whereNull("answers.postId");
-    }
-    if (options.hasAnswers) {
-      query.whereNotNull("answers.postId");
-    }
-    if (options.noCorrectAnswer) {
-      query.leftJoin("answers as correct_answer", (builder) => {
-        builder.on("posts.id", "correct_answer.postId").on("correct_answer.correct", this.db.raw("?", [true]));
-      });
-      query.whereNull("correct_answer.postId");
-    }
-    if (options.noVotes) {
-      query.whereNull("post_votes.postId");
-    }
-    if (options.favorite) {
-      query.where("user_favorite.user", "=", user_ref);
-      query.whereNotNull("user_favorite.postId");
-    }
-    if (options.includeTrend || options.orderBy === "trend") {
-      query.select(
-        this.db.raw(
-          `(
-            (SELECT COALESCE(SUM(score), 0) FROM post_votes WHERE "postId" = posts.id) * 200 + 
-            (SELECT COALESCE(COUNT(*), 0) FROM answers WHERE "postId" = posts.id) * 100 +
-            (SELECT COALESCE(COUNT(*), 0) FROM user_favorite WHERE "postId" = posts.id) * 50 +
-            (SELECT COALESCE(COUNT(*), 0) FROM post_views WHERE "postId" = posts.id) * 10 +
-            (SELECT COALESCE(COUNT(*), 0) FROM comments WHERE "postId" = posts.id) * 30
-          ) / 
-          POWER(
-            EXTRACT(EPOCH FROM (now() - posts.created)) / 172800 + 1,
-            1.5
-          ) as trend`
-        )
-      );
-    }
-    if (options.ids) {
-      query.whereIn("posts.id", options.ids);
-    }
-    const totalQuery = query.clone();
-    if (options.random) {
-      query.orderByRaw("RANDOM()");
-    } else if (options.orderBy) {
-      query.orderBy(options.orderBy, options.order ? options.order : "desc");
-    } else {
-      query.orderBy("created", "desc");
-    }
-    if (options.limit) {
-      query.limit(options.limit);
-    }
-    if (options.offset) {
-      query.offset(options.offset);
-    }
-    const results = await Promise.all([
-      query,
-      includeTotal ? this.db(totalQuery.as("totalQuery")).count("* as CNT").first() : void 0
-    ]);
-    const rows = results[0];
-    const total = this.mapToInteger(results[1]?.CNT);
-    return {
-      posts: await Promise.all(
-        rows.map(async (val) => {
-          return this.mapPostEntity(val, user_ref, {
-            ...opts,
-            includeAnswers: options.includeAnswers ?? opts?.includeAnswers,
-            includeVotes: options.includeVotes ?? opts?.includeVotes,
-            includeEntities: options.includeEntities ?? opts?.includeEntities,
-            includeAttachments: options.includeAttachments ?? opts?.includeAttachments,
-            includeExperts: options.includeExperts ?? opts?.includeExperts
-          });
-        })
-      ),
-      total
-    };
+    return this.postsStore.getPosts(user_ref, options, filters, opts);
   }
   async getPost(user_ref, id, recordView, options) {
-    const rows = await this.getPostsBaseQuery(user_ref).where(
-      "posts.id",
-      "=",
-      id
-    );
-    if (!rows || rows.length === 0) {
-      return null;
-    }
-    const post = rows[0];
-    if ((recordView === void 0 || recordView) && post.status === "active") {
-      this.recordPostView(id, user_ref);
-    }
-    return await this.mapPostEntity(post, user_ref, options);
+    return this.postsStore.getPost(user_ref, id, recordView, options);
   }
   async getPostByAnswerId(user_ref, answerId, recordView, options) {
-    const rows = await this.getPostsBaseQuery(user_ref).where("answers.id", "=", answerId).select("posts.*");
-    if (!rows || rows.length === 0) {
-      return null;
-    }
-    if (recordView === void 0 || recordView) {
-      this.recordPostView(rows[0].id, user_ref);
-    }
-    return await this.mapPostEntity(
-      rows[0],
+    return this.postsStore.getPostByAnswerId(
       user_ref,
+      answerId,
+      recordView,
       options
     );
   }
   async createPost(options) {
-    const {
+    return this.postsStore.createPost(options);
+  }
+  async updatePost(options) {
+    return this.postsStore.updatePost(options);
+  }
+  async deletePost(id, permanently) {
+    return this.postsStore.deletePost(id, permanently);
+  }
+  async votePost(user_ref, postId, score) {
+    return this.postsStore.votePost(user_ref, postId, score);
+  }
+  async deletePostVote(user_ref, postId) {
+    return this.postsStore.deletePostVote(user_ref, postId);
+  }
+  async favoritePost(user_ref, postId) {
+    return this.postsStore.favoritePost(user_ref, postId);
+  }
+  async unfavoritePost(user_ref, postId) {
+    return this.postsStore.unfavoritePost(user_ref, postId);
+  }
+  async getUsersWhoFavoritedPost(postId) {
+    return this.postsStore.getUsersWhoFavoritedPost(postId);
+  }
+  async getAnswers(user_ref, options, filters, opts) {
+    return this.answersStore.getAnswers(user_ref, options, filters, opts);
+  }
+  async getAnswer(answerId, user_ref, options) {
+    return this.answersStore.getAnswer(answerId, user_ref, options);
+  }
+  async answerPost(user_ref, questionId, answer, created, images, anonymous, options) {
+    return this.answersStore.answerPost(
       user_ref,
-      title,
-      content,
-      author,
+      questionId,
+      answer,
       created,
-      tags,
-      entities,
       images,
       anonymous,
-      type = "question",
-      headerImage,
-      url,
-      opts,
-      status = "active"
-    } = options;
-    const posts = await this.db.insert(
-      {
-        author: author ?? user_ref,
-        title,
-        content,
-        created,
-        anonymous: anonymous ?? false,
-        type: type ?? "question",
-        headerImage,
-        url,
-        status,
-        published: status === "active" ? created : null
-      },
-      ["id"]
-    ).into("posts").returning([
-      "id",
-      "author",
-      "title",
-      "content",
-      "created",
-      "anonymous",
-      "type",
-      "status",
-      "url"
-    ]);
-    await Promise.all([
-      this.addTags(posts[0].id, tags),
-      this.addEntities(posts[0].id, entities)
-    ]);
-    await this.updateAttachments(
-      "postId",
-      content ?? "",
-      images ?? [],
-      posts[0].id,
-      headerImage
+      options
     );
-    return this.mapPostEntity(posts[0], user_ref, opts);
-  }
-  async commentPost(post_id, user_ref, content, created, options) {
-    await this.db.insert({
-      author: user_ref,
-      content,
-      created,
-      postId: post_id
-    }).into("comments");
-    return await this.getPost(user_ref, post_id, false, options);
-  }
-  async updatePostComment(post_id, id, user_ref, content, options) {
-    const query = this.db("comments").where("id", "=", id).where("postId", "=", post_id);
-    await query.update({ content, updatedBy: user_ref, updated: /* @__PURE__ */ new Date() });
-    return this.getPost(user_ref, post_id, false, options);
-  }
-  async deletePostComment(post_id, id, user_ref, permanently, options) {
-    const query = this.db("comments").where("id", "=", id).where("postId", "=", post_id);
-    if (permanently) {
-      await query.delete();
-    } else {
-      await query.update({ status: "deleted" });
-    }
-    return this.getPost(user_ref, post_id, false, options);
   }
-  async commentAnswer(answer_id, user_ref, content, created, options) {
-    await this.db.insert({
-      author: user_ref,
-      content,
-      created,
-      answerId: answer_id
-    }).into("comments");
-    return this.getAnswer(answer_id, user_ref, options);
-  }
-  async updateAnswerComment(answer_id, id, user_ref, content, options) {
-    const query = this.db("comments").where("id", "=", id).where("answerId", "=", answer_id);
-    await query.update({ content, updatedBy: user_ref, updated: /* @__PURE__ */ new Date() });
-    return this.getAnswer(answer_id, user_ref, options);
-  }
-  async deleteAnswerComment(answer_id, id, user_ref, permanently, options) {
-    const query = this.db("comments").where("id", "=", id).where("answerId", "=", answer_id);
-    if (permanently) {
-      await query.delete();
-    } else {
-      await query.update({ status: "deleted" });
-    }
-    return this.getAnswer(answer_id, user_ref, options);
-  }
-  async updatePost(options) {
-    const {
-      id,
+  async updateAnswer(user_ref, questionId, answerId, answer, author, images, options) {
+    return this.answersStore.updateAnswer(
       user_ref,
-      title,
-      content,
+      questionId,
+      answerId,
+      answer,
       author,
-      tags,
-      entities,
       images,
-      headerImage,
-      url,
-      setUpdatedBy = true,
-      opts,
-      status = "active"
-    } = options;
-    const currentPost = await this.db("posts").select("status", "published").where("id", "=", id).first();
-    const shouldSetPublished = currentPost && currentPost.status === "draft" && status === "active" && !currentPost.published;
-    const query = this.db("posts").where("posts.id", "=", id);
-    const rows = await query.update({
-      title,
+      options
+    );
+  }
+  async deleteAnswer(id) {
+    return this.answersStore.deleteAnswer(id);
+  }
+  async voteAnswer(user_ref, answerId, score) {
+    return this.answersStore.voteAnswer(user_ref, answerId, score);
+  }
+  async deleteAnswerVote(user_ref, answerId) {
+    return this.answersStore.deleteAnswerVote(user_ref, answerId);
+  }
+  async markAnswerCorrect(postId, answerId) {
+    return this.answersStore.markAnswerCorrect(postId, answerId);
+  }
+  async markAnswerIncorrect(postId, answerId) {
+    return this.answersStore.markAnswerIncorrect(postId, answerId);
+  }
+  async clickPost(user_ref, postId) {
+    const vote = await this.postsStore.getPostVote(user_ref, postId);
+    const score = (vote?.score || 0) + 1;
+    await this.postsStore.votePost(user_ref, postId, score);
+  }
+  async commentPost(post_id, user_ref, content, created) {
+    await this.commentsStore.commentPost(post_id, user_ref, content, created);
+    return this.getPost(user_ref, post_id);
+  }
+  async commentAnswer(answer_id, user_ref, content, created) {
+    await this.commentsStore.commentAnswer(
+      answer_id,
+      user_ref,
       content,
-      headerImage,
-      author,
-      url,
-      updatedBy: setUpdatedBy ? user_ref : void 0,
-      updated: setUpdatedBy ? /* @__PURE__ */ new Date() : void 0,
-      status,
-      published: shouldSetPublished ? /* @__PURE__ */ new Date() : void 0
-    });
-    if (!rows) {
-      return null;
-    }
-    await Promise.all([
-      this.addTags(id, tags, true),
-      this.addEntities(id, entities, true)
-    ]);
-    await this.updateAttachments(
-      "postId",
-      content ?? "",
-      images ?? [],
-      id,
-      headerImage
+      created
     );
-    return await this.getPost(user_ref, id, false, opts);
+    return this.getAnswer(answer_id, user_ref);
   }
-  async deletePost(id, permanently) {
-    if (permanently) {
-      const rows2 = await this.db("posts").where("id", "=", id).delete();
-      return rows2 > 0;
-    }
-    const rows = await this.db("posts").where("id", "=", id).update({
-      status: "deleted"
-    });
-    return rows > 0;
+  async updatePostComment(post_id, id, user_ref, content) {
+    await this.commentsStore.updatePostComment(post_id, id, user_ref, content);
+    return this.getPost(user_ref, post_id);
   }
-  async answerPost(user_ref, postId, answer, created, images, anonymous, options) {
-    const answers = await this.db.insert({
-      postId,
-      author: user_ref,
-      content: answer,
-      correct: false,
-      created,
-      anonymous: anonymous ?? false
-    }).into("answers").returning("id");
-    await this.updateAttachments(
-      "answerId",
-      answer,
-      images ?? [],
-      answers[0].id
+  async updateAnswerComment(answer_id, id, user_ref, content) {
+    await this.commentsStore.updateAnswerComment(
+      answer_id,
+      id,
+      user_ref,
+      content
     );
-    return this.getAnswer(answers[0].id, user_ref, options);
+    return this.getAnswer(answer_id, user_ref);
   }
-  async updateAnswer(user_ref, postId, answerId, answer, author, images, options) {
-    const query = this.db("answers").where("answers.id", "=", answerId).where("answers.postId", "=", postId);
-    const rows = await query.update({
-      content: answer,
-      author,
-      updatedBy: user_ref,
-      updated: /* @__PURE__ */ new Date()
-    });
-    if (!rows) {
-      return null;
-    }
-    await this.updateAttachments("answerId", answer, images ?? [], answerId);
-    return this.getAnswer(answerId, user_ref, options);
+  async deletePostComment(post_id, id, user_ref) {
+    await this.commentsStore.deletePostComment(post_id, id);
+    return this.getPost(user_ref, post_id);
   }
-  async getAnswers(user_ref, options, filters, opts) {
-    const { includeStatusFilter = true } = opts ?? {};
-    const query = this.getAnswerBaseQuery();
-    if (includeStatusFilter) {
-      query.where("answers.status", "=", "active");
-    }
-    if (options.fromDate && options.toDate) {
-      query.whereBetween("answers.created", [
-        `${options.fromDate} 00:00:00.000+00`,
-        `${options.toDate} 23:59:59.999+00`
-      ]);
-    }
-    if (options.author) {
-      query.where("answers.author", "=", options.author);
-    }
-    if (filters) {
-      parseFilter(filters, query, this.db, "answer");
-    }
-    if (options.tags) {
-      const tags = backstagePluginQetaCommon.filterTags(options.tags);
-      if (options.tagsRelation === "or") {
-        query.innerJoin("post_tags", "answers.postId", "post_tags.postId");
-        query.innerJoin("tags", "post_tags.tagId", "tags.id");
-        query.whereIn("tags.tag", tags);
-      } else {
-        tags.forEach((t, i) => {
-          query.innerJoin(
-            `post_tags AS at${i}`,
-            "answers.postId",
-            `at${i}.postId`
-          );
-          query.innerJoin(`tags AS t${i}`, `at${i}.tagId`, `t${i}.id`);
-          query.where(`t${i}.tag`, "=", t);
-        });
-      }
-    }
-    if (options.entities) {
-      if (options.entitiesRelation === "or") {
-        query.innerJoin(
-          "post_entities",
-          "answers.postId",
-          "post_entities.postId"
-        );
-        query.innerJoin("entities", "post_entities.entityId", "entities.id");
-        query.whereIn("entities.entity_ref", options.entities);
-      } else {
-        options.entities.forEach((t, i) => {
-          query.innerJoin(
-            `post_entities AS pe${i}`,
-            "answers.postId",
-            `pe${i}.postId`
-          );
-          query.innerJoin(`entities AS e${i}`, `pe${i}.entityId`, `e${i}.id`);
-          query.where(`e${i}.entity_ref`, "=", t);
-        });
-      }
-    }
-    if (options.noCorrectAnswer) {
-      query.where("correct", "=", false);
-    }
-    if (options.noVotes) {
-      query.whereNull("answer_votes.answerId");
-    }
-    if (options.searchQuery) {
-      this.applySearchQuery(query, ["answers.content"], options.searchQuery);
-    }
-    const totalQuery = query.clone();
-    if (options.orderBy) {
-      query.orderBy(options.orderBy, options.order ? options.order : "desc");
-    } else {
-      query.orderBy("created", "desc");
-    }
-    if (options.limit) {
-      query.limit(options.limit);
-    }
-    if (options.offset) {
-      query.offset(options.offset);
-    }
-    if (options.ids) {
-      query.whereIn("answers.id", options.ids);
-    }
-    const results = await Promise.all([
-      query,
-      this.db(totalQuery.as("totalQuery")).count("* as CNT").first()
-    ]);
-    const rows = results[0];
-    const total = this.mapToInteger(results[1]?.CNT);
-    return {
-      answers: await Promise.all(
-        rows.map(async (val) => {
-          return this.mapAnswer(val, user_ref, opts);
-        })
-      ),
-      total
-    };
+  async deleteAnswerComment(answer_id, id, user_ref) {
+    await this.commentsStore.deleteAnswerComment(answer_id, id);
+    return this.getAnswer(answer_id, user_ref);
   }
-  async getAnswer(answerId, user_ref, options) {
-    const { includeStatusFilter = true } = options ?? {};
-    const query = this.getAnswerBaseQuery().where("id", "=", answerId);
-    if (includeStatusFilter) {
-      query.where("answers.status", "=", "active");
-    }
-    const answers = await query.select();
-    return this.mapAnswer(answers[0], user_ref, options);
+  async getCollections(user_ref, options, opts) {
+    return this.collectionsStore.getCollections(user_ref, options, opts);
   }
-  async getComments(options, opts) {
-    const { includeStatusFilter = true } = opts ?? {};
-    const query = this.db("comments");
-    if (options?.ids) {
-      query.whereIn("id", options.ids);
-    }
-    if (includeStatusFilter) {
-      query.where("status", "=", "active");
-    }
-    const comments = await query.select();
-    return await Promise.all(comments.map(this.mapComment));
+  async getCollection(user_ref, id, options) {
+    return this.collectionsStore.getCollection(user_ref, id, options);
   }
-  async getComment(commentId, opts) {
-    const { includeStatusFilter = true } = opts ?? {};
-    const query = this.db("comments").where("comments.id", "=", commentId);
-    if (includeStatusFilter) {
-      query.where("status", "=", "active");
-    }
-    if (opts?.postId) {
-      query.andWhere("comments.postId", "=", opts.postId);
-    }
-    if (opts?.answerId) {
-      query.andWhere("comments.answerId", "=", opts.answerId);
-    }
-    const comments = await query.select();
-    if (comments.length === 0) {
-      return null;
-    }
-    return await this.mapComment(comments[0]);
+  async createCollection(options) {
+    return this.collectionsStore.createCollection(
+      options
+    );
   }
-  async deleteAnswer(id, permanently) {
-    const query = this.db("answers").where("id", "=", id);
-    if (permanently) {
-      return !!await query.delete();
-    }
-    const rows = await query.update({ status: "deleted" });
-    return rows > 0;
+  async updateCollection(options) {
+    return this.collectionsStore.updateCollection(options);
   }
-  async clickPost(user_ref, postId) {
-    const existingRows = await this.db("post_votes").where("author", "=", user_ref).where("postId", "=", postId);
-    if (existingRows.length) {
-      await this.db("post_votes").where("author", "=", user_ref).where("postId", "=", postId).increment("score", 1);
-    } else {
-      await this.db.insert({
-        author: user_ref,
-        postId,
-        score: 1,
-        timestamp: /* @__PURE__ */ new Date()
-      }).onConflict().ignore().into("post_votes");
-    }
+  async deleteCollection(id) {
+    return this.collectionsStore.deleteCollection(id);
   }
-  async deletePostVote(user_ref, postId) {
-    return !!await this.db("post_votes").where("author", "=", user_ref).where("postId", "=", postId).delete();
+  async addPostToCollection(user_ref, id, postId, options) {
+    return this.collectionsStore.addPostToCollection(
+      user_ref,
+      id,
+      postId,
+      options
+    );
   }
-  async votePost(user_ref, postId, score) {
-    await this.db("post_votes").where("author", "=", user_ref).where("postId", "=", postId).delete();
-    const id = await this.db.insert(
-      {
-        author: user_ref,
-        postId,
-        score,
-        timestamp: /* @__PURE__ */ new Date()
-      },
-      ["postId"]
-    ).onConflict().ignore().into("post_votes");
-    return id && id.length > 0;
+  async removePostFromCollection(user_ref, id, postId, options) {
+    return this.collectionsStore.removePostFromCollection(
+      user_ref,
+      id,
+      postId,
+      options
+    );
   }
-  async favoritePost(user_ref, postId) {
-    const id = await this.db.insert(
-      {
-        user: user_ref,
-        postId
-      },
-      ["postId"]
-    ).onConflict().ignore().into("user_favorite");
-    return id && id.length > 0;
+  async getUsersForCollection(collectionId) {
+    return this.collectionsStore.getUsersForCollection(collectionId);
   }
-  async unfavoritePost(user_ref, postId) {
-    return !!await this.db("user_favorite").where("user", "=", user_ref).where("postId", "=", postId).delete();
+  async followCollection(user_ref, collectionId) {
+    return this.collectionsStore.followCollection(user_ref, collectionId);
   }
-  async getUsersWhoFavoritedPost(postId) {
-    const query = this.db("user_favorite").where("postId", "=", postId);
-    const users = await query.select("user");
-    return users.map((u) => u.user);
+  async unfollowCollection(user_ref, collectionId) {
+    return this.collectionsStore.unfollowCollection(user_ref, collectionId);
   }
-  async deleteAnswerVote(user_ref, answerId) {
-    return !!await this.db("answer_votes").where("author", "=", user_ref).where("answerId", "=", answerId).delete();
+  async getUserCollections(user_ref, options) {
+    return this.collectionsStore.getUserCollections(user_ref, options);
   }
-  async voteAnswer(user_ref, answerId, score) {
-    await this.db("answer_votes").where("author", "=", user_ref).where("answerId", "=", answerId).delete();
-    const id = await this.db.insert(
-      {
-        author: user_ref,
-        answerId,
-        score,
-        timestamp: /* @__PURE__ */ new Date()
-      },
-      ["answerId"]
-    ).onConflict().ignore().into("answer_votes");
-    return id && id.length > 0;
+  async getPostRank(collectionId, postId) {
+    return this.collectionsStore.getPostRank(collectionId, postId);
   }
-  async markAnswerCorrect(postId, answerId) {
-    return await this.markAnswer(postId, answerId, true);
+  async getTopRankedPostId(collectionId) {
+    return this.collectionsStore.getTopRankedPostId(collectionId);
   }
-  async markAnswerIncorrect(postId, answerId) {
-    return await this.markAnswer(postId, answerId, false);
+  async getBottomRankedPostId(collectionId) {
+    return this.collectionsStore.getBottomRankedPostId(collectionId);
   }
-  async getTags(options, filters) {
-    const { includeExperts = true } = options ?? {};
-    const query = this.getTagBaseQuery();
-    if (options?.noDescription) {
-      query.whereNull("tags.description");
-    }
-    if (options?.searchQuery) {
-      this.applySearchQuery(
-        query,
-        ["tags.tag", "tags.description"],
-        options.searchQuery
-      );
-    }
-    if (options?.ids) {
-      query.whereIn("tags.id", options.ids);
-    }
-    if (filters) {
-      parseFilter(filters, query, this.db);
-    }
-    const totalQuery = query.clone();
-    if (options?.orderBy) {
-      query.orderBy(options?.orderBy, options?.order || "desc");
-    }
-    if (options?.limit) {
-      query.limit(options.limit);
-    }
-    if (options?.offset) {
-      query.offset(options.offset);
-    }
-    const results = await Promise.all([
-      query,
-      this.db(totalQuery.as("totalQuery")).count("* as CNT").first()
-    ]);
-    const rows = results[0];
-    const total = this.mapToInteger(results[1]?.CNT);
-    return {
-      total,
-      tags: await Promise.all(
-        rows.map(async (tag) => {
-          return {
-            id: tag.id,
-            tag: tag.tag,
-            description: tag.description,
-            postsCount: this.mapToInteger(tag.postsCount),
-            followerCount: this.mapToInteger(tag.followerCount),
-            experts: includeExperts ? await this.getTagExpertsById(tag.id) : void 0
-          };
-        })
-      )
-    };
+  async getNextRankedPostId(collectionId, postId) {
+    return this.collectionsStore.getNextRankedPostId(collectionId, postId);
   }
-  async getTagById(id) {
-    const query = this.getTagBaseQuery();
-    const tags = await query.where("tags.id", "=", id);
-    if (tags.length === 0) {
-      return null;
-    }
-    return {
-      id: tags[0].id,
-      tag: tags[0].tag,
-      description: tags[0].description,
-      postsCount: this.mapToInteger(tags[0].postsCount),
-      followerCount: this.mapToInteger(tags[0].followerCount),
-      experts: await this.getTagExpertsById(tags[0].id)
-    };
+  async getPreviousRankedPostId(collectionId, postId) {
+    return this.collectionsStore.getPreviousRankedPostId(collectionId, postId);
   }
-  async getTag(tag) {
-    const query = this.getTagBaseQuery();
-    const tags = await query.where("tags.tag", "=", tag);
-    if (tags.length === 0) {
-      return null;
-    }
-    return {
-      id: tags[0].id,
-      tag: tags[0].tag,
-      description: tags[0].description,
-      postsCount: this.mapToInteger(tags[0].postsCount),
-      followerCount: this.mapToInteger(tags[0].followerCount),
-      experts: await this.getTagExpertsById(tags[0].id)
-    };
+  async updatePostRank(collectionId, postId, rank) {
+    return this.collectionsStore.updatePostRank(collectionId, postId, rank);
   }
-  async deleteTag(id) {
-    const query = this.db("tags").where("id", "=", id);
-    return !!await query.delete();
+  async getTags(options, filters) {
+    return this.tagsStore.getTags(options, filters);
   }
   async getTagExperts(tags) {
-    if (tags.length === 0) {
-      return [];
-    }
-    const query = this.db("tag_experts").leftJoin("tags", "tag_experts.tagId", "tags.id").whereIn("tags.tag", tags);
-    const resp = await query.select("entityRef");
-    return [...new Set(resp.map((r) => r.entityRef))];
+    return this.tagsStore.getTagExperts(tags);
+  }
+  async getTag(tag) {
+    return this.tagsStore.getTag(tag);
+  }
+  async getTagById(id) {
+    return this.tagsStore.getTagById(id);
   }
   async createTag(tag, description, experts) {
-    const trimmed = tag.trim();
-    const ret = await this.db.insert({ tag: trimmed, description }).into("tags").returning(["id"]).onConflict("tag").ignore();
-    if (ret && experts && experts.length > 0) {
-      await this.updateTagExperts(ret[0].id, experts);
-    }
-    return this.getTag(trimmed);
+    return this.tagsStore.createTag(tag, description, experts);
   }
   async updateTag(id, description, experts) {
-    await this.db("tags").where("tags.id", "=", id).update({ description: description ?? null });
-    if (experts && experts.length > 0) {
-      await this.updateTagExperts(id, experts);
-    }
-    return this.getTagById(id);
+    return this.tagsStore.updateTag(id, description, experts);
   }
-  async getUsersCount() {
-    const query = await this.db("unique_authors").count("author as CNT");
-    return Number(query[0].CNT);
+  async deleteTag(id) {
+    return this.tagsStore.deleteTag(id);
+  }
+  async getEntities(options) {
+    return this.entitiesStore.getEntities(options);
+  }
+  async getEntity(entity_ref) {
+    return this.entitiesStore.getEntity(entity_ref);
   }
   async getUsers(options) {
-    const query = this.getUserBaseQuery();
-    if (options?.entityRefs) {
-      query.whereIn("unique_authors.author", options.entityRefs);
-    }
-    const totalQuery = query.clone();
-    if (options?.orderBy) {
-      query.orderBy(options?.orderBy, options?.order || "desc");
-    }
-    if (options?.limit) {
-      query.limit(options.limit);
-    }
-    if (options?.offset) {
-      query.offset(options.offset);
-    }
-    const results = await Promise.all([
-      query,
-      this.db(totalQuery.as("totalQuery")).count("* as CNT").first()
-    ]);
-    const rows = results[0];
-    const total = this.mapToInteger(results[1]?.CNT);
-    return {
-      total,
-      users: rows.map((r) => ({
-        userRef: r.author,
-        totalViews: this.mapToInteger(r.totalViews),
-        totalQuestions: this.mapToInteger(r.totalQuestions),
-        totalAnswers: this.mapToInteger(r.totalAnswers),
-        totalComments: this.mapToInteger(r.postComments) + this.mapToInteger(r.answerComments),
-        totalVotes: this.mapToInteger(r.postVotes) + this.mapToInteger(r.answerVotes),
-        totalArticles: this.mapToInteger(r.totalArticles),
-        totalFollowers: this.mapToInteger(r.totalFollowers),
-        totalLinks: this.mapToInteger(r.totalLinks)
-      }))
-    };
+    return this.usersStore.getUsers(options);
   }
   async getUser(user_ref) {
-    const q = this.getUserBaseQuery();
-    const rows = await q.where("author", user_ref);
-    if (rows.length === 0) {
-      return null;
-    }
-    return {
-      userRef: rows[0].author,
-      totalViews: this.mapToInteger(rows[0].totalViews),
-      totalQuestions: this.mapToInteger(rows[0].totalQuestions),
-      totalAnswers: this.mapToInteger(rows[0].totalAnswers),
-      totalComments: this.mapToInteger(rows[0].postComments) + this.mapToInteger(rows[0].answerComments),
-      totalVotes: this.mapToInteger(rows[0].postVotes) + this.mapToInteger(rows[0].answerVotes),
-      totalArticles: this.mapToInteger(rows[0].totalArticles),
-      totalFollowers: this.mapToInteger(rows[0].totalFollowers),
-      totalLinks: this.mapToInteger(rows[0].totalLinks)
-    };
+    return this.usersStore.getUser(user_ref);
   }
-  async getUserCollections(user_ref, options) {
-    const rows = await this.db("user_collections").where("userRef", user_ref).leftJoin(
-      "collections",
-      "user_collections.collectionId",
-      "collections.id"
-    ).select("*");
-    return {
-      collections: await Promise.all(
-        rows.map(async (val) => {
-          return this.mapCollectionEntity(val, user_ref, options);
-        })
-      ),
-      count: rows.length
-    };
+  async getUserTags(user_ref, filters) {
+    return this.tagsStore.getUserTags(user_ref, filters);
   }
-  async getUsersForCollection(collectionId) {
-    const users = await this.db("user_collections").where("collectionId", collectionId).select("userRef");
-    return users.map((user) => user.userRef);
+  async followTag(user_ref, tag) {
+    return this.tagsStore.followTag(user_ref, tag);
   }
-  async followCollection(user_ref, collectionId) {
-    await this.db.insert(
-      {
-        userRef: user_ref,
-        collectionId
-      },
-      ["collectionId"]
-    ).into("user_collections");
-    return true;
+  async unfollowTag(user_ref, tag) {
+    return this.tagsStore.unfollowTag(user_ref, tag);
   }
-  async unfollowCollection(user_ref, collectionId) {
-    await this.db("user_collections").where("userRef", user_ref).where("collectionId", collectionId).delete();
-    return true;
+  async getUserEntities(user_ref) {
+    return this.entitiesStore.getUserEntities(user_ref);
   }
-  async getUserTags(user_ref, filters) {
-    const query = this.db("user_tags").where("userRef", user_ref).leftJoin("tags", "user_tags.tagId", "tags.id");
-    if (filters) {
-      parseFilter(filters, query, this.db);
-    }
-    const tags = await query.select("tags.tag");
-    return {
-      tags: tags.map((tag) => tag.tag),
-      count: tags.length
-    };
+  async followEntity(user_ref, entityRef) {
+    return this.entitiesStore.followEntity(user_ref, entityRef);
+  }
+  async unfollowEntity(user_ref, entityRef) {
+    return this.entitiesStore.unfollowEntity(user_ref, entityRef);
   }
   async getUsersForTags(tags) {
-    if (!tags || tags.length === 0) {
-      return [];
-    }
-    const followingUsersQuery = this.db("user_tags").leftJoin("tags", "user_tags.tagId", "tags.id").whereIn("tags.tag", tags).select("userRef");
-    const [followingUsers, experts] = await Promise.all([
-      followingUsersQuery,
-      this.getTagExperts(tags)
-    ]);
-    return [
-      .../* @__PURE__ */ new Set([...followingUsers.map((user) => user.userRef), ...experts])
-    ];
+    return this.tagsStore.getUsersForTags(tags);
   }
-  async followTag(user_ref, tag) {
-    const tagId = await this.db("tags").where("tag", tag).select("id").first();
-    if (!tagId) {
-      return false;
-    }
-    await this.db.insert(
-      {
-        userRef: user_ref,
-        tagId: tagId.id
-      },
-      ["tagId"]
-    ).into("user_tags");
-    return true;
+  async getUsersForEntities(entityRefs) {
+    return this.entitiesStore.getUsersForEntities(entityRefs);
   }
-  async unfollowTag(user_ref, tag) {
-    const tagId = await this.db("tags").where("tag", tag).select("id").first();
-    if (!tagId) {
-      return false;
-    }
-    await this.db("user_tags").where("userRef", user_ref).where("tagId", tagId.id).delete();
-    return true;
+  async getFollowedUsers(user_ref) {
+    return this.usersStore.getFollowedUsers(user_ref);
   }
-  async getEntities(options) {
-    const query = this.getEntitiesBaseQuery();
-    if (options?.entityRefs) {
-      query.whereIn("entities.entity_ref", options.entityRefs);
-    }
-    const totalQuery = query.clone();
-    if (options?.orderBy) {
-      query.orderBy(options?.orderBy, options?.order || "desc");
-    }
-    if (options?.limit) {
-      query.limit(options.limit);
-    }
-    if (options?.offset) {
-      query.offset(options.offset);
-    }
-    const results = await Promise.all([
-      query,
-      this.db(totalQuery.as("totalQuery")).count("* as CNT").first()
-    ]);
-    const rows = results[0];
-    const total = this.mapToInteger(results[1]?.CNT);
-    return {
-      total,
-      entities: rows.map((entity) => {
-        return {
-          id: entity.id,
-          entityRef: entity.entity_ref,
-          postsCount: this.mapToInteger(entity.postsCount),
-          followerCount: this.mapToInteger(entity.followerCount)
-        };
-      })
-    };
+  async followUser(user_ref, followedUserRef) {
+    return this.usersStore.followUser(user_ref, followedUserRef);
   }
-  async getEntity(entity_ref) {
-    const query = this.getEntitiesBaseQuery();
-    const rows = await query.where("entity_ref", "=", entity_ref);
-    if (rows.length === 0) {
-      return null;
-    }
-    return {
-      id: rows[0].id,
-      entityRef: rows[0].entity_ref,
-      postsCount: this.mapToInteger(rows[0].postsCount),
-      followerCount: this.mapToInteger(rows[0].followerCount)
-    };
+  async unfollowUser(user_ref, followedUserRef) {
+    return this.usersStore.unfollowUser(user_ref, followedUserRef);
   }
-  async getUserEntities(user_ref) {
-    const entities = await this.db("user_entities").where("userRef", user_ref).select("entityRef");
-    return {
-      entityRefs: entities.map((e) => e.entityRef),
-      count: entities.length
-    };
+  async getGlobalStats() {
+    return this.statsStore.getGlobalStats();
   }
-  async getUsersForEntities(entityRefs) {
-    if (!entityRefs || entityRefs.length === 0) {
-      return [];
-    }
-    const users = await this.db("user_entities").whereIn("entityRef", entityRefs).select("userRef");
-    return users.map((user) => user.userRef);
+  async getUserStats(user_ref) {
+    return this.statsStore.getUserStats(user_ref);
   }
-  async followEntity(user_ref, entityRef) {
-    await this.db.insert({
-      userRef: user_ref,
-      entityRef
-    }).into("user_entities");
-    return true;
+  async getTemplates() {
+    return this.templatesStore.getTemplates();
   }
-  async unfollowEntity(user_ref, entityRef) {
-    await this.db("user_entities").where("userRef", user_ref).where("entityRef", entityRef).delete();
-    return true;
+  async getTemplate(id) {
+    return this.templatesStore.getTemplate(id);
   }
-  async getFollowedUsers(user_ref) {
-    const entities = await this.db("user_users").where("userRef", user_ref).select("followedUserRef");
-    return {
-      followedUserRefs: entities.map((e) => e.followedUserRef),
-      count: entities.length
-    };
+  async createTemplate(options) {
+    return this.templatesStore.createTemplate(options);
   }
-  async getFollowingUsers(user_ref) {
-    const users = await this.db("user_users").where("followedUserRef", user_ref).select("userRef");
-    return users.map((user) => user.userRef);
+  async deleteTemplate(id) {
+    return this.templatesStore.deleteTemplate(id);
   }
-  async followUser(user_ref, followedUserRef) {
-    await this.db.insert({
-      userRef: user_ref,
-      followedUserRef
-    }).into("user_users");
-    return true;
+  async updateTemplate(options) {
+    return this.templatesStore.updateTemplate(options);
   }
-  async unfollowUser(user_ref, followedUserRef) {
-    await this.db("user_users").where("userRef", user_ref).where("followedUserRef", followedUserRef).delete();
-    return true;
+  async getAIAnswer(postId) {
+    return this.postsStore.getAIAnswer(postId);
+  }
+  async saveAIAnswer(postId, response) {
+    return this.postsStore.saveAIAnswer(postId, response);
+  }
+  async deleteAIAnswer(postId) {
+    return this.postsStore.deleteAIAnswer(postId);
+  }
+  async postAttachment({
+    uuid,
+    locationType,
+    locationUri,
+    extension,
+    mimeType,
+    binaryImage,
+    path,
+    creator
+  }) {
+    return this.attachmentsStore.postAttachment({
+      uuid,
+      locationType,
+      locationUri,
+      extension,
+      mimeType,
+      binaryImage,
+      path,
+      creator
+    });
+  }
+  async getAttachment(uuid) {
+    return this.attachmentsStore.getAttachment(uuid);
+  }
+  async deleteAttachment(uuid) {
+    return this.attachmentsStore.deleteAttachment(uuid);
   }
+  async getDeletableAttachments(dayLimit) {
+    return this.attachmentsStore.getDeletableAttachments(dayLimit);
+  }
+  // Stats
   async getMostUpvotedPosts({
     author,
     options
   }) {
-    const query = this.db("posts as q").sum("qv.score as total").select("q.author").join("post_votes as qv", "q.id", "qv.postId").groupBy("q.author").orderBy("total", "desc").where("anonymous", "!=", true);
-    if (author) {
-      query.where("q.author", "=", author);
-    }
-    if (options?.period) {
-      query.where("q.created", ">", options.period);
-    }
-    if (options?.type) {
-      query.where("q.type", "=", options.type);
-    }
-    if (options?.limit) {
-      query.limit(options.limit);
-    }
-    const rows = await query;
-    rows.map((row, index) => {
-      row.position = index + 1;
-    });
-    return rows;
+    return this.statsStore.getMostUpvotedPosts({ author, options });
   }
   async getTotalPosts({
     author,
     options
   }) {
-    const query = this.db("posts as q").count("q.id as total").select("q.author").groupBy("author").orderBy("total", "desc").where("q.anonymous", "!=", true);
-    if (author) {
-      query.where("q.author", "=", author);
-    }
-    if (options?.period) {
-      query.where("q.created", ">", options.period);
-    }
-    if (options?.type) {
-      query.where("q.type", "=", options.type);
-    }
-    if (options?.limit) {
-      query.limit(options.limit);
-    }
-    const rows = await query;
-    if (!author) {
-      rows.map((row, index) => {
-        row.position = index + 1;
-      });
-    }
-    return rows;
+    return this.statsStore.getTotalPosts({ author, options });
   }
   async getMostUpvotedAnswers({
     author,
     options
   }) {
-    const query = this.db("answers as a").sum("av.score as total").select("a.author").join("answer_votes as av", "a.id", "av.answerId").groupBy("a.author").orderBy("total", "desc").where("a.anonymous", "!=", true);
-    if (author) {
-      query.where("a.author", "=", author);
-    }
-    if (options?.period) {
-      query.where("a.created", ">", options.period);
-    }
-    if (options?.limit) {
-      query.limit(options.limit);
-    }
-    const rows = await query;
-    rows.map((row, index) => {
-      row.position = index + 1;
-    });
-    return rows;
+    return this.statsStore.getMostUpvotedAnswers({ author, options });
   }
   async getMostUpvotedCorrectAnswers({
     author,
     options
   }) {
-    const query = this.db("answers as a").sum("av.score as total").select("a.author").join("answer_votes as av", "a.id", "av.answerId").groupBy("a.author").orderBy("total", "desc").where("a.correct", "=", true).where("a.anonymous", "!=", true);
-    if (author) {
-      query.where("a.author", "=", author);
-    }
-    if (options?.period) {
-      query.where("a.created", ">", options.period);
-    }
-    if (options?.limit) {
-      query.limit(options.limit);
-    }
-    const rows = await query;
-    rows.map((row, index) => {
-      row.position = index + 1;
-    });
-    return rows;
+    return this.statsStore.getMostUpvotedCorrectAnswers({ author, options });
   }
   async getTotalAnswers({
     author,
     options
   }) {
-    const query = this.db("answers as a").count("a.id as total").select("a.author").groupBy("author").orderBy("total", "desc").where("a.anonymous", "!=", true);
-    if (author) {
-      query.where("a.author", "=", author);
-    }
-    if (options?.period) {
-      query.where("a.created", ">", options.period);
-    }
-    if (options?.limit) {
-      query.limit(options.limit);
-    }
-    const rows = await query;
-    if (!author) {
-      rows.map((row, index) => {
-        row.position = index + 1;
-      });
-    }
-    return rows;
-  }
-  async postAttachment({
-    uuid,
-    locationType,
-    locationUri,
-    extension,
-    mimeType,
-    binaryImage,
-    path,
-    creator,
-    postId,
-    answerId,
-    collectionId
-  }) {
-    const attachments = await this.db.insert(
-      {
-        uuid,
-        locationType,
-        locationUri,
-        extension,
-        mimeType,
-        path,
-        binaryImage,
-        creator,
-        created: /* @__PURE__ */ new Date(),
-        postId,
-        answerId,
-        collectionId
-      },
-      ["id", "uuid", "locationUri", "locationType"]
-    ).into("attachments");
-    return attachments[0];
-  }
-  async deleteAttachment(uuid) {
-    const query = this.db("attachments").where("uuid", "=", uuid);
-    return !!await query.delete();
-  }
-  async getAttachment(uuid) {
-    const rawAttachment = await this.db("attachments").where("uuid", "=", uuid).first();
-    if (!rawAttachment) {
-      return void 0;
-    }
-    return this.mapAttachment(rawAttachment);
-  }
-  async getDeletableAttachments(dayLimit) {
-    const now = /* @__PURE__ */ new Date();
-    now.setDate(now.getDate() - dayLimit);
-    return this.db("attachments").whereNull("postId").whereNull("answerId").whereNull("collectionId").where(`created`, "<=", now).select();
-  }
-  async getTotalViews(user_ref, lastDays, excludeUser) {
-    const now = /* @__PURE__ */ new Date();
-    if (lastDays) {
-      now.setDate(now.getDate() - lastDays);
-    }
-    const postViewsQuery = this.db("post_views").innerJoin("posts", "post_views.postId", "posts.id").where("posts.author", user_ref);
-    if (lastDays) {
-      postViewsQuery.where("posts.created", ">", now);
-    }
-    if (excludeUser) {
-      postViewsQuery.where("post_views.author", "!=", user_ref);
-    }
-    const answerViewsQuery = this.db("post_views").innerJoin("answers", "post_views.postId", "answers.postId").innerJoin("posts", "post_views.postId", "posts.id").where("answers.author", user_ref).whereNot("posts.author", user_ref);
-    if (lastDays) {
-      answerViewsQuery.where("answers.created", ">", now);
-    }
-    if (excludeUser) {
-      answerViewsQuery.where("post_views.author", "!=", user_ref);
-    }
-    const postViews = await postViewsQuery.count("* as total");
-    const answerViews = await answerViewsQuery.count("* as total");
-    return Number(postViews[0].total) + Number(answerViews[0].total);
+    return this.statsStore.getTotalAnswers({ author, options });
   }
-  async saveUserStats(user, date) {
-    await this.db("user_stats").insert({
-      ...user,
-      date
-    }).onConflict(["userRef", "date"]).merge();
+  async getCount(table, filters) {
+    return this.statsStore.getCount(table, filters);
   }
   async saveGlobalStats(date) {
-    await this.db("global_stats").insert({
-      totalQuestions: await this.getCount("posts", { type: "question" }),
-      totalAnswers: await this.getCount("answers"),
-      totalUsers: await this.getUsersCount(),
-      totalTags: await this.getCount("tags"),
-      totalViews: await this.getCount("post_views"),
-      totalComments: await this.getCount("comments"),
-      totalVotes: await this.getCount("post_votes") + await this.getCount("answer_votes"),
-      totalArticles: await this.getCount("posts", { type: "article" }),
-      totalLinks: await this.getCount("posts", { type: "link" }),
-      date
-    }).onConflict(["date"]).merge();
+    return this.statsStore.saveGlobalStats(date);
   }
-  async getGlobalStats() {
-    return this.db("global_stats").select("*").orderBy("date", "desc");
+  async saveUserStats(user, date) {
+    return this.statsStore.saveUserStats(user, date);
   }
-  async getUserStats(user_ref) {
-    return this.db("user_stats").where("userRef", user_ref).select("*").orderBy("date", "desc");
+  async getTotalViews(user_ref, lastDays, excludeUser) {
+    return this.statsStore.getTotalViews(user_ref, lastDays, excludeUser);
   }
   async cleanStats(days, date) {
-    const now = new Date(date);
-    now.setDate(now.getDate() - days);
-    await this.db("user_stats").where("date", "<=", now).delete();
-    await this.db("global_stats").where("date", "<=", now).delete();
-  }
-  async getCount(table, filters) {
-    const query = this.db(table);
-    if (filters?.author) {
-      query.where("author", filters.author);
-    }
-    if (filters?.type) {
-      query.where("type", filters.type);
-    }
-    const result = await query.count("* as total").first();
-    return this.mapToInteger(result?.total);
-  }
-  async getCollections(user_ref, options, opts) {
-    const query = this.getCollectionsBaseQuery();
-    if (options.owner) {
-      query.where("owner", options.owner);
-    }
-    if (options.fromDate && options.toDate) {
-      query.whereBetween("collections.created", [
-        `${options.fromDate} 00:00:00.000+00`,
-        `${options.toDate} 23:59:59.999+00`
-      ]);
-    }
-    if (options.searchQuery) {
-      this.applySearchQuery(
-        query,
-        ["collections.title", "collections.description"],
-        options.searchQuery
-      );
-    }
-    if (options.tags) {
-      const tags = backstagePluginQetaCommon.filterTags(options.tags);
-      if (options.tagsRelation === "or") {
-        query.leftJoin(
-          "post_tags",
-          "collection_posts.postId",
-          "post_tags.postId"
-        );
-        query.leftJoin("tags", "post_tags.tagId", "tags.id");
-        query.where((qb) => {
-          qb.whereIn("tags.tag", tags).orWhereNull("collection_posts.postId");
-        });
-      } else {
-        tags.forEach((t, i) => {
-          query.innerJoin(
-            `post_tags AS qt${i}`,
-            "collection_posts.postId",
-            `qt${i}.postId`
-          );
-          query.innerJoin(`tags AS t${i}`, `qt${i}.tagId`, `t${i}.id`);
-          query.where(`t${i}.tag`, "=", t);
-        });
-      }
-    }
-    if (options.entities) {
-      const entityValues = Array.isArray(options.entities) ? options.entities : [options.entities];
-      if (options.entitiesRelation === "or") {
-        query.leftJoin(
-          "post_entities",
-          "collection_posts.postId",
-          "post_entities.postId"
-        );
-        query.leftJoin("entities", "post_entities.entityId", "entities.id");
-        query.where((qb) => {
-          qb.whereIn("entities.entity_ref", entityValues).orWhereNull(
-            "collection_posts.postId"
-          );
-        });
-      } else {
-        entityValues.forEach((t, i) => {
-          query.innerJoin(
-            `post_entities AS pe${i}`,
-            "collection_posts.postId",
-            `pe${i}.postId`
-          );
-          query.innerJoin(`entities AS e${i}`, `pe${i}.entityId`, `e${i}.id`);
-          query.where(`e${i}.entity_ref`, "=", t);
-        });
-      }
-    }
-    if (options.ids) {
-      query.whereIn("collections.id", options.ids);
-    }
-    if (opts?.filters) {
-      parseFilter(opts.filters, query, this.db);
-    }
-    const totalQuery = query.clone();
-    if (options.orderBy) {
-      query.orderBy(options.orderBy, options.order || "desc");
-    } else {
-      query.orderBy("created", "desc");
-    }
-    if (options.limit) {
-      query.limit(options.limit);
-    }
-    if (options.offset) {
-      query.offset(options.offset);
-    }
-    const results = await Promise.all([
-      query,
-      this.db(totalQuery.as("totalQuery")).count("* as CNT").first()
-    ]);
-    const rows = results[0];
-    const total = this.mapToInteger(results[1]?.CNT);
-    return {
-      collections: await Promise.all(
-        rows.map(async (val) => {
-          return this.mapCollectionEntity(val, user_ref, {
-            ...opts,
-            includePosts: options.includePosts ?? opts?.includePosts,
-            includeExperts: options.includeExperts ?? opts?.includeExperts
-          });
-        })
-      ),
-      total
-    };
-  }
-  async getCollection(user_ref, id, options) {
-    const collections = await this.db("collections").where("id", "=", id);
-    if (collections.length === 0) {
-      return null;
-    }
-    return this.mapCollectionEntity(collections[0], user_ref, options);
-  }
-  async createCollection(options) {
-    const { user_ref, title, description, created, images, headerImage, opts } = options;
-    const collections = await this.db.insert(
-      {
-        owner: user_ref,
-        title,
-        description,
-        created,
-        headerImage
-      },
-      ["id"]
-    ).into("collections").returning(["id", "title", "description", "created", "headerImage"]);
-    await this.updateAttachments(
-      "collectionId",
-      description ?? "",
-      images ?? [],
-      collections[0].id,
-      headerImage
-    );
-    return this.mapCollectionEntity(collections[0], user_ref, opts);
-  }
-  async updateCollection(options) {
-    const { id, user_ref, title, description, images, headerImage, opts } = options;
-    const query = this.db("collections").where("collections.id", "=", id);
-    const rows = await query.update({
-      title,
-      description,
-      headerImage
-    });
-    if (!rows) {
-      return null;
-    }
-    await this.updateAttachments(
-      "collectionId",
-      description ?? "",
-      images ?? [],
-      id,
-      headerImage
-    );
-    return await this.getCollection(user_ref, id, opts);
-  }
-  async deleteCollection(id) {
-    const query = this.db("collections").where("id", "=", id);
-    return !!await query.delete();
-  }
-  async addPostToCollection(user_ref, id, postId, options) {
-    await this.db.insert({
-      collectionId: id,
-      postId
-    }).into("collection_posts").onConflict().ignore();
-    return await this.getCollection(user_ref, id, options);
-  }
-  async removePostFromCollection(user_ref, id, postId, options) {
-    await this.db("collection_posts").where("collectionId", id).where("postId", postId).delete();
-    return await this.getCollection(user_ref, id, options);
-  }
-  async getTemplates() {
-    const templates = await this.db("templates").select("*");
-    return {
-      templates: await Promise.all(
-        templates.map((t) => this.mapTemplateEntity(t))
-      ),
-      total: templates.length
-    };
-  }
-  async createTemplate(options) {
-    const {
-      title,
-      questionTitle,
-      questionContent,
-      description,
-      tags,
-      entities
-    } = options;
-    const templates = await this.db.insert(
-      {
-        title,
-        description,
-        questionTitle,
-        questionContent
-      },
-      ["id"]
-    ).into("templates").returning([
-      "id",
-      "title",
-      "description",
-      "questionTitle",
-      "questionContent"
-    ]);
-    await Promise.all([
-      this.addTags(templates[0].id, tags, true, "template_tags", "templateId"),
-      this.addEntities(
-        templates[0].id,
-        entities,
-        true,
-        "template_entities",
-        "templateId"
-      )
-    ]);
-    return this.mapTemplateEntity(templates[0]);
-  }
-  async getTemplate(id) {
-    const templates = await this.db("templates").where("id", "=", id);
-    if (templates.length === 0) {
-      return null;
-    }
-    return this.mapTemplateEntity(templates[0]);
-  }
-  async deleteTemplate(id) {
-    const query = this.db("templates").where("id", "=", id);
-    return !!await query.delete();
-  }
-  async updateTemplate(options) {
-    const {
-      id,
-      title,
-      description,
-      questionTitle,
-      questionContent,
-      tags,
-      entities
-    } = options;
-    const query = this.db("templates").where("templates.id", "=", id);
-    const rows = await query.update({
-      title,
-      description,
-      questionTitle,
-      questionContent
-    });
-    if (!rows) {
-      return null;
-    }
-    await Promise.all([
-      this.addTags(id, tags, true, "template_tags", "templateId"),
-      this.addEntities(id, entities, true, "template_entities", "templateId")
-    ]);
-    return await this.getTemplate(id);
-  }
-  async getAIAnswer(postId) {
-    const row = await this.db("post_ai_answers").where("postId", postId).select().first();
-    if (!row) {
-      return null;
-    }
-    return {
-      answer: row.answer,
-      created: row.created
-    };
-  }
-  async saveAIAnswer(postId, response) {
-    await this.db.insert({
-      postId,
-      answer: response.answer,
-      created: /* @__PURE__ */ new Date()
-    }).into("post_ai_answers").onConflict().ignore();
+    return this.statsStore.cleanStats(days, date);
   }
-  async deleteAIAnswer(postId) {
-    return !!await this.db("post_ai_answers").where("postId", postId).delete();
-  }
-  async getPostRank(collectionId, postId) {
-    const rank = await this.db("collection_posts").where("collectionId", collectionId).where("postId", postId).select("rank").first();
-    return rank?.rank ?? null;
-  }
-  async getTopRankedPostId(collectionId) {
-    const post = await this.db("collection_posts").where("collectionId", collectionId).orderBy("rank", "desc").limit(1).select(["postId", "rank"]);
-    return post[0] ? { postId: post[0].postId, rank: post[0].rank } : null;
-  }
-  async getBottomRankedPostId(collectionId) {
-    const post = await this.db("collection_posts").where("collectionId", collectionId).orderBy("rank", "asc").limit(1).select(["postId", "rank"]);
-    return post[0] ? { postId: post[0].postId, rank: post[0].rank } : null;
-  }
-  async getNextRankedPostId(collectionId, postId) {
-    const rank = await this.getPostRank(collectionId, postId);
-    if (rank === null) {
-      return null;
-    }
-    const post = await this.db("collection_posts").where("collectionId", collectionId).where("rank", ">", rank).orderBy("rank", "asc").select(["postId", "rank"]).first();
-    return post ? { postId: post.postId, rank: post.rank } : null;
-  }
-  async getPreviousRankedPostId(collectionId, postId) {
-    const rank = await this.getPostRank(collectionId, postId);
-    if (rank === null) {
-      return null;
-    }
-    const post = await this.db("collection_posts").where("collectionId", collectionId).where("rank", "<", rank).orderBy("rank", "desc").select(["postId", "rank"]).first();
-    return post ? { postId: post.postId, rank: post.rank } : null;
+  async getUsersCount() {
+    return this.usersStore.getUsersCount();
   }
-  async updatePostRank(collectionId, postId, rank) {
-    await this.db("collection_posts").where("collectionId", collectionId).where("postId", postId).update({ rank });
+  async getFollowingUsers(user_ref) {
+    return this.usersStore.getFollowingUsers(user_ref);
   }
   async getEntityLinks() {
-    const rows = await this.db("post_entities").leftJoin("entities", "post_entities.entityId", "entities.id").leftJoin("posts", "post_entities.postId", "posts.id").whereNotNull("posts.url").where("posts.status", "active").where("posts.type", "link").whereNotNull("entities.entity_ref").select("entities.entity_ref as entityRef", "posts.title", "posts.url");
-    const entityLinksMap = /* @__PURE__ */ new Map();
-    for (const row of rows) {
-      const entityRef = row.entityRef;
-      const link = {
-        title: row.title,
-        url: row.url,
-        type: "qeta"
-      };
-      if (!entityLinksMap.has(entityRef)) {
-        entityLinksMap.set(entityRef, []);
-      }
-      entityLinksMap.get(entityRef).push(link);
-    }
-    return Array.from(entityLinksMap.entries()).map(([entityRef, links]) => ({
-      entityRef,
-      links
-    }));
-  }
-  async getTagExpertsById(id) {
-    const rows = await this.db("tag_experts").where("tagId", id).select("entityRef");
-    return rows.map((r) => r.entityRef);
-  }
-  async updateTagExperts(id, experts) {
-    await this.db("tag_experts").where("tagId", id).delete();
-    await this.db.insert(experts.map((e) => ({ tagId: id, entityRef: e }))).into("tag_experts").onConflict(["tagId", "entityRef"]).merge();
-  }
-  getEntitiesBaseQuery() {
-    const entityId = this.db.ref("entities.id");
-    const entityRef = this.db.ref("entities.entity_ref");
-    const postsCount = this.db("post_entities").where("post_entities.entityId", entityId).count("*").as("postsCount");
-    const followerCount = this.db("user_entities").where("user_entities.entityRef", entityRef).count("*").as("followerCount");
-    return this.db("entities").rightJoin("post_entities", "entities.id", "post_entities.entityId").orderBy("postsCount", "desc").select("id", "entity_ref", postsCount, followerCount).groupBy("entities.id");
-  }
-  getTagBaseQuery() {
-    const tagRef = this.db.ref("tags.id");
-    const postsCount = this.db("post_tags").where("post_tags.tagId", tagRef).count("*").as("postsCount");
-    const followerCount = this.db("user_tags").where("user_tags.tagId", tagRef).count("*").as("followerCount");
-    return this.db("tags").leftJoin("post_tags", "tags.id", "post_tags.tagId").orderBy("postsCount", "desc").select("id", "tag", "description", postsCount, followerCount).groupBy("tags.id");
-  }
-  getUserBaseQuery() {
-    if (this.db.client.config.client !== "pg") {
-      return this.db("posts").select([
-        "author",
-        this.db.raw("0 as totalViews"),
-        this.db.raw("0 as totalQuestions"),
-        this.db.raw("0 as totalArticles"),
-        this.db.raw("0 as totalLinks"),
-        this.db.raw("0 as totalAnswers"),
-        this.db.raw("0 as answerComments"),
-        this.db.raw("0 as postComments"),
-        this.db.raw("0 as answerVotes"),
-        this.db.raw("0 as postVotes"),
-        this.db.raw("0 as totalFollowers")
-      ]).distinct();
-    }
-    const authorRef = this.db.ref("unique_authors.author");
-    const views = this.db("post_views").where("post_views.author", authorRef).count("*").as("totalViews");
-    const questions = this.db("posts").where("posts.author", authorRef).where("posts.type", "question").count("*").as("totalQuestions");
-    const articles = this.db("posts").where("posts.author", authorRef).where("posts.type", "article").count("*").as("totalArticles");
-    const links = this.db("posts").where("posts.author", authorRef).where("posts.type", "link").count("*").as("totalLinks");
-    const answers = this.db("answers").where("answers.author", authorRef).count("*").as("totalAnswers");
-    const comments = this.db("comments").where("comments.author", authorRef).count("*").as("comments");
-    const aVotes = this.db("answer_votes").where("answer_votes.author", authorRef).count("*").as("answerVotes");
-    const pVotes = this.db("post_votes").where("post_votes.author", authorRef).count("*").as("postVotes");
-    const followers = this.db("user_users").where("user_users.followedUserRef", authorRef).count("*").as("totalFollowers");
-    return this.db("unique_authors").select(
-      "author",
-      views,
-      questions,
-      answers,
-      articles,
-      links,
-      comments,
-      pVotes,
-      aVotes,
-      followers
-    );
+    return this.entitiesStore.getEntityLinks();
   }
-  /**
-   * Maps string or number value to integer. This is due to fact that postgres returns
-   * strings instead numbers for count and sum functions.
-   * @param val
-   */
-  mapToInteger = (val) => {
-    return typeof val === "string" ? Number.parseInt(val, 10) : val ?? 0;
-  };
-  async mapCollectionEntity(val, user_ref, options) {
-    const { postFilters, includePosts = true } = options ?? {};
-    const results = await Promise.all([
-      includePosts ? this.getPosts(
-        user_ref,
-        { collectionId: val.id, includeEntities: true },
-        postFilters,
-        {
-          tagsFilter: options?.tagFilters,
-          includeComments: false,
-          includeAnswers: false,
-          includeAttachments: false,
-          includeVotes: false,
-          includeTotal: false,
-          includeExperts: options?.includeExperts ?? false
-        }
-      ) : { posts: [] },
-      this.db("attachments").where("collectionId", val.id).select("id"),
-      this.db("user_collections").count("*").as("followers").where("collectionId", val.id).first(),
-      options?.includeExperts ?? true ? this.getCollectionExperts(val.id) : void 0
-    ]);
-    const entities = lodash.compact([
-      ...new Set(results[0].posts.map((p) => p.entities).flat())
-    ]);
-    const tags = lodash.compact([
-      ...new Set(results[0].posts.map((p) => p.tags).flat())
-    ]);
-    return {
-      id: val.id,
-      title: val.title,
-      owner: val.owner,
-      description: val.description,
-      created: val.created,
-      posts: results[0].posts,
-      headerImage: val.headerImage,
-      postsCount: this.mapToInteger(val.postsCount),
-      entities,
-      tags,
-      images: results[1].map((r) => r.id),
-      followers: this.mapToInteger(results[2].count),
-      experts: results[3]
-    };
-  }
-  async getCollectionExperts(collectionId) {
-    const rows = await this.db("tag_experts").leftJoin("tags", "tag_experts.tagId", "tags.id").leftJoin("post_tags", "post_tags.tagId", "tags.id").leftJoin(
-      "collection_posts",
-      "collection_posts.postId",
-      "post_tags.postId"
-    ).where("collection_posts.collectionId", collectionId).select("tag_experts.entityRef");
-    return [...new Set(rows.map((r) => r.entityRef))];
-  }
-  async mapTemplateEntity(val) {
-    const additionalInfo = await Promise.all([
-      this.getRelatedTags(val.id, "template_tags", "templateId"),
-      this.getRelatedEntities(val.id, "template_entities", "templateId")
-    ]);
-    return {
-      id: val.id,
-      title: val.title,
-      description: val.description,
-      questionTitle: val.questionTitle ?? void 0,
-      questionContent: val.questionContent ?? void 0,
-      tags: additionalInfo[0],
-      entities: additionalInfo[1]
-    };
-  }
-  async mapPostEntity(val, user_ref, options) {
-    const {
-      includeTags = true,
-      includeAnswers = true,
-      includeVotes = true,
-      includeEntities = true,
-      includeComments = true,
-      includeAttachments = true,
-      includeExperts = true,
-      tagsFilter
-    } = options ?? {};
-    const additionalInfo = await Promise.all([
-      includeTags ? this.getRelatedTags(val.id, "post_tags", "postId", tagsFilter) : void 0,
-      includeAnswers ? this.getPostAnswers(val.id, user_ref, {
-        ...options,
-        includePost: false,
-        filter: options?.answersFilter
-      }) : void 0,
-      includeVotes ? this.getPostVotes(val.id) : void 0,
-      includeEntities ? this.getRelatedEntities(val.id) : void 0,
-      includeComments ? this.getPostComments(val.id, options?.commentsFilter) : void 0,
-      includeAttachments ? this.db("attachments").select("id").where("postId", val.id) : void 0,
-      includeExperts ? this.getPostExperts(val.id) : void 0
-    ]);
-    return {
-      id: val.id,
-      author: val.anonymous && val.author !== user_ref ? "anonymous" : val.author,
-      own: val.author === user_ref,
-      title: val.title,
-      content: val.content,
-      created: val.created,
-      updated: val.updated,
-      updatedBy: val.updatedBy,
-      status: val.status,
-      score: this.mapToInteger(val.score),
-      views: this.mapToInteger(val.views),
-      answersCount: this.mapToInteger(val.answersCount),
-      correctAnswer: this.mapToInteger(val.correctAnswers) > 0,
-      commentsCount: this.mapToInteger(val.commentsCount),
-      favorite: this.mapToInteger(val.favorite) > 0,
-      tags: additionalInfo[0],
-      answers: additionalInfo[1],
-      votes: additionalInfo[2],
-      entities: additionalInfo[3],
-      trend: this.mapToInteger(val.trend),
-      comments: additionalInfo[4],
-      ownVote: additionalInfo[2]?.find((v) => v.author === user_ref)?.score,
-      anonymous: val.anonymous,
-      type: val.type,
-      headerImage: val.headerImage,
-      url: val.url ?? void 0,
-      images: additionalInfo[5]?.map((r) => r.id),
-      experts: additionalInfo[6],
-      published: val.published ? val.published : void 0
-    };
-  }
-  mapComment(val) {
-    return {
-      id: val.id,
-      author: val.author,
-      content: val.content,
-      created: val.created,
-      updated: val.updated,
-      updatedBy: val.updatedBy,
-      status: val.status
-    };
-  }
-  async mapAnswer(val, user_ref, options) {
-    const {
-      includeVotes = true,
-      includeComments = true,
-      includePost = true,
-      includeExperts = true
-    } = options ?? {};
-    const additionalInfo = await Promise.all([
-      includeVotes ? this.getAnswerVotes(val.id) : void 0,
-      includeComments ? this.getAnswerComments(val.id, options?.commentsFilter) : void 0,
-      includePost ? this.getPost(user_ref, val.postId, false) : void 0,
-      this.db("attachments").select("id").where("answerId", val.id),
-      includeExperts ? this.getAnswerExperts(val.id) : void 0
-    ]);
-    return {
-      id: val.id,
-      postId: val.postId,
-      own: val.author === user_ref,
-      author: val.anonymous && val.author !== user_ref ? "anonymous" : val.author,
-      content: val.content,
-      correct: val.correct,
-      created: val.created,
-      updated: val.updated,
-      updatedBy: val.updatedBy,
-      score: this.mapToInteger(val.score),
-      status: val.status,
-      votes: additionalInfo[0],
-      comments: additionalInfo[1],
-      anonymous: val.anonymous,
-      post: additionalInfo[2] ?? void 0,
-      images: additionalInfo[3].map((r) => r.id),
-      experts: additionalInfo[4] ?? void 0
-    };
-  }
-  mapVote(val) {
-    return {
-      author: val.author,
-      score: val.score,
-      timestamp: val.timestamp
-    };
-  }
-  mapAttachment(val) {
-    return {
-      ...val,
-      created: val.created instanceof Date ? val.created : new Date(val.created)
-    };
-  }
-  async getRelatedTags(id, tableName = "post_tags", columnName = "postId", tagsFilter) {
-    const query = this.db("tags").leftJoin(tableName, "tags.id", `${tableName}.tagId`).where(`${tableName}.${columnName}`, "=", id);
-    if (tagsFilter) {
-      parseFilter(tagsFilter, query, this.db, "tags");
-    }
-    const rows = await query.select();
-    return rows.map((val) => val.tag);
-  }
-  async getPostComments(postId, commentsFilter, opts) {
-    const { includeStatusFilter = true } = opts ?? {};
-    const query = this.db("comments").where("comments.postId", "=", postId).orderBy("created");
-    if (includeStatusFilter) {
-      query.where("comments.status", "=", "active");
-    }
-    if (commentsFilter) {
-      parseFilter(commentsFilter, query, this.db, "comments");
-    }
-    const rows = await query.select();
-    return rows.map((val) => this.mapComment(val));
-  }
-  async getPostExperts(postId) {
-    const rows = await this.db("tag_experts").leftJoin("post_tags", "tag_experts.tagId", "post_tags.tagId").where("post_tags.postId", postId).select("tag_experts.entityRef");
-    return [...new Set(rows.map((r) => r.entityRef))];
-  }
-  async getAnswerComments(answerId, commentsFilter, opts) {
-    const { includeStatusFilter = true } = opts ?? {};
-    const query = this.db("comments").where("comments.answerId", "=", answerId).orderBy("created");
-    if (includeStatusFilter) {
-      query.where("comments.status", "=", "active");
-    }
-    if (commentsFilter) {
-      parseFilter(commentsFilter, query, this.db, "comments");
-    }
-    const rows = await query.select();
-    return rows.map((val) => this.mapComment(val));
-  }
-  async getRelatedEntities(id, tableName = "post_entities", columnName = "postId") {
-    const rows = await this.db("entities").leftJoin(tableName, "entities.id", `${tableName}.entityId`).where(`${tableName}.${columnName}`, "=", id).select();
-    return rows.map((val) => val.entity_ref);
-  }
-  async getPostVotes(postId) {
-    const rows = await this.db("post_votes").where("postId", "=", postId).select();
-    return rows.map((val) => this.mapVote(val));
-  }
-  async getAnswerVotes(answerId) {
-    const rows = await this.db("answer_votes").where("answerId", "=", answerId).select();
-    return rows.map((val) => this.mapVote(val));
-  }
-  async getAnswerExperts(answerId) {
-    const rows = await this.db("tag_experts").leftJoin("tags", "tag_experts.tagId", "tags.id").leftJoin("post_tags", "post_tags.tagId", "tags.id").leftJoin("answers", "answers.postId", "post_tags.postId").where("answers.id", answerId).select("tag_experts.entityRef");
-    return [...new Set(rows.map((r) => r.entityRef))];
-  }
-  getAnswerBaseQuery() {
-    const postRef = this.db.ref("answers.id");
-    const score = this.db("answer_votes").where("answer_votes.answerId", postRef).sum("score").as("score");
-    return this.db("answers").leftJoin("answer_votes", "answers.id", "answer_votes.answerId").select("answers.*", score).groupBy("answers.id");
-  }
-  async getPostAnswers(postId, user_ref, options) {
-    const { includeStatusFilter = true } = options ?? {};
-    const query = this.getAnswerBaseQuery().where("postId", "=", postId).orderBy("answers.correct", "desc").orderBy("answers.created");
-    if (includeStatusFilter) {
-      query.where("answers.status", "=", "active");
-    }
-    if (options?.filter) {
-      parseFilter(options.filter, query, this.db, "answer");
-    }
-    const rows = await query.select();
-    return await Promise.all(
-      rows.map(async (val) => {
-        return this.mapAnswer(val, user_ref, options);
-      })
-    );
-  }
-  async recordPostView(postId, user_ref) {
-    await this.db.insert({
-      author: user_ref,
-      postId,
-      timestamp: /* @__PURE__ */ new Date()
-    }).into("post_views");
-  }
-  getPostsBaseQuery(user, opts) {
-    const { includeStatusFilter = true } = opts ?? {};
-    const postRef = this.db.ref("posts.id");
-    const score = this.db("post_votes").where("post_votes.postId", postRef).sum("score").as("score");
-    const views = this.db("post_views").where("post_views.postId", postRef).count("*").as("views");
-    const answersCount = this.db("answers").where("answers.postId", postRef).count("*").as("answersCount");
-    if (includeStatusFilter) {
-      answersCount.where("answers.status", "=", "active");
-    }
-    const correctAnswers = this.db("answers").where("answers.postId", postRef).where("answers.correct", "=", true).count("*").as("correctAnswers");
-    if (includeStatusFilter) {
-      correctAnswers.where("answers.status", "=", "active");
-    }
-    const commentsCount = this.db("comments").where("comments.postId", postRef).count("*").as("commentsCount");
-    const favorite = this.db("user_favorite").where("user_favorite.user", "=", user).where("user_favorite.postId", postRef).count("*").as("favorite");
-    return this.db("posts").select(
-      "posts.*",
-      score,
-      views,
-      answersCount,
-      correctAnswers,
-      commentsCount,
-      favorite
-    ).leftJoin("post_votes", "posts.id", "post_votes.postId").leftJoin("post_views", "posts.id", "post_views.postId").leftJoin("answers", "posts.id", "answers.postId").leftJoin("comments", "posts.id", "comments.postId").leftJoin("user_favorite", "posts.id", "user_favorite.postId").groupBy("posts.id");
-  }
-  getCollectionsBaseQuery() {
-    const collectionRef = this.db.ref("collections.id");
-    const postsCount = this.db("collection_posts").leftJoin("posts", "collection_posts.postId", "posts.id").where("collection_posts.collectionId", collectionRef).where("posts.status", "=", "active").count("*").as("postsCount");
-    return this.db("collections").select("collections.*", postsCount).leftJoin(
-      "collection_posts",
-      "collections.id",
-      "collection_posts.collectionId"
-    ).leftJoin("posts", "collection_posts.postId", "posts.id").groupBy("collections.id");
-  }
-  async addTags(id, tagsInput, removeOld, tableName = "post_tags", columnName = "postId") {
-    const tags = backstagePluginQetaCommon.filterTags(tagsInput);
-    if (removeOld) {
-      await this.db(tableName).where(columnName, "=", id).delete();
-    }
-    if (!tags || tags.length === 0) {
-      return;
-    }
-    const existingTags = await this.db("tags").whereIn("tag", tags).returning("id").select();
-    const newTags = tags.filter((t) => !existingTags.some((e) => e.tag === t));
-    const allTags = {
-      ...tagDb.TAGS,
-      ...await this.tagDatabase?.getTags()
-    };
-    const tagIds = (await Promise.all(
-      [...new Set(newTags)].map(async (tag) => {
-        const trimmed = tag.trim();
-        const description = trimmed in allTags ? allTags[trimmed] : void 0;
-        return this.db.insert({ tag: trimmed, description }).into("tags").returning("id").onConflict("tag").ignore();
-      })
-    )).flat().map((tag) => tag.id).concat(existingTags.map((t) => t.id));
-    await Promise.all(
-      tagIds.map(async (tagId) => {
-        await this.db.insert({ [columnName]: id, tagId }).into(tableName).onConflict().ignore();
-      })
-    );
-  }
-  async addEntities(id, entitiesInput, removeOld, tableName = "post_entities", columnName = "postId") {
-    if (removeOld) {
-      await this.db(tableName).where(columnName, "=", id).delete();
-    }
-    const regex = /\w+:\w+\/\w+/g;
-    const entities = entitiesInput?.filter((input) => input.match(regex));
-    if (!entities || entities.length === 0) {
-      return;
-    }
-    const existingEntities = await this.db("entities").whereIn("entity_ref", entities).returning("id").select();
-    const newEntities = entities.filter(
-      (t) => !existingEntities.some((e) => e.entity_ref === t)
-    );
-    const entityIds = (await Promise.all(
-      [...new Set(newEntities)].map(
-        async (entity) => await this.db.insert({ entity_ref: entity }).into("entities").returning("id").onConflict("entity_ref").ignore()
-      )
-    )).flat().map((entity) => entity.id).concat(existingEntities.map((c) => c.id));
-    await Promise.all(
-      entityIds.map(async (entityId) => {
-        await this.db.insert({ [columnName]: id, entityId }).into(tableName).onConflict().ignore();
-      })
-    );
-  }
-  async markAnswer(postId, answerId, correct) {
-    if (correct) {
-      const exists = await this.db("answers").select("id").where("correct", "=", true).where("postId", "=", postId);
-      if (exists && exists.length > 0) {
-        return false;
-      }
-    }
-    const query = this.db("answers").onConflict().ignore().where("answers.id", "=", answerId).where("postId", "=", postId);
-    const ret = await query.update({ correct }, ["id"]);
-    return ret !== void 0 && ret?.length > 0;
+  async getComments(options, opts) {
+    return this.commentsStore.getComments(options, opts);
   }
-  async updateAttachments(key, content, images, id, headerImage) {
-    if (images.length > 0) {
-      await this.db("attachments").whereIn("id", images).update({ [key]: id });
-    }
-    const attachments = await this.db("attachments").where(key, id).select("uuid");
-    const uuids = attachments.map((a) => a.uuid);
-    const toRemove = uuids.filter((uuid) => {
-      return !(content.includes(uuid) || headerImage?.includes(uuid));
-    });
-    await this.db("attachments").whereIn("uuid", toRemove).update({ [key]: null });
-  }
-  applySearchQuery(query, columns, searchQuery) {
-    if (this.db.client.config.client === "pg") {
-      query.whereRaw(
-        `((to_tsvector(CONCAT(${columns.join(
-          ","
-        )})) @@ to_tsquery(quote_literal(?) || ':*')))`,
-        [`${searchQuery}`]
-      );
-    } else {
-      query.whereRaw(`LOWER(CONCAT(${columns.join(",")})) LIKE LOWER(?)`, [
-        `%${searchQuery}%`
-      ]);
-    }
+  async getComment(commentId, opts) {
+    return this.commentsStore.getComment(commentId, opts);
   }
 }