π₯π₯π₯ Open-source Jira, Linear, Monday, and ClickUp alternative. Plane is a modern project management platform to manage tasks, sprints, docs, and triage.
TypeScript boardsbug-trackerdjangodockerganttissue-trackerjirajira-alternativekanbanlinearpostgresqlproduct-managementproject-managementproject-planningpythonreactredistypesciptvitework-management
chore: common services package (#6255)
sriram veeraghanta043f4eaa5e93
diff --git a/packages/constants/src/ai.ts b/packages/constants/src/ai.tsnew file mode 100644index 0000000000..8125302440--- /dev/null+++ b/packages/constants/src/ai.ts@@ -0,0 +1,3 @@+export enum AI_EDITOR_TASKS {+ ASK_ANYTHING = "ASK_ANYTHING",+}diff --git a/packages/constants/src/endpoints.ts b/packages/constants/src/endpoints.tsindex 8f7b504644..b17f7c1a06 100644--- a/packages/constants/src/endpoints.ts+++ b/packages/constants/src/endpoints.ts@@ -1,26 +1,25 @@export const API_BASE_URL = process.env.NEXT_PUBLIC_API_BASE_URL || "";-// PI Base Url-export const PI_BASE_URL = process.env.NEXT_PUBLIC_PI_BASE_URL || "";+export const API_BASE_PATH = process.env.NEXT_PUBLIC_API_BASE_PATH || "/";+export const API_URL = encodeURI(`${API_BASE_URL}${API_BASE_PATH}`);// God Mode Admin App Base Urlexport const ADMIN_BASE_URL = process.env.NEXT_PUBLIC_ADMIN_BASE_URL || "";-export const ADMIN_BASE_PATH = process.env.NEXT_PUBLIC_ADMIN_BASE_PATH || "";-export const GOD_MODE_URL = encodeURI(`${ADMIN_BASE_URL}${ADMIN_BASE_PATH}/`);+export const ADMIN_BASE_PATH = process.env.NEXT_PUBLIC_ADMIN_BASE_PATH || "/";+export const GOD_MODE_URL = encodeURI(`${ADMIN_BASE_URL}${ADMIN_BASE_PATH}`);// Publish App Base Urlexport const SPACE_BASE_URL = process.env.NEXT_PUBLIC_SPACE_BASE_URL || "";-export const SPACE_BASE_PATH = process.env.NEXT_PUBLIC_SPACE_BASE_PATH || "";-export const SITES_URL = encodeURI(`${SPACE_BASE_URL}${SPACE_BASE_PATH}/`);+export const SPACE_BASE_PATH = process.env.NEXT_PUBLIC_SPACE_BASE_PATH || "/";+export const SITES_URL = encodeURI(`${SPACE_BASE_URL}${SPACE_BASE_PATH}`);// Live App Base Urlexport const LIVE_BASE_URL = process.env.NEXT_PUBLIC_LIVE_BASE_URL || "";-export const LIVE_BASE_PATH = process.env.NEXT_PUBLIC_LIVE_BASE_PATH || "";-export const LIVE_URL = encodeURI(`${LIVE_BASE_URL}${LIVE_BASE_PATH}/`);+export const LIVE_BASE_PATH = process.env.NEXT_PUBLIC_LIVE_BASE_PATH || "/";+export const LIVE_URL = encodeURI(`${LIVE_BASE_URL}${LIVE_BASE_PATH}`);// Web App Base Urlexport const WEB_BASE_URL = process.env.NEXT_PUBLIC_WEB_BASE_URL || "";-export const WEB_BASE_PATH = process.env.NEXT_PUBLIC_WEB_BASE_PATH || "";+export const WEB_BASE_PATH = process.env.NEXT_PUBLIC_WEB_BASE_PATH || "/";export const WEB_URL = encodeURI(`${WEB_BASE_URL}${WEB_BASE_PATH}`);// plane website urlexport const WEBSITE_URL =process.env.NEXT_PUBLIC_WEBSITE_URL || "https://plane.so";-// support emailexport const SUPPORT_EMAIL =process.env.NEXT_PUBLIC_SUPPORT_EMAIL || "[email protected]";diff --git a/packages/constants/src/index.ts b/packages/constants/src/index.tsindex 0913197869..95a4f97843 100644--- a/packages/constants/src/index.ts+++ b/packages/constants/src/index.ts@@ -1,3 +1,4 @@+export * from "./ai";export * from "./auth";export * from "./endpoints";export * from "./file";diff --git a/packages/eslint-config/library.js b/packages/eslint-config/library.jsindex 283590693e..790364230f 100644--- a/packages/eslint-config/library.js+++ b/packages/eslint-config/library.js@@ -44,6 +44,30 @@ module.exports = {"@typescript-eslint/no-explicit-any": "warn","@typescript-eslint/no-useless-empty-export": "error","@typescript-eslint/prefer-ts-expect-error": "warn",+ "import/order": [+ "warn",+ {+ groups: ["builtin", "external", "internal", "parent", "sibling"],+ pathGroups: [+ {+ pattern: "@plane/**",+ group: "external",+ position: "after",+ },+ {+ pattern: "@/**",+ group: "internal",+ position: "before",+ },+ ],+ pathGroupsExcludedImportTypes: ["builtin", "internal", "react"],+ alphabetize: {+ order: "asc",+ caseInsensitive: true,+ },+ },+ ],},+ignorePatterns: [".*.js", "node_modules/", "dist/"],};diff --git a/packages/services/.eslintignore b/packages/services/.eslintignorenew file mode 100644index 0000000000..6019047c3e--- /dev/null+++ b/packages/services/.eslintignore@@ -0,0 +1,3 @@+build/*+dist/*+out/*\ No newline at end of filediff --git a/packages/services/.eslintrc.js b/packages/services/.eslintrc.jsnew file mode 100644index 0000000000..558b8f76ed--- /dev/null+++ b/packages/services/.eslintrc.js@@ -0,0 +1,9 @@+/** @type {import("eslint").Linter.Config} */+module.exports = {+ root: true,+ extends: ["@plane/eslint-config/library.js"],+ parser: "@typescript-eslint/parser",+ parserOptions: {+ project: true,+ },+};diff --git a/packages/services/.prettierrc b/packages/services/.prettierrcnew file mode 100644index 0000000000..87d988f1b2--- /dev/null+++ b/packages/services/.prettierrc@@ -0,0 +1,5 @@+{+ "printWidth": 120,+ "tabWidth": 2,+ "trailingComma": "es5"+}diff --git a/packages/services/package.json b/packages/services/package.jsonnew file mode 100644index 0000000000..e3473942f7--- /dev/null+++ b/packages/services/package.json@@ -0,0 +1,14 @@+{+ "name": "@plane/services",+ "version": "0.24.1",+ "private": true,+ "main": "./src/index.ts",+ "scripts": {+ "lint": "eslint src --ext .ts,.tsx",+ "lint:errors": "eslint src --ext .ts,.tsx --quiet"+ },+ "dependencies": {+ "@plane/constants": "*",+ "axios": "^1.4.0"+ }+}diff --git a/packages/services/src/ai/ai.service.ts b/packages/services/src/ai/ai.service.tsnew file mode 100644index 0000000000..6a3b3c637c--- /dev/null+++ b/packages/services/src/ai/ai.service.ts@@ -0,0 +1,67 @@+// plane web constants+import { AI_EDITOR_TASKS, API_BASE_URL } from "@plane/constants";+// services+import { APIService } from "@/api.service";++/**+ * Payload type for AI editor tasks+ * @typedef {Object} TTaskPayload+ * @property {number} [casual_score] - Optional score for casual tone analysis+ * @property {number} [formal_score] - Optional score for formal tone analysis+ * @property {AI_EDITOR_TASKS} task - Type of AI editor task to perform+ * @property {string} text_input - The input text to be processed+ */+export type TTaskPayload = {+ casual_score?: number;+ formal_score?: number;+ task: AI_EDITOR_TASKS;+ text_input: string;+};++/**+ * Service class for handling AI-related API operations+ * Extends the base APIService class to interact with AI endpoints+ * @extends {APIService}+ */+export class AIService extends APIService {+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }++ /**+ * Creates a GPT-based task for a specific workspace+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {Object} data - The data payload for the GPT task+ * @param {string} data.prompt - The prompt text for the GPT model+ * @param {string} data.task - The type of task to be performed+ * @returns {Promise<any>} The response data from the GPT task+ * @throws {Error} Throws the response error if the request fails+ */+ async prompt(workspaceSlug: string, data: { prompt: string; task: string }): Promise<any> {+ return this.post(`/api/workspaces/${workspaceSlug}/ai-assistant/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response;+ });+ }++ /**+ * Performs an editor-specific AI task for text processing+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {TTaskPayload} data - The task payload containing text and processing parameters+ * @returns {Promise<{response: string}>} The processed text response+ * @throws {Error} Throws the response data if the request fails+ */+ async rephraseGrammar(+ workspaceSlug: string,+ data: TTaskPayload+ ): Promise<{+ response: string;+ }> {+ return this.post(`/api/workspaces/${workspaceSlug}/rephrase-grammar/`, data)+ .then((res) => res?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }+}diff --git a/packages/services/src/ai/index.ts b/packages/services/src/ai/index.tsnew file mode 100644index 0000000000..bce346aa66--- /dev/null+++ b/packages/services/src/ai/index.ts@@ -0,0 +1 @@+export * from "./ai.service";diff --git a/packages/services/src/analytics/analytics.service.ts b/packages/services/src/analytics/analytics.service.tsnew file mode 100644index 0000000000..c012fd26f4--- /dev/null+++ b/packages/services/src/analytics/analytics.service.ts@@ -0,0 +1,93 @@+// constants+import { API_BASE_URL } from "@plane/constants";+// types+import {+ IAnalyticsParams,+ IAnalyticsResponse,+ IDefaultAnalyticsResponse,+ IExportAnalyticsFormData,+ ISaveAnalyticsFormData,+} from "@plane/types";+// services+import { APIService } from "../api.service";++export class AnalyticsService extends APIService {+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }++ /**+ * Retrieves analytics data for a specific workspace+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {IAnalyticsParams} params - Parameters for filtering analytics data+ * @param {string|number} [params.project] - Optional project identifier that will be converted to string+ * @returns {Promise<IAnalyticsResponse>} The analytics data for the workspace+ * @throws {Error} Throws response data if the request fails+ */+ async getAnalytics(workspaceSlug: string, params: IAnalyticsParams): Promise<IAnalyticsResponse> {+ return this.get(`/api/workspaces/${workspaceSlug}/analytics/`, {+ params: {+ ...params,+ project: params?.project ? params.project.toString() : null,+ },+ })+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Retrieves default analytics data for a workspace+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {Partial<IAnalyticsParams>} [params] - Optional parameters for filtering default analytics+ * @param {string|number} [params.project] - Optional project identifier that will be converted to string+ * @returns {Promise<IDefaultAnalyticsResponse>} The default analytics data+ * @throws {Error} Throws response data if the request fails+ */+ async getDefaultAnalytics(+ workspaceSlug: string,+ params?: Partial<IAnalyticsParams>+ ): Promise<IDefaultAnalyticsResponse> {+ return this.get(`/api/workspaces/${workspaceSlug}/default-analytics/`, {+ params: {+ ...params,+ project: params?.project ? params.project.toString() : null,+ },+ })+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Saves analytics view configuration for a workspace+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {ISaveAnalyticsFormData} data - The analytics configuration data to save+ * @returns {Promise<any>} The response from saving the analytics view+ * @throws {Error} Throws response data if the request fails+ */+ async save(workspaceSlug: string, data: ISaveAnalyticsFormData): Promise<any> {+ return this.post(`/api/workspaces/${workspaceSlug}/analytic-view/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Exports analytics data for a workspace+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {IExportAnalyticsFormData} data - Configuration for the analytics export+ * @returns {Promise<any>} The exported analytics data+ * @throws {Error} Throws response data if the request fails+ */+ async export(workspaceSlug: string, data: IExportAnalyticsFormData): Promise<any> {+ return this.post(`/api/workspaces/${workspaceSlug}/export-analytics/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }+}diff --git a/packages/services/src/analytics/index.ts b/packages/services/src/analytics/index.tsnew file mode 100644index 0000000000..7655bd4424--- /dev/null+++ b/packages/services/src/analytics/index.ts@@ -0,0 +1 @@+export * from "./analytics.service";diff --git a/packages/services/src/api.service.ts b/packages/services/src/api.service.tsnew file mode 100644index 0000000000..3574424daf--- /dev/null+++ b/packages/services/src/api.service.ts@@ -0,0 +1,110 @@+/* eslint-disable @typescript-eslint/no-explicit-any */+import axios, { AxiosInstance, AxiosRequestConfig } from "axios";++/**+ * Abstract base class for making HTTP requests using axios+ * @abstract+ */+export abstract class APIService {+ protected baseURL: string;+ private axiosInstance: AxiosInstance;++ /**+ * Creates an instance of APIService+ * @param {string} baseURL - The base URL for all HTTP requests+ */+ constructor(baseURL: string) {+ this.baseURL = baseURL;+ this.axiosInstance = axios.create({+ baseURL,+ withCredentials: true,+ });++ this.setupInterceptors();+ }++ /**+ * Sets up axios interceptors for handling responses+ * Currently handles 401 unauthorized responses by redirecting to login+ * @private+ */+ private setupInterceptors() {+ this.axiosInstance.interceptors.response.use(+ (response) => response,+ (error) => {+ if (error.response && error.response.status === 401) {+ const currentPath = window.location.pathname;+ window.location.replace(`/${currentPath ? `?next_path=${currentPath}` : ``}`);+ }+ return Promise.reject(error);+ }+ );+ }++ /**+ * Makes a GET request to the specified URL+ * @param {string} url - The endpoint URL+ * @param {object} [params={}] - URL parameters+ * @param {AxiosRequestConfig} [config={}] - Additional axios configuration+ * @returns {Promise} Axios response promise+ */+ get(url: string, params = {}, config: AxiosRequestConfig = {}) {+ return this.axiosInstance.get(url, {+ ...params,+ ...config,+ });+ }++ /**+ * Makes a POST request to the specified URL+ * @param {string} url - The endpoint URL+ * @param {object} [data={}] - Request body data+ * @param {AxiosRequestConfig} [config={}] - Additional axios configuration+ * @returns {Promise} Axios response promise+ */+ post(url: string, data = {}, config: AxiosRequestConfig = {}) {+ return this.axiosInstance.post(url, data, config);+ }++ /**+ * Makes a PUT request to the specified URL+ * @param {string} url - The endpoint URL+ * @param {object} [data={}] - Request body data+ * @param {AxiosRequestConfig} [config={}] - Additional axios configuration+ * @returns {Promise} Axios response promise+ */+ put(url: string, data = {}, config: AxiosRequestConfig = {}) {+ return this.axiosInstance.put(url, data, config);+ }++ /**+ * Makes a PATCH request to the specified URL+ * @param {string} url - The endpoint URL+ * @param {object} [data={}] - Request body data+ * @param {AxiosRequestConfig} [config={}] - Additional axios configuration+ * @returns {Promise} Axios response promise+ */+ patch(url: string, data = {}, config: AxiosRequestConfig = {}) {+ return this.axiosInstance.patch(url, data, config);+ }++ /**+ * Makes a DELETE request to the specified URL+ * @param {string} url - The endpoint URL+ * @param {any} [data] - Request body data+ * @param {AxiosRequestConfig} [config={}] - Additional axios configuration+ * @returns {Promise} Axios response promise+ */+ delete(url: string, data?: any, config: AxiosRequestConfig = {}) {+ return this.axiosInstance.delete(url, { data, ...config });+ }++ /**+ * Makes a custom request with the provided configuration+ * @param {object} [config={}] - Axios request configuration+ * @returns {Promise} Axios response promise+ */+ request(config = {}) {+ return this.axiosInstance(config);+ }+}diff --git a/packages/services/src/auth/auth.service.ts b/packages/services/src/auth/auth.service.tsnew file mode 100644index 0000000000..87e75e536f--- /dev/null+++ b/packages/services/src/auth/auth.service.ts@@ -0,0 +1,124 @@+import { API_BASE_URL } from "@plane/constants";+// types+import { ICsrfTokenData, IEmailCheckData, IEmailCheckResponse } from "@plane/types";+// services+import { APIService } from "../api.service";++/**+ * Service class for handling authentication-related operations+ * Provides methods for user authentication, password management, and session handling+ * @extends {APIService}+ */+export default class AuthService extends APIService {+ /**+ * Creates an instance of AuthService+ * Initializes with the base API URL+ */+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }++ /**+ * Requests a CSRF token for form submission security+ * @returns {Promise<ICsrfTokenData>} Object containing the CSRF token+ * @throws {Error} Throws the complete error object if the request fails+ */+ async requestCSRFToken(): Promise<ICsrfTokenData> {+ return this.get("/auth/get-csrf-token/")+ .then((response) => response.data)+ .catch((error) => {+ throw error;+ });+ }++ /**+ * Checks if an email exists in the system+ * @param {IEmailCheckData} data - Email data to verify+ * @returns {Promise<IEmailCheckResponse>} Response indicating email status+ * @throws {Error} Throws response data if the request fails+ */+ async emailCheck(data: IEmailCheckData): Promise<IEmailCheckResponse> {+ return this.post("/auth/email-check/", data, { headers: {} })+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Sends a password reset link to the specified email address+ * @param {{ email: string }} data - Object containing the email address+ * @returns {Promise<any>} Response from the password reset request+ * @throws {Error} Throws response object if the request fails+ */+ async sendResetPasswordLink(data: { email: string }): Promise<any> {+ return this.post(`/auth/forgot-password/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response;+ });+ }++ /**+ * Sets a new password using a reset token+ * @param {string} token - CSRF token for form submission security+ * @param {{ password: string }} data - Object containing the new password+ * @returns {Promise<any>} Response from the password update request+ * @throws {Error} Throws response data if the request fails+ */+ async setPassword(token: string, data: { password: string }): Promise<any> {+ return this.post(`/auth/set-password/`, data, {+ headers: {+ "X-CSRFTOKEN": token,+ },+ })+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Generates a unique code for magic link authentication+ * @param {{ email: string }} data - Object containing the email address+ * @returns {Promise<any>} Response containing the generated unique code+ * @throws {Error} Throws response data if the request fails+ */+ async generateUniqueCode(data: { email: string }): Promise<any> {+ return this.post("/auth/magic-generate/", data, { headers: {} })+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Performs user sign out by submitting a form with CSRF token+ * Creates and submits a form dynamically to handle the sign-out process+ * @param {string} baseUrl - Base URL for the sign-out endpoint+ * @returns {Promise<any>} Resolves when sign-out is complete+ * @throws {Error} Throws error if CSRF token is not found+ */+ async signOut(baseUrl: string): Promise<any> {+ await this.requestCSRFToken().then((data) => {+ const csrfToken = data?.csrf_token;++ if (!csrfToken) throw Error("CSRF token not found");++ const form = document.createElement("form");+ const element1 = document.createElement("input");++ form.method = "POST";+ form.action = `${baseUrl}/auth/sign-out/`;++ element1.value = csrfToken;+ element1.name = "csrfmiddlewaretoken";+ element1.type = "hidden";+ form.appendChild(element1);++ document.body.appendChild(form);++ form.submit();+ });+ }+}diff --git a/packages/services/src/auth/index.ts b/packages/services/src/auth/index.tsnew file mode 100644index 0000000000..2ab33e86ab--- /dev/null+++ b/packages/services/src/auth/index.ts@@ -0,0 +1 @@+export * from "./auth.service";diff --git a/packages/services/src/cycle/cycle-analytics.service.ts b/packages/services/src/cycle/cycle-analytics.service.tsnew file mode 100644index 0000000000..4897926a92--- /dev/null+++ b/packages/services/src/cycle/cycle-analytics.service.ts@@ -0,0 +1,78 @@+import { API_BASE_URL } from "@plane/constants";+import type { TCycleDistribution, TProgressSnapshot, TCycleEstimateDistribution } from "@plane/types";+import { APIService } from "@/api.service";++/**+ * Service class for managing cycles within a workspace and project context.+ * Extends APIService to handle HTTP requests to the cycle-related endpoints.+ * @extends {APIService}+ */+export class CycleAnalyticsService extends APIService {+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }++ /**+ * Retrieves analytics for active cycles in a workspace.+ * @param {string} workspaceSlug - The workspace identifier+ * @param {string} projectId - The project identifier+ * @param {string} cycleId - The cycle identifier+ * @param {string} [analytic_type="points"] - The type of analytics to retrieve+ * @returns {Promise<TCycleDistribution | TCycleEstimateDistribution>} The cycle analytics data+ * @throws {Error} If the request fails+ */+ async workspaceActiveCyclesAnalytics(+ workspaceSlug: string,+ projectId: string,+ cycleId: string,+ analytic_type: string = "points"+ ): Promise<TCycleDistribution | TCycleEstimateDistribution> {+ return this.get(+ `/api/workspaces/${workspaceSlug}/projects/${projectId}/cycles/${cycleId}/analytics?type=${analytic_type}`+ )+ .then((res) => res?.data)+ .catch((err) => {+ throw err?.response?.data;+ });+ }++ /**+ * Retrieves progress data for active cycles.+ * @param {string} workspaceSlug - The workspace identifier+ * @param {string} projectId - The project identifier+ * @param {string} cycleId - The cycle identifier+ * @returns {Promise<TProgressSnapshot>} The cycle progress data+ * @throws {Error} If the request fails+ */+ async workspaceActiveCyclesProgress(+ workspaceSlug: string,+ projectId: string,+ cycleId: string+ ): Promise<TProgressSnapshot> {+ return this.get(`/api/workspaces/${workspaceSlug}/projects/${projectId}/cycles/${cycleId}/progress/`)+ .then((res) => res?.data)+ .catch((err) => {+ throw err?.response?.data;+ });+ }++ /**+ * Retrieves advanced progress data for active cycles (Pro feature).+ * @param {string} workspaceSlug - The workspace identifier+ * @param {string} projectId - The project identifier+ * @param {string} cycleId - The cycle identifier+ * @returns {Promise<TProgressSnapshot>} The detailed cycle progress data+ * @throws {Error} If the request fails+ */+ async workspaceActiveCyclesProgressPro(+ workspaceSlug: string,+ projectId: string,+ cycleId: string+ ): Promise<TProgressSnapshot> {+ return this.get(`/api/workspaces/${workspaceSlug}/projects/${projectId}/cycles/${cycleId}/cycle-progress/`)+ .then((res) => res?.data)+ .catch((err) => {+ throw err?.response?.data;+ });+ }+}diff --git a/packages/services/src/cycle/cycle-archive.service.ts b/packages/services/src/cycle/cycle-archive.service.tsnew file mode 100644index 0000000000..8c40f0a298--- /dev/null+++ b/packages/services/src/cycle/cycle-archive.service.ts@@ -0,0 +1,83 @@+import { API_BASE_URL } from "@plane/constants";+import { ICycle } from "@plane/types";+import { APIService } from "@/api.service";++/**+ * Service class for managing archived cycles in a project+ * Provides methods for retrieving, archiving, and restoring project cycles+ * @extends {APIService}+ */+export class CycleArchiveService extends APIService {+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }++ /**+ * Retrieves all archived cycles for a specific project+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {string} projectId - The unique identifier for the project+ * @returns {Promise<ICycle[]>} Array of archived cycles+ * @throws {Error} Throws response data if the request fails+ */+ async list(workspaceSlug: string, projectId: string): Promise<ICycle[]> {+ return this.get(`/api/workspaces/${workspaceSlug}/projects/${projectId}/archived-cycles/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Retrieves details of a specific archived cycle+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {string} projectId - The unique identifier for the project+ * @param {string} cycleId - The unique identifier for the cycle+ * @returns {Promise<ICycle>} Details of the archived cycle+ * @throws {Error} Throws response data if the request fails+ */+ async retrieve(workspaceSlug: string, projectId: string, cycleId: string): Promise<ICycle> {+ return this.get(`/api/workspaces/${workspaceSlug}/projects/${projectId}/archived-cycles/${cycleId}/`)+ .then((res) => res?.data)+ .catch((err) => {+ throw err?.response?.data;+ });+ }++ /**+ * Archives a specific cycle in a project+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {string} projectId - The unique identifier for the project+ * @param {string} cycleId - The unique identifier for the cycle to archive+ * @returns {Promise<{archived_at: string}>} Object containing the archive timestamp+ * @throws {Error} Throws response data if the request fails+ */+ async archive(+ workspaceSlug: string,+ projectId: string,+ cycleId: string+ ): Promise<{+ archived_at: string;+ }> {+ return this.post(`/api/workspaces/${workspaceSlug}/projects/${projectId}/cycles/${cycleId}/archive/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Restores a previously archived cycle+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {string} projectId - The unique identifier for the project+ * @param {string} cycleId - The unique identifier for the cycle to restore+ * @returns {Promise<void>} Resolves when the cycle is successfully restored+ * @throws {Error} Throws response data if the request fails+ */+ async restore(workspaceSlug: string, projectId: string, cycleId: string): Promise<void> {+ return this.delete(`/api/workspaces/${workspaceSlug}/projects/${projectId}/cycles/${cycleId}/archive/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }+}diff --git a/packages/services/src/cycle/cycle-operations.service.ts b/packages/services/src/cycle/cycle-operations.service.tsnew file mode 100644index 0000000000..3e6f32cd9a--- /dev/null+++ b/packages/services/src/cycle/cycle-operations.service.ts@@ -0,0 +1,70 @@+import { API_BASE_URL } from "@plane/constants";+import { APIService } from "@/api.service";++export class CycleOperationsService extends APIService {+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }++ /**+ * Adds a cycle to user favorites.+ * @param {string} workspaceSlug - The workspace identifier+ * @param {string} projectId - The project identifier+ * @param {{cycle: string}} data - The favorite cycle data+ * @returns {Promise<any>} The response data+ * @throws {Error} If the request fails+ */+ async addToFavorites(+ workspaceSlug: string,+ projectId: string,+ data: {+ cycle: string;+ }+ ): Promise<any> {+ return this.post(`/api/workspaces/${workspaceSlug}/projects/${projectId}/user-favorite-cycles/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Removes a cycle from user favorites.+ * @param {string} workspaceSlug - The workspace identifier+ * @param {string} projectId - The project identifier+ * @param {string} cycleId - The cycle identifier+ * @returns {Promise<any>} The removal response+ * @throws {Error} If the request fails+ */+ async removeFromFavorites(workspaceSlug: string, projectId: string, cycleId: string): Promise<any> {+ return this.delete(`/api/workspaces/${workspaceSlug}/projects/${projectId}/user-favorite-cycles/${cycleId}/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Transfers issues between cycles.+ * @param {string} workspaceSlug - The workspace identifier+ * @param {string} projectId - The project identifier+ * @param {string} cycleId - The source cycle identifier+ * @param {{new_cycle_id: string}} data - The target cycle data+ * @returns {Promise<any>} The transfer response+ * @throws {Error} If the request fails+ */+ async transferIssues(+ workspaceSlug: string,+ projectId: string,+ cycleId: string,+ data: {+ new_cycle_id: string;+ }+ ): Promise<any> {+ return this.post(`/api/workspaces/${workspaceSlug}/projects/${projectId}/cycles/${cycleId}/transfer-issues/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }+}diff --git a/packages/services/src/cycle/cycle.service.ts b/packages/services/src/cycle/cycle.service.tsnew file mode 100644index 0000000000..c697c2da4a--- /dev/null+++ b/packages/services/src/cycle/cycle.service.ts@@ -0,0 +1,184 @@+import { API_BASE_URL } from "@plane/constants";+import type { CycleDateCheckData, ICycle, TIssuesResponse, IWorkspaceActiveCyclesResponse } from "@plane/types";+import { APIService } from "@/api.service";++/**+ * Service class for managing cycles within a workspace and project context.+ * Extends APIService to handle HTTP requests to the cycle-related endpoints.+ * @extends {APIService}+ */+export class CycleService extends APIService {+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }++ /**+ * Retrieves paginated list of active cycles in a workspace.+ * @param {string} workspaceSlug - The workspace identifier+ * @param {string} cursor - The pagination cursor+ * @param {number} per_page - Number of items per page+ * @returns {Promise<IWorkspaceActiveCyclesResponse>} Paginated active cycles data+ * @throws {Error} If the request fails+ */+ async workspaceActiveCycles(+ workspaceSlug: string,+ cursor: string,+ per_page: number+ ): Promise<IWorkspaceActiveCyclesResponse> {+ return this.get(`/api/workspaces/${workspaceSlug}/active-cycles/`, {+ params: {+ per_page,+ cursor,+ },+ })+ .then((res) => res?.data)+ .catch((err) => {+ throw err?.response?.data;+ });+ }++ /**+ * Gets all cycles in a workspace.+ * @param {string} workspaceSlug - The workspace identifier+ * @returns {Promise<ICycle[]>} Array of cycle objects+ * @throws {Error} If the request fails+ */+ async getWorkspaceCycles(workspaceSlug: string): Promise<ICycle[]> {+ return this.get(`/api/workspaces/${workspaceSlug}/cycles/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Creates a new cycle in a project.+ * @param {string} workspaceSlug - The workspace identifier+ * @param {string} projectId - The project identifier+ * @param {any} data - The cycle creation data+ * @returns {Promise<ICycle>} The created cycle object+ * @throws {Error} If the request fails+ */+ async create(workspaceSlug: string, projectId: string, data: any): Promise<ICycle> {+ return this.post(`/api/workspaces/${workspaceSlug}/projects/${projectId}/cycles/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Retrieves cycles with optional filtering parameters.+ * @param {string} workspaceSlug - The workspace identifier+ * @param {string} projectId - The project identifier+ * @param {"current"} [cycleType] - Optional filter for cycle type+ * @returns {Promise<ICycle[]>} Array of filtered cycle objects+ * @throws {Error} If the request fails+ */+ async getWithParams(workspaceSlug: string, projectId: string, cycleType?: "current"): Promise<ICycle[]> {+ return this.get(`/api/workspaces/${workspaceSlug}/projects/${projectId}/cycles/`, {+ params: {+ cycle_view: cycleType,+ },+ })+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Retrieves detailed information for a specific cycle.+ * @param {string} workspaceSlug - The workspace identifier+ * @param {string} projectId - The project identifier+ * @param {string} cycleId - The cycle identifier+ * @returns {Promise<ICycle>} The cycle details+ * @throws {Error} If the request fails+ */+ async retrieve(workspaceSlug: string, projectId: string, cycleId: string): Promise<ICycle> {+ return this.get(`/api/workspaces/${workspaceSlug}/projects/${projectId}/cycles/${cycleId}/`)+ .then((res) => res?.data)+ .catch((err) => {+ throw err?.response?.data;+ });+ }++ /**+ * Retrieves issues associated with a specific cycle.+ * @param {string} workspaceSlug - The workspace identifier+ * @param {string} projectId - The project identifier+ * @param {string} cycleId - The cycle identifier+ * @param {any} [queries] - Optional query parameters+ * @param {object} [config={}] - Optional request configuration+ * @returns {Promise<TIssuesResponse>} The cycle issues data+ * @throws {Error} If the request fails+ */+ async getCycleIssues(+ workspaceSlug: string,+ projectId: string,+ cycleId: string,+ queries?: any,+ config = {}+ ): Promise<TIssuesResponse> {+ return this.get(+ `/api/workspaces/${workspaceSlug}/projects/${projectId}/cycles/${cycleId}/cycle-issues/`,+ {+ params: queries,+ },+ config+ )+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Updates a cycle with partial data.+ * @param {string} workspaceSlug - The workspace identifier+ * @param {string} projectId - The project identifier+ * @param {string} cycleId - The cycle identifier+ * @param {Partial<ICycle>} data - The partial cycle data to update+ * @returns {Promise<any>} The update response+ * @throws {Error} If the request fails+ */+ async update(workspaceSlug: string, projectId: string, cycleId: string, data: Partial<ICycle>): Promise<any> {+ return this.patch(`/api/workspaces/${workspaceSlug}/projects/${projectId}/cycles/${cycleId}/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Deletes a specific cycle.+ * @param {string} workspaceSlug - The workspace identifier+ * @param {string} projectId - The project identifier+ * @param {string} cycleId - The cycle identifier+ * @returns {Promise<any>} The deletion response+ * @throws {Error} If the request fails+ */+ async destroy(workspaceSlug: string, projectId: string, cycleId: string): Promise<any> {+ return this.delete(`/api/workspaces/${workspaceSlug}/projects/${projectId}/cycles/${cycleId}/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Validates cycle dates.+ * @param {string} workspaceSlug - The workspace identifier+ * @param {string} projectId - The project identifier+ * @param {CycleDateCheckData} data - The date check data+ * @returns {Promise<any>} The validation response+ * @throws {Error} If the request fails+ */+ async validateDates(workspaceSlug: string, projectId: string, data: CycleDateCheckData): Promise<any> {+ return this.post(`/api/workspaces/${workspaceSlug}/projects/${projectId}/cycles/date-check/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }+}diff --git a/packages/services/src/cycle/index.ts b/packages/services/src/cycle/index.tsnew file mode 100644index 0000000000..5956023cbd--- /dev/null+++ b/packages/services/src/cycle/index.ts@@ -0,0 +1,4 @@+export * from "./cycle-analytics.service";+export * from "./cycle-archive.service";+export * from "./cycle-operations.service";+export * from "./cycle.service";diff --git a/packages/services/src/dashboard/dashboard.service.ts b/packages/services/src/dashboard/dashboard.service.tsnew file mode 100644index 0000000000..6a4a6bcca7--- /dev/null+++ b/packages/services/src/dashboard/dashboard.service.ts@@ -0,0 +1,79 @@+import { API_BASE_URL } from "@plane/constants";+import { THomeDashboardResponse, TWidget, TWidgetStatsResponse, TWidgetStatsRequestParams } from "@plane/types";+import { APIService } from "../api.service";++export default class DashboardService extends APIService {+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }++ /**+ * Retrieves home dashboard widgets for a specific workspace+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @returns {Promise<THomeDashboardResponse>} Promise resolving to dashboard widget data+ * @throws {Error} If the API request fails+ */+ async getHomeWidgets(workspaceSlug: string): Promise<THomeDashboardResponse> {+ return this.get(`/api/workspaces/${workspaceSlug}/dashboard/`, {+ params: {+ dashboard_type: "home",+ },+ })+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Fetches statistics for a specific dashboard widget+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {string} dashboardId - The unique identifier for the dashboard+ * @param {TWidgetStatsRequestParams} params - Parameters for filtering widget statistics+ * @returns {Promise<TWidgetStatsResponse>} Promise resolving to widget statistics data+ * @throws {Error} If the API request fails+ */+ async getWidgetStats(+ workspaceSlug: string,+ dashboardId: string,+ params: TWidgetStatsRequestParams+ ): Promise<TWidgetStatsResponse> {+ return this.get(`/api/workspaces/${workspaceSlug}/dashboard/${dashboardId}/`, {+ params,+ })+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Retrieves detailed information about a specific dashboard+ * @param {string} dashboardId - The unique identifier for the dashboard+ * @returns {Promise<TWidgetStatsResponse>} Promise resolving to dashboard details+ * @throws {Error} If the API request fails+ */+ async retrieve(dashboardId: string): Promise<TWidgetStatsResponse> {+ return this.get(`/api/dashboard/${dashboardId}/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Updates a specific widget within a dashboard+ * @param {string} dashboardId - The unique identifier for the dashboard+ * @param {string} widgetId - The unique identifier for the widget+ * @param {Partial<TWidget>} data - Partial widget data to update+ * @returns {Promise<TWidget>} Promise resolving to the updated widget data+ * @throws {Error} If the API request fails+ */+ async updateWidget(dashboardId: string, widgetId: string, data: Partial<TWidget>): Promise<TWidget> {+ return this.patch(`/api/dashboard/${dashboardId}/widgets/${widgetId}/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }+}diff --git a/packages/services/src/dashboard/index.ts b/packages/services/src/dashboard/index.tsnew file mode 100644index 0000000000..79e3f04009--- /dev/null+++ b/packages/services/src/dashboard/index.ts@@ -0,0 +1 @@+export * from "./dashboard.service";diff --git a/packages/services/src/developer/api-token.service.ts b/packages/services/src/developer/api-token.service.tsnew file mode 100644index 0000000000..92ee523ea6--- /dev/null+++ b/packages/services/src/developer/api-token.service.ts@@ -0,0 +1,68 @@+import { API_BASE_URL } from "@plane/constants";+import { IApiToken } from "@plane/types";+import { APIService } from "@/api.service";++export class APITokenService extends APIService {+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }++ /**+ * Retrieves all API tokens for a specific workspace+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @returns {Promise<IApiToken[]>} Array of API tokens associated with the workspace+ * @throws {Error} Throws response data if the request fails+ */+ async list(workspaceSlug: string): Promise<IApiToken[]> {+ return this.get(`/api/workspaces/${workspaceSlug}/api-tokens/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Retrieves a specific API token by its ID+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {string} tokenId - The unique identifier of the API token+ * @returns {Promise<IApiToken>} The requested API token's details+ * @throws {Error} Throws response data if the request fails+ */+ async retrieve(workspaceSlug: string, tokenId: string): Promise<IApiToken> {+ return this.get(`/api/workspaces/${workspaceSlug}/api-tokens/${tokenId}`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Creates a new API token for a workspace+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {Partial<IApiToken>} data - The data for creating the new API token+ * @returns {Promise<IApiToken>} The newly created API token+ * @throws {Error} Throws response data if the request fails+ */+ async create(workspaceSlug: string, data: Partial<IApiToken>): Promise<IApiToken> {+ return this.post(`/api/workspaces/${workspaceSlug}/api-tokens/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Deletes a specific API token from the workspace+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {string} tokenId - The unique identifier of the API token to delete+ * @returns {Promise<IApiToken>} The deleted API token's details+ * @throws {Error} Throws response data if the request fails+ */+ async destroy(workspaceSlug: string, tokenId: string): Promise<IApiToken> {+ return this.delete(`/api/workspaces/${workspaceSlug}/api-tokens/${tokenId}`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }+}diff --git a/packages/services/src/developer/index.ts b/packages/services/src/developer/index.tsnew file mode 100644index 0000000000..a78a7b0929--- /dev/null+++ b/packages/services/src/developer/index.ts@@ -0,0 +1,2 @@+export * from "./api-token.service";+export * from "./webhook.service";diff --git a/packages/services/src/developer/webhook.service.ts b/packages/services/src/developer/webhook.service.tsnew file mode 100644index 0000000000..e48da3430b--- /dev/null+++ b/packages/services/src/developer/webhook.service.ts@@ -0,0 +1,104 @@+import { API_BASE_URL } from "@plane/constants";+import { IWebhook } from "@plane/types";+import { APIService } from "../api.service";++/**+ * Service class for managing webhooks+ * Handles CRUD operations for webhooks and secret key management+ * @extends {APIService}+ */+export default class WebhookService extends APIService {+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }++ /**+ * Retrieves all webhooks for a workspace+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @returns {Promise<IWebhook[]>} Promise resolving to array of webhooks+ * @throws {Error} If the API request fails+ */+ async list(workspaceSlug: string): Promise<IWebhook[]> {+ return this.get(`/api/workspaces/${workspaceSlug}/webhooks/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Retrieves details of a specific webhook+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @param {string} webhookId - The unique identifier for the webhook+ * @returns {Promise<IWebhook>} Promise resolving to webhook details+ * @throws {Error} If the API request fails+ */+ async retrieve(workspaceSlug: string, webhookId: string): Promise<IWebhook> {+ return this.get(`/api/workspaces/${workspaceSlug}/webhooks/${webhookId}/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Creates a new webhook in the workspace+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @param {Object} [data={}] - Webhook configuration data+ * @returns {Promise<IWebhook>} Promise resolving to the created webhook+ * @throws {Error} If the API request fails+ */+ async create(workspaceSlug: string, data = {}): Promise<IWebhook> {+ return this.post(`/api/workspaces/${workspaceSlug}/webhooks/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Updates an existing webhook+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @param {string} webhookId - The unique identifier for the webhook+ * @param {Object} [data={}] - Updated webhook configuration data+ * @returns {Promise<IWebhook>} Promise resolving to the updated webhook+ * @throws {Error} If the API request fails+ */+ async update(workspaceSlug: string, webhookId: string, data = {}): Promise<IWebhook> {+ return this.patch(`/api/workspaces/${workspaceSlug}/webhooks/${webhookId}/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Deletes a webhook from the workspace+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @param {string} webhookId - The unique identifier for the webhook+ * @returns {Promise<void>} Promise resolving when webhook is deleted+ * @throws {Error} If the API request fails+ */+ async destroy(workspaceSlug: string, webhookId: string): Promise<void> {+ return this.delete(`/api/workspaces/${workspaceSlug}/webhooks/${webhookId}/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Regenerates the secret key for a webhook+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @param {string} webhookId - The unique identifier for the webhook+ * @returns {Promise<IWebhook>} Promise resolving to the webhook with new secret key+ * @throws {Error} If the API request fails+ */+ async regenerateSecretKey(workspaceSlug: string, webhookId: string): Promise<IWebhook> {+ return this.post(`/api/workspaces/${workspaceSlug}/webhooks/${webhookId}/regenerate/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }+}diff --git a/packages/services/src/index.ts b/packages/services/src/index.tsnew file mode 100644index 0000000000..677aa28e7a--- /dev/null+++ b/packages/services/src/index.ts@@ -0,0 +1,12 @@+export * from "./ai";+export * from "./analytics";+export * from "./developer";+export * from "./auth";+export * from "./cycle";+export * from "./dashboard";+export * from "./instance";+export * from "./intake";+export * from "./module";+export * from "./user";+export * from "./project";+export * from "./workspace";diff --git a/packages/services/src/instance/index.ts b/packages/services/src/instance/index.tsnew file mode 100644index 0000000000..dd3d4a663c--- /dev/null+++ b/packages/services/src/instance/index.ts@@ -0,0 +1 @@+export * from "./instance.service";diff --git a/packages/services/src/instance/instance.service.ts b/packages/services/src/instance/instance.service.tsnew file mode 100644index 0000000000..0ffe451fbc--- /dev/null+++ b/packages/services/src/instance/instance.service.ts@@ -0,0 +1,44 @@+import { API_BASE_URL } from "@plane/constants";+import type { IInstanceInfo, TPage } from "@plane/types";+import { APIService } from "@/api.service";++/**+ * Service class for managing instance-related operations+ * Handles retrieval of instance information and changelog+ * @extends {APIService}+ */+export default class InstanceService extends APIService {+ /**+ * Creates an instance of InstanceService+ * Initializes the service with the base API URL+ */+ constructor() {+ super(API_BASE_URL);+ }++ /**+ * Retrieves information about the current instance+ * @returns {Promise<IInstanceInfo>} Promise resolving to instance information+ * @throws {Error} If the API request fails+ */+ async info(): Promise<IInstanceInfo> {+ return this.get("/api/instances/")+ .then((response) => response.data)+ .catch((error) => {+ throw error;+ });+ }++ /**+ * Fetches the changelog for the current instance+ * @returns {Promise<TPage>} Promise resolving to the changelog page data+ * @throws {Error} If the API request fails+ */+ async changelog(): Promise<TPage> {+ return this.get("/api/instances/changelog/")+ .then((response) => response.data)+ .catch((error) => {+ throw error;+ });+ }+}diff --git a/packages/services/src/intake/index.ts b/packages/services/src/intake/index.tsnew file mode 100644index 0000000000..cde9ddbd34--- /dev/null+++ b/packages/services/src/intake/index.ts@@ -0,0 +1,2 @@+export * from "./intake.service";+export * from "./issue.service";diff --git a/packages/services/src/intake/intake.service.ts b/packages/services/src/intake/intake.service.tsnew file mode 100644index 0000000000..1f7f722956--- /dev/null+++ b/packages/services/src/intake/intake.service.ts@@ -0,0 +1,8 @@+import { API_BASE_URL } from "@plane/constants";+import { APIService } from "@/api.service";++export default class IntakeService extends APIService {+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }+}diff --git a/packages/services/src/intake/issue.service.ts b/packages/services/src/intake/issue.service.tsnew file mode 100644index 0000000000..37e1f81dca--- /dev/null+++ b/packages/services/src/intake/issue.service.ts@@ -0,0 +1,18 @@+import { API_BASE_URL } from "@plane/constants";+import { APIService } from "@/api.service";++export default class IntakeIssueService extends APIService {+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }++ async list(workspaceSlug: string, projectId: string, params = {}) {+ return this.get(`/api/workspaces/${workspaceSlug}/projects/${projectId}/inbox-issues/`, {+ params,+ })+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }+}diff --git a/packages/services/src/live.service.ts b/packages/services/src/live.service.tsnew file mode 100644index 0000000000..ae4b80864c--- /dev/null+++ b/packages/services/src/live.service.ts@@ -0,0 +1,8 @@+import { API_BASE_URL } from "@plane/constants";+import { APIService } from "./api.service";++export abstract class LiveService extends APIService {+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }+}diff --git a/packages/services/src/module/index.ts b/packages/services/src/module/index.tsnew file mode 100644index 0000000000..8f08f92b83--- /dev/null+++ b/packages/services/src/module/index.ts@@ -0,0 +1,3 @@+export * from "./link.service";+export * from "./module.service";+export * from "./operations.service";diff --git a/packages/services/src/module/link.service.ts b/packages/services/src/module/link.service.tsnew file mode 100644index 0000000000..0caee9e198--- /dev/null+++ b/packages/services/src/module/link.service.ts@@ -0,0 +1,86 @@+// types+import type { ILinkDetails, ModuleLink } from "@plane/types";+// services+import { APIService } from "@/api.service";++/**+ * Service class for handling module link related operations.+ * Extends the base APIService class to interact with module link endpoints.+ */+export class ModuleLinkService extends APIService {+ /**+ * Creates an instance of ModuleLinkService.+ * @param {string} baseURL - The base URL for the API endpoints+ */+ constructor(baseURL: string) {+ super(baseURL);+ }++ /**+ * Creates a new module link.+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {string} projectId - The unique identifier for the project+ * @param {string} moduleId - The unique identifier for the module+ * @param {Partial<ModuleLink>} data - The module link data to be created+ * @returns {Promise<ILinkDetails>} The created module link details+ * @throws {Error} When the API request fails+ */+ async create(+ workspaceSlug: string,+ projectId: string,+ moduleId: string,+ data: Partial<ModuleLink>+ ): Promise<ILinkDetails> {+ return this.post(`/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/${moduleId}/module-links/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response;+ });+ }++ /**+ * Updates an existing module link.+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {string} projectId - The unique identifier for the project+ * @param {string} moduleId - The unique identifier for the module+ * @param {string} linkId - The unique identifier for the link to update+ * @param {Partial<ModuleLink>} data - The module link data to be updated+ * @returns {Promise<ILinkDetails>} The updated module link details+ * @throws {Error} When the API request fails+ */+ async update(+ workspaceSlug: string,+ projectId: string,+ moduleId: string,+ linkId: string,+ data: Partial<ModuleLink>+ ): Promise<ILinkDetails> {+ return this.patch(+ `/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/${moduleId}/module-links/${linkId}/`,+ data+ )+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response;+ });+ }++ /**+ * Deletes a module link.+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {string} projectId - The unique identifier for the project+ * @param {string} moduleId - The unique identifier for the module+ * @param {string} linkId - The unique identifier for the link to delete+ * @returns {Promise<any>} Response data from the server+ * @throws {Error} When the API request fails+ */+ async destroy(workspaceSlug: string, projectId: string, moduleId: string, linkId: string): Promise<any> {+ return this.delete(+ `/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/${moduleId}/module-links/${linkId}/`+ )+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }+}diff --git a/packages/services/src/module/module.service.ts b/packages/services/src/module/module.service.tsnew file mode 100644index 0000000000..1d1732aa91--- /dev/null+++ b/packages/services/src/module/module.service.ts@@ -0,0 +1,212 @@+// types+import type { IModule, ILinkDetails, ModuleLink, TIssuesResponse } from "@plane/types";+// services+import { APIService } from "@/api.service";++export class ModuleService extends APIService {+ constructor(baseURL: string) {+ super(baseURL);+ }++ async workspaceModulesList(workspaceSlug: string): Promise<IModule[]> {+ return this.get(`/api/workspaces/${workspaceSlug}/modules/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ async projectModulesList(workspaceSlug: string, projectId: string): Promise<IModule[]> {+ return this.get(`/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ async create(workspaceSlug: string, projectId: string, data: any): Promise<IModule> {+ return this.post(`/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ async retrieve(workspaceSlug: string, projectId: string, moduleId: string): Promise<IModule> {+ return this.get(`/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/${moduleId}/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ // async update(workspaceSlug: string, projectId: string, moduleId: string, data: any): Promise<any> {+ // return this.put(`/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/${moduleId}/`, data)+ // .then((response) => response?.data)+ // .catch((error) => {+ // throw error?.response?.data;+ // });+ // }++ async update(workspaceSlug: string, projectId: string, moduleId: string, data: Partial<IModule>): Promise<IModule> {+ return this.patch(`/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/${moduleId}/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ async destroy(workspaceSlug: string, projectId: string, moduleId: string): Promise<any> {+ return this.delete(`/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/${moduleId}/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ async getModuleIssues(+ workspaceSlug: string,+ projectId: string,+ moduleId: string,+ queries?: any,+ config = {}+ ): Promise<TIssuesResponse> {+ return this.get(+ `/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/${moduleId}/issues/`,+ {+ params: queries,+ },+ config+ )+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ async addIssuesToModule(+ workspaceSlug: string,+ projectId: string,+ moduleId: string,+ data: { issues: string[] }+ ): Promise<void> {+ return this.post(`/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/${moduleId}/issues/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ async addModulesToIssue(+ workspaceSlug: string,+ projectId: string,+ issueId: string,+ data: { modules: string[]; removed_modules?: string[] }+ ): Promise<void> {+ return this.post(`/api/workspaces/${workspaceSlug}/projects/${projectId}/issues/${issueId}/modules/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ async removeIssuesFromModuleBulk(+ workspaceSlug: string,+ projectId: string,+ moduleId: string,+ issueIds: string[]+ ): Promise<void> {+ const promiseDataUrls: any = [];+ issueIds.forEach((issueId) => {+ promiseDataUrls.push(+ this.delete(`/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/${moduleId}/issues/${issueId}/`)+ );+ });+ await Promise.all(promiseDataUrls)+ .then((response) => response)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ async removeModulesFromIssueBulk(+ workspaceSlug: string,+ projectId: string,+ issueId: string,+ moduleIds: string[]+ ): Promise<void> {+ const promiseDataUrls: any = [];+ moduleIds.forEach((moduleId) => {+ promiseDataUrls.push(+ this.delete(`/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/${moduleId}/issues/${issueId}/`)+ );+ });+ await Promise.all(promiseDataUrls)+ .then((response) => response)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ async createModuleLink(+ workspaceSlug: string,+ projectId: string,+ moduleId: string,+ data: Partial<ModuleLink>+ ): Promise<ILinkDetails> {+ return this.post(`/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/${moduleId}/module-links/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response;+ });+ }++ async updateModuleLink(+ workspaceSlug: string,+ projectId: string,+ moduleId: string,+ linkId: string,+ data: Partial<ModuleLink>+ ): Promise<ILinkDetails> {+ return this.patch(+ `/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/${moduleId}/module-links/${linkId}/`,+ data+ )+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response;+ });+ }++ async deleteModuleLink(workspaceSlug: string, projectId: string, moduleId: string, linkId: string): Promise<any> {+ return this.delete(+ `/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/${moduleId}/module-links/${linkId}/`+ )+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ async addModuleToFavorites(+ workspaceSlug: string,+ projectId: string,+ data: {+ module: string;+ }+ ): Promise<any> {+ return this.post(`/api/workspaces/${workspaceSlug}/projects/${projectId}/user-favorite-modules/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ async removeModuleFromFavorites(workspaceSlug: string, projectId: string, moduleId: string): Promise<any> {+ return this.delete(`/api/workspaces/${workspaceSlug}/projects/${projectId}/user-favorite-modules/${moduleId}/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }+}diff --git a/packages/services/src/module/operations.service.ts b/packages/services/src/module/operations.service.tsnew file mode 100644index 0000000000..b8fddb37d5--- /dev/null+++ b/packages/services/src/module/operations.service.ts@@ -0,0 +1,146 @@+// types+// import type { IModule, ILinkDetails, ModuleLink, TIssuesResponse } from "@plane/types";+// services+import { APIService } from "@/api.service";++export class ModuleOperationService extends APIService {+ constructor(baseURL: string) {+ super(baseURL);+ }++ /**+ * Add issues to a module+ * @param {string} workspaceSlug - The slug of the workspace+ * @param {string} projectId - The ID of the project+ * @param {string} moduleId - The ID of the module+ * @param {object} data - The data to be sent in the request body+ * @param {string[]} data.issues - The IDs of the issues to be added+ * @returns {Promise<void>}+ */+ async addIssuesToModule(+ workspaceSlug: string,+ projectId: string,+ moduleId: string,+ data: { issues: string[] }+ ): Promise<void> {+ return this.post(`/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/${moduleId}/issues/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Add modules to an issue+ * @param {string} workspaceSlug - The slug of the workspace+ * @param {string} projectId - The ID of the project+ * @param {string} issueId - The ID of the issue+ * @param {object} data - The data to be sent in the request body+ * @param {string[]} data.modules - The IDs of the modules to be added+ * @param {string[]} [data.removed_modules] - The IDs of the modules to be removed+ * @returns {Promise<void>}+ */+ async addModulesToIssue(+ workspaceSlug: string,+ projectId: string,+ issueId: string,+ data: { modules: string[]; removed_modules?: string[] }+ ): Promise<void> {+ return this.post(`/api/workspaces/${workspaceSlug}/projects/${projectId}/issues/${issueId}/modules/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Remove issues from a module+ * @param {string} workspaceSlug - The slug of the workspace+ * @param {string} projectId - The ID of the project+ * @param {string} moduleId - The ID of the module+ * @param {string[]} issueIds - The IDs of the issues to be removed+ * @returns {Promise<void>}+ */+ async removeIssuesFromModuleBulk(+ workspaceSlug: string,+ projectId: string,+ moduleId: string,+ issueIds: string[]+ ): Promise<void> {+ const promiseDataUrls: any = [];+ issueIds.forEach((issueId) => {+ promiseDataUrls.push(+ this.delete(`/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/${moduleId}/issues/${issueId}/`)+ );+ });+ await Promise.all(promiseDataUrls)+ .then((response) => response)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Remove modules from an issue+ * @param {string} workspaceSlug - The slug of the workspace+ * @param {string} projectId - The ID of the project+ * @param {string} issueId - The ID of the issue+ * @param {string[]} moduleIds - The IDs of the modules to be removed+ * @returns {Promise<void>}+ */+ async removeModulesFromIssueBulk(+ workspaceSlug: string,+ projectId: string,+ issueId: string,+ moduleIds: string[]+ ): Promise<void> {+ const promiseDataUrls: any = [];+ moduleIds.forEach((moduleId) => {+ promiseDataUrls.push(+ this.delete(`/api/workspaces/${workspaceSlug}/projects/${projectId}/modules/${moduleId}/issues/${issueId}/`)+ );+ });+ await Promise.all(promiseDataUrls)+ .then((response) => response)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Add a module to favorites+ * @param {string} workspaceSlug - The slug of the workspace+ * @param {string} projectId - The ID of the project+ * @param {object} data - The data to be sent in the request body+ * @param {string} data.module - The ID of the module to be added+ * @returns {Promise<any>}+ */+ async addModuleToFavorites(+ workspaceSlug: string,+ projectId: string,+ data: {+ module: string;+ }+ ): Promise<any> {+ return this.post(`/api/workspaces/${workspaceSlug}/projects/${projectId}/user-favorite-modules/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Remove a module from favorites+ * @param {string} workspaceSlug - The slug of the workspace+ * @param {string} projectId - The ID of the project+ * @param {string} moduleId - The ID of the module to be removed+ * @returns {Promise<any>}+ */+ async removeModuleFromFavorites(workspaceSlug: string, projectId: string, moduleId: string): Promise<any> {+ return this.delete(`/api/workspaces/${workspaceSlug}/projects/${projectId}/user-favorite-modules/${moduleId}/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }+}diff --git a/packages/services/src/project/index.ts b/packages/services/src/project/index.tsnew file mode 100644index 0000000000..6ec55d7f7a--- /dev/null+++ b/packages/services/src/project/index.ts@@ -0,0 +1 @@+export * from "./view.service";diff --git a/packages/services/src/project/view.service.ts b/packages/services/src/project/view.service.tsnew file mode 100644index 0000000000..e69de29bb2diff --git a/packages/services/src/user/favorite.service.ts b/packages/services/src/user/favorite.service.tsnew file mode 100644index 0000000000..7e838a3c6c--- /dev/null+++ b/packages/services/src/user/favorite.service.ts@@ -0,0 +1,94 @@+import { API_BASE_URL } from "@plane/constants";+import type { IFavorite } from "@plane/types";+import { APIService } from "@/api.service";++/**+ * Service class for managing user favorites+ * Handles operations for adding, updating, removing, and retrieving user favorites within a workspace+ * @extends {APIService}+ */+export class UserFavoriteService extends APIService {+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }++ /**+ * Adds a new item to user favorites+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @param {Partial<IFavorite>} data - Favorite item data to be added+ * @returns {Promise<IFavorite>} Promise resolving to the created favorite item+ * @throws {Error} If the API request fails+ */+ async add(workspaceSlug: string, data: Partial<IFavorite>): Promise<IFavorite> {+ return this.post(`/api/workspaces/${workspaceSlug}/user-favorites/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response;+ });+ }++ /**+ * Updates an existing favorite item+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @param {string} favoriteId - The unique identifier for the favorite item+ * @param {Partial<IFavorite>} data - Updated favorite item data+ * @returns {Promise<IFavorite>} Promise resolving to the updated favorite item+ * @throws {Error} If the API request fails+ */+ async update(workspaceSlug: string, favoriteId: string, data: Partial<IFavorite>): Promise<IFavorite> {+ return this.patch(`/api/workspaces/${workspaceSlug}/user-favorites/${favoriteId}/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response;+ });+ }++ /**+ * Removes an item from user favorites+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @param {string} favoriteId - The unique identifier for the favorite item to remove+ * @returns {Promise<void>} Promise resolving when the favorite item is removed+ * @throws {Error} If the API request fails+ */+ async remove(workspaceSlug: string, favoriteId: string): Promise<void> {+ return this.delete(`/api/workspaces/${workspaceSlug}/user-favorites/${favoriteId}/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response;+ });+ }++ /**+ * Retrieves all favorite items for a user in a workspace+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @returns {Promise<IFavorite[]>} Promise resolving to array of favorite items+ * @throws {Error} If the API request fails+ * @remarks This method includes the 'all' parameter to retrieve all favorites+ */+ async list(workspaceSlug: string): Promise<IFavorite[]> {+ return this.get(`/api/workspaces/${workspaceSlug}/user-favorites/`, {+ params: {+ all: true,+ },+ })+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Retrieves grouped favorite items for a specific favorite in a workspace+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @param {string} favoriteId - The unique identifier for the favorite item to get grouped items for+ * @returns {Promise<IFavorite[]>} Promise resolving to array of grouped favorite items+ * @throws {Error} If the API request fails+ */+ async groupedList(workspaceSlug: string, favoriteId: string): Promise<IFavorite[]> {+ return this.get(`/api/workspaces/${workspaceSlug}/user-favorites/${favoriteId}/group/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }+}diff --git a/packages/services/src/user/index.ts b/packages/services/src/user/index.tsnew file mode 100644index 0000000000..41df23a178--- /dev/null+++ b/packages/services/src/user/index.ts@@ -0,0 +1 @@+export * from "./favorite.service";diff --git a/packages/services/src/workspace/index.ts b/packages/services/src/workspace/index.tsnew file mode 100644index 0000000000..4076a51f52--- /dev/null+++ b/packages/services/src/workspace/index.ts@@ -0,0 +1,5 @@+export * from "./invitation.service";+export * from "./member.service";+export * from "./notification.service";+export * from "./view.service";+export * from "./workspace.service";diff --git a/packages/services/src/workspace/invitation.service.ts b/packages/services/src/workspace/invitation.service.tsnew file mode 100644index 0000000000..fa34460202--- /dev/null+++ b/packages/services/src/workspace/invitation.service.ts@@ -0,0 +1,117 @@+import { API_BASE_URL } from "@plane/constants";+import { IWorkspaceMemberInvitation, IWorkspaceBulkInviteFormData, IWorkspaceMember } from "@plane/types";+import { APIService } from "@/api.service";++/**+ * Service class for managing workspace invitations+ * Handles operations related to inviting users to workspaces and managing invitations+ * @extends {APIService}+ */+export class WorkspaceInvitationService extends APIService {+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }++ /**+ * Retrieves all workspace invitations for the current user+ * @returns {Promise<IWorkspaceMemberInvitation[]>} Promise resolving to array of workspace invitations+ * @throws {Error} If the API request fails+ */+ async userInvitations(): Promise<IWorkspaceMemberInvitation[]> {+ return this.get("/api/users/me/workspaces/invitations/")+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Retrieves all invitations for a specific workspace+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @returns {Promise<IWorkspaceMemberInvitation[]>} Promise resolving to array of workspace invitations+ * @throws {Error} If the API request fails+ */+ async workspaceInvitations(workspaceSlug: string): Promise<IWorkspaceMemberInvitation[]> {+ return this.get(`/api/workspaces/${workspaceSlug}/invitations/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Sends bulk invitations to users for a workspace+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @param {IWorkspaceBulkInviteFormData} data - Bulk invitation data containing user information+ * @returns {Promise<any>} Promise resolving to the invitation response+ * @throws {Error} If the API request fails+ */+ async invite(workspaceSlug: string, data: IWorkspaceBulkInviteFormData): Promise<any> {+ return this.post(`/api/workspaces/${workspaceSlug}/invitations/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Update Invitation+ * @param workspaceSlug+ * @param invitationId+ * @param data+ * @returns+ */+ async update(workspaceSlug: string, invitationId: string, data: Partial<IWorkspaceMember>): Promise<any> {+ return this.patch(`/api/workspaces/${workspaceSlug}/invitations/${invitationId}/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Delete Workspace invitation+ * @param workspaceSlug+ * @param invitationId+ * @returns+ */+ async destroy(workspaceSlug: string, invitationId: string): Promise<any> {+ return this.delete(`/api/workspaces/${workspaceSlug}/invitations/${invitationId}/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Accepts an invitation to join a workspace+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @param {string} invitationId - The unique identifier for the invitation+ * @param {any} data - Additional data required for joining the workspace+ * @returns {Promise<any>} Promise resolving to the join response+ * @throws {Error} If the API request fails+ */+ async join(workspaceSlug: string, invitationId: string, data: any): Promise<any> {+ return this.post(`/api/workspaces/${workspaceSlug}/invitations/${invitationId}/join/`, data, {+ headers: {},+ })+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Accepts multiple workspace invitations at once+ * @param {any} data - Data containing information about invitations to accept+ * @returns {Promise<any>} Promise resolving to the bulk join response+ * @throws {Error} If the API request fails+ */+ async joinMany(data: any): Promise<any> {+ return this.post("/api/users/me/workspaces/invitations/", data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }+}diff --git a/packages/services/src/workspace/member.service.ts b/packages/services/src/workspace/member.service.tsnew file mode 100644index 0000000000..e92225af38--- /dev/null+++ b/packages/services/src/workspace/member.service.ts@@ -0,0 +1,92 @@+import { API_BASE_URL } from "@plane/constants";+import { IWorkspaceMemberMe, IWorkspaceMember, IUserProjectsRole } from "@plane/types";+import { APIService } from "../api.service";++/**+ * Service class for managing workspace members+ * Handles operations related to workspace membership, including member information,+ * updates, deletions, and role management+ * @extends {APIService}+ */+export class WorkspaceMemberService extends APIService {+ /**+ * Creates an instance of WorkspaceMemberService+ * @param {string} baseUrl - The base URL for API requests+ */+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }++ /**+ * Retrieves current user's information for a specific workspace+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @returns {Promise<IWorkspaceMemberMe>} Promise resolving to current user's workspace member information+ * @throws {Error} If the API request fails+ */+ async myInfo(workspaceSlug: string): Promise<IWorkspaceMemberMe> {+ return this.get(`/api/workspaces/${workspaceSlug}/workspace-members/me/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response;+ });+ }++ /**+ * Retrieves all members of a specific workspace+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @returns {Promise<IWorkspaceMember[]>} Promise resolving to array of workspace members+ * @throws {Error} If the API request fails+ */+ async list(workspaceSlug: string): Promise<IWorkspaceMember[]> {+ return this.get(`/api/workspaces/${workspaceSlug}/members/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Updates a workspace member's information+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @param {string} memberId - The unique identifier for the member+ * @param {Partial<IWorkspaceMember>} data - Updated member data+ * @returns {Promise<IWorkspaceMember>} Promise resolving to the updated member information+ * @throws {Error} If the API request fails+ */+ async update(workspaceSlug: string, memberId: string, data: Partial<IWorkspaceMember>): Promise<IWorkspaceMember> {+ return this.patch(`/api/workspaces/${workspaceSlug}/members/${memberId}/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Removes a member from a workspace+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @param {string} memberId - The unique identifier for the member to remove+ * @returns {Promise<any>} Promise resolving to the deletion response+ * @throws {Error} If the API request fails+ */+ async destroy(workspaceSlug: string, memberId: string): Promise<any> {+ return this.delete(`/api/workspaces/${workspaceSlug}/members/${memberId}/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Retrieves the current user's project roles within a workspace+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @returns {Promise<IUserProjectsRole>} Promise resolving to user's project roles+ * @throws {Error} If the API request fails+ */+ async getWorkspaceUserProjectsRole(workspaceSlug: string): Promise<IUserProjectsRole> {+ return this.get(`/api/users/me/workspaces/${workspaceSlug}/project-roles/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }+}diff --git a/packages/services/src/workspace/notification.service.ts b/packages/services/src/workspace/notification.service.tsnew file mode 100644index 0000000000..a21f632222--- /dev/null+++ b/packages/services/src/workspace/notification.service.ts@@ -0,0 +1,137 @@+import { API_BASE_URL } from "@plane/constants";+import {+ TUnreadNotificationsCount,+ TNotificationPaginatedInfo,+ TNotification,+ TNotificationPaginatedInfoQueryParams,+} from "@plane/types";+// services+import { APIService } from "../api.service";++export class WorkspaceNotificationService extends APIService {+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }++ /**+ * Retrieves the count of unread notifications for a workspace+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @returns {Promise<TUnreadNotificationsCount | undefined>} The count of unread notifications+ */+ async getUnreadCount(workspaceSlug: string): Promise<TUnreadNotificationsCount | undefined> {+ return this.get(`/api/workspaces/${workspaceSlug}/users/notifications/unread/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Retrieves paginated notifications for a workspace+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {TNotificationPaginatedInfoQueryParams} params - Query parameters for pagination and filtering+ * @returns {Promise<TNotificationPaginatedInfo | undefined>} Paginated list of notifications+ */+ async list(+ workspaceSlug: string,+ params: TNotificationPaginatedInfoQueryParams+ ): Promise<TNotificationPaginatedInfo | undefined> {+ return this.get(`/api/workspaces/${workspaceSlug}/users/notifications`, { params })+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Updates a specific notification by ID+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {string} notificationId - The unique identifier for the notification+ * @param {Partial<TNotification>} data - The notification data to update+ * @returns {Promise<TNotification | undefined>} The updated notification+ */+ async update(+ workspaceSlug: string,+ notificationId: string,+ data: Partial<TNotification>+ ): Promise<TNotification | undefined> {+ return this.patch(`/api/workspaces/${workspaceSlug}/users/notifications/${notificationId}/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Marks a notification as read+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {string} notificationId - The unique identifier for the notification+ * @returns {Promise<TNotification | undefined>} The updated notification+ */+ async markAsRead(workspaceSlug: string, notificationId: string): Promise<TNotification | undefined> {+ return this.post(`/api/workspaces/${workspaceSlug}/users/notifications/${notificationId}/read/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Marks a notification as unread+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {string} notificationId - The unique identifier for the notification+ * @returns {Promise<TNotification | undefined>} The updated notification+ */+ async markAsUnread(workspaceSlug: string, notificationId: string): Promise<TNotification | undefined> {+ return this.delete(`/api/workspaces/${workspaceSlug}/users/notifications/${notificationId}/read/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Archives a notification+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {string} notificationId - The unique identifier for the notification+ * @returns {Promise<TNotification | undefined>} The updated notification+ */+ async archive(workspaceSlug: string, notificationId: string): Promise<TNotification | undefined> {+ return this.post(`/api/workspaces/${workspaceSlug}/users/notifications/${notificationId}/archive/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Unarchives a notification+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {string} notificationId - The unique identifier for the notification+ * @returns {Promise<TNotification | undefined>} The updated notification+ */+ async unarchive(workspaceSlug: string, notificationId: string): Promise<TNotification | undefined> {+ return this.delete(`/api/workspaces/${workspaceSlug}/users/notifications/${notificationId}/archive/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Marks all notifications as read based on filter criteria+ * @param {string} workspaceSlug - The unique identifier for the workspace+ * @param {TNotificationPaginatedInfoQueryParams} data - Filter criteria for notifications to mark as read+ * @returns {Promise<TNotification | undefined>} The result of the operation+ */+ async markAllAsRead(+ workspaceSlug: string,+ data: TNotificationPaginatedInfoQueryParams+ ): Promise<TNotification | undefined> {+ return this.post(`/api/workspaces/${workspaceSlug}/users/notifications/mark-all-read/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }+}diff --git a/packages/services/src/workspace/view.service.ts b/packages/services/src/workspace/view.service.tsnew file mode 100644index 0000000000..ca782d4335--- /dev/null+++ b/packages/services/src/workspace/view.service.ts@@ -0,0 +1,67 @@+import { API_BASE_URL } from "@plane/constants";+import { IWorkspaceView, TIssuesResponse } from "@plane/types";+import { APIService } from "@/api.service";++export class WorkspaceViewService extends APIService {+ /**+ * Creates an instance of WorkspaceViewService+ * @param {string} baseUrl - The base URL for API requests+ */+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }++ async create(workspaceSlug: string, data: Partial<IWorkspaceView>): Promise<IWorkspaceView> {+ return this.post(`/api/workspaces/${workspaceSlug}/views/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ async update(workspaceSlug: string, viewId: string, data: Partial<IWorkspaceView>): Promise<IWorkspaceView> {+ return this.patch(`/api/workspaces/${workspaceSlug}/views/${viewId}/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ async destroy(workspaceSlug: string, viewId: string): Promise<any> {+ return this.delete(`/api/workspaces/${workspaceSlug}/views/${viewId}/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ async list(workspaceSlug: string): Promise<IWorkspaceView[]> {+ return this.get(`/api/workspaces/${workspaceSlug}/views/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ async retrieve(workspaceSlug: string, viewId: string): Promise<IWorkspaceView> {+ return this.get(`/api/workspaces/${workspaceSlug}/views/${viewId}/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ async getViewIssues(workspaceSlug: string, params: any, config = {}): Promise<TIssuesResponse> {+ return this.get(+ `/api/workspaces/${workspaceSlug}/issues/`,+ {+ params,+ },+ config+ )+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }+}diff --git a/packages/services/src/workspace/workspace.service.ts b/packages/services/src/workspace/workspace.service.tsnew file mode 100644index 0000000000..72ef9fcefd--- /dev/null+++ b/packages/services/src/workspace/workspace.service.ts@@ -0,0 +1,141 @@+import { API_BASE_URL } from "@plane/constants";+import { IWorkspace, ILastActiveWorkspaceDetails, IWorkspaceSearchResults } from "@plane/types";+import { APIService } from "../api.service";++/**+ * Service class for managing workspace operations+ * Handles CRUD operations and various workspace-related functionalities+ * @extends {APIService}+ */+export class WorkspaceService extends APIService {+ /**+ * Creates an instance of WorkspaceService+ * @param {string} baseUrl - The base URL for API requests+ */+ constructor(BASE_URL?: string) {+ super(BASE_URL || API_BASE_URL);+ }+ /**+ * Retrieves all workspaces for the current user+ * @returns {Promise<IWorkspace[]>} Promise resolving to an array of workspaces+ * @throws {Error} If the API request fails+ */+ async list(): Promise<IWorkspace[]> {+ return this.get("/api/users/me/workspaces/")+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Retrieves details of a specific workspace+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @returns {Promise<IWorkspace>} Promise resolving to workspace details+ * @throws {Error} If the API request fails+ */+ async retrieve(workspaceSlug: string): Promise<IWorkspace> {+ return this.get(`/api/workspaces/${workspaceSlug}/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response;+ });+ }++ /**+ * Creates a new workspace+ * @param {Partial<IWorkspace>} data - Workspace data for creation+ * @returns {Promise<IWorkspace>} Promise resolving to the created workspace+ * @throws {Error} If the API request fails+ */+ async create(data: Partial<IWorkspace>): Promise<IWorkspace> {+ return this.post("/api/workspaces/", data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Updates an existing workspace+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @param {Partial<IWorkspace>} data - Updated workspace data+ * @returns {Promise<IWorkspace>} Promise resolving to the updated workspace+ * @throws {Error} If the API request fails+ */+ async update(workspaceSlug: string, data: Partial<IWorkspace>): Promise<IWorkspace> {+ return this.patch(`/api/workspaces/${workspaceSlug}/`, data)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Deletes a workspace+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @returns {Promise<any>} Promise resolving to the deletion response+ * @throws {Error} If the API request fails+ */+ async destroy(workspaceSlug: string): Promise<any> {+ return this.delete(`/api/workspaces/${workspaceSlug}/`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Retrieves information about the user's last visited workspace+ * @returns {Promise<ILastActiveWorkspaceDetails>} Promise resolving to last active workspace details+ * @throws {Error} If the API request fails+ */+ async lastVisited(): Promise<ILastActiveWorkspaceDetails> {+ return this.get("/api/users/last-visited-workspace/")+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Checks if a workspace slug is available+ * @param {string} slug - The workspace slug to check+ * @returns {Promise<any>} Promise resolving to slug availability status+ * @throws {Error} If the API request fails+ */+ async slugCheck(slug: string): Promise<any> {+ return this.get(`/api/workspace-slug-check/?slug=${slug}`)+ .then((response) => response?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }++ /**+ * Searches within a workspace+ * @param {string} workspaceSlug - The unique slug identifier for the workspace+ * @param {Object} params - Search parameters+ * @param {string} [params.project_id] - Optional project ID to scope the search+ * @param {string} params.search - Search query string+ * @param {boolean} params.workspace_search - Whether to search across the entire workspace+ * @returns {Promise<IWorkspaceSearchResults>} Promise resolving to search results+ * @throws {Error} If the API request fails+ */+ async search(+ workspaceSlug: string,+ params: {+ project_id?: string;+ search: string;+ workspace_search: boolean;+ }+ ): Promise<IWorkspaceSearchResults> {+ return this.get(`/api/workspaces/${workspaceSlug}/search/`, {+ params,+ })+ .then((res) => res?.data)+ .catch((error) => {+ throw error?.response?.data;+ });+ }+}diff --git a/packages/services/tsconfig.json b/packages/services/tsconfig.jsonnew file mode 100644index 0000000000..0c2f64d1a8--- /dev/null+++ b/packages/services/tsconfig.json@@ -0,0 +1,12 @@+{+ "extends": "@plane/typescript-config/react-library.json",+ "compilerOptions": {+ "jsx": "react",+ "lib": ["esnext", "dom"],+ "paths": {+ "@/*": ["./src/*"]+ }+ },+ "include": ["./src"],+ "exclude": ["dist", "build", "node_modules"]+}