@abyss-project/workspace 0.0.0-stage → 1.0.0

package/src/api/atlas-page.api.ts

@@ -0,0 +1,148 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  ICreateAtlasPageBody,
+  ICreateAtlasPageParams,
+  ICreateAtlasPageResponse,
+  IDeleteAtlasPageParams,
+  IDeleteAtlasPageResponse,
+  IDuplicateAtlasPageBody,
+  IDuplicateAtlasPageParams,
+  IDuplicateAtlasPageResponse,
+  IGetAtlasPageParams,
+  IGetAtlasPageResponse,
+  IPaginateAtlasPageParams,
+  IPaginateAtlasPageQuery,
+  IPaginateAtlasPageResponse,
+  IUpdateAtlasPageBody,
+  IUpdateAtlasPageParams,
+  IUpdateAtlasPageResponse,
+  IUpdateAtlasPageContentParams,
+  IUpdateAtlasPageContentBody,
+  IUpdateAtlasPageContentResponse,
+  ISearchAtlasContentParams,
+  ISearchAtlasContentQuery,
+  ISearchAtlasContentResponse,
+  IGetAtlasPageContentHistoryParams,
+  IGetAtlasPageContentHistoryQuery,
+  IGetAtlasPageContentHistoryResponse,
+  IRestoreAtlasPageContentParams,
+  IRestoreAtlasPageContentResponse,
+} from '../types';
+
+export const paginateAtlasPage = async (
+  params: IPaginateAtlasPageParams,
+  query: IPaginateAtlasPageQuery,
+): Promise<IPaginateAtlasPageResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IPaginateAtlasPageResponse>(
+      `atlas/${params.atlasId}/page/paginate`,
+      {
+        params: query,
+      },
+    )
+  ).data;
+};
+
+export const getAtlasPage = async (params: IGetAtlasPageParams): Promise<IGetAtlasPageResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetAtlasPageResponse>(
+      `atlas/${params.atlasId}/page/${params.atlasPageId}`,
+    )
+  ).data;
+};
+
+export const deleteAtlasPage = async (
+  params: IDeleteAtlasPageParams,
+): Promise<IDeleteAtlasPageResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IDeleteAtlasPageResponse>(
+      `atlas/${params.atlasId}/page/${params.atlasPageId}`,
+    )
+  ).data;
+};
+
+export const updateAtlasPage = async (
+  params: IUpdateAtlasPageParams,
+  body: IUpdateAtlasPageBody,
+): Promise<IUpdateAtlasPageResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateAtlasPageResponse>(
+      `atlas/${params.atlasId}/page/${params.atlasPageId}`,
+      body,
+    )
+  ).data;
+};
+
+export const createAtlasPage = async (
+  params: ICreateAtlasPageParams,
+  body: ICreateAtlasPageBody,
+): Promise<ICreateAtlasPageResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ICreateAtlasPageResponse>(
+      `atlas/${params.atlasId}/page`,
+      body,
+    )
+  ).data;
+};
+
+export const duplicateAtlasPage = async (
+  params: IDuplicateAtlasPageParams,
+  body: IDuplicateAtlasPageBody,
+): Promise<IDuplicateAtlasPageResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<IDuplicateAtlasPageResponse>(
+      `atlas/${params.atlasId}/page/${params.atlasPageId}/duplicate`,
+      body,
+    )
+  ).data;
+};
+
+export const updateAtlasPageContent = async (
+  params: IUpdateAtlasPageContentParams,
+  body: IUpdateAtlasPageContentBody,
+): Promise<IUpdateAtlasPageContentResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateAtlasPageContentResponse>(
+      `atlas/${params.atlasId}/page/${params.atlasPageId}/content`,
+      body,
+    )
+  ).data;
+};
+
+export const searchAtlasContent = async (
+  params: ISearchAtlasContentParams,
+  query: ISearchAtlasContentQuery,
+): Promise<ISearchAtlasContentResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<ISearchAtlasContentResponse>(
+      `atlas/${params.atlasId}/page/search`,
+      {
+        params: query,
+      },
+    )
+  ).data;
+};
+
+export const getAtlasPageContentHistory = async (
+  params: IGetAtlasPageContentHistoryParams,
+  query: IGetAtlasPageContentHistoryQuery,
+): Promise<IGetAtlasPageContentHistoryResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetAtlasPageContentHistoryResponse>(
+      `atlas/${params.atlasId}/page/${params.atlasPageId}/content/history`,
+      {
+        params: query,
+      },
+    )
+  ).data;
+};
+
+export const restoreAtlasPageContent = async (
+  params: IRestoreAtlasPageContentParams,
+): Promise<IRestoreAtlasPageContentResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IRestoreAtlasPageContentResponse>(
+      `atlas/${params.atlasId}/page/${params.atlasPageId}/content/restore/${params.version}`,
+    )
+  ).data;
+};

package/src/api/atlas.api.ts

@@ -0,0 +1,109 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  ICreateAtlasBody,
+  ICreateAtlasResponse,
+  ICreateForOrganizationAtlasParams,
+  IDeleteAtlasParams,
+  IDeleteAtlasResponse,
+  IGetAtlasParams,
+  IGetAtlasResponse,
+  IPaginateAtlasQuery,
+  IPaginateAtlasResponse,
+  IPaginateProjectAtlasParams,
+  IUpdateAtlasBody,
+  IUpdateAtlasParams,
+  IUpdateAtlasResponse,
+  IPaginateOrganizationAtlasParams,
+  ITransferContentBody,
+  ITransferAtlasResponse,
+  ICountOrganizationResponse,
+} from '../types';
+
+export const paginateAtlas = async (
+  query: IPaginateAtlasQuery,
+): Promise<IPaginateAtlasResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IPaginateAtlasResponse>(`atlas/paginate`, { params: query })
+  ).data;
+};
+
+export const paginateProjectAtlas = async (
+  params: IPaginateProjectAtlasParams,
+  query: IPaginateAtlasQuery,
+): Promise<IPaginateAtlasResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IPaginateAtlasResponse>(
+      `project/${params.projectId}/atlas/paginate`,
+      {
+        params: query,
+      },
+    )
+  ).data;
+};
+
+export const getAtlas = async (params: IGetAtlasParams): Promise<IGetAtlasResponse> => {
+  return (await AbyssWorkspaceCore.axios.get<IGetAtlasResponse>(`atlas/${params.atlasId}`)).data;
+};
+
+export const deleteAtlas = async (params: IDeleteAtlasParams): Promise<IDeleteAtlasResponse> => {
+  return (await AbyssWorkspaceCore.axios.delete<IDeleteAtlasResponse>(`atlas/${params.atlasId}`))
+    .data;
+};
+
+export const updateAtlas = async (
+  params: IUpdateAtlasParams,
+  body: IUpdateAtlasBody,
+): Promise<IUpdateAtlasResponse> => {
+  return (await AbyssWorkspaceCore.axios.put<IUpdateAtlasResponse>(`atlas/${params.atlasId}`, body))
+    .data;
+};
+
+export const createAtlas = async (body: ICreateAtlasBody): Promise<ICreateAtlasResponse> => {
+  return (await AbyssWorkspaceCore.axios.post<ICreateAtlasResponse>(`atlas`, body)).data;
+};
+
+export const createForOrganizationAtlas = async (
+  params: ICreateForOrganizationAtlasParams,
+  body: ICreateAtlasBody,
+): Promise<ICreateAtlasResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ICreateAtlasResponse>(
+      `atlas/organization/${params.organizationId}`,
+      body,
+    )
+  ).data;
+};
+
+export const paginateOrganizationAtlas = async (
+  params: IPaginateOrganizationAtlasParams,
+  query: IPaginateAtlasQuery,
+): Promise<IPaginateAtlasResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IPaginateAtlasResponse>(
+      `organization/${params.organizationId}/atlas/paginate`,
+      { params: query },
+    )
+  ).data;
+};
+
+export const transferAtlas = async (
+  params: { atlasId: string },
+  body: ITransferContentBody,
+): Promise<ITransferAtlasResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ITransferAtlasResponse>(
+      `atlas/${params.atlasId}/transfer`,
+      body,
+    )
+  ).data;
+};
+
+export const countOrganizationAtlas = async (params: {
+  organizationId: string;
+}): Promise<ICountOrganizationResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<ICountOrganizationResponse>(
+      `atlas/organization/${params.organizationId}/count`,
+    )
+  ).data;
+};

package/src/api/atlas.public.api.ts

@@ -0,0 +1,44 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  IGetAtlasPublicParams,
+  IGetAtlasPublicResponse,
+  IGetPageAtlasPublicParams,
+  IGetPageAtlasPublicResponse,
+  ISearchContentAtlasPublicParams,
+  ISearchContentAtlasPublicQuery,
+  ISearchContentAtlasPublicResponse,
+} from '../types';
+
+export const getAtlasPublic = async (
+  params: IGetAtlasPublicParams,
+): Promise<IGetAtlasPublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetAtlasPublicResponse>(
+      `atlas/public/${params.publicAccessToken}`,
+    )
+  ).data;
+};
+
+export const getPageAtlasPublic = async (
+  params: IGetPageAtlasPublicParams,
+): Promise<IGetPageAtlasPublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetPageAtlasPublicResponse>(
+      `atlas/public/${params.publicAccessToken}/page/${params.atlasPageId}`,
+    )
+  ).data;
+};
+
+export const searchContentAtlasPublic = async (
+  params: ISearchContentAtlasPublicParams,
+  query: ISearchContentAtlasPublicQuery,
+): Promise<ISearchContentAtlasPublicResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<ISearchContentAtlasPublicResponse>(
+      `atlas/public/${params.publicAccessToken}/search`,
+      {
+        params: query,
+      },
+    )
+  ).data;
+};

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

@@ -0,0 +1,99 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  IAddRowBoardCardChecklistBody,
+  IAddRowBoardCardChecklistParams,
+  IAddRowBoardCardChecklistResponse,
+  ICreateBoardCardChecklistBody,
+  ICreateBoardCardChecklistParams,
+  ICreateBoardCardChecklistResponse,
+  IDeleteBoardCardChecklistParams,
+  IDeleteBoardCardChecklistResponse,
+  IGetBoardCardChecklistParams,
+  IGetBoardCardChecklistResponse,
+  IRemoveRowBoardCardChecklistParams,
+  IRemoveRowBoardCardChecklistResponse,
+  IUpdateBoardCardChecklistBody,
+  IUpdateBoardCardChecklistParams,
+  IUpdateBoardCardChecklistResponse,
+  IUpdateRowBoardCardChecklistBody,
+  IUpdateRowBoardCardChecklistParams,
+  IUpdateRowBoardCardChecklistResponse,
+} from '../types';
+
+export const getBoardCardChecklist = async (
+  params: IGetBoardCardChecklistParams,
+): Promise<IGetBoardCardChecklistResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetBoardCardChecklistResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/checklist/${params.boardCardChecklistId}`,
+    )
+  ).data;
+};
+
+export const deleteBoardCardChecklist = async (
+  params: IDeleteBoardCardChecklistParams,
+): Promise<IDeleteBoardCardChecklistResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IDeleteBoardCardChecklistResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/checklist/${params.boardCardChecklistId}`,
+    )
+  ).data;
+};
+
+export const updateBoardCardChecklist = async (
+  params: IUpdateBoardCardChecklistParams,
+  body: IUpdateBoardCardChecklistBody,
+): Promise<IUpdateBoardCardChecklistResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateBoardCardChecklistResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/checklist/${params.boardCardChecklistId}`,
+      body,
+    )
+  ).data;
+};
+
+export const createBoardCardChecklist = async (
+  params: ICreateBoardCardChecklistParams,
+  body: ICreateBoardCardChecklistBody,
+): Promise<ICreateBoardCardChecklistResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ICreateBoardCardChecklistResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/checklist`,
+      body,
+    )
+  ).data;
+};
+
+export const addRowBoardCardChecklist = async (
+  params: IAddRowBoardCardChecklistParams,
+  body: IAddRowBoardCardChecklistBody,
+): Promise<IAddRowBoardCardChecklistResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<IAddRowBoardCardChecklistResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/checklist/${params.boardCardChecklistId}/row`,
+      body,
+    )
+  ).data;
+};
+
+export const removeRowBoardCardChecklist = async (
+  params: IRemoveRowBoardCardChecklistParams,
+): Promise<IRemoveRowBoardCardChecklistResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IRemoveRowBoardCardChecklistResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/checklist/${params.boardCardChecklistId}/row/${params.boardCardChecklistRowId}`,
+    )
+  ).data;
+};
+
+export const updateRowBoardCardChecklist = async (
+  params: IUpdateRowBoardCardChecklistParams,
+  body: IUpdateRowBoardCardChecklistBody,
+): Promise<IUpdateRowBoardCardChecklistResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateRowBoardCardChecklistResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/checklist/${params.boardCardChecklistId}/row/${params.boardCardChecklistRowId}`,
+      body,
+    )
+  ).data;
+};

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

@@ -0,0 +1,57 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  ICreateBoardCardCommentBody,
+  ICreateBoardCardCommentParams,
+  ICreateBoardCardCommentResponse,
+  IDeleteBoardCardCommentParams,
+  IDeleteBoardCardCommentResponse,
+  IGetBoardCardCommentParams,
+  IGetBoardCardCommentResponse,
+  IUpdateBoardCardCommentBody,
+  IUpdateBoardCardCommentParams,
+  IUpdateBoardCardCommentResponse,
+} from '../types';
+
+export const getBoardCardComment = async (
+  params: IGetBoardCardCommentParams,
+): Promise<IGetBoardCardCommentResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetBoardCardCommentResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/comment/${params.boardCardCommentId}`,
+    )
+  ).data;
+};
+
+export const deleteBoardCardComment = async (
+  params: IDeleteBoardCardCommentParams,
+): Promise<IDeleteBoardCardCommentResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IDeleteBoardCardCommentResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/comment/${params.boardCardCommentId}`,
+    )
+  ).data;
+};
+
+export const updateBoardCardComment = async (
+  params: IUpdateBoardCardCommentParams,
+  body: IUpdateBoardCardCommentBody,
+): Promise<IUpdateBoardCardCommentResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.put<IUpdateBoardCardCommentResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/comment/${params.boardCardCommentId}`,
+      body,
+    )
+  ).data;
+};
+
+export const createBoardCardComment = async (
+  params: ICreateBoardCardCommentParams,
+  body: ICreateBoardCardCommentBody,
+): Promise<ICreateBoardCardCommentResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ICreateBoardCardCommentResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/comment`,
+      body,
+    )
+  ).data;
+};

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

@@ -0,0 +1,57 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  ICloudImportBoardCardDocumentBody,
+  ICloudImportBoardCardDocumentParams,
+  ICloudImportBoardCardDocumentResponse,
+  IDeleteBoardCardDocumentParams,
+  IDeleteBoardCardDocumentResponse,
+  IGetBoardCardDocumentParams,
+  IGetBoardCardDocumentResponse,
+  IGetUploadPreSignedUrlBoardCardDocumentBody,
+  IGetUploadPreSignedUrlBoardCardDocumentParams,
+  IGetUploadPreSignedUrlBoardCardDocumentResponse,
+} from '../types';
+
+export const getBoardCardDocument = async (
+  params: IGetBoardCardDocumentParams,
+): Promise<IGetBoardCardDocumentResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IGetBoardCardDocumentResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/document/${params.boardCardDocumentId}`,
+    )
+  ).data;
+};
+
+export const deleteBoardCardDocument = async (
+  params: IDeleteBoardCardDocumentParams,
+): Promise<IDeleteBoardCardDocumentResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IDeleteBoardCardDocumentResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/document/${params.boardCardDocumentId}`,
+    )
+  ).data;
+};
+
+export const getUploadPreSignedUrlBoardCardDocument = async (
+  params: IGetUploadPreSignedUrlBoardCardDocumentParams,
+  body: IGetUploadPreSignedUrlBoardCardDocumentBody,
+): Promise<IGetUploadPreSignedUrlBoardCardDocumentResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<IGetUploadPreSignedUrlBoardCardDocumentResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/document`,
+      body,
+    )
+  ).data;
+};
+
+export const cloudImportBoardCardDocument = async (
+  params: ICloudImportBoardCardDocumentParams,
+  body: ICloudImportBoardCardDocumentBody,
+): Promise<ICloudImportBoardCardDocumentResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ICloudImportBoardCardDocumentResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/document/cloud-import`,
+      body,
+    )
+  ).data;
+};

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

@@ -0,0 +1,57 @@
+import { AbyssWorkspaceCore } from '..';
+import {
+  IBacklinksBoardCardLinkQuery,
+  IBacklinksBoardCardLinkResponse,
+  ICreateBoardCardLinkBody,
+  ICreateBoardCardLinkParams,
+  ICreateBoardCardLinkResponse,
+  IDeleteBoardCardLinkParams,
+  IDeleteBoardCardLinkResponse,
+  IListBoardCardLinkParams,
+  IListBoardCardLinkResponse,
+} from '../types';
+
+export const createBoardCardLink = async (
+  params: ICreateBoardCardLinkParams,
+  body: ICreateBoardCardLinkBody,
+): Promise<ICreateBoardCardLinkResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.post<ICreateBoardCardLinkResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/link`,
+      body,
+    )
+  ).data;
+};
+
+export const deleteBoardCardLink = async (
+  params: IDeleteBoardCardLinkParams,
+): Promise<IDeleteBoardCardLinkResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.delete<IDeleteBoardCardLinkResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/link/${params.boardCardLinkId}`,
+    )
+  ).data;
+};
+
+export const listBoardCardLink = async (
+  params: IListBoardCardLinkParams,
+): Promise<IListBoardCardLinkResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IListBoardCardLinkResponse>(
+      `board/${params.boardId}/card/${params.boardCardId}/links`,
+    )
+  ).data;
+};
+
+export const backlinksBoardCardLink = async (
+  query: IBacklinksBoardCardLinkQuery,
+): Promise<IBacklinksBoardCardLinkResponse> => {
+  return (
+    await AbyssWorkspaceCore.axios.get<IBacklinksBoardCardLinkResponse>(
+      'board-card-link/backlinks',
+      {
+        params: query,
+      },
+    )
+  ).data;
+};