@eightyfourthousand/data-access 2026.3.1 → 2026.4.0

package/src/lib/glossary.ts

@@ -1,147 +0,0 @@
-import {
-  DataClient,
-  GlossaryDetailDTO,
-  GlossaryEntityDTO,
-  GlossaryInstanceDTO,
-  GlossaryTermInstanceDTO,
-  GlossaryLandingItem,
-  GlossaryLandingItemDTO,
-  glossaryTermInstanceFromDTO,
-  glossaryLandingItemFromDTO,
-  glossaryPageItemFromDTO,
-  GlossaryTermInstancesDTO,
-} from './types';
-
-export const getAllGlossaryTerms = async ({
-  client,
-  uuids,
-}: {
-  client: DataClient;
-  uuids?: string[];
-}): Promise<GlossaryLandingItem[]> => {
-  const pageSize = 1000;
-  let start = 0;
-  let end = pageSize - 1;
-  let count = pageSize;
-  const terms: GlossaryLandingItem[] = [];
-
-  while (count === pageSize) {
-    let rpc = client.rpc('scholar_glossary_get_all');
-
-    if (uuids?.length) {
-      rpc = rpc.in('authority_uuid', uuids);
-    }
-
-    const { data, error } = await rpc.range(start, end);
-
-    if (error) {
-      console.error('Error fetching glossary terms:', error);
-      return [];
-    }
-    if (!data || !data.length) {
-      break;
-    }
-
-    const dtos = data as GlossaryLandingItemDTO[];
-    const items = dtos
-      .map((item) => glossaryLandingItemFromDTO(item as GlossaryLandingItemDTO))
-      .flatMap((item) => (item ? [item] : []));
-
-    terms.push(...items);
-    start += pageSize;
-    end += pageSize;
-    count = data.length;
-  }
-
-  return terms;
-};
-
-export const getGlossaryInstances = async ({
-  client,
-  uuid,
-  withAttestations = false,
-}: {
-  client: DataClient;
-  uuid: string;
-  withAttestations?: boolean;
-}) => {
-  const { data, error } = await client.rpc('show_glossary_entries', {
-    v_work_uuid: uuid,
-    v_with_attestation: withAttestations,
-  });
-  if (error) {
-    console.error(
-      `Error fetching glossary instances for work: ${uuid} `,
-      error,
-    );
-    return [];
-  }
-
-  const dto = data as GlossaryTermInstancesDTO;
-  return dto.glossary_entries.map(glossaryTermInstanceFromDTO).sort((a, b) => {
-    const nameA = a.names.english || '';
-    const nameB = b.names.english || '';
-    return nameA.localeCompare(nameB);
-  });
-};
-
-export const getGlossaryInstance = async ({
-  client,
-  uuid,
-}: {
-  client: DataClient;
-  uuid: string;
-}) => {
-  const { data, error } = await client.rpc('show_glossary_entry', {
-    v_glossary_uuid: uuid,
-  });
-
-  if (error) {
-    console.error(`Error fetching glossary instance: ${uuid} `, error);
-    return undefined;
-  }
-
-  return glossaryTermInstanceFromDTO(data as GlossaryTermInstanceDTO);
-};
-
-export const getGlossaryEntry = async ({
-  client,
-  uuid,
-}: {
-  client: DataClient;
-  uuid: string;
-}) => {
-  const { data: details = [], error: detailError } = await client.rpc(
-    'scholar_glossary_detail',
-    { v_uuid: uuid },
-  );
-
-  if (detailError || !details?.length) {
-    console.error('Error fetching glossary item:', detailError);
-    return null;
-  }
-
-  const detail = details[0];
-
-  const { data: entities = [], error: entitiesError } = await client.rpc(
-    'scholar_glossary_detail_related_entities',
-    { v_uuid: uuid },
-  );
-  if (entitiesError) {
-    console.error('Error fetching related entities:', entitiesError);
-  }
-
-  const { data: glossaries = [], error: glossariesError } = await client.rpc(
-    'scholar_glossary_detail_related_glossaries',
-    { v_uuid: uuid },
-  );
-  if (glossariesError) {
-    console.error('Error fetching related glossaries:', glossariesError);
-  }
-
-  return glossaryPageItemFromDTO(
-    detail as GlossaryDetailDTO,
-    glossaries as GlossaryInstanceDTO[],
-    entities as GlossaryEntityDTO[],
-  );
-};

package/src/lib/passage.ts

@@ -1,122 +0,0 @@
-import {
-  ANNOTATIONS_TO_IGNORE,
-  DataClient,
-  Passage,
-  PassageDTO,
-  annotationsFromDTO,
-  passageFromDTO,
-  passagesToDTO,
-  passagesToRowDTO,
-} from './types';
-
-export const getPassage = async ({
-  client,
-  uuid,
-}: {
-  client: DataClient;
-  uuid: string;
-}) => {
-  const { data } = await client
-    .rpc('get_passage_with_annotations', {
-      uuid_input: uuid,
-    })
-    .single();
-
-  if (!data) {
-    console.warn(`No passage found for uuid: ${uuid}`);
-    return undefined;
-  }
-
-  const dto = data as PassageDTO;
-  return passageFromDTO(
-    dto,
-    annotationsFromDTO(dto?.annotations || [], dto?.content.length || 0),
-  );
-};
-
-export const getPassageUuidByXmlId = async ({
-  client,
-  xmlId,
-}: {
-  client: DataClient;
-  xmlId: string;
-}) => {
-  const { data, error } = await client
-    .from('passages')
-    .select('uuid, workUuid:work_uuid')
-    .eq('xmlId', xmlId)
-    .single();
-
-  if (error) {
-    console.error(`Error fetching passage uuid for xmlId: ${xmlId}`, error);
-    return;
-  }
-
-  return data?.uuid;
-};
-
-export const savePassages = async ({
-  client,
-  passages,
-}: {
-  client: DataClient;
-  passages: Passage[];
-}) => {
-  /**
-   * 1. Extract all annotations from savePassages
-   * 2. Query the database for all current annotations for the savePassages
-   * 3. Determine which annotations need to be deleted or upserted
-   * 4. Upsert the passages
-   * 5. Upsert the annotations
-   * 6. Delete the annotations that are no longer present
-   */
-  const dtos = passagesToDTO(passages);
-  const passageRowDtos = passagesToRowDTO(passages);
-  const passageUuids = passages.map((p) => p.uuid);
-  const annotations = dtos.flatMap((p) => p.annotations || []);
-
-  const { data: existingAnnotations } = await client
-    .from('passage_annotations')
-    .select(`uuid`)
-    .in('passage_uuid', passageUuids)
-    .not('type', 'in', `(${ANNOTATIONS_TO_IGNORE.join(',')})`);
-
-  const annotationsToDelete = existingAnnotations?.filter(
-    (ea) => !annotations.find((a) => a.uuid === ea.uuid),
-  );
-
-  const { error: passageError } = await client
-    .from('passages')
-    .upsert(passageRowDtos, { onConflict: 'uuid' });
-
-  if (passageError) {
-    console.error('Error saving passages:', passageError);
-    return;
-  }
-
-  if (annotations.length > 0) {
-    const { error: annotationError } = await client
-      .from('passage_annotations')
-      .upsert(annotations, { onConflict: 'uuid' });
-
-    if (annotationError) {
-      console.error('Error saving annotations:', annotationError);
-      throw annotationError;
-    }
-  }
-
-  if (annotationsToDelete && annotationsToDelete.length > 0) {
-    const { error: deleteError } = await client
-      .from('passage_annotations')
-      .delete()
-      .in(
-        'uuid',
-        annotationsToDelete.map((a) => a.uuid),
-      );
-
-    if (deleteError) {
-      console.error('Error deleting annotations:', deleteError);
-      throw deleteError;
-    }
-  }
-};

package/src/lib/projects.ts

@@ -1,107 +0,0 @@
-import {
-  DataClient,
-  ProjectContributor,
-  ProjectContributorsDTO,
-  projectContributorsFromDTO,
-} from './types';
-import {
-  Project,
-  ProjectAsset,
-  ProjectStageDetail,
-  ProjectStageDetailsDTO,
-  ProjectTableDTO,
-  ProjectViewDTO,
-  projectFromTableDTO,
-  projectFromViewDTO,
-  projectStageDetailsFromDTO,
-} from './types/project';
-
-export const getProjects = async ({ client }: { client: DataClient }) => {
-  const { data } = await client.rpc('get_projects');
-
-  const dtos = (data as ProjectViewDTO[]) || [];
-  const projects = dtos.map(projectFromViewDTO);
-
-  return { projects };
-};
-
-export const getProjectByUuid = async ({
-  client,
-  uuid,
-}: {
-  client: DataClient;
-  uuid: string;
-}): Promise<Project> => {
-  const { data } = await client.rpc('get_project', { uuid_input: uuid });
-
-  return projectFromTableDTO(data as ProjectTableDTO);
-};
-
-export const getProjectStages = async ({
-  client,
-  uuid,
-}: {
-  client: DataClient;
-  uuid: string;
-}): Promise<ProjectStageDetail[]> => {
-  const { data } = await client.rpc('get_project_stages', { uuid_input: uuid });
-  return projectStageDetailsFromDTO(data as ProjectStageDetailsDTO[]);
-};
-
-export const getProjectAssets = async ({
-  client,
-  projectUuid,
-  stageUuid,
-}: {
-  client: DataClient;
-  projectUuid?: string;
-  stageUuid?: string;
-}): Promise<ProjectAsset[]> => {
-  if (!projectUuid && !stageUuid) {
-    console.error('One of projectUuid or stageUuid is required');
-    return [];
-  }
-
-  const { data } = await client.rpc('get_project_assets', {
-    project_uuid_input: projectUuid,
-    stage_uuid_input: stageUuid,
-  });
-  return data || [];
-};
-
-export const getProjectContributors = async ({
-  client,
-  projectUuid,
-  stageUuid,
-}: {
-  client: DataClient;
-  projectUuid?: string;
-  stageUuid?: string;
-}): Promise<ProjectContributor[]> => {
-  if (!projectUuid && !stageUuid) {
-    console.error('One of projectUuid or stageUuid is required');
-    return [];
-  }
-
-  const uuid = stageUuid ? stageUuid : projectUuid;
-  const key = stageUuid ? 'stage_uuid' : 'project_uuid';
-
-  const { data } = await client
-    .from('project_contributors')
-    .select(
-      `
-      uuid,
-      stageUuid:stage_uuid,
-      projectUuid:project_uuid,
-      ...authorities!contributor_uuid(
-        contributorUuid:uuid,
-        name:headword
-      ),
-      startDate:start_date,
-      endDate:end_date,
-      role:type
-    `,
-    )
-    .eq(key, uuid);
-  return projectContributorsFromDTO(data as ProjectContributorsDTO);
-};

package/src/lib/types/canon.ts

@@ -1,148 +0,0 @@
-import { TohokuCatalogEntry } from './toh';
-import { ExtendedTranslationLanguage } from './language';
-
-export type CanonNodeType =
-  | 'root'
-  | 'canonicalSection'
-  | 'nonCanonicalSection'
-  | 'textGrouping';
-
-export type CanonDTO = {
-  uuid: string;
-  created_at: string;
-  label: string;
-  parent_uuid?: string;
-  xmlId: string;
-  parent_xmlId?: string;
-  sort: number;
-  description: string;
-  type: CanonNodeType;
-  public_description?: string;
-  article_uuid?: string;
-};
-
-export type CanonHead = {
-  children: CanonNode[];
-};
-
-export type CanonNode = {
-  uuid: string;
-  label?: string;
-  xmlId?: string;
-  parentXmlId?: string;
-  parentUuid?: string;
-  sort: number;
-  description?: string;
-  type: CanonNodeType;
-  publicDescription?: string;
-  articleUuid?: string;
-  children?: CanonNode[];
-  createdAt?: string;
-};
-
-export type CanonArticleDTO = {
-  uuid: string;
-  title: string;
-  body: string;
-  image?: string;
-  caption?: string;
-};
-
-export type CanonArticle = CanonArticleDTO;
-
-export type CanonArticleTitleDTO = {
-  title: string;
-  language: ExtendedTranslationLanguage;
-};
-
-export type CanonArticleTitle = CanonArticleTitleDTO;
-
-export type CanonDetailDTO = {
-  uuid: string;
-  label: string;
-  description: string;
-  type: CanonNodeType;
-  article?: CanonArticleDTO;
-  titles: CanonArticleTitleDTO[];
-};
-export type CanonDetail = CanonDetailDTO & {
-  article?: CanonArticle;
-  titles: CanonArticleTitle[];
-};
-
-export type CanonWorkStatus = 'published' | 'in-progress' | 'not-started';
-
-export type CanonWorkDTO = {
-  uuid: string;
-  toh: TohokuCatalogEntry;
-  title: string;
-  published: boolean;
-  status: CanonWorkStatus;
-  pages: number;
-};
-
-export type CanonWork = CanonWorkDTO;
-
-export type CanonWorksDTO = {
-  works: CanonWorkDTO[];
-};
-
-export const canonNodeFromDTO = (dto: CanonDTO): CanonNode => {
-  return {
-    uuid: dto.uuid,
-    label: dto.label,
-    xmlId: dto.xmlId,
-    parentXmlId: dto.parent_xmlId,
-    parentUuid: dto.parent_uuid,
-    sort: dto.sort,
-    description: dto.description,
-    type: dto.type,
-    publicDescription: dto.public_description,
-    articleUuid: dto.article_uuid,
-    createdAt: dto.created_at,
-  };
-};
-
-export const canonTreeFromDTOs = (dtos: CanonDTO[]): CanonHead => {
-  const nodes: Record<string, CanonNode> = {};
-  dtos.forEach((dto) => {
-    nodes[dto.uuid] = canonNodeFromDTO(dto);
-  });
-
-  const tree: CanonNode[] = [];
-
-  Object.values(nodes).forEach((node) => {
-    if (node.parentUuid) {
-      const parent = nodes[node.parentUuid];
-      if (parent) {
-        parent.children = parent.children || [];
-        parent.children.push(node);
-      }
-    } else {
-      tree.push(node);
-    }
-  });
-
-  // Sort children by their sort order
-  const sortChildren = (children: CanonNode[]) => {
-    children.sort((a, b) => a.sort - b.sort);
-    children.forEach((child) => {
-      if (child.children) {
-        sortChildren(child.children);
-      }
-    });
-  };
-  sortChildren(tree);
-
-  return {
-    children: tree,
-  };
-};
-
-export const canonDetailFromDTO = (dto: CanonDetailDTO): CanonDetail => {
-  return dto as CanonDetail;
-};
-
-export const caononWorksFromDTO = (dto: CanonWorksDTO): CanonWork[] => {
-  return dto.works as CanonWork[];
-};

package/src/lib/types/contributor.ts

@@ -1,84 +0,0 @@
-export type ContributorRole =
-  | 'englishAdvisor'
-  | 'englishAssociateEditor'
-  | 'englishCopyEditor'
-  | 'englishDharmaMaster'
-  | 'englishFinalReviewer'
-  | 'englishMarkup'
-  | 'englishProjectEditor'
-  | 'englishProjectManager'
-  | 'englishProofReader'
-  | 'englishReviser'
-  | 'englishTranslator'
-  | 'englishTranslationSponsor'
-  | 'englishTranslationTeam'
-  | 'tibetanTranslator';
-
-export type Contributor = {
-  name: string;
-  role: ContributorRole;
-};
-
-export type ProjectContributor = Contributor & {
-  uuid: string;
-  contributorUuid: string;
-  startDate?: Date;
-  endDate?: Date;
-  projectUuid: string;
-  stageUuid?: string;
-};
-
-export type Contributors = Contributor[];
-export type ProjectContributors = ProjectContributor[];
-
-export type ContributorDTO = {
-  name: string;
-  role: ContributorRole;
-};
-
-export type ContributorsDTO = ContributorDTO[];
-
-export type ProjectContributorDTO = {
-  uuid: string;
-  projectUuid: string;
-  stageUuid?: string;
-  contributorUuid: string;
-  name: string;
-  role: ContributorRole;
-  startDate: string;
-  endDate: string;
-};
-
-export type ProjectContributorsDTO = ProjectContributorDTO[];
-
-export const contributorFromDTO = (dto: ContributorDTO): Contributor => {
-  return {
-    name: dto.name,
-    role: dto.role,
-  };
-};
-
-export const contributorsFromDTO = (dto?: ContributorsDTO): Contributors => {
-  return dto?.map(contributorFromDTO) || [];
-};
-
-export const projectContributorFromDTO = (
-  dto: ProjectContributorDTO,
-): ProjectContributor => {
-  return {
-    uuid: dto.uuid,
-    name: dto.name,
-    contributorUuid: dto.contributorUuid,
-    role: dto.role,
-    startDate: new Date(dto.startDate),
-    endDate: new Date(dto.endDate),
-    projectUuid: dto.projectUuid,
-    stageUuid: dto.stageUuid,
-  };
-};
-
-export const projectContributorsFromDTO = (
-  dto?: ProjectContributorsDTO,
-): ProjectContributors => {
-  return dto?.map(projectContributorFromDTO) || [];
-};