@eightyfourthousand/data-access 2026.3.0

package/src/lib/passage.ts

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

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

@@ -0,0 +1,68 @@
+import { createServerClient } from '@supabase/ssr';
+import { jwtDecode } from 'jwt-decode';
+import { NextResponse, type NextRequest } from 'next/server';
+import { UserRole } from './types';
+
+export async function updateSession(request: NextRequest) {
+  const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
+  const supabaseAnonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
+
+  if (!supabaseUrl || !supabaseAnonKey) {
+    throw new Error('Missing Supabase credentials');
+  }
+  let supabaseResponse = NextResponse.next({
+    request,
+  });
+
+  const supabase = createServerClient(supabaseUrl, supabaseAnonKey, {
+    cookies: {
+      getAll() {
+        return request.cookies.getAll();
+      },
+      setAll(
+        cookiesToSet: Array<{
+          name: string;
+          value: string;
+          options?: Record<string, unknown>;
+        }>,
+      ) {
+        cookiesToSet.forEach(({ name, value }) =>
+          request.cookies.set(name, value),
+        );
+        supabaseResponse = NextResponse.next({
+          request,
+        });
+        cookiesToSet.forEach(({ name, value, options }) =>
+          supabaseResponse.cookies.set(name, value, options),
+        );
+      },
+    },
+  });
+
+  // Do not run code between update and
+  // supabase.auth.getUser(). A simple mistake could make it very hard to debug
+  // issues with users being randomly logged out.
+
+  // IMPORTANT: DO NOT REMOVE auth.getUser()
+
+  const {
+    data: { user },
+  } = await supabase.auth.getUser();
+
+  const {
+    data: { session },
+  } = await supabase.auth.getSession();
+  let role: UserRole = 'reader';
+  if (session?.access_token) {
+    try {
+      const { user_role: userRole } = jwtDecode(session.access_token) as {
+        user_role: string;
+      };
+      role = (userRole as UserRole) || 'reader';
+    } catch (error) {
+      console.error('Failed to decode JWT:', error);
+    }
+  }
+
+  return { user, role, supabaseResponse };
+}

package/src/lib/publications.ts

@@ -0,0 +1,213 @@
+import {
+  BodyItemType,
+  DataClient,
+  TitlesDTO,
+  WorkDTO,
+  titlesFromDTO,
+  workFromDTO,
+  passagesPageFromDTO,
+  PassagesPageDTO,
+  PassagesPage,
+  PaginationDirection,
+  passagesPageAroundFromDTO,
+  PassagesPageAroundDTO,
+  Work,
+} from './types';
+
+export const getTranslationUuids = async ({
+  client,
+}: {
+  client: DataClient;
+}): Promise<string[]> => {
+  const { data } = await client.rpc('get_static_translation_uuids');
+  return data?.map(({ uuid }: { uuid: string }) => uuid) || [];
+};
+
+export const getTranslationPassages = async ({
+  client,
+  uuid,
+  type,
+  cursor,
+  maxPassages,
+  maxCharacters,
+  direction,
+}: {
+  client: DataClient;
+  uuid: string;
+  type?: BodyItemType;
+  cursor?: string;
+  maxPassages?: number;
+  maxCharacters?: number;
+  direction?: PaginationDirection;
+}): Promise<PassagesPage> => {
+  const { data, error } = await client.rpc('get_passages_page', {
+    uuid_input: uuid,
+    passage_type_input: type,
+    cursor,
+    max_passages: maxPassages,
+    char_budget: maxCharacters,
+    direction,
+  });
+
+  if (error) {
+    console.error('Error fetching translation passages:', error);
+    return {
+      hasMoreAfter: false,
+      hasMoreBefore: false,
+      passages: [],
+    };
+  }
+
+  return passagesPageFromDTO(direction || 'forward', data as PassagesPageDTO);
+};
+
+export const getTranslationPassagesAround = async ({
+  client,
+  uuid,
+  passageUuid,
+  type,
+  maxPassages,
+  maxCharacters,
+}: {
+  client: DataClient;
+  uuid: string;
+  passageUuid: string;
+  type?: BodyItemType;
+  maxPassages?: number;
+  maxCharacters?: number;
+}): Promise<PassagesPage> => {
+  const { data, error } = await client.rpc('get_passages_page_around', {
+    uuid_input: uuid,
+    cursor: passageUuid,
+    passage_type_input: type,
+    max_passages: maxPassages,
+    char_budget: maxCharacters,
+  });
+
+  if (error) {
+    console.error('Error fetching translation passages around:', error);
+    return {
+      hasMoreAfter: false,
+      hasMoreBefore: false,
+      passages: [],
+    };
+  }
+
+  return passagesPageAroundFromDTO(data as PassagesPageAroundDTO);
+};
+
+export const getTranslationTitles = async ({
+  client,
+  uuid,
+}: {
+  client: DataClient;
+  uuid: string;
+}) => {
+  const { data } = await client.rpc('get_work_titles', {
+    work_uuid_input: uuid,
+  });
+
+  return titlesFromDTO(data as TitlesDTO);
+};
+
+export const getTranslationMetadataByUuid = async ({
+  client,
+  uuid,
+}: {
+  client: DataClient;
+  uuid: string;
+}) => {
+  const { data, error } = await client
+    .from('works')
+    .select(
+      `
+      uuid,
+      title,
+      description,
+      tohs:work_toh!inner(toh:toh_clean),
+      publicationDate,
+      publicationVersion,
+      pages:source_pages,
+      restriction,
+      breadcrumb
+    `,
+    )
+    .eq('uuid', uuid)
+    .single();
+
+  if (error) {
+    throw new Error(
+      `Error fetching translation metadata by UUID: ${error.message}`,
+    );
+  }
+
+  return workFromDTO(data as WorkDTO);
+};
+
+export const getTranslationMetadataByToh = async ({
+  client,
+  toh,
+}: {
+  client: DataClient;
+  toh: string;
+}) => {
+  const { data, error } = await client
+    .from('work_toh')
+    .select(
+      `
+      work_uuid,
+      works!inner(
+        uuid,
+        title,
+        description,
+        tohs:work_toh!inner(toh:toh_clean),
+        publicationDate,
+        publicationVersion,
+        pages:source_pages,
+        restriction,
+        breadcrumb
+      )
+    `,
+    )
+    .eq('toh_clean', toh)
+    .single();
+
+  // Extract the work data from the joined result
+  const workData = data?.works as WorkDTO | undefined;
+  if (error || !workData) {
+    console.error('Error fetching translation metadata by TOH:', error);
+    return null;
+  }
+
+  return workFromDTO(workData);
+};
+
+export const getTranslationsMetadata = async ({
+  client,
+}: {
+  client: DataClient;
+}): Promise<Work[]> => {
+  const { data, error } = await client
+    .from('works')
+    .select(
+      `
+      uuid,
+      title,
+      description,
+      tohs:work_toh!inner(toh:toh_clean),
+      publicationDate,
+      publicationVersion,
+      pages:source_pages,
+      restriction,
+      breadcrumb
+    `,
+    )
+    .not('toh', 'like', 'toh00%');
+  if (error) {
+    console.error('Error fetching translations metadata:', error);
+    return [];
+  }
+
+  const dto = data as WorkDTO[];
+  return dto?.map((work) => workFromDTO(work as WorkDTO)) || [];
+};

package/src/lib/storage.ts

@@ -0,0 +1,23 @@
+import { DataClient } from './types';
+
+export const uploadToStorage = async ({
+  client,
+  bucket,
+  path,
+  file,
+}: {
+  client: DataClient;
+  bucket: string;
+  path: string;
+  file: File;
+}) => {
+  const { error } = await client.storage.from(bucket).upload(path, file);
+
+  if (error) {
+    console.error('Error uploading to storage:', error);
+    return null;
+  }
+
+  const { data } = client.storage.from(bucket).getPublicUrl(path);
+  return data.publicUrl;
+};

package/src/lib/types/alignment.ts

@@ -0,0 +1,32 @@
+import { TohokuCatalogEntry } from './toh';
+
+export type AlignmentDTO = {
+  passage_uuid: string;
+  folio_uuid: string;
+  toh: TohokuCatalogEntry;
+  tibetan: string;
+  folio_number: number;
+  volume_number: number;
+};
+
+export type Alignment = {
+  folioUuid: string;
+  toh: TohokuCatalogEntry;
+  tibetan: string;
+  folioNumber: number;
+  volumeNumber: number;
+};
+
+export const alignmentFromDTO = (dto: AlignmentDTO): Alignment => {
+  return {
+    folioUuid: dto.folio_uuid,
+    toh: dto.toh,
+    tibetan: dto.tibetan,
+    folioNumber: dto.folio_number,
+    volumeNumber: dto.volume_number,
+  };
+};
+
+export const alignmentsFromDTO = (dtos: AlignmentDTO[]): Alignment[] => {
+  return dtos.map(alignmentFromDTO);
+};

package/src/lib/types/annotation/abbreviation.ts

@@ -0,0 +1,30 @@
+import type { AnnotationDTO, AnnotationDTOContent } from './annotation-type';
+import {
+  type AbbreviationAnnotation,
+  type AnnotationExporter,
+  type AnnotationTransformer,
+  baseAnnotationFromDTO,
+  baseAnnotationToDto,
+} from './annotation';
+
+export const transformer: AnnotationTransformer = (
+  dto,
+): AbbreviationAnnotation => {
+  const baseAnnotation = baseAnnotationFromDTO(dto);
+  const abbreviation = baseAnnotation as AbbreviationAnnotation;
+  dto.content.forEach((content) => {
+    if (content.uuid) {
+      abbreviation.abbreviation = content.uuid as string;
+    }
+  });
+  return abbreviation;
+};
+
+export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
+  const { abbreviation: uuid } = annotation as AbbreviationAnnotation;
+  const dto = baseAnnotationToDto(annotation);
+  dto.content.push({
+    uuid,
+  } as AnnotationDTOContent);
+  return dto;
+};