@abyss-project/tools 1.0.0

package/dist/utils/shape.utils.d.ts

@@ -0,0 +1,26 @@
+import { Id, Point, DrawSize, DrawStyle, DrawShapeToJsonResult } from '../types/draw.type';
+export type Endpoint = {
+    style: DrawArrowEndpointStyle;
+} & ({
+    kind: 'free';
+    x: number;
+    y: number;
+} | {
+    kind: 'anchor';
+    shapeId: Id;
+    relativeX: number;
+    relativeY: number;
+});
+export type DrawArrowEndpointStyle = 'arrow' | 'circle' | 'square' | 'diamond' | 'none';
+export type CurvePoint = Point & {
+    type: 'straight' | 'curved';
+};
+export declare const rectangleToSvg: (position: Point, size: DrawSize, style: DrawStyle) => string;
+export declare const diamondToSvg: (position: Point, size: DrawSize, style: DrawStyle) => string;
+export declare const ellipseToSvg: (position: Point, size: DrawSize, style: DrawStyle) => string;
+export declare const textToSvg: (position: Point, style: DrawStyle, text: string) => string;
+export declare const iconToSvg: (position: Point, size: DrawSize, style: DrawStyle, iconSymbol: string) => string;
+export declare const imageToSvg: (position: Point, size: DrawSize, style: DrawStyle, src: string) => string;
+export declare const commentToSvg: (position: Point, size: DrawSize, style: DrawStyle, id: string) => string;
+export declare const arrowToSvg: (style: DrawStyle, startEndpoint: Endpoint, endEndpoint: Endpoint, fromPos: Point, toPos: Point) => string;
+export declare const sceneToSVG: (shapes: DrawShapeToJsonResult[], width: number, height: number) => string;

package/dist/utils/shape.utils.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sceneToSVG = exports.arrowToSvg = exports.commentToSvg = exports.imageToSvg = exports.iconToSvg = exports.textToSvg = exports.ellipseToSvg = exports.diamondToSvg = exports.rectangleToSvg = void 0;
+const icons_utils_1 = require("./icons.utils");
+const draw_type_1 = require("../types/draw.type");
+const rectangleToSvg = (position, size, style) => {
+    const x = position.x - size.width / 2;
+    const y = position.y - size.height / 2;
+    const width = size.width;
+    const height = size.height;
+    const fillColor = style.fillColor === 'none' ? 'none' : style.fillColor;
+    const strokeColor = style.strokeColor === 'none' ? 'none' : style.strokeColor;
+    const centerX = position.x;
+    const centerY = position.y;
+    return `<rect x="${x}" y="${y}" width="${width}" height="${height}" fill="${fillColor}" stroke="${strokeColor}" stroke-width="${style.strokeWidth}" opacity="${style.opacity}" rx="${style.cornerRadius}" ry="${style.cornerRadius}" stroke-dasharray="${style.lineDash || 'none'}" transform="rotate(${style.rotation} ${centerX} ${centerY})" />`;
+};
+exports.rectangleToSvg = rectangleToSvg;
+const diamondToSvg = (position, size, style) => {
+    const cx = position.x;
+    const cy = position.y;
+    const halfWidth = size.width / 2;
+    const halfHeight = size.height / 2;
+    const fillColor = style.fillColor === 'none' ? 'none' : style.fillColor;
+    const strokeColor = style.strokeColor === 'none' ? 'none' : style.strokeColor;
+    const points = [
+        `${cx},${cy - halfHeight}`,
+        `${cx + halfWidth},${cy}`,
+        `${cx},${cy + halfHeight}`,
+        `${cx - halfWidth},${cy}`,
+    ].join(' ');
+    return `<polygon points="${points}" fill="${fillColor}" stroke="${strokeColor}" stroke-width="${style.strokeWidth}" stroke-dasharray="${style.lineDash || 'none'}" opacity="${style.opacity}" transform="rotate(${style.rotation} ${cx} ${cy})" />`;
+};
+exports.diamondToSvg = diamondToSvg;
+const ellipseToSvg = (position, size, style) => {
+    const cx = position.x;
+    const cy = position.y;
+    const radiusX = size.width / 2;
+    const radiusY = size.height / 2;
+    const fillColor = style.fillColor === 'none' ? 'none' : style.fillColor;
+    const strokeColor = style.strokeColor === 'none' ? 'none' : style.strokeColor;
+    return `<ellipse cx="${cx}" cy="${cy}" rx="${radiusX}" ry="${radiusY}" fill="${fillColor}" stroke="${strokeColor}" stroke-width="${style.strokeWidth}" opacity="${style.opacity}" stroke-dasharray="${style.lineDash || 'none'}" transform="rotate(${style.rotation} ${cx} ${cy})" />`;
+};
+exports.ellipseToSvg = ellipseToSvg;
+const textToSvg = (position, style, text) => {
+    const x = position.x;
+    const y = position.y;
+    const fillColor = style.fillColor === 'none' ? 'none' : style.fillColor;
+    const strokeColor = style.strokeColor === 'none' ? 'none' : style.strokeColor;
+    return `<text x="${x}" y="${y}" fill="${fillColor}" stroke="${strokeColor}" stroke-width="${style.strokeWidth}" opacity="${style.opacity}" font-size="${style.fontSize}" font-family="${style.fontFamily}"
+  stroke-dasharray="${style.lineDash || 'none'}" text-anchor="middle" dominant-baseline="middle" transform="rotate(${style.rotation} ${x} ${y})">${text}</text>`;
+};
+exports.textToSvg = textToSvg;
+const iconToSvg = (position, size, style, iconSymbol) => {
+    const x = position.x;
+    const y = position.y;
+    const fillColor = style.fillColor === 'none' ? 'none' : style.fillColor;
+    const strokeColor = style.strokeColor === 'none' ? 'none' : style.strokeColor;
+    const fontSize = Math.min(size.width, size.height) * 0.8;
+    return `<text x="${x}" y="${y}" fill="${fillColor}" stroke="${strokeColor}" stroke-width="${style.strokeWidth}" opacity="${style.opacity}" font-size="${fontSize}" font-family="Arial" text-anchor="middle" dominant-baseline="middle" transform="rotate(${style.rotation} ${x} ${y})">${iconSymbol}</text>`;
+};
+exports.iconToSvg = iconToSvg;
+const imageToSvg = (position, size, style, src) => {
+    const x = position.x - size.width / 2;
+    const y = position.y - size.height / 2;
+    const width = size.width;
+    const height = size.height;
+    const strokeColor = style.strokeColor === 'none' ? 'none' : style.strokeColor;
+    const centerX = position.x;
+    const centerY = position.y;
+    return `<image x="${x}" y="${y}" width="${width}" height="${height}" href="${src}" opacity="${style.opacity}" stroke="${strokeColor}" stroke-width="${style.strokeWidth}" rx="${style.cornerRadius}" ry="${style.cornerRadius}" transform="rotate(${style.rotation} ${centerX} ${centerY})" />`;
+};
+exports.imageToSvg = imageToSvg;
+const commentToSvg = (position, size, style, id) => {
+    const cx = position.x;
+    const cy = position.y;
+    const radius = size.width / 2;
+    const fillColor = style.fillColor === 'none' ? 'transparent' : style.fillColor;
+    const strokeColor = style.strokeColor === 'none' ? 'none' : style.strokeColor;
+    const fontSize = size.width * 0.6;
+    const textX = cx;
+    const textY = cy + fontSize * 0.35;
+    return `
+    <g opacity="${style.opacity}" transform="rotate(${style.rotation} ${cx} ${cy})">
+      <defs>
+        <filter id="comment-shadow-${id}" x="-50%" y="-50%" width="200%" height="200%">
+          <feDropShadow dx="2" dy="2" stdDeviation="5" flood-color="black" flood-opacity="0.3"/>
+        </filter>
+      </defs>
+      <circle cx="${cx}" cy="${cy}" r="${radius}" fill="${fillColor}" stroke="${strokeColor}" stroke-width="${style.strokeWidth}" filter="url(#comment-shadow-${id})" />
+      <text x="${textX}" y="${textY}" fill="white" font-size="${fontSize}" font-family="Arial" text-anchor="middle" dominant-baseline="middle" font-weight="bold">!</text>
+    </g>`;
+};
+exports.commentToSvg = commentToSvg;
+const renderEndpointStyleSvg = (x, y, style, angle, strokeColor, fillColor, strokeWidth) => {
+    switch (style) {
+        case 'circle':
+            return `<circle cx="${x}" cy="${y}" r="6" fill="${fillColor}" stroke="${strokeColor}" stroke-width="${strokeWidth}" />`;
+        case 'square':
+            const squareX = x - 6;
+            const squareY = y - 6;
+            return `<rect x="${squareX}" y="${squareY}" width="12" height="12" fill="${fillColor}" stroke="${strokeColor}" stroke-width="${strokeWidth}" transform="rotate(${angle * (180 / Math.PI)} ${x} ${y})" />`;
+        case 'diamond':
+            return `<polygon points="${x},${y - 6} ${x + 6},${y} ${x},${y + 6} ${x - 6},${y}" fill="${fillColor}" stroke="${strokeColor}" stroke-width="${strokeWidth}" transform="rotate(${angle * (180 / Math.PI)} ${x} ${y})" />`;
+        case 'arrow':
+            const arrowSize = 8;
+            const x1 = x - arrowSize * Math.cos(angle - Math.PI / 6);
+            const y1 = y - arrowSize * Math.sin(angle - Math.PI / 6);
+            const x2 = x - arrowSize * Math.cos(angle + Math.PI / 6);
+            const y2 = y - arrowSize * Math.sin(angle + Math.PI / 6);
+            return `<polygon points="${x},${y} ${x1},${y1} ${x2},${y2}" fill="${fillColor}" stroke="${strokeColor}" stroke-width="${strokeWidth}" />`;
+        case 'none':
+        default:
+            return '';
+    }
+};
+const arrowToSvg = (style, startEndpoint, endEndpoint, fromPos, toPos) => {
+    const angle = Math.atan2(toPos.y - fromPos.y, toPos.x - fromPos.x);
+    let svg = `<g opacity="${style.opacity}">`;
+    svg += `<line x1="${fromPos.x}" y1="${fromPos.y}" x2="${toPos.x}" y2="${toPos.y}" stroke="${style.strokeColor}" stroke-width="${style.strokeWidth}" />`;
+    svg += renderEndpointStyleSvg(fromPos.x, fromPos.y, startEndpoint.style, angle + Math.PI, style.strokeColor, style.fillColor, style.strokeWidth);
+    svg += renderEndpointStyleSvg(toPos.x, toPos.y, endEndpoint.style, angle, style.strokeColor, style.fillColor, style.strokeWidth);
+    svg += '</g>';
+    return svg;
+};
+exports.arrowToSvg = arrowToSvg;
+const sceneToSVG = (shapes, width, height) => {
+    const shapeEls = shapes
+        .sort((a, b) => (a.zIndex || 0) - (b.zIndex || 0))
+        .map((s) => {
+        var _a, _b;
+        switch (s.type) {
+            case draw_type_1.DrawShapeType.RECTANGLE:
+                return (0, exports.rectangleToSvg)(s.position, s.size, s.style);
+            case draw_type_1.DrawShapeType.DIAMOND:
+                return (0, exports.diamondToSvg)(s.position, s.size, s.style);
+            case draw_type_1.DrawShapeType.ELLIPSE:
+                return (0, exports.ellipseToSvg)(s.position, s.size, s.style);
+            case draw_type_1.DrawShapeType.TEXT:
+                return (0, exports.textToSvg)(s.position, s.style, s.text || '');
+            case draw_type_1.DrawShapeType.ICON:
+                const iconSymbol = icons_utils_1.ICON_LIBRARY[s.iconType] || '';
+                return (0, exports.iconToSvg)(s.position, s.size, s.style, iconSymbol);
+            case draw_type_1.DrawShapeType.IMAGE:
+                return (0, exports.imageToSvg)(s.position, s.size, s.style, s.src);
+            case draw_type_1.DrawShapeType.COMMENT:
+                return (0, exports.commentToSvg)(s.position, s.size, s.style, s.id);
+            case draw_type_1.DrawShapeType.ARROW:
+                if (s.startEndpoint && s.endEndpoint) {
+                    const fromPos = s.startEndpoint.kind === 'anchor'
+                        ? (_a = shapes.find((shape) => { var _a; return shape.id === ((_a = s.startEndpoint) === null || _a === void 0 ? void 0 : _a.shapeId); })) === null || _a === void 0 ? void 0 : _a.position
+                        : {
+                            x: s.startEndpoint.x,
+                            y: s.startEndpoint.y,
+                        };
+                    const toPos = s.endEndpoint.kind === 'anchor'
+                        ? (_b = shapes.find((shape) => { var _a; return shape.id === ((_a = s.endEndpoint) === null || _a === void 0 ? void 0 : _a.shapeId); })) === null || _b === void 0 ? void 0 : _b.position
+                        : {
+                            x: s.endEndpoint.x,
+                            y: s.endEndpoint.y,
+                        };
+                    if (!fromPos || !toPos)
+                        return '';
+                    return (0, exports.arrowToSvg)(s.style, s.startEndpoint, s.endEndpoint, fromPos, toPos);
+                }
+                return '';
+            default:
+                return '';
+        }
+    });
+    const defs = `
+<defs>
+  <marker id="arrow" markerWidth="10" markerHeight="10" refX="10" refY="5" orient="auto-start-reverse">
+    <path d="M0,0 L10,5 L0,10 z" fill="currentColor"/>
+  </marker>
+</defs>`;
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}">
+  ${defs}
+  ${shapeEls.join('\n')}
+</svg>`;
+};
+exports.sceneToSVG = sceneToSVG;

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@abyss-project/tools",
+  "version": "1.0.0",
+  "description": "Core package to interact with Abyss-Project Tools",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/abyss-group"
+  },
+  "keywords": [],
+  "author": "scylla",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.2.2",
+    "axios-retry": "^3.5.0",
+    "date-fns": "^2.30.0",
+    "dayjs": "^1.10.7",
+    "jsonwebtoken": "^8.5.1",
+    "reflect-metadata": "^0.1.13",
+    "ts-node": "^10.4.0",
+    "ts-node-dev": "^1.1.1",
+    "uuid": "^8.3.2"
+  },
+  "devDependencies": {
+    "@types/express-serve-static-core": "^4.17.31",
+    "@types/jsonwebtoken": "^8.5.0",
+    "@types/node": "^20.11.0",
+    "@types/uuid": "^8.3.0",
+    "@typescript-eslint/eslint-plugin": "6.21.0",
+    "@typescript-eslint/parser": "7.3.1",
+    "eslint": "^7.28.0",
+    "eslint-config-airbnb-base": "^14.2.1",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-plugin-filenames-simple": "^0.7.0",
+    "eslint-plugin-import": "^2.23.4",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^3.4.0",
+    "eslint-plugin-promise": "^5.1.0",
+    "prettier": "2.3.1",
+    "typescript": "5.4.2",
+    "tsc-watch": "^4.6.2"
+  },
+  "scripts": {
+    "lint": "eslint \"{src,apps,libs,test,core}/**/*.ts\" --fix",
+    "lint:check": "eslint \"{src,apps,libs,test,core}/**/*.ts\" --max-warnings 0",
+    "tsc": "tsc",
+    "build": "tsc",
+    "prepublish": "tsc",
+    "dev": "tsc --watch"
+  }
+}

package/src/api/abyss.admin.api.ts

@@ -0,0 +1,60 @@
+import {
+  AbyssToolsCore,
+  IActivateUserServiceAbyssAdminBody,
+  IActivateUserServiceAbyssAdminResponse,
+  ISyncOrganizationAbyssAdminBody,
+  ISyncOrganizationAbyssAdminResponse,
+  ISyncProjectAbyssAdminBody,
+  ISyncProjectAbyssAdminResponse,
+} from '..';
+
+export const deleteUserAbyssAdmin = async (
+  userId: string,
+): Promise<void> => {
+  await AbyssToolsCore.axios.delete(`abyss/admin/user/${userId}`);
+};
+
+export const activateUserServiceAbyssAdmin = async (
+  body: IActivateUserServiceAbyssAdminBody,
+): Promise<IActivateUserServiceAbyssAdminResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<IActivateUserServiceAbyssAdminResponse>(
+      `abyss/admin/user/activate-service`,
+      body,
+    )
+  ).data;
+};
+
+export const syncOrganizationAbyssAdmin = async (
+  body: ISyncOrganizationAbyssAdminBody,
+): Promise<ISyncOrganizationAbyssAdminResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<ISyncOrganizationAbyssAdminResponse>(
+      `abyss/admin/organization/sync`,
+      body,
+    )
+  ).data;
+};
+
+export const deleteOrganizationAbyssAdmin = async (
+  organizationId: string,
+): Promise<void> => {
+  await AbyssToolsCore.axios.delete(`abyss/admin/organization/${organizationId}`);
+};
+
+export const syncProjectAbyssAdmin = async (
+  body: ISyncProjectAbyssAdminBody,
+): Promise<ISyncProjectAbyssAdminResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<ISyncProjectAbyssAdminResponse>(
+      `abyss/admin/project/sync`,
+      body,
+    )
+  ).data;
+};
+
+export const deleteProjectAbyssAdmin = async (
+  projectId: string,
+): Promise<void> => {
+  await AbyssToolsCore.axios.delete(`abyss/admin/project/${projectId}`);
+};

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

@@ -0,0 +1,68 @@
+import { AbyssToolsCore } from '..';
+import {
+  IDeleteAtlasDocumentParams,
+  IDeleteAtlasDocumentResponse,
+  IGetAtlasDocumentParams,
+  IGetAtlasDocumentResponse,
+  IGetUploadPreSignedUrlAtlasDocumentBody,
+  IGetUploadPreSignedUrlAtlasDocumentParams,
+  IGetUploadPreSignedUrlAtlasDocumentResponse,
+  IPaginateAtlasDocumentParams,
+  IPaginateAtlasDocumentQuery,
+  IPaginateAtlasDocumentResponse,
+  IListAtlasDocumentParams,
+  IListAtlasDocumentResponse,
+} from '../types';
+
+export const getAtlasDocument = async (
+  params: IGetAtlasDocumentParams,
+): Promise<IGetAtlasDocumentResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetAtlasDocumentResponse>(
+      `atlas/${params.atlasId}/document/${params.atlasDocumentId}`,
+    )
+  ).data;
+};
+
+export const deleteAtlasDocument = async (
+  params: IDeleteAtlasDocumentParams,
+): Promise<IDeleteAtlasDocumentResponse> => {
+  return (
+    await AbyssToolsCore.axios.delete<IDeleteAtlasDocumentResponse>(
+      `atlas/${params.atlasId}/document/${params.atlasDocumentId}`,
+    )
+  ).data;
+};
+
+export const getUploadPreSignedUrlAtlasDocument = async (
+  params: IGetUploadPreSignedUrlAtlasDocumentParams,
+  body: IGetUploadPreSignedUrlAtlasDocumentBody,
+): Promise<IGetUploadPreSignedUrlAtlasDocumentResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<IGetUploadPreSignedUrlAtlasDocumentResponse>(
+      `atlas/${params.atlasId}/document/${params.atlasPageId}`,
+      body,
+    )
+  ).data;
+};
+
+export const paginateAtlasDocument = async (
+  params: IPaginateAtlasDocumentParams,
+  query?: IPaginateAtlasDocumentQuery,
+): Promise<IPaginateAtlasDocumentResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IPaginateAtlasDocumentResponse>(`atlas/${params.atlasId}/document`, {
+      params: query,
+    })
+  ).data;
+};
+
+export const listAtlasDocument = async (
+  params: IListAtlasDocumentParams,
+): Promise<IListAtlasDocumentResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IListAtlasDocumentResponse>(
+      `atlas/${params.atlasId}/document/page/${params.atlasPageId}`,
+    )
+  ).data;
+};

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

@@ -0,0 +1,69 @@
+import { AbyssToolsCore } from '..';
+import {
+  ICreateAtlasGroupBody,
+  ICreateAtlasGroupParams,
+  ICreateAtlasGroupResponse,
+  IDeleteAtlasGroupParams,
+  IDeleteAtlasGroupResponse,
+  IGetAtlasGroupParams,
+  IGetAtlasGroupResponse,
+  IPaginateAtlasGroupParams,
+  IPaginateAtlasGroupQuery,
+  IPaginateAtlasGroupResponse,
+  IUpdateAtlasGroupBody,
+  IUpdateAtlasGroupParams,
+  IUpdateAtlasGroupResponse,
+} from '../types';
+
+export const paginateAtlasGroup = async (
+  params: IPaginateAtlasGroupParams,
+  query: IPaginateAtlasGroupQuery,
+): Promise<IPaginateAtlasGroupResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IPaginateAtlasGroupResponse>(
+      `atlas/${params.atlasId}/group/paginate`,
+      { params: query },
+    )
+  ).data;
+};
+
+export const getAtlasGroup = async (
+  params: IGetAtlasGroupParams,
+): Promise<IGetAtlasGroupResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetAtlasGroupResponse>(
+      `atlas/${params.atlasId}/group/${params.atlasGroupId}`,
+    )
+  ).data;
+};
+
+export const deleteAtlasGroup = async (
+  params: IDeleteAtlasGroupParams,
+): Promise<IDeleteAtlasGroupResponse> => {
+  return (
+    await AbyssToolsCore.axios.delete<IDeleteAtlasGroupResponse>(
+      `atlas/${params.atlasId}/group/${params.atlasGroupId}`,
+    )
+  ).data;
+};
+
+export const updateAtlasGroup = async (
+  params: IUpdateAtlasGroupParams,
+  body: IUpdateAtlasGroupBody,
+): Promise<IUpdateAtlasGroupResponse> => {
+  return (
+    await AbyssToolsCore.axios.put<IUpdateAtlasGroupResponse>(
+      `atlas/${params.atlasId}/group/${params.atlasGroupId}`,
+      body,
+    )
+  ).data;
+};
+
+export const createAtlasGroup = async (
+  params: ICreateAtlasGroupParams,
+  body: ICreateAtlasGroupBody,
+): Promise<ICreateAtlasGroupResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<ICreateAtlasGroupResponse>(`atlas/${params.atlasId}/group`, body)
+  ).data;
+};

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

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

package/src/api/atlas.api.ts

@@ -0,0 +1,65 @@
+import { AbyssToolsCore } from '..';
+import {
+  ICreateAtlasBody,
+  ICreateAtlasResponse,
+  ICreateForProjectAtlasParams,
+  IDeleteAtlasParams,
+  IDeleteAtlasResponse,
+  IGetAtlasParams,
+  IGetAtlasResponse,
+  IPaginateAtlasQuery,
+  IPaginateAtlasResponse,
+  IPaginateProjectAtlasParams,
+  IUpdateAtlasBody,
+  IUpdateAtlasParams,
+  IUpdateAtlasResponse,
+} from '../types';
+
+export const paginateAtlas = async (
+  query: IPaginateAtlasQuery,
+): Promise<IPaginateAtlasResponse> => {
+  return (await AbyssToolsCore.axios.get<IPaginateAtlasResponse>(`atlas/paginate`, { params: query }))
+    .data;
+};
+
+export const paginateProjectAtlas = async (
+  params: IPaginateProjectAtlasParams,
+  query: IPaginateAtlasQuery,
+): Promise<IPaginateAtlasResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IPaginateAtlasResponse>(
+      `project/${params.projectId}/atlas/paginate`,
+      {
+        params: query,
+      },
+    )
+  ).data;
+};
+
+export const getAtlas = async (params: IGetAtlasParams): Promise<IGetAtlasResponse> => {
+  return (await AbyssToolsCore.axios.get<IGetAtlasResponse>(`atlas/${params.atlasId}`)).data;
+};
+
+export const deleteAtlas = async (params: IDeleteAtlasParams): Promise<IDeleteAtlasResponse> => {
+  return (await AbyssToolsCore.axios.delete<IDeleteAtlasResponse>(`atlas/${params.atlasId}`)).data;
+};
+
+export const updateAtlas = async (
+  params: IUpdateAtlasParams,
+  body: IUpdateAtlasBody,
+): Promise<IUpdateAtlasResponse> => {
+  return (await AbyssToolsCore.axios.put<IUpdateAtlasResponse>(`atlas/${params.atlasId}`, body)).data;
+};
+
+export const createAtlas = async (body: ICreateAtlasBody): Promise<ICreateAtlasResponse> => {
+  return (await AbyssToolsCore.axios.post<ICreateAtlasResponse>(`atlas`, body)).data;
+};
+
+export const createForProjectAtlas = async (
+  params: ICreateForProjectAtlasParams,
+  body: ICreateAtlasBody,
+): Promise<ICreateAtlasResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<ICreateAtlasResponse>(`atlas/project/${params.projectId}`, body)
+  ).data;
+};