@eightyfourthousand/client-graphql 2026.3.0

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

@@ -0,0 +1,150 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,111 @@
+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

@@ -0,0 +1,38 @@
+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/index.ts

@@ -0,0 +1,33 @@
+export { getPassage } from './get-passage';
+export { getTranslationPassages } from './get-translation-passages';
+export { getTranslationPassagesAround } from './get-translation-passages-around';
+export {
+  getTranslationBlocks,
+  type TranslationBlocksPage,
+} from './get-translation-blocks';
+export { getTranslationBlocksAround } from './get-translation-blocks-around';
+export { getTranslationTitles } from './get-translation-titles';
+export {
+  getTranslationMetadataByUuid,
+  getTranslationMetadataByToh,
+} from './get-translation-metadata';
+export { getTranslationsMetadata } from './get-translations-metadata';
+export { getTranslationUuids } from './get-translation-uuids';
+export { getTranslationToc } from './get-translation-toc';
+export { getTranslationImprint } from './get-translation-imprint';
+export { getGlossaryTerms } from './get-glossary-terms';
+export { getGlossaryEntry } from './get-glossary-entry';
+export { getGlossaryInstance } from './get-glossary-instance';
+export { getWorkGlossary } from './get-work-glossary';
+export {
+  getWorkGlossaryTerms,
+  type GlossaryTermsPage,
+} from './get-work-glossary-terms';
+export { getWorkGlossaryTermsAround } from './get-work-glossary-terms-around';
+export { getTermPassages, type GlossaryPassagesPage } from './get-term-passages';
+export { getBibliographyEntry } from './get-bibliography-entry';
+export { getWorkBibliography } from './get-work-bibliography';
+export { getWorkFolios } from './get-work-folios';
+export { getWorks, type WorksPage } from './get-works';
+export { hasPermission, type Permission } from './has-permission';
+export { savePassages } from './save-passages';

package/src/lib/functions/save-passages.ts

@@ -0,0 +1,76 @@
+import type { GraphQLClient } from 'graphql-request';
+import { gql } from 'graphql-request';
+import type { Passage } from '@eightyfourthousand/data-access';
+
+const SAVE_PASSAGES_MUTATION = gql`
+  mutation SavePassages($passages: [PassageInput!]!, $deletedUuids: [ID!]) {
+    savePassages(passages: $passages, deletedUuids: $deletedUuids) {
+      success
+      savedCount
+      deletedCount
+      error
+    }
+  }
+`;
+
+interface SavePassagesResponse {
+  savePassages: {
+    success: boolean;
+    savedCount: number;
+    deletedCount?: number;
+    error?: string;
+  };
+}
+
+interface PassageInput {
+  uuid: string;
+  workUuid: string;
+  content: string;
+  label: string;
+  sort: number;
+  type: string;
+  xmlId?: string;
+  annotations: unknown[];
+}
+
+/**
+ * Convert a Passage to the GraphQL input format
+ */
+const passageToInput = (passage: Passage): PassageInput => ({
+  uuid: passage.uuid,
+  workUuid: passage.workUuid,
+  content: passage.content,
+  label: passage.label,
+  sort: passage.sort,
+  type: passage.type,
+  xmlId: passage.xmlId,
+  annotations: passage.annotations,
+});
+
+/**
+ * Save one or more passages via GraphQL mutation.
+ * Requires editor.edit permission.
+ */
+export const savePassages = async ({
+  client,
+  passages,
+  deletedUuids,
+}: {
+  client: GraphQLClient;
+  passages: Passage[];
+  deletedUuids?: string[];
+}): Promise<{
+  success: boolean;
+  savedCount: number;
+  deletedCount?: number;
+  error?: string;
+}> => {
+  const passageInputs = passages.map(passageToInput);
+
+  const response = await client.request<SavePassagesResponse>(
+    SAVE_PASSAGES_MUTATION,
+    { passages: passageInputs, deletedUuids },
+  );
+
+  return response.savePassages;
+};