@drodil/backstage-plugin-qeta-common 2.15.0 → 3.0.0

package/dist/api/QetaClient.cjs.js

@@ -0,0 +1,649 @@
+'use strict';
+
+var errors = require('@backstage/errors');
+var omitBy = require('lodash/omitBy');
+var crossFetch = require('cross-fetch');
+var qs = require('qs');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var omitBy__default = /*#__PURE__*/_interopDefaultCompat(omitBy);
+var crossFetch__default = /*#__PURE__*/_interopDefaultCompat(crossFetch);
+var qs__default = /*#__PURE__*/_interopDefaultCompat(qs);
+
+class QetaError extends errors.CustomErrorBase {
+  errors;
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+  }
+}
+class QetaClient {
+  fetchApi;
+  discoveryApi;
+  constructor(options) {
+    this.fetchApi = options.fetchApi ?? { fetch: crossFetch__default.default };
+    this.discoveryApi = options.discoveryApi;
+  }
+  async getBaseUrl() {
+    return this.discoveryApi.getBaseUrl("qeta");
+  }
+  async getPosts(options, requestOptions) {
+    const query = this.getQueryParameters(options);
+    let url = `${await this.getBaseUrl()}/posts`;
+    if (query) {
+      url += `?${query}`;
+    }
+    const headers = {};
+    if (requestOptions?.token) {
+      headers.Authorization = `Bearer ${requestOptions.token}`;
+    }
+    const response = await this.fetchApi.fetch(url, { method: "GET", headers });
+    if (response.status === 403) {
+      return { posts: [], total: 0 };
+    }
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async getPostsList(type, options) {
+    const query = this.getQueryParameters(options);
+    let url = `${await this.getBaseUrl()}/posts/list/${type}`;
+    if (query) {
+      url += `?${query}`;
+    }
+    const response = await this.fetchApi.fetch(url);
+    if (response.status === 403) {
+      return { posts: [], total: 0 };
+    }
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async createPost(question) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts`,
+      {
+        method: "POST",
+        body: JSON.stringify(question),
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async commentPost(id, content) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${id}/comments`,
+      {
+        method: "POST",
+        body: JSON.stringify({ content }),
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async deletePostComment(questionId, id) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${questionId}/comments/${id}`,
+      {
+        method: "DELETE"
+      }
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async getPost(id) {
+    if (!id) {
+      throw new QetaError("Invalid id provided", void 0);
+    }
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${id}`
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async getTags() {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/tags`
+    );
+    return await response.json();
+  }
+  async getTag(tag) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/tags/${tag}`
+    );
+    if (!response.ok) {
+      return null;
+    }
+    return await response.json();
+  }
+  async updateTag(tag, description) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/tags/${tag}`,
+      {
+        method: "POST",
+        body: JSON.stringify({ description }),
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+    if (!response.ok) {
+      return null;
+    }
+    return await response.json();
+  }
+  async getUsers() {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/users`
+    );
+    return await response.json();
+  }
+  async getEntities() {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/entities`
+    );
+    return await response.json();
+  }
+  async getEntity(entityRef) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/entities/${entityRef}`
+    );
+    if (!response.ok) {
+      return null;
+    }
+    return await response.json();
+  }
+  async votePostUp(id) {
+    if (!id) {
+      throw new QetaError("Invalid id provided", void 0);
+    }
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${id}/upvote`
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async votePostDown(id) {
+    if (!id) {
+      throw new QetaError("Invalid id provided", void 0);
+    }
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${id}/downvote`
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async favoritePost(id) {
+    if (!id) {
+      throw new QetaError("Invalid id provided", void 0);
+    }
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${id}/favorite`
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async unfavoritePost(id) {
+    if (!id) {
+      throw new QetaError("Invalid id provided", void 0);
+    }
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${id}/unfavorite`
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async postAnswer(answer) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${answer.postId}/answers`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          answer: answer.answer,
+          images: answer.images,
+          anonymous: answer.anonymous
+        }),
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async commentAnswer(questionId, id, content) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${questionId}/answers/${id}/comments`,
+      {
+        method: "POST",
+        body: JSON.stringify({ content }),
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async deleteAnswerComment(questionId, answerId, id) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${questionId}/answers/${answerId}/comments/${id}`,
+      {
+        method: "DELETE"
+      }
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async voteAnswerUp(questionId, id) {
+    if (!id || !questionId) {
+      throw new QetaError("Invalid id provided", void 0);
+    }
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${questionId}/answers/${id}/upvote`
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async voteAnswerDown(questionId, id) {
+    if (!id || !questionId) {
+      throw new QetaError("Invalid id provided", void 0);
+    }
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${questionId}/answers/${id}/downvote`
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async markAnswerCorrect(questionId, id) {
+    if (!id || !questionId) {
+      throw new QetaError("Invalid id provided", void 0);
+    }
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${questionId}/answers/${id}/correct`
+    );
+    const data = await response;
+    return data.ok;
+  }
+  async markAnswerIncorrect(questionId, id) {
+    if (!id || !questionId) {
+      throw new QetaError("Invalid id provided", void 0);
+    }
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${questionId}/answers/${id}/incorrect`
+    );
+    const data = await response;
+    return data.ok;
+  }
+  async deletePost(questionId) {
+    if (!questionId) {
+      throw new QetaError("Invalid id provided", void 0);
+    }
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${questionId}`,
+      {
+        method: "DELETE"
+      }
+    );
+    const data = await response;
+    return data.ok;
+  }
+  async deleteAnswer(questionId, id) {
+    if (!questionId || !id) {
+      throw new QetaError("Invalid id provided", void 0);
+    }
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${questionId}/answers/${id}`,
+      {
+        method: "DELETE"
+      }
+    );
+    const data = await response;
+    return data.ok;
+  }
+  async updatePost(id, question) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${id}`,
+      {
+        method: "POST",
+        body: JSON.stringify(question),
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to update", data.errors);
+    }
+    return data;
+  }
+  async updateAnswer(id, answer) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${answer.postId}/answers/${id}`,
+      {
+        method: "POST",
+        body: JSON.stringify({ answer: answer.answer, images: answer.images }),
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async getAnswers(options) {
+    const query = this.getQueryParameters(options);
+    let url = `${await this.getBaseUrl()}/answers`;
+    if (query) {
+      url += `?${query}`;
+    }
+    const response = await this.fetchApi.fetch(url);
+    if (response.status === 403) {
+      return { answers: [], total: 0 };
+    }
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async getAnswer(questionId, id) {
+    if (!questionId || !id) {
+      throw new QetaError("Invalid id provided", void 0);
+    }
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/posts/${questionId}/answers/${id}`
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async getFollowedTags() {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/tags/followed`
+    );
+    return await response.json();
+  }
+  async followTag(tag) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/tags/follow/${tag}`,
+      {
+        method: "PUT"
+      }
+    );
+    return response.ok;
+  }
+  async unfollowTag(tag) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/tags/follow/${tag}`,
+      {
+        method: "DELETE"
+      }
+    );
+    return response.ok;
+  }
+  async getFollowedEntities() {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/entities/followed`
+    );
+    return await response.json();
+  }
+  async followEntity(entityRef) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/entities/follow/${entityRef}`,
+      {
+        method: "PUT"
+      }
+    );
+    return response.ok;
+  }
+  async unfollowEntity(entityRef) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/entities/follow/${entityRef}`,
+      {
+        method: "DELETE"
+      }
+    );
+    return response.ok;
+  }
+  async postAttachment(file) {
+    const qetaUrl = `${await this.getBaseUrl()}/attachments`;
+    const formData = new FormData();
+    formData.append("image", file);
+    const requestOptions = {
+      method: "POST",
+      body: formData
+    };
+    const response = await this.fetchApi.fetch(qetaUrl, requestOptions);
+    return await response.json();
+  }
+  async getMostUpvotedAnswers(options) {
+    const query = this.getQueryParameters(options.options);
+    let url = `${await this.getBaseUrl()}/statistics/answers/top-upvoted-users`;
+    if (query) {
+      url += `?${query}`;
+    }
+    const response = await this.fetchApi.fetch(url);
+    return await response.json();
+  }
+  async getMostUpvotedCorrectAnswers(options) {
+    const query = this.getQueryParameters(options.options);
+    let url = `${await this.getBaseUrl()}/statistics/answers/top-correct-upvoted-users`;
+    if (query) {
+      url += `?${query}`;
+    }
+    const response = await this.fetchApi.fetch(url);
+    return await response.json();
+  }
+  async getMostUpvotedPosts(options) {
+    const query = this.getQueryParameters(options.options);
+    let url = `${await this.getBaseUrl()}/statistics/posts/top-upvoted-users`;
+    if (query) {
+      url += `?${query}`;
+    }
+    const response = await this.fetchApi.fetch(url);
+    return await response.json();
+  }
+  async getMostPosts(options) {
+    const query = this.getQueryParameters(options.options);
+    let url = `${await this.getBaseUrl()}/statistics/posts/most-questions`;
+    if (query) {
+      url += `?${query}`;
+    }
+    const response = await this.fetchApi.fetch(url);
+    return await response.json();
+  }
+  async getMostAnswers(options) {
+    const query = this.getQueryParameters(options.options);
+    let url = `${await this.getBaseUrl()}/statistics/answers/most-answers`;
+    if (query) {
+      url += `?${query}`;
+    }
+    const response = await this.fetchApi.fetch(url);
+    const data = await response.json();
+    return data;
+  }
+  async getTopStatisticsHomepage(options) {
+    const response = await Promise.all([
+      this.getMostPosts(options),
+      this.getMostAnswers(options),
+      this.getMostUpvotedPosts(options),
+      this.getMostUpvotedAnswers(options),
+      this.getMostUpvotedCorrectAnswers(options)
+    ]);
+    return response;
+  }
+  async getUserImpact() {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/statistics/user/impact`
+    );
+    return await response.json();
+  }
+  async getGlobalStats() {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/statistics/global`
+    );
+    return await response.json();
+  }
+  async getUserStats(userRef) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/statistics/user/${userRef}`
+    );
+    return await response.json();
+  }
+  async getCollections(options) {
+    const query = this.getQueryParameters(options);
+    let url = `${await this.getBaseUrl()}/collections`;
+    if (query) {
+      url += `?${query}`;
+    }
+    const response = await this.fetchApi.fetch(url);
+    if (response.status === 403) {
+      return { collections: [], total: 0 };
+    }
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async getCollection(id) {
+    if (!id) {
+      throw new QetaError("Invalid id provided", void 0);
+    }
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/collections/${id}`
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async createCollection(collection) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/collections`,
+      {
+        method: "POST",
+        body: JSON.stringify(collection),
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to fetch", data.errors);
+    }
+    return data;
+  }
+  async updateCollection(id, collection) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/collections/${id}`,
+      {
+        method: "POST",
+        body: JSON.stringify(collection),
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to update", data.errors);
+    }
+    return data;
+  }
+  async deleteCollection(id) {
+    if (!id) {
+      throw new QetaError("Invalid id provided", void 0);
+    }
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/collections/${id}`,
+      {
+        method: "DELETE"
+      }
+    );
+    const data = await response;
+    return data.ok;
+  }
+  async addPostToCollection(collectionId, postId) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/collections/${collectionId}/posts`,
+      {
+        method: "POST",
+        body: JSON.stringify({ postId }),
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to update", data.errors);
+    }
+    return data;
+  }
+  async removePostFromCollection(collectionId, postId) {
+    const response = await this.fetchApi.fetch(
+      `${await this.getBaseUrl()}/collections/${collectionId}/posts`,
+      {
+        method: "DELETE",
+        body: JSON.stringify({ postId }),
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+    const data = await response.json();
+    if ("errors" in data) {
+      throw new QetaError("Failed to update", data.errors);
+    }
+    return data;
+  }
+  getQueryParameters(params) {
+    if (!params) {
+      return "";
+    }
+    const cleaned = omitBy__default.default(params, (v) => !Boolean(v));
+    return qs__default.default.stringify(cleaned);
+  }
+}
+
+exports.QetaClient = QetaClient;
+exports.QetaError = QetaError;
+//# sourceMappingURL=QetaClient.cjs.js.map