@eightyfourthousand/data-access 2026.4.0 → 2026.4.2

package/src/lib/passage/read.ts

@@ -1,100 +0,0 @@
-import {
-  DataClient,
-  PassageDTO,
-  annotationsFromDTO,
-  passageFromDTO,
-} from '../types';
-
-import { PassageConnectionNode } from './pagination';
-
-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 getPassageByUuidOrXmlId = async ({
-  client,
-  uuid,
-  xmlId,
-}: {
-  client: DataClient;
-  uuid?: string;
-  xmlId?: string;
-}): Promise<PassageConnectionNode | null> => {
-  if (!uuid && !xmlId) {
-    return null;
-  }
-
-  let query = client
-    .from('passages')
-    .select('uuid, content, label, sort, type, xmlId, toh, work_uuid');
-
-  if (uuid) {
-    query = query.eq('uuid', uuid);
-  } else if (xmlId) {
-    query = query.eq('xmlId', xmlId);
-  }
-
-  const { data, error } = await query.single();
-
-  if (error) {
-    console.error(`Error fetching passage ${uuid || xmlId}:`, error);
-    return null;
-  }
-
-  if (!data) {
-    return null;
-  }
-
-  return {
-    uuid: data.uuid,
-    workUuid: data.work_uuid,
-    content: data.content,
-    label: data.label,
-    sort: data.sort,
-    type: data.type,
-    toh: data.toh ?? null,
-    xmlId: data.xmlId ?? null,
-  };
-};
-
-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;
-};

package/src/lib/passage/replace-persistence.ts

@@ -1,153 +0,0 @@
-import {
-  ANNOTATIONS_TO_IGNORE,
-  AnnotationDTO,
-  DataClient,
-  Passage,
-  passagesToDTO,
-  passagesToRowDTO,
-} from '../types';
-
-export type ReplacePassageRow = {
-  content: string;
-  label: string | null;
-  sort: number;
-  toh: string | null;
-  type: string;
-  uuid: string;
-  work_uuid: string;
-  xmlId: string | null;
-};
-
-export const fetchReplaceRows = async ({
-  client,
-  targetUuids,
-}: {
-  client: DataClient;
-  targetUuids: string[];
-}) => {
-  const { data, error } = await client
-    .from('passages')
-    .select('uuid, work_uuid, content, label, sort, type, toh, xmlId')
-    .in('uuid', targetUuids);
-
-  if (error) {
-    console.error('Error fetching replace targets:', error);
-    return {
-      ok: false as const,
-      error: `Failed to fetch replace targets: ${error.message}`,
-    };
-  }
-
-  const rowsByUuid = new Map((data ?? []).map((row) => [row.uuid, row]));
-  const missingUuids = targetUuids.filter((uuid) => !rowsByUuid.has(uuid));
-  if (missingUuids.length > 0) {
-    return {
-      ok: false as const,
-      error: `Unknown target UUIDs: ${missingUuids.join(', ')}`,
-    };
-  }
-
-  return {
-    ok: true as const,
-    orderedRows: targetUuids
-      .map((uuid) => rowsByUuid.get(uuid))
-      .filter((row): row is ReplacePassageRow => Boolean(row)),
-  };
-};
-
-export const fetchReplaceAnnotations = async ({
-  client,
-  targetUuids,
-}: {
-  client: DataClient;
-  targetUuids: string[];
-}) => {
-  const { data, error } = await client
-    .from('passage_annotations')
-    .select('uuid, content, end, start, type, passage_uuid, toh')
-    .in('passage_uuid', targetUuids)
-    .not('type', 'in', `(${ANNOTATIONS_TO_IGNORE.join(',')})`);
-
-  if (error) {
-    console.error('Error fetching annotations for replace:', error);
-    return {
-      ok: false as const,
-      error: `Failed to fetch annotations: ${error.message}`,
-    };
-  }
-
-  return {
-    ok: true as const,
-    rawAnnotations: (data ?? []) as AnnotationDTO[],
-  };
-};
-
-export const persistReplaceChanges = async ({
-  client,
-  rawAnnotations,
-  updatedPassages,
-}: {
-  client: DataClient;
-  rawAnnotations: AnnotationDTO[];
-  updatedPassages: Passage[];
-}) => {
-  const passageRowDtos = passagesToRowDTO(updatedPassages);
-  const annotationDtos = passagesToDTO(updatedPassages).flatMap(
-    (passage) => passage.annotations || [],
-  );
-  const updatedPassageUuids = updatedPassages.map((passage) => passage.uuid);
-  const updatedAnnotationUuids = new Set(annotationDtos.map((a) => a.uuid));
-  const annotationsToDelete = rawAnnotations.filter(
-    (annotation) =>
-      updatedPassageUuids.includes(annotation.passage_uuid || '') &&
-      !updatedAnnotationUuids.has(annotation.uuid),
-  );
-
-  const { error: passageError } = await client
-    .from('passages')
-    .upsert(passageRowDtos, { onConflict: 'uuid' });
-
-  if (passageError) {
-    console.error('Error saving replaced passages:', passageError);
-    return {
-      ok: false as const,
-      error: `Failed to save replaced passages: ${passageError.message}`,
-    };
-  }
-
-  if (annotationDtos.length > 0) {
-    const { error: annotationError } = await client
-      .from('passage_annotations')
-      .upsert(annotationDtos, { onConflict: 'uuid' });
-
-    if (annotationError) {
-      console.error('Error saving replaced annotations:', annotationError);
-      return {
-        ok: false as const,
-        error: `Failed to save replaced annotations: ${annotationError.message}`,
-      };
-    }
-  }
-
-  if (annotationsToDelete.length > 0) {
-    const { error: deleteError } = await client
-      .from('passage_annotations')
-      .delete()
-      .in(
-        'uuid',
-        annotationsToDelete.map((annotation) => annotation.uuid),
-      );
-
-    if (deleteError) {
-      console.error('Error deleting replaced annotations:', deleteError);
-      return {
-        ok: false as const,
-        error: `Failed to delete replaced annotations: ${deleteError.message}`,
-      };
-    }
-  }
-
-  return {
-    ok: true as const,
-  };
-};

package/src/lib/passage/save.ts

@@ -1,324 +0,0 @@
-import {
-  ANNOTATIONS_TO_IGNORE,
-  DataClient,
-  Passage,
-  passagesToDTO,
-  passagesToRowDTO,
-} from '../types';
-
-const SAVE_PAGE_SIZE = 500;
-
-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;
-    }
-  }
-};
-
-async function normalizePassageLabelsAfter({
-  client,
-  workUuid,
-  fromSort,
-  fromLabel,
-  delta,
-}: {
-  client: DataClient;
-  workUuid: string;
-  fromSort: number;
-  fromLabel: string;
-  delta: number;
-}): Promise<void> {
-  const parts = fromLabel.split('.');
-  const depth = parts.length;
-  const prefix = depth > 1 ? `${parts.slice(0, -1).join('.')}.` : '';
-  let nextInt = Number.parseInt(parts[depth - 1], 10) + Math.max(delta, 0);
-  let lastSort = fromSort;
-  let done = false;
-
-  while (!done) {
-    const { data, error } = await client
-      .from('passages')
-      .select('uuid, label, sort')
-      .eq('work_uuid', workUuid)
-      .gt('sort', lastSort)
-      .order('sort', { ascending: true })
-      .limit(SAVE_PAGE_SIZE);
-
-    if (error || !data || data.length === 0) break;
-
-    const labelUpdates: { uuid: string; label: string }[] = [];
-    const prefixRenames: { oldPrefix: string; newPrefix: string }[] = [];
-
-    for (const row of data) {
-      const rowParts = (row.label ?? '').split('.');
-
-      if (rowParts.length < depth || !row.label?.startsWith(prefix)) {
-        done = true;
-        break;
-      }
-
-      if (rowParts.length > depth) continue;
-
-      const expectedLabel = prefix + nextInt;
-      if (row.label === expectedLabel) {
-        done = true;
-        break;
-      }
-
-      labelUpdates.push({ uuid: row.uuid, label: expectedLabel });
-      prefixRenames.push({
-        oldPrefix: `${row.label}.`,
-        newPrefix: `${expectedLabel}.`,
-      });
-      nextInt++;
-    }
-
-    if (labelUpdates.length > 0) {
-      const { error: upsertError } = await client
-        .from('passages')
-        .upsert(labelUpdates, { onConflict: 'uuid' });
-      if (upsertError) {
-        console.error('Error normalizing passage labels:', upsertError);
-      }
-
-      for (const { oldPrefix, newPrefix } of prefixRenames) {
-        const { error: prefixError } = await client.rpc(
-          'rename_passage_label_prefix',
-          {
-            p_work_uuid: workUuid,
-            p_old_prefix: oldPrefix,
-            p_new_prefix: newPrefix,
-          },
-        );
-        if (prefixError) {
-          console.error('Error renaming passage label prefix:', prefixError);
-        }
-      }
-    }
-
-    if (done || data.length < SAVE_PAGE_SIZE) break;
-    lastSort = data[data.length - 1].sort;
-  }
-}
-
-export type SavePassagesWithDeletionsResult = {
-  success: boolean;
-  savedCount: number;
-  deletedCount?: number;
-  error?: string;
-};
-
-export const savePassagesWithDeletions = async ({
-  client,
-  passages,
-  deletedUuids = [],
-}: {
-  client: DataClient;
-  passages: Passage[];
-  deletedUuids?: string[];
-}): Promise<SavePassagesWithDeletionsResult> => {
-  const inputUuids = passages.map((p) => p.uuid);
-  const { data: existingRows } = await client
-    .from('passages')
-    .select('uuid')
-    .in('uuid', inputUuids);
-  const existingUuidSet = new Set((existingRows ?? []).map((r) => r.uuid));
-  const newPassages = passages.filter((p) => !existingUuidSet.has(p.uuid));
-  const sortedNewPassages = [...newPassages].sort((a, b) => b.sort - a.sort);
-
-  for (const passage of sortedNewPassages) {
-    const { error } = await client.rpc('shift_passage_sorts', {
-      p_work_uuid: passage.workUuid,
-      p_from_sort: passage.sort,
-      p_delta: 1,
-    });
-    if (error) {
-      console.error('Error shifting passage sorts:', error);
-    }
-  }
-
-  for (const passage of sortedNewPassages) {
-    await normalizePassageLabelsAfter({
-      client,
-      workUuid: passage.workUuid,
-      fromSort: passage.sort,
-      fromLabel: passage.label,
-      delta: 1,
-    });
-  }
-
-  let deletedCount = 0;
-  if (deletedUuids.length > 0) {
-    const { data: deletedPassages } = await client
-      .from('passages')
-      .select('uuid, sort, label, work_uuid')
-      .in('uuid', deletedUuids);
-
-    if (deletedPassages && deletedPassages.length > 0) {
-      const sortedDeleted = [...deletedPassages].sort(
-        (a, b) => b.sort - a.sort,
-      );
-      for (const deletedPassage of sortedDeleted) {
-        await normalizePassageLabelsAfter({
-          client,
-          workUuid: deletedPassage.work_uuid,
-          fromSort: deletedPassage.sort,
-          fromLabel: deletedPassage.label,
-          delta: -1,
-        });
-      }
-
-      const { error: deleteAnnotationsError } = await client
-        .from('passage_annotations')
-        .delete()
-        .in('passage_uuid', deletedUuids);
-
-      if (deleteAnnotationsError) {
-        console.error(
-          'Error deleting annotations for deleted passages:',
-          deleteAnnotationsError,
-        );
-      }
-
-      const { error: deletePassagesError } = await client
-        .from('passages')
-        .delete()
-        .in('uuid', deletedUuids);
-
-      if (deletePassagesError) {
-        console.error('Error deleting passages:', deletePassagesError);
-        return {
-          success: false,
-          savedCount: 0,
-          error: `Failed to delete passages: ${deletePassagesError.message}`,
-        };
-      }
-
-      deletedCount = deletedPassages.length;
-    }
-  }
-
-  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(
-    (existingAnnotation) =>
-      !annotations.find(
-        (annotation) => annotation.uuid === existingAnnotation.uuid,
-      ),
-  );
-
-  const { error: passageError } = await client
-    .from('passages')
-    .upsert(passageRowDtos, { onConflict: 'uuid' });
-
-  if (passageError) {
-    console.error('Error saving passages:', passageError);
-    return {
-      success: false,
-      savedCount: 0,
-      error: `Failed to save passages: ${passageError.message}`,
-    };
-  }
-
-  if (annotations.length > 0) {
-    const { error: annotationError } = await client
-      .from('passage_annotations')
-      .upsert(annotations, { onConflict: 'uuid' });
-
-    if (annotationError) {
-      console.error('Error saving annotations:', annotationError);
-      return {
-        success: false,
-        savedCount: passages.length,
-        error: `Passages saved but annotations failed: ${annotationError.message}`,
-      };
-    }
-  }
-
-  if (annotationsToDelete && annotationsToDelete.length > 0) {
-    const { error: deleteError } = await client
-      .from('passage_annotations')
-      .delete()
-      .in(
-        'uuid',
-        annotationsToDelete.map((annotation) => annotation.uuid),
-      );
-
-    if (deleteError) {
-      console.error('Error deleting annotations:', deleteError);
-    }
-  }
-
-  return {
-    success: true,
-    savedCount: passages.length,
-    deletedCount,
-  };
-};

package/src/lib/proxy.ts

@@ -1,68 +0,0 @@
-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 };
-}