@eightyfourthousand/client-graphql 2026.3.1 → 2026.4.1

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,126 +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
-          }
-          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,150 +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
-          }
-          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/get-work-glossary.ts

@@ -1,54 +0,0 @@
-import type { GraphQLClient } from 'graphql-request';
-import { gql } from 'graphql-request';
-import type { GlossaryTermInstance } from '@eightyfourthousand/data-access';
-
-const GET_WORK_GLOSSARY = gql`
-  query GetWorkGlossary($uuid: ID!, $withAttestations: Boolean) {
-    work(uuid: $uuid) {
-      glossary(withAttestations: $withAttestations) {
-        uuid
-        authority
-        definition
-        names {
-          english
-          tibetan
-          sanskrit
-          pali
-          chinese
-          wylie
-        }
-      }
-    }
-  }
-`;
-
-type GetWorkGlossaryResponse = {
-  work: {
-    glossary: GlossaryTermInstance[];
-  } | null;
-};
-
-/**
- * Get glossary term instances for a specific work.
- */
-export async function getWorkGlossary({
-  client,
-  uuid,
-  withAttestations = false,
-}: {
-  client: GraphQLClient;
-  uuid: string;
-  withAttestations?: boolean;
-}): Promise<GlossaryTermInstance[]> {
-  try {
-    const response = await client.request<GetWorkGlossaryResponse>(
-      GET_WORK_GLOSSARY,
-      { uuid, withAttestations },
-    );
-
-    return response.work?.glossary ?? [];
-  } catch (error) {
-    console.error('Error fetching work glossary:', error);
-    return [];
-  }
-}

package/src/lib/functions/get-works.ts

@@ -1,111 +0,0 @@
-import type { GraphQLClient } from 'graphql-request';
-import { gql } from 'graphql-request';
-import type { Work } from '@eightyfourthousand/data-access';
-
-const GET_WORKS = gql`
-  query GetWorks($cursor: String, $limit: Int) {
-    works(cursor: $cursor, limit: $limit) {
-      items {
-        uuid
-        title
-        toh
-        publicationDate
-        publicationVersion
-        pages
-        restriction
-        section
-      }
-      pageInfo {
-        nextCursor
-        prevCursor
-        hasMoreAfter
-        hasMoreBefore
-      }
-      totalCount
-    }
-  }
-`;
-
-type GraphQLWork = {
-  uuid: string;
-  title: string;
-  toh: string[];
-  publicationDate: string;
-  publicationVersion: string;
-  pages: number;
-  restriction: boolean;
-  section: string;
-};
-
-type PageInfo = {
-  nextCursor: string | null;
-  prevCursor: string | null;
-  hasMoreAfter: boolean;
-  hasMoreBefore: boolean;
-};
-
-type GetWorksResponse = {
-  works: {
-    items: GraphQLWork[];
-    pageInfo: PageInfo;
-    totalCount: number;
-  };
-};
-
-export type WorksPage = {
-  items: Work[];
-  pageInfo: PageInfo;
-  totalCount: number;
-};
-
-function workFromGraphQL(gqlWork: GraphQLWork): Work {
-  return {
-    uuid: gqlWork.uuid,
-    title: gqlWork.title,
-    toh: gqlWork.toh as Work['toh'],
-    publicationDate: new Date(gqlWork.publicationDate),
-    publicationVersion:
-      gqlWork.publicationVersion as Work['publicationVersion'],
-    pages: gqlWork.pages,
-    restriction: gqlWork.restriction,
-    section: gqlWork.section,
-  };
-}
-
-/**
- * Get paginated works.
- */
-export async function getWorks({
-  client,
-  cursor,
-  limit = 50,
-}: {
-  client: GraphQLClient;
-  cursor?: string;
-  limit?: number;
-}): Promise<WorksPage> {
-  try {
-    const response = await client.request<GetWorksResponse>(GET_WORKS, {
-      cursor,
-      limit,
-    });
-
-    return {
-      items: response.works.items.map(workFromGraphQL),
-      pageInfo: response.works.pageInfo,
-      totalCount: response.works.totalCount,
-    };
-  } catch (error) {
-    console.error('Error fetching works:', error);
-    return {
-      items: [],
-      pageInfo: {
-        nextCursor: null,
-        prevCursor: null,
-        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;
-};