@eightyfourthousand/client-graphql 2026.4.0 → 2026.4.1

package/src/lib/functions/get-translation-uuids.ts

@@ -1,63 +0,0 @@
-import type { GraphQLClient } from 'graphql-request';
-import { gql } from 'graphql-request';
-
-const DEFAULT_PAGE_SIZE = 200;
-
-const GET_WORK_UUIDS = gql`
-  query GetWorkUuids($cursor: String, $limit: Int, $filter: WorkFilter) {
-    works(cursor: $cursor, limit: $limit, filter: $filter) {
-      items {
-        uuid
-      }
-      pageInfo {
-        nextCursor
-        hasMoreAfter
-      }
-    }
-  }
-`;
-
-type GetWorkUuidsResponse = {
-  works: {
-    items: Array<{ uuid: string }>;
-    pageInfo: {
-      nextCursor: string | null;
-      hasMoreAfter: boolean;
-    };
-  };
-};
-
-type WorkFilter = {
-  maxPages?: number;
-};
-
-/**
- * Get work UUIDs with optional filtering.
- * @param client - GraphQL client
- * @param filter - Optional filter criteria (e.g., maxPages)
- * @param limit - Optional limit on total results (fetches all pages if not specified)
- */
-export async function getTranslationUuids({
-  client,
-  filter,
-  limit,
-}: {
-  client: GraphQLClient;
-  filter?: WorkFilter;
-  limit?: number;
-}): Promise<string[]> {
-  try {
-    // Single request - no pagination needed for static params
-    const response: GetWorkUuidsResponse =
-      await client.request<GetWorkUuidsResponse>(GET_WORK_UUIDS, {
-        cursor: null,
-        limit: limit ?? DEFAULT_PAGE_SIZE,
-        filter,
-      });
-
-    return response.works.items.map((w) => w.uuid);
-  } catch (error) {
-    console.error('Error fetching translation UUIDs:', error);
-    return [];
-  }
-}

package/src/lib/functions/get-translations-metadata.ts

@@ -1,81 +0,0 @@
-import type { GraphQLClient } from 'graphql-request';
-import { gql } from 'graphql-request';
-import type { Work } from '@eightyfourthousand/data-access';
-import { worksFromGraphQL } from '../mappers';
-
-const GET_ALL_WORKS = gql`
-  query GetAllWorks($cursor: String, $limit: Int) {
-    works(cursor: $cursor, limit: $limit) {
-      items {
-        uuid
-        title
-        toh
-        publicationDate
-        publicationVersion
-        pages
-        restriction
-        section
-      }
-      pageInfo {
-        nextCursor
-        hasMoreAfter
-      }
-    }
-  }
-`;
-
-type GraphQLWork = {
-  uuid: string;
-  title: string;
-  toh: string[];
-  publicationDate: string;
-  publicationVersion: string;
-  pages: number;
-  restriction: boolean;
-  section: string;
-};
-
-type GetAllWorksResponse = {
-  works: {
-    items: GraphQLWork[];
-    pageInfo: {
-      nextCursor: string | null;
-      hasMoreAfter: boolean;
-    };
-  };
-};
-
-/**
- * Get metadata for all published translation works (fetches all pages).
- */
-export async function getTranslationsMetadata({
-  client,
-  limit = 200,
-}: {
-  client: GraphQLClient;
-  limit?: number;
-}): Promise<Work[]> {
-  try {
-    const allWorks: GraphQLWork[] = [];
-    let cursor: string | null = null;
-
-    // Fetch all pages
-    do {
-      const response: GetAllWorksResponse =
-        await client.request<GetAllWorksResponse>(GET_ALL_WORKS, {
-          cursor,
-          limit,
-        });
-
-      allWorks.push(...response.works.items);
-      cursor = response.works.pageInfo.hasMoreAfter
-        ? response.works.pageInfo.nextCursor
-        : null;
-    } while (cursor !== null);
-
-    return worksFromGraphQL(allWorks);
-  } catch (error) {
-    console.error('Error fetching translations metadata:', error);
-    return [];
-  }
-}

package/src/lib/functions/get-work-bibliography.ts

@@ -1,47 +0,0 @@
-import type { GraphQLClient } from 'graphql-request';
-import { gql } from 'graphql-request';
-import type { BibliographyEntries } from '@eightyfourthousand/data-access';
-
-const GET_WORK_BIBLIOGRAPHY = gql`
-  query GetWorkBibliography($uuid: ID!) {
-    work(uuid: $uuid) {
-      bibliography {
-        heading
-        entries {
-          uuid
-          html
-          workUuid
-        }
-      }
-    }
-  }
-`;
-
-type GetWorkBibliographyResponse = {
-  work: {
-    bibliography: BibliographyEntries;
-  } | null;
-};
-
-/**
- * Get bibliography entries for a specific work.
- */
-export async function getWorkBibliography({
-  client,
-  uuid,
-}: {
-  client: GraphQLClient;
-  uuid: string;
-}): Promise<BibliographyEntries> {
-  try {
-    const response = await client.request<GetWorkBibliographyResponse>(
-      GET_WORK_BIBLIOGRAPHY,
-      { uuid },
-    );
-
-    return response.work?.bibliography ?? [];
-  } catch (error) {
-    console.error('Error fetching work bibliography:', error);
-    return [];
-  }
-}

package/src/lib/functions/get-work-folios.ts

@@ -1,52 +0,0 @@
-import type { GraphQLClient } from 'graphql-request';
-import { gql } from 'graphql-request';
-import type { Folio } from '@eightyfourthousand/data-access';
-
-const GET_WORK_FOLIOS = gql`
-  query GetWorkFolios($uuid: ID!, $toh: String!, $page: Int, $size: Int) {
-    work(uuid: $uuid) {
-      folios(toh: $toh, page: $page, size: $size) {
-        uuid
-        content
-        volume
-        folio
-        side
-      }
-    }
-  }
-`;
-
-type GetWorkFoliosResponse = {
-  work: {
-    folios: Folio[];
-  } | null;
-};
-
-/**
- * Get folios for a specific work, filtered by toh and paginated.
- */
-export async function getWorkFolios({
-  client,
-  uuid,
-  toh,
-  page = 0,
-  size = 10,
-}: {
-  client: GraphQLClient;
-  uuid: string;
-  toh: string;
-  page?: number;
-  size?: number;
-}): Promise<Folio[]> {
-  try {
-    const response = await client.request<GetWorkFoliosResponse>(
-      GET_WORK_FOLIOS,
-      { uuid, toh, page, size },
-    );
-
-    return response.work?.folios ?? [];
-  } catch (error) {
-    console.error('Error fetching work folios:', error);
-    return [];
-  }
-}

package/src/lib/functions/get-work-glossary-terms-around.ts

@@ -1,127 +0,0 @@
-import type { GraphQLClient } from 'graphql-request';
-import { gql } from 'graphql-request';
-import type { GlossaryTermInstance } from '@eightyfourthousand/data-access';
-import type { GlossaryTermsPage } from './get-work-glossary-terms';
-
-const GET_WORK_GLOSSARY_TERMS_AROUND = gql`
-  query GetWorkGlossaryTermsAround(
-    $uuid: ID!
-    $cursor: String!
-    $limit: Int
-    $withAttestations: Boolean
-  ) {
-    work(uuid: $uuid) {
-      glossaryTerms(
-        cursor: $cursor
-        limit: $limit
-        direction: AROUND
-        withAttestations: $withAttestations
-      ) {
-        nodes {
-          uuid
-          authority
-          definition
-          termNumber
-          names {
-            english
-            tibetan
-            sanskrit
-            pali
-            chinese
-            wylie
-            alternatives
-          }
-          passages(first: 10) {
-            items {
-              uuid
-              type
-              label
-            }
-            nextCursor
-            hasMore
-          }
-        }
-        pageInfo {
-          nextCursor
-          prevCursor
-          hasMoreAfter
-          hasMoreBefore
-        }
-        totalCount
-      }
-    }
-  }
-`;
-
-type GetWorkGlossaryTermsAroundResponse = {
-  work: {
-    glossaryTerms: {
-      nodes: GlossaryTermInstance[];
-      pageInfo: {
-        nextCursor?: string | null;
-        prevCursor?: string | null;
-        hasMoreAfter: boolean;
-        hasMoreBefore: boolean;
-      };
-      totalCount: number;
-    };
-  } | null;
-};
-
-/**
- * Get glossary terms around a specific term UUID.
- * Used for navigating to a glossary entry that hasn't been loaded yet.
- */
-export async function getWorkGlossaryTermsAround({
-  client,
-  uuid,
-  termUuid,
-  limit,
-  withAttestations = false,
-}: {
-  client: GraphQLClient;
-  uuid: string;
-  termUuid: string;
-  limit?: number;
-  withAttestations?: boolean;
-}): Promise<GlossaryTermsPage> {
-  try {
-    const response = await client.request<GetWorkGlossaryTermsAroundResponse>(
-      GET_WORK_GLOSSARY_TERMS_AROUND,
-      {
-        uuid,
-        cursor: termUuid,
-        limit,
-        withAttestations,
-      },
-    );
-
-    if (!response.work) {
-      return {
-        terms: [],
-        hasMoreAfter: false,
-        hasMoreBefore: false,
-        totalCount: 0,
-      };
-    }
-
-    const { glossaryTerms } = response.work;
-
-    return {
-      terms: glossaryTerms.nodes,
-      nextCursor: glossaryTerms.pageInfo.nextCursor ?? undefined,
-      prevCursor: glossaryTerms.pageInfo.prevCursor ?? undefined,
-      hasMoreAfter: glossaryTerms.pageInfo.hasMoreAfter,
-      hasMoreBefore: glossaryTerms.pageInfo.hasMoreBefore,
-      totalCount: glossaryTerms.totalCount,
-    };
-  } catch (error) {
-    console.error('Error fetching glossary terms around:', error);
-    return {
-      terms: [],
-      hasMoreAfter: false,
-      hasMoreBefore: false,
-      totalCount: 0,
-    };
-  }
-}

package/src/lib/functions/get-work-glossary-terms.ts

@@ -1,154 +0,0 @@
-import type { GraphQLClient } from 'graphql-request';
-import { gql } from 'graphql-request';
-import type {
-  GlossaryTermInstance,
-  PaginationDirection,
-} from '@eightyfourthousand/data-access';
-
-const GET_WORK_GLOSSARY_TERMS = gql`
-  query GetWorkGlossaryTerms(
-    $uuid: ID!
-    $cursor: String
-    $limit: Int
-    $direction: PaginationDirection
-    $withAttestations: Boolean
-  ) {
-    work(uuid: $uuid) {
-      glossaryTerms(
-        cursor: $cursor
-        limit: $limit
-        direction: $direction
-        withAttestations: $withAttestations
-      ) {
-        nodes {
-          uuid
-          authority
-          definition
-          termNumber
-          names {
-            english
-            tibetan
-            sanskrit
-            pali
-            chinese
-            wylie
-            alternatives
-          }
-          passages(first: 10) {
-            items {
-              uuid
-              type
-              label
-            }
-            nextCursor
-            hasMore
-          }
-        }
-        pageInfo {
-          nextCursor
-          prevCursor
-          hasMoreAfter
-          hasMoreBefore
-        }
-        totalCount
-      }
-    }
-  }
-`;
-
-type GetWorkGlossaryTermsResponse = {
-  work: {
-    glossaryTerms: {
-      nodes: GlossaryTermInstance[];
-      pageInfo: {
-        nextCursor?: string | null;
-        prevCursor?: string | null;
-        hasMoreAfter: boolean;
-        hasMoreBefore: boolean;
-      };
-      totalCount: number;
-    };
-  } | null;
-};
-
-/**
- * Result of fetching glossary terms with pagination info
- */
-export type GlossaryTermsPage = {
-  terms: GlossaryTermInstance[];
-  nextCursor?: string;
-  prevCursor?: string;
-  hasMoreAfter: boolean;
-  hasMoreBefore: boolean;
-  totalCount: number;
-};
-
-/**
- * Map internal pagination direction to GraphQL enum
- */
-function mapDirection(
-  direction?: PaginationDirection,
-): 'FORWARD' | 'BACKWARD' | undefined {
-  if (!direction) return undefined;
-  return direction === 'forward' ? 'FORWARD' : 'BACKWARD';
-}
-
-/**
- * Get paginated glossary terms for a work.
- */
-export async function getWorkGlossaryTerms({
-  client,
-  uuid,
-  cursor,
-  limit = 50,
-  direction,
-  withAttestations = false,
-}: {
-  client: GraphQLClient;
-  uuid: string;
-  cursor?: string;
-  limit?: number;
-  direction?: PaginationDirection;
-  withAttestations?: boolean;
-}): Promise<GlossaryTermsPage> {
-  try {
-    const response = await client.request<GetWorkGlossaryTermsResponse>(
-      GET_WORK_GLOSSARY_TERMS,
-      {
-        uuid,
-        cursor,
-        limit,
-        direction: mapDirection(direction),
-        withAttestations,
-      },
-    );
-
-    if (!response.work) {
-      return {
-        terms: [],
-        hasMoreAfter: false,
-        hasMoreBefore: false,
-        totalCount: 0,
-      };
-    }
-
-    const { glossaryTerms } = response.work;
-
-    return {
-      terms: glossaryTerms.nodes,
-      nextCursor: glossaryTerms.pageInfo.nextCursor ?? undefined,
-      prevCursor: glossaryTerms.pageInfo.prevCursor ?? undefined,
-      hasMoreAfter: glossaryTerms.pageInfo.hasMoreAfter,
-      hasMoreBefore: glossaryTerms.pageInfo.hasMoreBefore,
-      totalCount: glossaryTerms.totalCount,
-    };
-  } catch (error) {
-    console.error('Error fetching work glossary terms:', error);
-    return {
-      terms: [],
-      hasMoreAfter: false,
-      hasMoreBefore: false,
-      totalCount: 0,
-    };
-  }
-}

package/src/lib/functions/has-permission.ts

@@ -1,38 +0,0 @@
-import type { GraphQLClient } from 'graphql-request';
-import { gql } from 'graphql-request';
-
-// Permission enum matching the GraphQL schema
-export type Permission =
-  | 'PROJECTS_READ'
-  | 'PROJECTS_EDIT'
-  | 'PROJECTS_ADMIN'
-  | 'EDITOR_READ'
-  | 'EDITOR_EDIT'
-  | 'EDITOR_ADMIN';
-
-const HAS_PERMISSION_QUERY = gql`
-  query HasPermission($permission: Permission!) {
-    hasPermission(permission: $permission)
-  }
-`;
-
-interface HasPermissionResponse {
-  hasPermission: boolean;
-}
-
-/**
- * Check if the current user has a specific permission
- */
-export const hasPermission = async ({
-  client,
-  permission,
-}: {
-  client: GraphQLClient;
-  permission: Permission;
-}): Promise<boolean> => {
-  const response = await client.request<HasPermissionResponse>(
-    HAS_PERMISSION_QUERY,
-    { permission },
-  );
-  return response.hasPermission;
-};

package/src/lib/functions/replace.ts

@@ -1,91 +0,0 @@
-import type { GraphQLClient } from 'graphql-request';
-import { gql } from 'graphql-request';
-import type { TranslationEditorContentItem } from '@eightyfourthousand/data-access';
-
-export type ReplaceType = 'PASSAGE';
-
-export interface ReplacedPassage {
-  json?: TranslationEditorContentItem | null;
-  uuid: string;
-}
-
-interface ReplaceResponse {
-  replace: {
-    deletedAnnotationCount: number;
-    error?: string;
-    nextOccurrenceStart?: number | null;
-    nextPassageUuid?: string | null;
-    passages: ReplacedPassage[];
-    replacedOccurrenceCount: number;
-    success: boolean;
-    updatedAnnotationCount: number;
-    updatedCount: number;
-  };
-}
-
-const REPLACE_MUTATION = gql`
-  mutation Replace(
-    $searchText: String!
-    $replaceText: String!
-    $targetUuids: [ID!]!
-    $type: ReplaceType
-    $occurrenceIndex: Int
-    $cursorPassageUuid: ID
-    $cursorStart: Int
-  ) {
-    replace(
-      searchText: $searchText
-      replaceText: $replaceText
-      targetUuids: $targetUuids
-      type: $type
-      occurrenceIndex: $occurrenceIndex
-      cursorPassageUuid: $cursorPassageUuid
-      cursorStart: $cursorStart
-    ) {
-      success
-      updatedCount
-      replacedOccurrenceCount
-      updatedAnnotationCount
-      deletedAnnotationCount
-      nextPassageUuid
-      nextOccurrenceStart
-      error
-      passages {
-        uuid
-        json
-      }
-    }
-  }
-`;
-
-export const replace = async ({
-  client,
-  cursorPassageUuid,
-  cursorStart,
-  occurrenceIndex,
-  replaceText,
-  searchText,
-  targetUuids,
-  type = 'PASSAGE',
-}: {
-  client: GraphQLClient;
-  occurrenceIndex?: number;
-  replaceText: string;
-  searchText: string;
-  cursorPassageUuid?: string;
-  cursorStart?: number;
-  targetUuids: string[];
-  type?: ReplaceType;
-}) => {
-  const response = await client.request<ReplaceResponse>(REPLACE_MUTATION, {
-    searchText,
-    replaceText,
-    targetUuids,
-    type,
-    occurrenceIndex,
-    cursorPassageUuid,
-    cursorStart,
-  });
-
-  return response.replace;
-};