@abyss-project/workspace 0.0.0-stage → 1.0.0

package/src/api/board-card.api.ts

@@ -0,0 +1,140 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  IAddMemberBoardCardParams,
+  IAddMemberBoardCardResponse,
+  ICreateBoardCardBody,
+  ICreateBoardCardParams,
+  ICreateBoardCardResponse,
+  IDeleteBoardCardParams,
+  IDeleteBoardCardResponse,
+  IGetAllBoardCardParams,
+  IGetAllBoardCardQuery,
+  IGetAllBoardCardResponse,
+  IGetBoardCardParams,
+  IGetBoardCardResponse,
+  IMoveToBoardBoardCardBody,
+  IMoveToBoardBoardCardParams,
+  IMoveToBoardBoardCardResponse,
+  IRemoveMemberBoardCardParams,
+  IRemoveMemberBoardCardResponse,
+  IRestoreBoardCardBody,
+  IRestoreBoardCardParams,
+  IRestoreBoardCardResponse,
+  IUpdateBoardCardBody,
+  IUpdateBoardCardParams,
+  IUpdateBoardCardResponse,
+  ISearchBoardCardParams,
+  ISearchBoardCardQuery,
+  ISearchBoardCardResponse,
+} from '../types';
+
+export const getBoardCard = async (params: IGetBoardCardParams): Promise<IGetBoardCardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetBoardCardResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}`,
+    )
+  ).data;
+};
+
+export const getAllBoardCard = async (
+  params: IGetAllBoardCardParams,
+  query: IGetAllBoardCardQuery,
+): Promise<IGetAllBoardCardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetAllBoardCardResponse>(`board/${params.boardId}/card`, {
+      params: query,
+    })
+  ).data;
+};
+
+export const deleteBoardCard = async (
+  params: IDeleteBoardCardParams,
+): Promise<IDeleteBoardCardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IDeleteBoardCardResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}`,
+    )
+  ).data;
+};
+
+export const updateBoardCard = async (
+  params: IUpdateBoardCardParams,
+  body: IUpdateBoardCardBody,
+): Promise<IUpdateBoardCardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateBoardCardResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}`,
+      body,
+    )
+  ).data;
+};
+
+export const restoreBoardCard = async (
+  params: IRestoreBoardCardParams,
+  body: IRestoreBoardCardBody,
+): Promise<IRestoreBoardCardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<IRestoreBoardCardResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/restore`,
+      body,
+    )
+  ).data;
+};
+
+export const createBoardCard = async (
+  params: ICreateBoardCardParams,
+  body: ICreateBoardCardBody,
+): Promise<ICreateBoardCardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ICreateBoardCardResponse>(
+      `board/${params.boardId}/card/${params.boardColumnId}`,
+      body,
+    )
+  ).data;
+};
+
+export const addMemberBoardCard = async (
+  params: IAddMemberBoardCardParams,
+): Promise<IAddMemberBoardCardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<IAddMemberBoardCardResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/member/${params.userId}`,
+    )
+  ).data;
+};
+
+export const removeMemberBoardCard = async (
+  params: IRemoveMemberBoardCardParams,
+): Promise<IRemoveMemberBoardCardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IRemoveMemberBoardCardResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/member/${params.userId}`,
+    )
+  ).data;
+};
+
+export const moveToBoardBoardCard = async (
+  params: IMoveToBoardBoardCardParams,
+  body: IMoveToBoardBoardCardBody,
+): Promise<IMoveToBoardBoardCardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<IMoveToBoardBoardCardResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/move-to-board`,
+      body,
+    )
+  ).data;
+};
+
+export const searchBoardCard = async (
+  params: ISearchBoardCardParams,
+  query: ISearchBoardCardQuery,
+): Promise<ISearchBoardCardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<ISearchBoardCardResponse>(
+      `board/${params.boardId}/card/search`,
+      {
+        params: query,
+      },
+    )
+  ).data;
+};

package/src/api/board-column.api.ts

@@ -0,0 +1,57 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  ICreateBoardColumnBody,
+  ICreateBoardColumnParams,
+  ICreateBoardColumnResponse,
+  IDeleteBoardColumnParams,
+  IDeleteBoardColumnResponse,
+  IGetBoardColumnParams,
+  IGetBoardColumnResponse,
+  IUpdateBoardColumnBody,
+  IUpdateBoardColumnParams,
+  IUpdateBoardColumnResponse,
+} from '../types';
+
+export const getBoardColumn = async (
+  params: IGetBoardColumnParams,
+): Promise<IGetBoardColumnResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetBoardColumnResponse>(
+      `board/${params.boardId}/column/${params.boardColumnId}`,
+    )
+  ).data;
+};
+
+export const deleteBoardColumn = async (
+  params: IDeleteBoardColumnParams,
+): Promise<IDeleteBoardColumnResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IDeleteBoardColumnResponse>(
+      `board/${params.boardId}/column/${params.boardColumnId}`,
+    )
+  ).data;
+};
+
+export const updateBoardColumn = async (
+  params: IUpdateBoardColumnParams,
+  body: IUpdateBoardColumnBody,
+): Promise<IUpdateBoardColumnResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateBoardColumnResponse>(
+      `board/${params.boardId}/column/${params.boardColumnId}`,
+      body,
+    )
+  ).data;
+};
+
+export const createBoardColumn = async (
+  params: ICreateBoardColumnParams,
+  body: ICreateBoardColumnBody,
+): Promise<ICreateBoardColumnResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ICreateBoardColumnResponse>(
+      `board/${params.boardId}/column`,
+      body,
+    )
+  ).data;
+};

package/src/api/board-label.api.ts

@@ -0,0 +1,93 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  IAddBoardLabelParams,
+  IAddBoardLabelResponse,
+  ICreateBoardLabelBody,
+  ICreateBoardLabelParams,
+  ICreateBoardLabelResponse,
+  IDeleteBoardLabelParams,
+  IDeleteBoardLabelResponse,
+  IGetBoardLabelParams,
+  IGetBoardLabelResponse,
+  IListBoardLabelParams,
+  IListBoardLabelResponse,
+  IRemoveBoardLabelParams,
+  IRemoveBoardLabelResponse,
+  IUpdateBoardLabelBody,
+  IUpdateBoardLabelParams,
+  IUpdateBoardLabelResponse,
+} from '../types';
+
+export const getBoardLabel = async (
+  params: IGetBoardLabelParams,
+): Promise<IGetBoardLabelResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetBoardLabelResponse>(
+      `board/${params.boardId}/label/${params.boardLabelId}`,
+    )
+  ).data;
+};
+
+export const deleteBoardLabel = async (
+  params: IDeleteBoardLabelParams,
+): Promise<IDeleteBoardLabelResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IDeleteBoardLabelResponse>(
+      `board/${params.boardId}/label/${params.boardLabelId}`,
+    )
+  ).data;
+};
+
+export const updateBoardLabel = async (
+  params: IUpdateBoardLabelParams,
+  body: IUpdateBoardLabelBody,
+): Promise<IUpdateBoardLabelResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateBoardLabelResponse>(
+      `board/${params.boardId}/label/${params.boardLabelId}`,
+      body,
+    )
+  ).data;
+};
+
+export const createBoardLabel = async (
+  params: ICreateBoardLabelParams,
+  body: ICreateBoardLabelBody,
+): Promise<ICreateBoardLabelResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ICreateBoardLabelResponse>(
+      `board/${params.boardId}/label`,
+      body,
+    )
+  ).data;
+};
+
+export const addBoardLabel = async (
+  params: IAddBoardLabelParams,
+): Promise<IAddBoardLabelResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<IAddBoardLabelResponse>(
+      `board/${params.boardId}/label/${params.boardLabelId}/card/${params.boardCardId}`,
+    )
+  ).data;
+};
+
+export const removeBoardLabel = async (
+  params: IRemoveBoardLabelParams,
+): Promise<IRemoveBoardLabelResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IRemoveBoardLabelResponse>(
+      `board/${params.boardId}/label/${params.boardLabelId}/card/${params.boardCardId}`,
+    )
+  ).data;
+};
+
+export const listBoardLabels = async (
+  params: IListBoardLabelParams,
+): Promise<IListBoardLabelResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IListBoardLabelResponse>(
+      `board/${params.boardId}/label/list`,
+    )
+  ).data;
+};

package/src/api/board.api.ts

@@ -0,0 +1,135 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  ICreateBoardBody,
+  ICreateBoardResponse,
+  ICreateForOrganizationBoardParams,
+  IDeleteBoardParams,
+  IDeleteBoardResponse,
+  IGetBoardParams,
+  IGetBoardResponse,
+  IGetBySlugBoardParams,
+  IGetBySlugBoardResponse,
+  IGetNextCardPreviewBoardResponse,
+  IListBoardUserResponse,
+  IPaginateBoardQuery,
+  IPaginateBoardResponse,
+  IPaginateOrganizationBoardParams,
+  IUpdateBoardBody,
+  IUpdateBoardParams,
+  IUpdateBoardResponse,
+  IListOrganizationBoardParams,
+  IListOrganizationBoardQuery,
+  ITransferContentBody,
+  ITransferBoardResponse,
+  ICountOrganizationResponse,
+} from '../types';
+
+export const getBoard = async (params: IGetBoardParams): Promise<IGetBoardResponse> => {
+  return (await AbyssWorkspaceCore.axios.get<IGetBoardResponse>(`board/${params.boardId}`)).data;
+};
+
+export const getBySlugBoard = async (
+  params: IGetBySlugBoardParams,
+): Promise<IGetBySlugBoardResponse> => {
+  return (await AbyssWorkspaceCore.axios.get<IGetBySlugBoardResponse>(`board/slug/${params.slug}`))
+    .data;
+};
+
+export const deleteBoard = async (params: IDeleteBoardParams): Promise<IDeleteBoardResponse> => {
+  return (await AbyssWorkspaceCore.axios.delete<IDeleteBoardResponse>(`board/${params.boardId}`))
+    .data;
+};
+
+export const updateBoard = async (
+  params: IUpdateBoardParams,
+  body: IUpdateBoardBody,
+): Promise<IUpdateBoardResponse> => {
+  return (await AbyssWorkspaceCore.axios.put<IUpdateBoardResponse>(`board/${params.boardId}`, body))
+    .data;
+};
+
+export const createBoard = async (body: ICreateBoardBody): Promise<ICreateBoardResponse> => {
+  return (await AbyssWorkspaceCore.axios.post<ICreateBoardResponse>(`board`, body)).data;
+};
+
+export const createForOrganizationBoard = async (
+  params: ICreateForOrganizationBoardParams,
+  body: ICreateBoardBody,
+): Promise<ICreateBoardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ICreateBoardResponse>(
+      `board/organization/${params.organizationId}`,
+      body,
+    )
+  ).data;
+};
+
+export const listBoard = async (query?: {
+  sharedWithMe?: boolean;
+}): Promise<IListBoardUserResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IListBoardUserResponse>('board/list', { params: query })
+  ).data;
+};
+
+export const listBoardProject = async (params: {
+  projectId: string;
+}): Promise<IListBoardUserResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IListBoardUserResponse>(
+      `board/project/${params.projectId}/list`,
+    )
+  ).data;
+};
+
+export const getNextCardPreviewBoard = async (): Promise<IGetNextCardPreviewBoardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<IGetNextCardPreviewBoardResponse>(`board/next-card-preview`)
+  ).data;
+};
+
+export const listBoardOrganization = async (
+  params: IListOrganizationBoardParams,
+  query?: IListOrganizationBoardQuery,
+): Promise<IListBoardUserResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IListBoardUserResponse>(
+      `board/organization/${params.organizationId}/list`,
+      { params: query },
+    )
+  ).data;
+};
+
+export const paginateOrganizationBoard = async (
+  params: IPaginateOrganizationBoardParams,
+  query: IPaginateBoardQuery,
+): Promise<IPaginateBoardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IPaginateBoardResponse>(
+      `board/organization/${params.organizationId}/paginate`,
+      { params: query },
+    )
+  ).data;
+};
+
+export const transferBoard = async (
+  params: { boardId: string },
+  body: ITransferContentBody,
+): Promise<ITransferBoardResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ITransferBoardResponse>(
+      `board/${params.boardId}/transfer`,
+      body,
+    )
+  ).data;
+};
+
+export const countOrganizationBoard = async (params: {
+  organizationId: string;
+}): Promise<ICountOrganizationResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<ICountOrganizationResponse>(
+      `board/organization/${params.organizationId}/count`,
+    )
+  ).data;
+};

package/src/api/draw-image.api.ts

@@ -0,0 +1,55 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  IGetDrawImageParams,
+  IGetDrawImagePublicParams,
+  IGetDrawImagePublicResponse,
+  IGetDrawImageResponse,
+  IGetUploadSessionDrawImageBody,
+  IGetUploadSessionDrawImageParams,
+  IGetUploadSessionDrawImagePublicBody,
+  IGetUploadSessionDrawImagePublicParams,
+  IGetUploadSessionDrawImagePublicResponse,
+  IGetUploadSessionDrawImageResponse,
+} from '../types';
+
+export const getUploadSessionDrawImage = async (
+  params: IGetUploadSessionDrawImageParams,
+  body: IGetUploadSessionDrawImageBody,
+): Promise<IGetUploadSessionDrawImageResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<IGetUploadSessionDrawImageResponse>(
+      `draw/${params.drawId}/image/upload`,
+      body,
+    )
+  ).data;
+};
+
+export const getDrawImage = async (params: IGetDrawImageParams): Promise<IGetDrawImageResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetDrawImageResponse>(
+      `draw/${params.drawId}/image/${params.imageId}`,
+    )
+  ).data;
+};
+
+export const getUploadSessionDrawImagePublic = async (
+  params: IGetUploadSessionDrawImagePublicParams,
+  body: IGetUploadSessionDrawImagePublicBody,
+): Promise<IGetUploadSessionDrawImagePublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<IGetUploadSessionDrawImagePublicResponse>(
+      `draw/public/${params.publicAccessToken}/image/upload`,
+      body,
+    )
+  ).data;
+};
+
+export const getDrawImagePublic = async (
+  params: IGetDrawImagePublicParams,
+): Promise<IGetDrawImagePublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetDrawImagePublicResponse>(
+      `draw/public/${params.publicAccessToken}/image/${params.imageId}`,
+    )
+  ).data;
+};

package/src/api/draw.api.ts

@@ -0,0 +1,106 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  ICreateDrawBody,
+  ICreateDrawResponse,
+  ICreateForOrganizationDrawParams,
+  IDeleteDrawParams,
+  IDeleteDrawResponse,
+  IGetDrawParams,
+  IGetDrawResponse,
+  IPaginateDrawQuery,
+  IPaginateDrawResponse,
+  IPaginateProjectDrawParams,
+  IUpdateDrawBody,
+  IUpdateDrawParams,
+  IUpdateDrawResponse,
+  IPaginateOrganizationDrawParams,
+  ITransferContentBody,
+  ITransferDrawResponse,
+  ICountOrganizationResponse,
+} from '../types';
+
+export const paginateDraw = async (query: IPaginateDrawQuery): Promise<IPaginateDrawResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IPaginateDrawResponse>(`draw/paginate`, { params: query })
+  ).data;
+};
+
+export const paginateProjectDraw = async (
+  params: IPaginateProjectDrawParams,
+  query: IPaginateDrawQuery,
+): Promise<IPaginateDrawResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IPaginateDrawResponse>(
+      `project/${params.projectId}/draw/paginate`,
+      {
+        params: query,
+      },
+    )
+  ).data;
+};
+
+export const getDraw = async (params: IGetDrawParams): Promise<IGetDrawResponse> => {
+  return (await AbyssWorkspaceCore.axios.get<IGetDrawResponse>(`draw/${params.drawId}`)).data;
+};
+
+export const deleteDraw = async (params: IDeleteDrawParams): Promise<IDeleteDrawResponse> => {
+  return (await AbyssWorkspaceCore.axios.delete<IDeleteDrawResponse>(`draw/${params.drawId}`)).data;
+};
+
+export const updateDraw = async (
+  params: IUpdateDrawParams,
+  body: IUpdateDrawBody,
+): Promise<IUpdateDrawResponse> => {
+  return (await AbyssWorkspaceCore.axios.put<IUpdateDrawResponse>(`draw/${params.drawId}`, body))
+    .data;
+};
+
+export const createDraw = async (body: ICreateDrawBody): Promise<ICreateDrawResponse> => {
+  return (await AbyssWorkspaceCore.axios.post<ICreateDrawResponse>(`draw`, body)).data;
+};
+
+export const createForOrganizationDraw = async (
+  params: ICreateForOrganizationDrawParams,
+  body: ICreateDrawBody,
+): Promise<ICreateDrawResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ICreateDrawResponse>(
+      `draw/organization/${params.organizationId}`,
+      body,
+    )
+  ).data;
+};
+
+export const paginateOrganizationDraw = async (
+  params: IPaginateOrganizationDrawParams,
+  query: IPaginateDrawQuery,
+): Promise<IPaginateDrawResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IPaginateDrawResponse>(
+      `organization/${params.organizationId}/draw/paginate`,
+      { params: query },
+    )
+  ).data;
+};
+
+export const transferDraw = async (
+  params: { drawId: string },
+  body: ITransferContentBody,
+): Promise<ITransferDrawResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ITransferDrawResponse>(
+      `draw/${params.drawId}/transfer`,
+      body,
+    )
+  ).data;
+};
+
+export const countOrganizationDraw = async (params: {
+  organizationId: string;
+}): Promise<ICountOrganizationResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<ICountOrganizationResponse>(
+      `draw/organization/${params.organizationId}/count`,
+    )
+  ).data;
+};

package/src/api/draw.public.api.ts

@@ -0,0 +1,50 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  ICreateDrawPublicBody,
+  ICreateDrawPublicResponse,
+  IDeleteDrawPublicParams,
+  IDeleteDrawPublicResponse,
+  IGetDrawPublicParams,
+  IGetDrawPublicResponse,
+  IUpdateDrawPublicBody,
+  IUpdateDrawPublicParams,
+  IUpdateDrawPublicResponse,
+} from '../types';
+
+export const getDrawPublic = async (
+  params: IGetDrawPublicParams,
+): Promise<IGetDrawPublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetDrawPublicResponse>(
+      `draw/public/${params.publicAccessToken}`,
+    )
+  ).data;
+};
+
+export const deleteDrawPublic = async (
+  params: IDeleteDrawPublicParams,
+): Promise<IDeleteDrawPublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IDeleteDrawPublicResponse>(
+      `draw/public/${params.publicAccessToken}`,
+    )
+  ).data;
+};
+
+export const updateDrawPublic = async (
+  params: IUpdateDrawPublicParams,
+  body: IUpdateDrawPublicBody,
+): Promise<IUpdateDrawPublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateDrawPublicResponse>(
+      `draw/public/${params.publicAccessToken}`,
+      body,
+    )
+  ).data;
+};
+
+export const createDrawPublic = async (
+  body: ICreateDrawPublicBody,
+): Promise<ICreateDrawPublicResponse> => {
+  return (await AbyssWorkspaceCore.axios.post<ICreateDrawPublicResponse>(`draw/public`, body)).data;
+};

package/src/api/index.ts

@@ -0,0 +1,48 @@
+export * from './abyss.admin.api';
+
+// Atlas
+export * from './atlas.api';
+export * from './atlas.public.api';
+export * from './atlas-document.api';
+export * from './atlas-group.api';
+export * from './atlas-page.api';
+
+// Board
+export * from './board.api';
+export * from './board-card.api';
+export * from './board-card-checklist.api';
+export * from './board-card-comment.api';
+export * from './board-card-document.api';
+export * from './board-card-link.api';
+export * from './board-column.api';
+export * from './board-label.api';
+
+// Draw
+export * from './draw.api';
+export * from './draw.public.api';
+export * from './draw-image.api';
+
+// Retrospective
+export * from './retrospective.api';
+export * from './retrospective.public.api';
+export * from './retrospective-card.api';
+export * from './retrospective-action.api';
+export * from './retrospective-member.api';
+export * from './retrospective-section.api';
+
+// Short Link
+export * from './short-link.api';
+export * from './short-link.public.api';
+export * from './short-link.admin.api';
+
+// Metrics
+export * from './metrics.api';
+
+// Organization
+export * from './organization.api';
+
+// Tag
+export * from './tag.api';
+
+// Monitor (liveness)
+export * from './monitor.api';