@abyss-project/tools 1.0.0

package/src/index.ts

@@ -0,0 +1,541 @@
+import axios from 'axios';
+import axiosRetry, { IAxiosRetryConfig, isNetworkOrIdempotentRequestError } from 'axios-retry';
+import * as abyssAdminApi from './api/abyss.admin.api';
+import * as boardApi from './api/board.api';
+import * as boardColumnApi from './api/board-column.api';
+import * as boardCardApi from './api/board-card.api';
+import * as boardLabelApi from './api/board-label.api';
+import * as boardCardCommentApi from './api/board-card-comment.api';
+import * as boardCardChecklistApi from './api/board-card-checklist.api';
+import * as boardCardDocumentApi from './api/board-card-document.api';
+import * as drawApi from './api/draw.api';
+import * as drawPublicApi from './api/draw.public.api';
+import * as retrospectiveApi from './api/retrospective.api';
+import * as retrospectiveCardApi from './api/retrospective-card.api';
+import * as retrospectiveMemberApi from './api/retrospective-member.api';
+import * as retrospectiveSectionApi from './api/retrospective-section.api';
+import * as retrospectivePublicApi from './api/retrospective.public.api';
+import * as atlasApi from './api/atlas.api';
+import * as atlasGroupApi from './api/atlas-group.api';
+import * as atlasPageApi from './api/atlas-page.api';
+import * as atlasDocumentApi from './api/atlas-document.api';
+import * as atlasPublicApi from './api/atlas.public.api';
+import * as memoApi from './api/memo.api';
+import * as shortLinkApiModule from './api/short-link.api';
+import * as shortLinkAdminApiModule from './api/short-link.admin.api';
+import * as shortLinkPublicApiModule from './api/short-link.public.api';
+import * as metricsApi from './api/metrics.api';
+import * as userTagApi from './api/user-tag.api';
+
+export * from './api';
+export * from './types';
+export * from './utils';
+export * from './constants';
+export * from './server-sent-events';
+
+const DEFAULT_BASE_URL = 'https://tools-api.abyss-project.fr/api/';
+
+export const API_KEY_HEADER = 'abyss-tools-api-key';
+export const ADMIN_TOKEN_HEADER = 'abyss-admin-token';
+
+const NUMBER_RETRY_API = 10;
+const BASE_DELAY_BETWEEN_RETRY = 5000;
+const RETRY_CODES = [
+  502, // Bad Gateway
+  503, // Service Unavailable
+];
+
+type CoreConfig = {
+  token?: string;
+  apiKey?: string;
+  adminToken?: string;
+  baseURL?: string;
+};
+
+type AbyssToolsCoreSDK = {
+  abyss: {
+    admin: {
+      activateUserService: typeof abyssAdminApi.activateUserServiceAbyssAdmin;
+      deleteUser: typeof abyssAdminApi.deleteUserAbyssAdmin;
+      syncOrganization: typeof abyssAdminApi.syncOrganizationAbyssAdmin;
+      deleteOrganization: typeof abyssAdminApi.deleteOrganizationAbyssAdmin;
+      syncProject: typeof abyssAdminApi.syncProjectAbyssAdmin;
+      deleteProject: typeof abyssAdminApi.deleteProjectAbyssAdmin;
+    };
+  };
+  board: {
+    getBoard: typeof boardApi.getBoard;
+    getBySlugBoard: typeof boardApi.getBySlugBoard;
+    listBoard: typeof boardApi.listBoard;
+    listBoardProject: typeof boardApi.listBoardProject;
+    deleteBoard: typeof boardApi.deleteBoard;
+    updateBoard: typeof boardApi.updateBoard;
+    createBoard: typeof boardApi.createBoard;
+    createForProjectBoard: typeof boardApi.createForProjectBoard;
+    getNextCardPreviewBoard: typeof boardApi.getNextCardPreviewBoard;
+  };
+  boardColumn: {
+    getBoardColumn: typeof boardColumnApi.getBoardColumn;
+    deleteBoardColumn: typeof boardColumnApi.deleteBoardColumn;
+    updateBoardColumn: typeof boardColumnApi.updateBoardColumn;
+    createBoardColumn: typeof boardColumnApi.createBoardColumn;
+  };
+  boardCard: {
+    getBoardCard: typeof boardCardApi.getBoardCard;
+    getAllBoardCard: typeof boardCardApi.getAllBoardCard;
+    deleteBoardCard: typeof boardCardApi.deleteBoardCard;
+    updateBoardCard: typeof boardCardApi.updateBoardCard;
+    restoreBoardCard: typeof boardCardApi.restoreBoardCard;
+    createBoardCard: typeof boardCardApi.createBoardCard;
+    addMemberBoardCard: typeof boardCardApi.addMemberBoardCard;
+    removeMemberBoardCard: typeof boardCardApi.removeMemberBoardCard;
+    moveToBoardBoardCard: typeof boardCardApi.moveToBoardBoardCard;
+    searchBoardCard: typeof boardCardApi.searchBoardCard;
+  };
+  boardLabel: {
+    getBoardLabel: typeof boardLabelApi.getBoardLabel;
+    deleteBoardLabel: typeof boardLabelApi.deleteBoardLabel;
+    updateBoardLabel: typeof boardLabelApi.updateBoardLabel;
+    createBoardLabel: typeof boardLabelApi.createBoardLabel;
+    addBoardLabel: typeof boardLabelApi.addBoardLabel;
+    removeBoardLabel: typeof boardLabelApi.removeBoardLabel;
+    listBoardLabels: typeof boardLabelApi.listBoardLabels;
+  };
+  boardCardComment: {
+    getBoardCardComment: typeof boardCardCommentApi.getBoardCardComment;
+    deleteBoardCardComment: typeof boardCardCommentApi.deleteBoardCardComment;
+    updateBoardCardComment: typeof boardCardCommentApi.updateBoardCardComment;
+    createBoardCardComment: typeof boardCardCommentApi.createBoardCardComment;
+  };
+  boardCardChecklist: {
+    getBoardCardChecklist: typeof boardCardChecklistApi.getBoardCardChecklist;
+    deleteBoardCardChecklist: typeof boardCardChecklistApi.deleteBoardCardChecklist;
+    updateBoardCardChecklist: typeof boardCardChecklistApi.updateBoardCardChecklist;
+    createBoardCardChecklist: typeof boardCardChecklistApi.createBoardCardChecklist;
+    addRowBoardCardChecklist: typeof boardCardChecklistApi.addRowBoardCardChecklist;
+    removeRowBoardCardChecklist: typeof boardCardChecklistApi.removeRowBoardCardChecklist;
+    updateRowBoardCardChecklist: typeof boardCardChecklistApi.updateRowBoardCardChecklist;
+  };
+  boardCardDocument: {
+    getBoardCardDocument: typeof boardCardDocumentApi.getBoardCardDocument;
+    deleteBoardCardDocument: typeof boardCardDocumentApi.deleteBoardCardDocument;
+    getUploadPreSignedUrlBoardCardDocument: typeof boardCardDocumentApi.getUploadPreSignedUrlBoardCardDocument;
+    cloudImportBoardCardDocument: typeof boardCardDocumentApi.cloudImportBoardCardDocument;
+  };
+  draw: {
+    paginateDraw: typeof drawApi.paginateDraw;
+    paginateProjectDraw: typeof drawApi.paginateProjectDraw;
+    getDraw: typeof drawApi.getDraw;
+    deleteDraw: typeof drawApi.deleteDraw;
+    updateDraw: typeof drawApi.updateDraw;
+    createDraw: typeof drawApi.createDraw;
+    createForProjectDraw: typeof drawApi.createForProjectDraw;
+    public: {
+      getDrawPublic: typeof drawPublicApi.getDrawPublic;
+      deleteDrawPublic: typeof drawPublicApi.deleteDrawPublic;
+      updateDrawPublic: typeof drawPublicApi.updateDrawPublic;
+      createDrawPublic: typeof drawPublicApi.createDrawPublic;
+    };
+  };
+  retrospective: {
+    getRetrospective: typeof retrospectiveApi.getRetrospective;
+    paginateProjectRetrospective: typeof retrospectiveApi.paginateProjectRetrospective;
+    paginateRetrospective: typeof retrospectiveApi.paginateRetrospective;
+    createForProjectRetrospective: typeof retrospectiveApi.createForProjectRetrospective;
+    createRetrospective: typeof retrospectiveApi.createRetrospective;
+    updateRetrospective: typeof retrospectiveApi.updateRetrospective;
+    deleteRetrospective: typeof retrospectiveApi.deleteRetrospective;
+    public: {
+      getRetrospectivePublic: typeof retrospectivePublicApi.getRetrospectivePublic;
+      updateRetrospectivePublic: typeof retrospectivePublicApi.updateRetrospectivePublic;
+      createSectionRetrospectivePublic: typeof retrospectivePublicApi.createSectionRetrospectivePublic;
+      updateSectionRetrospectivePublic: typeof retrospectivePublicApi.updateSectionRetrospectivePublic;
+      deleteSectionRetrospectivePublic: typeof retrospectivePublicApi.deleteSectionRetrospectivePublic;
+      joinMemberRetrospectivePublic: typeof retrospectivePublicApi.joinMemberRetrospectivePublic;
+      updateMemberRetrospectivePublic: typeof retrospectivePublicApi.updateMemberRetrospectivePublic;
+      createCardRetrospectivePublic: typeof retrospectivePublicApi.createCardRetrospectivePublic;
+      updateCardRetrospectivePublic: typeof retrospectivePublicApi.updateCardRetrospectivePublic;
+      deleteCardRetrospectivePublic: typeof retrospectivePublicApi.deleteCardRetrospectivePublic;
+    };
+  };
+  retrospectiveCard: {
+    getRetrospectiveCard: typeof retrospectiveCardApi.getRetrospectiveCard;
+    paginateRetrospectiveCard: typeof retrospectiveCardApi.paginateRetrospectiveCard;
+    createRetrospectiveCard: typeof retrospectiveCardApi.createRetrospectiveCard;
+    updateRetrospectiveCard: typeof retrospectiveCardApi.updateRetrospectiveCard;
+    deleteRetrospectiveCard: typeof retrospectiveCardApi.deleteRetrospectiveCard;
+  };
+  retrospectiveMember: {
+    getRetrospectiveMember: typeof retrospectiveMemberApi.getRetrospectiveMember;
+    listRetrospectiveMember: typeof retrospectiveMemberApi.listRetrospectiveMember;
+    joinRetrospectiveMember: typeof retrospectiveMemberApi.joinRetrospectiveMember;
+    updateRetrospectiveMember: typeof retrospectiveMemberApi.updateRetrospectiveMember;
+  };
+  retrospectiveSection: {
+    getRetrospectiveSection: typeof retrospectiveSectionApi.getRetrospectiveSection;
+    paginateRetrospectiveSection: typeof retrospectiveSectionApi.paginateRetrospectiveSection;
+    createRetrospectiveSection: typeof retrospectiveSectionApi.createRetrospectiveSection;
+    updateRetrospectiveSection: typeof retrospectiveSectionApi.updateRetrospectiveSection;
+    deleteRetrospectiveSection: typeof retrospectiveSectionApi.deleteRetrospectiveSection;
+  };
+  atlas: {
+    paginateAtlas: typeof atlasApi.paginateAtlas;
+    paginateProjectAtlas: typeof atlasApi.paginateProjectAtlas;
+    getAtlas: typeof atlasApi.getAtlas;
+    deleteAtlas: typeof atlasApi.deleteAtlas;
+    updateAtlas: typeof atlasApi.updateAtlas;
+    createAtlas: typeof atlasApi.createAtlas;
+    createForProjectAtlas: typeof atlasApi.createForProjectAtlas;
+    public: {
+      getAtlasPublic: typeof atlasPublicApi.getAtlasPublic;
+      getPageAtlasPublic: typeof atlasPublicApi.getPageAtlasPublic;
+      searchContentAtlasPublic: typeof atlasPublicApi.searchContentAtlasPublic;
+    };
+  };
+  atlasGroup: {
+    paginateAtlasGroup: typeof atlasGroupApi.paginateAtlasGroup;
+    getAtlasGroup: typeof atlasGroupApi.getAtlasGroup;
+    deleteAtlasGroup: typeof atlasGroupApi.deleteAtlasGroup;
+    updateAtlasGroup: typeof atlasGroupApi.updateAtlasGroup;
+    createAtlasGroup: typeof atlasGroupApi.createAtlasGroup;
+  };
+  atlasPage: {
+    paginateAtlasPage: typeof atlasPageApi.paginateAtlasPage;
+    getAtlasPage: typeof atlasPageApi.getAtlasPage;
+    deleteAtlasPage: typeof atlasPageApi.deleteAtlasPage;
+    updateAtlasPage: typeof atlasPageApi.updateAtlasPage;
+    createAtlasPage: typeof atlasPageApi.createAtlasPage;
+    updateAtlasPageContent: typeof atlasPageApi.updateAtlasPageContent;
+    searchAtlasContent: typeof atlasPageApi.searchAtlasContent;
+    getAtlasPageContentHistory: typeof atlasPageApi.getAtlasPageContentHistory;
+    restoreAtlasPageContent: typeof atlasPageApi.restoreAtlasPageContent;
+  };
+  atlasDocument: {
+    getAtlasDocument: typeof atlasDocumentApi.getAtlasDocument;
+    deleteAtlasDocument: typeof atlasDocumentApi.deleteAtlasDocument;
+    getUploadPreSignedUrlAtlasDocument: typeof atlasDocumentApi.getUploadPreSignedUrlAtlasDocument;
+    paginateAtlasDocument: typeof atlasDocumentApi.paginateAtlasDocument;
+    listAtlasDocument: typeof atlasDocumentApi.listAtlasDocument;
+  };
+  memo: {
+    paginateMemo: typeof memoApi.paginateMemo;
+    paginateProjectMemo: typeof memoApi.paginateProjectMemo;
+    getMemo: typeof memoApi.getMemo;
+    deleteMemo: typeof memoApi.deleteMemo;
+    updateMemo: typeof memoApi.updateMemo;
+    createMemo: typeof memoApi.createMemo;
+    createForProjectMemo: typeof memoApi.createForProjectMemo;
+  };
+  shortLink: {
+    get: typeof shortLinkApiModule.shortLinkApi.get;
+    paginate: typeof shortLinkApiModule.shortLinkApi.paginate;
+    paginateProject: typeof shortLinkApiModule.shortLinkApi.paginateProject;
+    create: typeof shortLinkApiModule.shortLinkApi.create;
+    createForProject: typeof shortLinkApiModule.shortLinkApi.createForProject;
+    update: typeof shortLinkApiModule.shortLinkApi.update;
+    delete: typeof shortLinkApiModule.shortLinkApi.delete;
+    getStats: typeof shortLinkApiModule.shortLinkApi.getStats;
+    getClicks: typeof shortLinkApiModule.shortLinkApi.getClicks;
+    admin: {
+      paginate: typeof shortLinkAdminApiModule.shortLinkAdminApi.paginate;
+      get: typeof shortLinkAdminApiModule.shortLinkAdminApi.get;
+      update: typeof shortLinkAdminApiModule.shortLinkAdminApi.update;
+      delete: typeof shortLinkAdminApiModule.shortLinkAdminApi.delete;
+    };
+    public: {
+      createAnonymous: typeof shortLinkPublicApiModule.shortLinkPublicApi.createAnonymous;
+      redirect: typeof shortLinkPublicApiModule.shortLinkPublicApi.redirect;
+      getStats: typeof shortLinkPublicApiModule.shortLinkPublicApi.getStats;
+      getClicks: typeof shortLinkPublicApiModule.shortLinkPublicApi.getClicks;
+      renew: typeof shortLinkPublicApiModule.shortLinkPublicApi.renew;
+    };
+  };
+  metrics: {
+    getOrganizationToolsMetrics: typeof metricsApi.getOrganizationToolsMetrics;
+  };
+  userTag: {
+    listUserTag: typeof userTagApi.listUserTag;
+    createUserTag: typeof userTagApi.createUserTag;
+    updateUserTag: typeof userTagApi.updateUserTag;
+    deleteUserTag: typeof userTagApi.deleteUserTag;
+    assignTag: typeof userTagApi.assignTag;
+    unassignTag: typeof userTagApi.unassignTag;
+    getUserTagStats: typeof userTagApi.getUserTagStats;
+    getEntityTags: typeof userTagApi.getEntityTags;
+  };
+};
+
+export class AbyssToolsCore {
+  private static config = {
+    token: '',
+    apiKey: '',
+    adminToken: '',
+    baseURL: DEFAULT_BASE_URL,
+  };
+  static axios = axios.create({
+    baseURL: this.config.baseURL,
+    withCredentials: true,
+  });
+
+  private static _sdk: AbyssToolsCoreSDK | null = null;
+
+  public static get sdk(): AbyssToolsCoreSDK {
+    if (!AbyssToolsCore._sdk) {
+      AbyssToolsCore._sdk = AbyssToolsCore.buildSDK();
+    }
+    return AbyssToolsCore._sdk;
+  }
+
+  private static buildSDK(): AbyssToolsCoreSDK {
+    return {
+      abyss: {
+        admin: {
+          activateUserService: abyssAdminApi.activateUserServiceAbyssAdmin,
+          deleteUser: abyssAdminApi.deleteUserAbyssAdmin,
+          syncOrganization: abyssAdminApi.syncOrganizationAbyssAdmin,
+          deleteOrganization: abyssAdminApi.deleteOrganizationAbyssAdmin,
+          syncProject: abyssAdminApi.syncProjectAbyssAdmin,
+          deleteProject: abyssAdminApi.deleteProjectAbyssAdmin,
+        },
+      },
+      board: {
+        getBoard: boardApi.getBoard,
+        getBySlugBoard: boardApi.getBySlugBoard,
+        listBoard: boardApi.listBoard,
+        listBoardProject: boardApi.listBoardProject,
+        deleteBoard: boardApi.deleteBoard,
+        updateBoard: boardApi.updateBoard,
+        createBoard: boardApi.createBoard,
+        createForProjectBoard: boardApi.createForProjectBoard,
+        getNextCardPreviewBoard: boardApi.getNextCardPreviewBoard,
+      },
+      boardColumn: {
+        getBoardColumn: boardColumnApi.getBoardColumn,
+        deleteBoardColumn: boardColumnApi.deleteBoardColumn,
+        updateBoardColumn: boardColumnApi.updateBoardColumn,
+        createBoardColumn: boardColumnApi.createBoardColumn,
+      },
+      boardCard: {
+        getBoardCard: boardCardApi.getBoardCard,
+        getAllBoardCard: boardCardApi.getAllBoardCard,
+        deleteBoardCard: boardCardApi.deleteBoardCard,
+        updateBoardCard: boardCardApi.updateBoardCard,
+        restoreBoardCard: boardCardApi.restoreBoardCard,
+        createBoardCard: boardCardApi.createBoardCard,
+        addMemberBoardCard: boardCardApi.addMemberBoardCard,
+        removeMemberBoardCard: boardCardApi.removeMemberBoardCard,
+        moveToBoardBoardCard: boardCardApi.moveToBoardBoardCard,
+        searchBoardCard: boardCardApi.searchBoardCard,
+      },
+      boardLabel: {
+        getBoardLabel: boardLabelApi.getBoardLabel,
+        deleteBoardLabel: boardLabelApi.deleteBoardLabel,
+        updateBoardLabel: boardLabelApi.updateBoardLabel,
+        createBoardLabel: boardLabelApi.createBoardLabel,
+        addBoardLabel: boardLabelApi.addBoardLabel,
+        removeBoardLabel: boardLabelApi.removeBoardLabel,
+        listBoardLabels: boardLabelApi.listBoardLabels,
+      },
+      boardCardComment: {
+        getBoardCardComment: boardCardCommentApi.getBoardCardComment,
+        deleteBoardCardComment: boardCardCommentApi.deleteBoardCardComment,
+        updateBoardCardComment: boardCardCommentApi.updateBoardCardComment,
+        createBoardCardComment: boardCardCommentApi.createBoardCardComment,
+      },
+      boardCardChecklist: {
+        getBoardCardChecklist: boardCardChecklistApi.getBoardCardChecklist,
+        deleteBoardCardChecklist: boardCardChecklistApi.deleteBoardCardChecklist,
+        updateBoardCardChecklist: boardCardChecklistApi.updateBoardCardChecklist,
+        createBoardCardChecklist: boardCardChecklistApi.createBoardCardChecklist,
+        addRowBoardCardChecklist: boardCardChecklistApi.addRowBoardCardChecklist,
+        removeRowBoardCardChecklist: boardCardChecklistApi.removeRowBoardCardChecklist,
+        updateRowBoardCardChecklist: boardCardChecklistApi.updateRowBoardCardChecklist,
+      },
+      boardCardDocument: {
+        getBoardCardDocument: boardCardDocumentApi.getBoardCardDocument,
+        deleteBoardCardDocument: boardCardDocumentApi.deleteBoardCardDocument,
+        getUploadPreSignedUrlBoardCardDocument:
+          boardCardDocumentApi.getUploadPreSignedUrlBoardCardDocument,
+        cloudImportBoardCardDocument: boardCardDocumentApi.cloudImportBoardCardDocument,
+      },
+      draw: {
+        paginateDraw: drawApi.paginateDraw,
+        paginateProjectDraw: drawApi.paginateProjectDraw,
+        getDraw: drawApi.getDraw,
+        deleteDraw: drawApi.deleteDraw,
+        updateDraw: drawApi.updateDraw,
+        createDraw: drawApi.createDraw,
+        createForProjectDraw: drawApi.createForProjectDraw,
+        public: {
+          getDrawPublic: drawPublicApi.getDrawPublic,
+          deleteDrawPublic: drawPublicApi.deleteDrawPublic,
+          updateDrawPublic: drawPublicApi.updateDrawPublic,
+          createDrawPublic: drawPublicApi.createDrawPublic,
+        },
+      },
+      retrospective: {
+        getRetrospective: retrospectiveApi.getRetrospective,
+        paginateProjectRetrospective: retrospectiveApi.paginateProjectRetrospective,
+        paginateRetrospective: retrospectiveApi.paginateRetrospective,
+        createForProjectRetrospective: retrospectiveApi.createForProjectRetrospective,
+        createRetrospective: retrospectiveApi.createRetrospective,
+        updateRetrospective: retrospectiveApi.updateRetrospective,
+        deleteRetrospective: retrospectiveApi.deleteRetrospective,
+        public: {
+          getRetrospectivePublic: retrospectivePublicApi.getRetrospectivePublic,
+          updateRetrospectivePublic: retrospectivePublicApi.updateRetrospectivePublic,
+          createSectionRetrospectivePublic: retrospectivePublicApi.createSectionRetrospectivePublic,
+          updateSectionRetrospectivePublic: retrospectivePublicApi.updateSectionRetrospectivePublic,
+          deleteSectionRetrospectivePublic: retrospectivePublicApi.deleteSectionRetrospectivePublic,
+          joinMemberRetrospectivePublic: retrospectivePublicApi.joinMemberRetrospectivePublic,
+          updateMemberRetrospectivePublic: retrospectivePublicApi.updateMemberRetrospectivePublic,
+          createCardRetrospectivePublic: retrospectivePublicApi.createCardRetrospectivePublic,
+          updateCardRetrospectivePublic: retrospectivePublicApi.updateCardRetrospectivePublic,
+          deleteCardRetrospectivePublic: retrospectivePublicApi.deleteCardRetrospectivePublic,
+        },
+      },
+      retrospectiveCard: {
+        getRetrospectiveCard: retrospectiveCardApi.getRetrospectiveCard,
+        paginateRetrospectiveCard: retrospectiveCardApi.paginateRetrospectiveCard,
+        createRetrospectiveCard: retrospectiveCardApi.createRetrospectiveCard,
+        updateRetrospectiveCard: retrospectiveCardApi.updateRetrospectiveCard,
+        deleteRetrospectiveCard: retrospectiveCardApi.deleteRetrospectiveCard,
+      },
+      retrospectiveMember: {
+        getRetrospectiveMember: retrospectiveMemberApi.getRetrospectiveMember,
+        listRetrospectiveMember: retrospectiveMemberApi.listRetrospectiveMember,
+        joinRetrospectiveMember: retrospectiveMemberApi.joinRetrospectiveMember,
+        updateRetrospectiveMember: retrospectiveMemberApi.updateRetrospectiveMember,
+      },
+      retrospectiveSection: {
+        getRetrospectiveSection: retrospectiveSectionApi.getRetrospectiveSection,
+        paginateRetrospectiveSection: retrospectiveSectionApi.paginateRetrospectiveSection,
+        createRetrospectiveSection: retrospectiveSectionApi.createRetrospectiveSection,
+        updateRetrospectiveSection: retrospectiveSectionApi.updateRetrospectiveSection,
+        deleteRetrospectiveSection: retrospectiveSectionApi.deleteRetrospectiveSection,
+      },
+      atlas: {
+        paginateAtlas: atlasApi.paginateAtlas,
+        paginateProjectAtlas: atlasApi.paginateProjectAtlas,
+        getAtlas: atlasApi.getAtlas,
+        deleteAtlas: atlasApi.deleteAtlas,
+        updateAtlas: atlasApi.updateAtlas,
+        createAtlas: atlasApi.createAtlas,
+        createForProjectAtlas: atlasApi.createForProjectAtlas,
+        public: {
+          getAtlasPublic: atlasPublicApi.getAtlasPublic,
+          getPageAtlasPublic: atlasPublicApi.getPageAtlasPublic,
+          searchContentAtlasPublic: atlasPublicApi.searchContentAtlasPublic,
+        },
+      },
+      atlasGroup: {
+        paginateAtlasGroup: atlasGroupApi.paginateAtlasGroup,
+        getAtlasGroup: atlasGroupApi.getAtlasGroup,
+        deleteAtlasGroup: atlasGroupApi.deleteAtlasGroup,
+        updateAtlasGroup: atlasGroupApi.updateAtlasGroup,
+        createAtlasGroup: atlasGroupApi.createAtlasGroup,
+      },
+      atlasPage: {
+        paginateAtlasPage: atlasPageApi.paginateAtlasPage,
+        getAtlasPage: atlasPageApi.getAtlasPage,
+        deleteAtlasPage: atlasPageApi.deleteAtlasPage,
+        updateAtlasPage: atlasPageApi.updateAtlasPage,
+        createAtlasPage: atlasPageApi.createAtlasPage,
+        updateAtlasPageContent: atlasPageApi.updateAtlasPageContent,
+        searchAtlasContent: atlasPageApi.searchAtlasContent,
+        getAtlasPageContentHistory: atlasPageApi.getAtlasPageContentHistory,
+        restoreAtlasPageContent: atlasPageApi.restoreAtlasPageContent,
+      },
+      atlasDocument: {
+        getAtlasDocument: atlasDocumentApi.getAtlasDocument,
+        deleteAtlasDocument: atlasDocumentApi.deleteAtlasDocument,
+        getUploadPreSignedUrlAtlasDocument: atlasDocumentApi.getUploadPreSignedUrlAtlasDocument,
+        paginateAtlasDocument: atlasDocumentApi.paginateAtlasDocument,
+        listAtlasDocument: atlasDocumentApi.listAtlasDocument,
+      },
+      memo: {
+        paginateMemo: memoApi.paginateMemo,
+        paginateProjectMemo: memoApi.paginateProjectMemo,
+        getMemo: memoApi.getMemo,
+        deleteMemo: memoApi.deleteMemo,
+        updateMemo: memoApi.updateMemo,
+        createMemo: memoApi.createMemo,
+        createForProjectMemo: memoApi.createForProjectMemo,
+      },
+      shortLink: {
+        get: shortLinkApiModule.shortLinkApi.get,
+        paginate: shortLinkApiModule.shortLinkApi.paginate,
+        paginateProject: shortLinkApiModule.shortLinkApi.paginateProject,
+        create: shortLinkApiModule.shortLinkApi.create,
+        createForProject: shortLinkApiModule.shortLinkApi.createForProject,
+        update: shortLinkApiModule.shortLinkApi.update,
+        delete: shortLinkApiModule.shortLinkApi.delete,
+        getStats: shortLinkApiModule.shortLinkApi.getStats,
+        getClicks: shortLinkApiModule.shortLinkApi.getClicks,
+        admin: {
+          paginate: shortLinkAdminApiModule.shortLinkAdminApi.paginate,
+          get: shortLinkAdminApiModule.shortLinkAdminApi.get,
+          update: shortLinkAdminApiModule.shortLinkAdminApi.update,
+          delete: shortLinkAdminApiModule.shortLinkAdminApi.delete,
+        },
+        public: {
+          createAnonymous: shortLinkPublicApiModule.shortLinkPublicApi.createAnonymous,
+          redirect: shortLinkPublicApiModule.shortLinkPublicApi.redirect,
+          getStats: shortLinkPublicApiModule.shortLinkPublicApi.getStats,
+          getClicks: shortLinkPublicApiModule.shortLinkPublicApi.getClicks,
+          renew: shortLinkPublicApiModule.shortLinkPublicApi.renew,
+        },
+      },
+      metrics: {
+        getOrganizationToolsMetrics: metricsApi.getOrganizationToolsMetrics,
+      },
+      userTag: {
+        listUserTag: userTagApi.listUserTag,
+        createUserTag: userTagApi.createUserTag,
+        updateUserTag: userTagApi.updateUserTag,
+        deleteUserTag: userTagApi.deleteUserTag,
+        assignTag: userTagApi.assignTag,
+        unassignTag: userTagApi.unassignTag,
+        getUserTagStats: userTagApi.getUserTagStats,
+        getEntityTags: userTagApi.getEntityTags,
+      },
+    };
+  }
+
+  public static enableAxiosRetry(axiosRetryConfig?: IAxiosRetryConfig): void {
+    axiosRetry(AbyssToolsCore.axios, {
+      retries: NUMBER_RETRY_API,
+      retryDelay: (retryCount) => retryCount * BASE_DELAY_BETWEEN_RETRY,
+      retryCondition: (error) =>
+        isNetworkOrIdempotentRequestError(error) ||
+        RETRY_CODES.includes(error.response?.status || 502),
+      ...axiosRetryConfig,
+    });
+  }
+
+  public static setConfig(config: CoreConfig): void {
+    AbyssToolsCore._sdk = null;
+
+    AbyssToolsCore.config = { ...AbyssToolsCore.config, ...config };
+
+    if (config.baseURL) {
+      AbyssToolsCore.axios.defaults.baseURL = config.baseURL;
+    }
+
+    if (config.token) {
+      AbyssToolsCore.axios.defaults.headers.common.Authorization = `Bearer ${config.token}`;
+    }
+
+    if (config.apiKey) {
+      AbyssToolsCore.axios.defaults.headers.common[API_KEY_HEADER] = `${config.apiKey}`;
+    }
+
+    if (config.adminToken) {
+      AbyssToolsCore.axios.defaults.headers.common[ADMIN_TOKEN_HEADER] = `${config.adminToken}`;
+    }
+  }
+
+  public static getConfig(): CoreConfig {
+    return AbyssToolsCore.config;
+  }
+}

package/src/server-sent-events/index.ts

@@ -0,0 +1,13 @@
+export * from './server-sent-events.manager';
+export * from './protocols';
+
+export enum SSEChannels {
+  BOARD = 'sse:board',
+  BOARD_CARD = 'sse:board-card',
+  USER_NOTIFICATION = 'sse:user-notification',
+  RETROSPECTIVE = 'sse:retrospective',
+  ATLAS = 'sse:atlas',
+
+  // AbyssCloud
+  CLOUD = 'sse:cloud',
+}

package/src/server-sent-events/protocols/atlas/atlas.sse-protocol.ts

@@ -0,0 +1,90 @@
+import { SystemSSEMessageContent } from '..';
+import { ValueOf } from '../../../types';
+import { IAtlas, IAtlasGroup, IAtlasPage, IAtlasDocument } from '../../../types/interface';
+
+export enum AtlasSSEEvent {
+  ATLAS_UPDATED = 'ATLAS_UPDATED',
+  ATLAS_DELETED = 'ATLAS_DELETED',
+  GROUP_CREATED = 'GROUP_CREATED',
+  GROUP_UPDATED = 'GROUP_UPDATED',
+  GROUP_DELETED = 'GROUP_DELETED',
+  PAGE_CREATED = 'PAGE_CREATED',
+  PAGE_UPDATED = 'PAGE_UPDATED',
+  PAGE_DELETED = 'PAGE_DELETED',
+  PAGE_CONTENT_DIFF_UPDATED = 'PAGE_CONTENT_DIFF_UPDATED',
+  ATLAS_DOCUMENT_CREATE = 'ATLAS_DOCUMENT_CREATE',
+  ATLAS_DOCUMENT_DELETE = 'ATLAS_DOCUMENT_DELETE',
+}
+
+export type AtlasSSEMessageContent = ValueOf<
+  {
+    [K in AtlasSSEEvent]: {
+      type: K;
+      payload: SourceAtlasSSEEventPayload[K];
+    };
+  }
+>;
+
+export class SourceAtlasSSEEventPayload implements Record<AtlasSSEEvent, Record<string, any>> {
+  [AtlasSSEEvent.ATLAS_UPDATED]!: {
+    atlasId: string;
+    atlas: IAtlas;
+  };
+
+  [AtlasSSEEvent.ATLAS_DELETED]!: {
+    atlasId: string;
+    userId?: string;
+  };
+
+  [AtlasSSEEvent.GROUP_CREATED]!: {
+    atlasId: string;
+    group: IAtlasGroup;
+  };
+
+  [AtlasSSEEvent.GROUP_UPDATED]!: {
+    atlasId: string;
+    group: IAtlasGroup;
+  };
+
+  [AtlasSSEEvent.GROUP_DELETED]!: {
+    atlasId: string;
+    groupId: string;
+  };
+
+  [AtlasSSEEvent.PAGE_CREATED]!: {
+    atlasId: string;
+    page: IAtlasPage;
+  };
+
+  [AtlasSSEEvent.PAGE_UPDATED]!: {
+    atlasId: string;
+    page: IAtlasPage;
+  };
+
+  [AtlasSSEEvent.PAGE_DELETED]!: {
+    atlasId: string;
+    pageId: string;
+  };
+
+  [AtlasSSEEvent.PAGE_CONTENT_DIFF_UPDATED]!: {
+    atlasId: string;
+    pageId: string;
+    diff: string | null;
+    version: number;
+    lastModifiedByUserId?: string;
+  };
+
+  [AtlasSSEEvent.ATLAS_DOCUMENT_CREATE]!: {
+    atlasId: string;
+    atlasPageId: string;
+    atlasDocument: IAtlasDocument;
+  };
+
+  [AtlasSSEEvent.ATLAS_DOCUMENT_DELETE]!: {
+    atlasId: string;
+    atlasPageId: string;
+    atlasDocumentId: string;
+  };
+}
+
+export type AtlasSSEEventContent = AtlasSSEMessageContent | SystemSSEMessageContent;

package/src/server-sent-events/protocols/atlas/index.ts

@@ -0,0 +1 @@
+export * from './atlas.sse-protocol';