@abyss-project/tools 1.1.1 → 1.3.0

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

@@ -1,124 +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;
-};
+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

@@ -1,103 +1,103 @@
-import { AbyssToolsCore } 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 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 createForOrganizationAtlas = async (
-  params: ICreateForOrganizationAtlasParams,
-  body: ICreateAtlasBody,
-): Promise<ICreateAtlasResponse> => {
-  return (
-    await AbyssToolsCore.axios.post<ICreateAtlasResponse>(`atlas/organization/${params.organizationId}`, body)
-  ).data;
-};
-
-export const paginateOrganizationAtlas = async (
-  params: IPaginateOrganizationAtlasParams,
-  query: IPaginateAtlasQuery,
-): Promise<IPaginateAtlasResponse> => {
-  return (
-    await AbyssToolsCore.axios.get<IPaginateAtlasResponse>(
-      `organization/${params.organizationId}/atlas/paginate`,
-      { params: query },
-    )
-  ).data;
-};
-
-export const transferAtlas = async (
-  params: { atlasId: string },
-  body: ITransferContentBody,
-): Promise<ITransferAtlasResponse> => {
-  return (
-    await AbyssToolsCore.axios.post<ITransferAtlasResponse>(
-      `atlas/${params.atlasId}/transfer`,
-      body,
-    )
-  ).data;
-};
-
-export const countOrganizationAtlas = async (
-  params: { organizationId: string },
-): Promise<ICountOrganizationResponse> => {
-  return (
-    await AbyssToolsCore.axios.get<ICountOrganizationResponse>(
-      `atlas/organization/${params.organizationId}/count`,
-    )
-  ).data;
-};
+import { AbyssToolsCore } 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 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 createForOrganizationAtlas = async (
+  params: ICreateForOrganizationAtlasParams,
+  body: ICreateAtlasBody,
+): Promise<ICreateAtlasResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<ICreateAtlasResponse>(`atlas/organization/${params.organizationId}`, body)
+  ).data;
+};
+
+export const paginateOrganizationAtlas = async (
+  params: IPaginateOrganizationAtlasParams,
+  query: IPaginateAtlasQuery,
+): Promise<IPaginateAtlasResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IPaginateAtlasResponse>(
+      `organization/${params.organizationId}/atlas/paginate`,
+      { params: query },
+    )
+  ).data;
+};
+
+export const transferAtlas = async (
+  params: { atlasId: string },
+  body: ITransferContentBody,
+): Promise<ITransferAtlasResponse> => {
+  return (
+    await AbyssToolsCore.axios.post<ITransferAtlasResponse>(
+      `atlas/${params.atlasId}/transfer`,
+      body,
+    )
+  ).data;
+};
+
+export const countOrganizationAtlas = async (
+  params: { organizationId: string },
+): Promise<ICountOrganizationResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<ICountOrganizationResponse>(
+      `atlas/organization/${params.organizationId}/count`,
+    )
+  ).data;
+};

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

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

package/src/api/beam.api.ts

@@ -42,6 +42,9 @@ import type {
   IAddRecipientsBeamBody,
   IAddRecipientsBeamResponse,
   IListRecipientsBeamResponse,
+  IGetBeamStatsParams,
+  IGetBeamStatsQuery,
+  IGetBeamStatsResponse,
 } from '../types';
 import { BEAM_MANAGE_TOKEN_HEADER } from '../constants/beam.constants';
 
@@ -51,6 +54,10 @@ import { BEAM_MANAGE_TOKEN_HEADER } from '../constants/beam.constants';
 const manageTokenHeader = (manageToken?: string): { headers?: Record<string, string> } =>
   manageToken ? { headers: { [BEAM_MANAGE_TOKEN_HEADER]: manageToken } } : {};
 
+// renew/reactivate POST body: only carry `days` when the caller requested a
+// specific extension window (the API clamps it to the tier cap; default 7).
+const renewalBody = (days?: number): { days?: number } => (days !== undefined ? { days } : {});
+
 export const beamApi = {
   get: async (params: IGetBeamParams): Promise<IGetBeamResponse> => {
     const response = await AbyssToolsCore.axios.get<IGetBeamResponse>(`/beam/${params.beamId}`);
@@ -138,13 +145,31 @@ export const beamApi = {
 
   renew: async (params: IRenewBeamParams): Promise<IRenewBeamResponse> => {
     return (
-      await AbyssToolsCore.axios.post<IRenewBeamResponse>(`/beam/${params.beamId}/renew`)
+      await AbyssToolsCore.axios.post<IRenewBeamResponse>(
+        `/beam/${params.beamId}/renew`,
+        renewalBody(params.days),
+      )
     ).data;
   },
 
   reactivate: async (params: IReactivateBeamParams): Promise<IReactivateBeamResponse> => {
     return (
-      await AbyssToolsCore.axios.post<IReactivateBeamResponse>(`/beam/${params.beamId}/reactivate`)
+      await AbyssToolsCore.axios.post<IReactivateBeamResponse>(
+        `/beam/${params.beamId}/reactivate`,
+        renewalBody(params.days),
+      )
+    ).data;
+  },
+
+  // Owner download stats (MANAGE-gated): per-day series + recent events + totals.
+  stats: async (
+    params: IGetBeamStatsParams,
+    query?: IGetBeamStatsQuery,
+  ): Promise<IGetBeamStatsResponse> => {
+    return (
+      await AbyssToolsCore.axios.get<IGetBeamStatsResponse>(`/beam/${params.beamId}/stats`, {
+        params: query,
+      })
     ).data;
   },
 
@@ -258,7 +283,7 @@ export const beamApi = {
       return (
         await AbyssToolsCore.axios.post<IRenewBeamResponse>(
           `/beam/${params.beamId}/renew`,
-          undefined,
+          renewalBody(params.days),
           manageTokenHeader(params.manageToken),
         )
       ).data;
@@ -269,7 +294,7 @@ export const beamApi = {
       return (
         await AbyssToolsCore.axios.post<IReactivateBeamResponse>(
           `/beam/${params.beamId}/reactivate`,
-          undefined,
+          renewalBody(params.days),
           manageTokenHeader(params.manageToken),
         )
       ).data;