@abyss-project/tools 1.0.3 → 1.1.1

package/src/api/beam.api.ts

@@ -0,0 +1,300 @@
+import { AbyssToolsCore } from '..';
+import type {
+  IGetBeamParams,
+  IGetBeamResponse,
+  IGetBeamBySlugParams,
+  IGetBeamPublicResponse,
+  IUnlockBeamPublicParams,
+  IUnlockBeamPublicBody,
+  IUnlockBeamPublicResponse,
+  IPaginateBeamQuery,
+  IPaginateBeamResponse,
+  IPaginateProjectBeamParams,
+  IPaginateOrganizationBeamParams,
+  ICreateBeamBody,
+  ICreateBeamResponse,
+  ICreateForOrganizationBeamParams,
+  IUpdateBeamParams,
+  IUpdateBeamBody,
+  IUpdateBeamResponse,
+  IDeleteBeamParams,
+  IDeleteBeamResponse,
+  ICreateBeamPublicBody,
+  IAddBeamFilesParams,
+  IAddBeamFilesBody,
+  IAddBeamFilesResponse,
+  IImportCloudBeamFilesParams,
+  IImportCloudBeamFilesBody,
+  IFinalizeBeamParams,
+  IFinalizeBeamBody,
+  IFinalizeBeamResponse,
+  IRenewBeamParams,
+  IRenewBeamResponse,
+  IReactivateBeamParams,
+  IReactivateBeamResponse,
+  ICreateBeamShareParams,
+  ICreateBeamShareBody,
+  ICreateBeamShareResponse,
+  IListBeamSharesParams,
+  IListBeamSharesResponse,
+  IRevokeBeamShareParams,
+  IRevokeBeamShareResponse,
+  IAddRecipientsBeamBody,
+  IAddRecipientsBeamResponse,
+  IListRecipientsBeamResponse,
+} from '../types';
+import { BEAM_MANAGE_TOKEN_HEADER } from '../constants/beam.constants';
+
+// Anonymous management requests carry the plaintext manage token as a header the
+// API (BeamMiddleware) compares to beam_transfers.manageTokenHash. Owner requests
+// omit it and authorize via the session JWT instead.
+const manageTokenHeader = (manageToken?: string): { headers?: Record<string, string> } =>
+  manageToken ? { headers: { [BEAM_MANAGE_TOKEN_HEADER]: manageToken } } : {};
+
+export const beamApi = {
+  get: async (params: IGetBeamParams): Promise<IGetBeamResponse> => {
+    const response = await AbyssToolsCore.axios.get<IGetBeamResponse>(`/beam/${params.beamId}`);
+    return response.data;
+  },
+
+  getBySlug: async (params: IGetBeamBySlugParams): Promise<IGetBeamPublicResponse> => {
+    const response = await AbyssToolsCore.axios.get<IGetBeamPublicResponse>(`/b/${params.slug}`);
+    return response.data;
+  },
+
+  unlock: async (
+    params: IUnlockBeamPublicParams,
+    body: IUnlockBeamPublicBody,
+  ): Promise<IUnlockBeamPublicResponse> => {
+    const response = await AbyssToolsCore.axios.post<IUnlockBeamPublicResponse>(
+      `/b/${params.slug}/unlock`,
+      body,
+    );
+    return response.data;
+  },
+
+  paginate: async (query: IPaginateBeamQuery): Promise<IPaginateBeamResponse> => {
+    const response = await AbyssToolsCore.axios.get<IPaginateBeamResponse>('/beam/paginate', {
+      params: query,
+    });
+    return response.data;
+  },
+
+  paginateProject: async (
+    params: IPaginateProjectBeamParams,
+    query: IPaginateBeamQuery,
+  ): Promise<IPaginateBeamResponse> => {
+    const response = await AbyssToolsCore.axios.get<IPaginateBeamResponse>(
+      `/beam/project/${params.projectId}/paginate`,
+      { params: query },
+    );
+    return response.data;
+  },
+
+  paginateOrganization: async (
+    params: IPaginateOrganizationBeamParams,
+    query: IPaginateBeamQuery,
+  ): Promise<IPaginateBeamResponse> => {
+    const response = await AbyssToolsCore.axios.get<IPaginateBeamResponse>(
+      `/beam/organization/${params.organizationId}/paginate`,
+      { params: query },
+    );
+    return response.data;
+  },
+
+  create: async (body: ICreateBeamBody): Promise<ICreateBeamResponse> => {
+    const response = await AbyssToolsCore.axios.post<ICreateBeamResponse>('/beam', body);
+    return response.data;
+  },
+
+  createForOrganization: async (
+    params: ICreateForOrganizationBeamParams,
+    body: ICreateBeamBody,
+  ): Promise<ICreateBeamResponse> => {
+    const response = await AbyssToolsCore.axios.post<ICreateBeamResponse>(
+      `/beam/organization/${params.organizationId}`,
+      body,
+    );
+    return response.data;
+  },
+
+  update: async (
+    params: IUpdateBeamParams,
+    body: IUpdateBeamBody,
+  ): Promise<IUpdateBeamResponse> => {
+    const response = await AbyssToolsCore.axios.put<IUpdateBeamResponse>(
+      `/beam/${params.beamId}`,
+      body,
+    );
+    return response.data;
+  },
+
+  delete: async (params: IDeleteBeamParams): Promise<IDeleteBeamResponse> => {
+    const response = await AbyssToolsCore.axios.delete<IDeleteBeamResponse>(
+      `/beam/${params.beamId}`,
+    );
+    return response.data;
+  },
+
+  renew: async (params: IRenewBeamParams): Promise<IRenewBeamResponse> => {
+    return (
+      await AbyssToolsCore.axios.post<IRenewBeamResponse>(`/beam/${params.beamId}/renew`)
+    ).data;
+  },
+
+  reactivate: async (params: IReactivateBeamParams): Promise<IReactivateBeamResponse> => {
+    return (
+      await AbyssToolsCore.axios.post<IReactivateBeamResponse>(`/beam/${params.beamId}/reactivate`)
+    ).data;
+  },
+
+  share: {
+    create: async (
+      params: ICreateBeamShareParams,
+      body: ICreateBeamShareBody,
+    ): Promise<ICreateBeamShareResponse> => {
+      return (
+        await AbyssToolsCore.axios.post<ICreateBeamShareResponse>(
+          `/beam/${params.beamId}/share`,
+          body,
+        )
+      ).data;
+    },
+    list: async (params: IListBeamSharesParams): Promise<IListBeamSharesResponse> => {
+      return (
+        await AbyssToolsCore.axios.get<IListBeamSharesResponse>(`/beam/${params.beamId}/share`)
+      ).data;
+    },
+    revoke: async (params: IRevokeBeamShareParams): Promise<IRevokeBeamShareResponse> => {
+      return (
+        await AbyssToolsCore.axios.delete<IRevokeBeamShareResponse>(
+          `/beam/${params.beamId}/share/${params.shareId}`,
+        )
+      ).data;
+    },
+  },
+
+  recipients: {
+    add: async (
+      params: { beamId: string },
+      body: IAddRecipientsBeamBody,
+    ): Promise<IAddRecipientsBeamResponse> =>
+      (
+        await AbyssToolsCore.axios.post<IAddRecipientsBeamResponse>(
+          `beam/${params.beamId}/recipients`,
+          body,
+        )
+      ).data,
+    list: async (params: { beamId: string }): Promise<IListRecipientsBeamResponse> =>
+      (
+        await AbyssToolsCore.axios.get<IListRecipientsBeamResponse>(
+          `beam/${params.beamId}/recipients`,
+        )
+      ).data,
+  },
+
+  addFiles: async (
+    params: IAddBeamFilesParams,
+    body: IAddBeamFilesBody,
+  ): Promise<IAddBeamFilesResponse> => {
+    return (
+      await AbyssToolsCore.axios.post<IAddBeamFilesResponse>(`/beam/${params.beamId}/files`, body)
+    ).data;
+  },
+
+  importCloudFiles: async (
+    params: IImportCloudBeamFilesParams,
+    body: IImportCloudBeamFilesBody,
+  ): Promise<IAddBeamFilesResponse> => {
+    return (
+      await AbyssToolsCore.axios.post<IAddBeamFilesResponse>(
+        `/beam/${params.beamId}/files/import-cloud`,
+        body,
+      )
+    ).data;
+  },
+
+  finalize: async (
+    params: IFinalizeBeamParams,
+    body?: IFinalizeBeamBody,
+  ): Promise<IFinalizeBeamResponse> => {
+    return (
+      await AbyssToolsCore.axios.post<IFinalizeBeamResponse>(
+        `/beam/${params.beamId}/finalize`,
+        body ?? {},
+      )
+    ).data;
+  },
+
+  public: {
+    create: async (body: ICreateBeamPublicBody): Promise<ICreateBeamResponse> => {
+      return (await AbyssToolsCore.axios.post<ICreateBeamResponse>(`/beam/public`, body)).data;
+    },
+    addFiles: async (
+      params: IAddBeamFilesParams,
+      body: IAddBeamFilesBody,
+    ): Promise<IAddBeamFilesResponse> => {
+      return (
+        await AbyssToolsCore.axios.post<IAddBeamFilesResponse>(
+          `/beam/public/${params.beamId}/files`,
+          body,
+        )
+      ).data;
+    },
+    finalize: async (
+      params: IFinalizeBeamParams,
+      body?: IFinalizeBeamBody,
+    ): Promise<IFinalizeBeamResponse> => {
+      return (
+        await AbyssToolsCore.axios.post<IFinalizeBeamResponse>(
+          `/beam/public/${params.beamId}/finalize`,
+          body ?? {},
+        )
+      ).data;
+    },
+    renew: async (
+      params: IRenewBeamParams & { manageToken?: string },
+    ): Promise<IRenewBeamResponse> => {
+      return (
+        await AbyssToolsCore.axios.post<IRenewBeamResponse>(
+          `/beam/${params.beamId}/renew`,
+          undefined,
+          manageTokenHeader(params.manageToken),
+        )
+      ).data;
+    },
+    reactivate: async (
+      params: IReactivateBeamParams & { manageToken?: string },
+    ): Promise<IReactivateBeamResponse> => {
+      return (
+        await AbyssToolsCore.axios.post<IReactivateBeamResponse>(
+          `/beam/${params.beamId}/reactivate`,
+          undefined,
+          manageTokenHeader(params.manageToken),
+        )
+      ).data;
+    },
+    update: async (
+      params: IUpdateBeamParams & { manageToken?: string },
+      body: IUpdateBeamBody,
+    ): Promise<IUpdateBeamResponse> => {
+      return (
+        await AbyssToolsCore.axios.put<IUpdateBeamResponse>(
+          `/beam/${params.beamId}`,
+          body,
+          manageTokenHeader(params.manageToken),
+        )
+      ).data;
+    },
+    delete: async (
+      params: IDeleteBeamParams & { manageToken?: string },
+    ): Promise<IDeleteBeamResponse> => {
+      return (
+        await AbyssToolsCore.axios.delete<IDeleteBeamResponse>(
+          `/beam/${params.beamId}`,
+          manageTokenHeader(params.manageToken),
+        )
+      ).data;
+    },
+  },
+};

package/src/api/extraction-plan-preset.api.test.ts

@@ -0,0 +1,24 @@
+// Type-level compile test for the extraction-plan-preset api surface.
+// No jest runner in this SDK package; compile guard only.
+// Run: npx tsc --noEmit (from packages/abyss_tools_core).
+
+import * as api from './extraction-plan-preset.api';
+
+// All seven functions must be exported.
+const _listModes: typeof api.listModes = api.listModes;
+const _listPresets: typeof api.listExtractionPlanPresets = api.listExtractionPlanPresets;
+const _getPreset: typeof api.getExtractionPlanPreset = api.getExtractionPlanPreset;
+const _createPreset: typeof api.createExtractionPlanPreset = api.createExtractionPlanPreset;
+const _updatePreset: typeof api.updateExtractionPlanPreset = api.updateExtractionPlanPreset;
+const _deletePreset: typeof api.deleteExtractionPlanPreset = api.deleteExtractionPlanPreset;
+const _setDefault: typeof api.setDefaultExtractionPlanPreset = api.setDefaultExtractionPlanPreset;
+
+void _listModes;
+void _listPresets;
+void _getPreset;
+void _createPreset;
+void _updatePreset;
+void _deletePreset;
+void _setDefault;
+
+export {};

package/src/api/extraction-plan-preset.api.ts

@@ -0,0 +1,51 @@
+// ──────────────────────────────────────────────
+// Extraction Plan Preset API (V2-P1).
+//
+// GET  /extract/modes            — list registered providers + interpreters.
+// GET  /extract/plans            — list plan presets (system + scoped).
+// GET  /extract/plans/:id        — get a single preset.
+// POST /extract/plans            — create a preset.
+// PUT  /extract/plans/:id        — update a preset.
+// DELETE /extract/plans/:id      — delete a preset.
+// POST /extract/plans/:id/default — set as scope default.
+// ──────────────────────────────────────────────
+
+import { AbyssToolsCore } from '..';
+import type {
+  ICreatePlanPresetBody,
+  IUpdatePlanPresetBody,
+  IListPlanPresetQuery,
+} from '../types';
+import type {
+  IListModesResponse,
+  IListPlanPresetsResponse,
+  IGetPlanPresetResponse,
+  IDeletePlanPresetResponse,
+} from '../types';
+
+const DEFAULT_API_KEY_HEADER = 'x-api-key';
+
+function authHeader(apiKey?: string): Record<string, string> {
+  return apiKey ? { [DEFAULT_API_KEY_HEADER]: apiKey } : {};
+}
+
+export const listModes = async (apiKey?: string): Promise<IListModesResponse> =>
+  (await AbyssToolsCore.axios.get<IListModesResponse>(`extract/modes`, { headers: authHeader(apiKey) })).data;
+
+export const listExtractionPlanPresets = async (query: IListPlanPresetQuery = {}, apiKey?: string): Promise<IListPlanPresetsResponse> =>
+  (await AbyssToolsCore.axios.get<IListPlanPresetsResponse>(`extract/plans`, { params: query, headers: authHeader(apiKey) })).data;
+
+export const getExtractionPlanPreset = async (id: string, apiKey?: string): Promise<IGetPlanPresetResponse> =>
+  (await AbyssToolsCore.axios.get<IGetPlanPresetResponse>(`extract/plans/${id}`, { headers: authHeader(apiKey) })).data;
+
+export const createExtractionPlanPreset = async (body: ICreatePlanPresetBody, apiKey?: string): Promise<IGetPlanPresetResponse> =>
+  (await AbyssToolsCore.axios.post<IGetPlanPresetResponse>(`extract/plans`, body, { headers: authHeader(apiKey) })).data;
+
+export const updateExtractionPlanPreset = async (id: string, body: IUpdatePlanPresetBody, apiKey?: string): Promise<IGetPlanPresetResponse> =>
+  (await AbyssToolsCore.axios.put<IGetPlanPresetResponse>(`extract/plans/${id}`, body, { headers: authHeader(apiKey) })).data;
+
+export const deleteExtractionPlanPreset = async (id: string, apiKey?: string): Promise<IDeletePlanPresetResponse> =>
+  (await AbyssToolsCore.axios.delete<IDeletePlanPresetResponse>(`extract/plans/${id}`, { headers: authHeader(apiKey) })).data;
+
+export const setDefaultExtractionPlanPreset = async (id: string, apiKey?: string): Promise<IGetPlanPresetResponse> =>
+  (await AbyssToolsCore.axios.post<IGetPlanPresetResponse>(`extract/plans/${id}/default`, {}, { headers: authHeader(apiKey) })).data;

package/src/api/extraction-settings.api.ts

@@ -0,0 +1,59 @@
+// ──────────────────────────────────────────────
+// Extraction Settings API (P4 / T7) — per-scope improvement-consent defaults.
+//
+// GET  /extract/settings   — fetch effective improvementDefault for the caller's scope.
+// PUT  /extract/settings   — upsert improvementDefault for the caller's scope.
+//
+// Scope is resolved by the server from standard ?organization_id / ?project_id
+// query params (same as every other extract route).
+// ──────────────────────────────────────────────
+
+import { AbyssToolsCore } from '..';
+import type {
+  IGetExtractionSettingsQuery,
+  IUpsertExtractionSettingsBody,
+} from '../types';
+import type {
+  IGetExtractionSettingsResponse,
+  IUpsertExtractionSettingsResponse,
+} from '../types';
+
+const DEFAULT_API_KEY_HEADER = 'x-api-key';
+
+function authHeader(apiKey?: string): Record<string, string> {
+  return apiKey ? { [DEFAULT_API_KEY_HEADER]: apiKey } : {};
+}
+
+/**
+ * Fetch the effective improvementDefault for the caller's scope.
+ * Returns `{ data: { improvement_default: boolean } }`.
+ * Pass `query.organization_id` or `query.project_id` to select org / project scope;
+ * omit both for personal (user) scope.
+ */
+export const getExtractionSettings = async (
+  query: IGetExtractionSettingsQuery = {},
+  apiKey?: string,
+): Promise<IGetExtractionSettingsResponse> => {
+  return (
+    await AbyssToolsCore.axios.get<IGetExtractionSettingsResponse>(`extract/settings`, {
+      params: query,
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};
+
+/**
+ * Upsert the improvementDefault for the caller's scope.
+ * Body: `{ improvement_default: boolean }`.
+ * Returns `{ data: { improvement_default: boolean } }` on success.
+ */
+export const upsertExtractionSettings = async (
+  body: IUpsertExtractionSettingsBody,
+  apiKey?: string,
+): Promise<IUpsertExtractionSettingsResponse> => {
+  return (
+    await AbyssToolsCore.axios.put<IUpsertExtractionSettingsResponse>(`extract/settings`, body, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
+};