memind/src/api/mindspace-publications.ts

import type {
  MindSpacePublication,
  MindSpacePublicationStats,
  MindSpacePublishCheck,
  MindSpaceRedactedCopyResult,
} from '../types';
import { apiFetch } from './core';
import { getMindSpacePage } from './mindspace-pages';

export async function checkMindSpacePagePublication(
  pageId: string,
  input: {
    pageVersionId: string;
    accessMode: MindSpacePublishCheck['accessMode'];
    urlSlug: string;
    password?: string;
    expiresAt?: number | null;
  },
): Promise<MindSpacePublishCheck> {
  const result = await apiFetch<{ data: MindSpacePublishCheck }>(
    `/mindspace/v1/pages/${encodeURIComponent(pageId)}/publish-check`,
    {
      method: 'POST',
      body: JSON.stringify({
        page_version_id: input.pageVersionId,
        access_mode: input.accessMode,
        url_slug: input.urlSlug,
        password: input.password,
        expires_at: input.expiresAt,
      }),
    },
  );
  return result.data;
}

export async function publishMindSpacePage(
  pageId: string,
  input: {
    pageVersionId: string;
    accessMode: MindSpacePublishCheck['accessMode'];
    urlSlug: string;
    acknowledgedFindingIds: string[];
    password?: string;
    expiresAt?: number | null;
  },
): Promise<MindSpacePublication> {
  const result = await apiFetch<{ data: MindSpacePublication }>(
    `/mindspace/v1/pages/${encodeURIComponent(pageId)}/publish`,
    {
      method: 'POST',
      body: JSON.stringify({
        page_version_id: input.pageVersionId,
        access_mode: input.accessMode,
        url_slug: input.urlSlug,
        password: input.password,
        expires_at: input.expiresAt,
        acknowledged_finding_ids: input.acknowledgedFindingIds,
      }),
    },
  );
  return result.data;
}

export async function updatePublicationStatus(
  publicationId: string,
  input: {
    accessMode: MindSpacePublishCheck['accessMode'];
    expiresAt?: number | null;
  },
): Promise<MindSpacePublication> {
  const result = await apiFetch<{ data: MindSpacePublication }>(
    `/mindspace/v1/publications/${encodeURIComponent(publicationId)}/update-status`,
    {
      method: 'POST',
      body: JSON.stringify({
        access_mode: input.accessMode,
        expires_at: input.expiresAt,
      }),
    },
  );
  return result.data;
}

export async function redactMindSpacePage(
  pageId: string,
  input: {
    pageVersionId: string;
    expectedVersion: number;
    title: string;
    summary: string;
    content: string;
  },
): Promise<MindSpaceRedactedCopyResult> {
  const result = await apiFetch<{ data: MindSpaceRedactedCopyResult }>(
    `/mindspace/v1/pages/${encodeURIComponent(pageId)}/redact`,
    {
      method: 'POST',
      body: JSON.stringify({
        page_version_id: input.pageVersionId,
        expected_version: input.expectedVersion,
        title: input.title,
        summary: input.summary,
        content: input.content,
      }),
    },
  );
  return result.data;
}

export async function fixMindSpacePagePublication(
  pageId: string,
  input: {
    pageVersionId: string;
    expectedVersion: number;
    title: string;
    summary: string;
    content: string;
  },
): Promise<MindSpaceRedactedCopyResult> {
  const result = await apiFetch<{ data: MindSpaceRedactedCopyResult }>(
    `/mindspace/v1/pages/${encodeURIComponent(pageId)}/publish-fix`,
    {
      method: 'POST',
      body: JSON.stringify({
        page_version_id: input.pageVersionId,
        expected_version: input.expectedVersion,
        title: input.title,
        summary: input.summary,
        content: input.content,
      }),
    },
  );
  return result.data;
}

/** @deprecated use redactMindSpacePage */
export async function createMindSpaceRedactedCopy(
  pageId: string,
  pageVersionId: string,
): Promise<MindSpaceRedactedCopyResult> {
  const page = await getMindSpacePage(pageId);
  return redactMindSpacePage(pageId, {
    pageVersionId,
    expectedVersion: page.versionNo,
    title: page.title,
    summary: page.summary,
    content: page.content ?? '',
  });
}

export async function offlineMindSpacePublication(publicationId: string): Promise<void> {
  await apiFetch(
    `/mindspace/v1/publications/${encodeURIComponent(publicationId)}/offline`,
    { method: 'POST', body: JSON.stringify({}) },
  );
}

export async function getMindSpacePublicationStats(
  publicationId: string,
): Promise<MindSpacePublicationStats> {
  const result = await apiFetch<{ data: MindSpacePublicationStats }>(
    `/mindspace/v1/publications/${encodeURIComponent(publicationId)}/stats`,
  );
  return result.data;
}