@eightyfourthousand/data-access 2026.4.0 → 2026.4.2

package/.babelrc

@@ -1,12 +0,0 @@
-{
-  "presets": [
-    [
-      "@nx/react/babel",
-      {
-        "runtime": "automatic",
-        "useBuiltIns": "usage"
-      }
-    ]
-  ],
-  "plugins": []
-}

package/.eslintrc.json

@@ -1,18 +0,0 @@
-{
-  "extends": ["plugin:@nx/react", "../../.eslintrc.json"],
-  "ignorePatterns": ["!**/*"],
-  "overrides": [
-    {
-      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.ts", "*.tsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.js", "*.jsx"],
-      "rules": {}
-    }
-  ]
-}

package/README.md

@@ -1,9 +0,0 @@
-# @eightyfourthousand/data-access
-
-Shared data-access clients, DTO mappers, and domain types for 84000 applications.
-
-Use this package for typed access to shared application data models and server/client data helpers.
-
-## Running unit tests
-
-Run `nx test data-access` to execute the unit tests via [Jest](https://jestjs.io).

package/jest.config.ts

@@ -1,10 +0,0 @@
-module.exports = {
-  displayName: 'data-access',
-  preset: '../../jest.preset.js',
-  transform: {
-    '^(?!.*\\.(js|jsx|ts|tsx|css|json)$)': '@nx/react/plugins/jest',
-    '^.+\\.[tj]sx?$': ['babel-jest', { presets: ['@nx/react/babel'] }],
-  },
-  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx'],
-  coverageDirectory: '../../coverage/libs/data-access',
-};

package/project.json

@@ -1,21 +0,0 @@
-{
-  "name": "data-access",
-  "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "libs/data-access/src",
-  "projectType": "library",
-  "tags": [],
-  "targets": {
-    "build": {
-      "executor": "@nx/js:tsc",
-      "outputs": ["{options.outputPath}"],
-      "options": {
-        "outputPath": "dist/libs/data-access",
-        "main": "libs/data-access/src/index.ts",
-        "tsConfig": "libs/data-access/tsconfig.lib.json",
-        "rootDir": "libs/data-access/src",
-        "generateExportsField": true,
-        "additionalEntryPoints": ["libs/data-access/src/ssr.ts"]
-      }
-    }
-  }
-}

package/src/lib/auth.ts

@@ -1,203 +0,0 @@
-import { jwtDecode } from 'jwt-decode';
-import { DataClient, UserClaims, UserPermission, UserRole } from './types';
-
-export const getSession = async ({ client }: { client: DataClient }) => {
-  const { data, error } = await client.auth.getSession();
-  if (error || !data?.session) {
-    console.info(`Failed to get session data: ${error}`);
-    return null;
-  }
-
-  const { access_token } = data.session;
-  if (!access_token) {
-    return null;
-  }
-
-  try {
-    const decoded = jwtDecode(access_token);
-    const { user_role: role = 'reader' } = decoded as {
-      user_role: UserRole;
-    };
-    const claims: UserClaims = {
-      role,
-    };
-
-    return { claims, ...data.session };
-  } catch (error) {
-    console.error('Failed to decode JWT:', error);
-    return null;
-  }
-};
-
-export const getUser = async ({ client }: { client: DataClient }) => {
-  const session = await getSession({ client });
-  if (!session) {
-    return null;
-  }
-
-  const { claims, user } = session;
-  const { role } = claims;
-
-  const { id, email, user_metadata: metadata } = user;
-  const { name, picture } = metadata;
-
-  if (!id || !email) {
-    return null;
-  }
-
-  const { error, data } = await client
-    .from('user_profiles')
-    .select('username, fullName:full_name, avatar:avatar_url, subscriptions')
-    .eq('id', id)
-    .single();
-
-  if (error) {
-    console.warn(`Failed to fetch user profile: ${error.message}`);
-  }
-
-  const { username, fullName, avatar, subscriptions } = data || {};
-  const subsArray = Array.isArray(subscriptions) ? subscriptions : [];
-
-  return {
-    id,
-    email,
-    username: username || email,
-    name: fullName || name,
-    avatar: avatar || picture,
-    role,
-    subscriptions: subsArray,
-  };
-};
-
-export const hasPermission = async ({
-  client,
-  permission,
-}: {
-  client: DataClient;
-  permission: UserPermission;
-}) => {
-  const { data, error } = await client.rpc('authorize', {
-    requested_permission: permission,
-  });
-  if (error) {
-    console.error(`Failed to check permission: ${error.message}`);
-    return false;
-  }
-  return data as boolean;
-};
-
-export const loginWithGoogle = async ({
-  client,
-  redirectTo = undefined,
-}: {
-  client: DataClient;
-  redirectTo: string | undefined;
-}) => {
-  await client.auth.signInWithOAuth({
-    provider: 'google',
-    options: {
-      redirectTo,
-      queryParams: {
-        access_type: 'offline',
-        prompt: 'consent',
-        hd: '84000.co',
-      },
-    },
-  });
-};
-
-export const loginWithApple = async ({
-  client,
-  redirectTo = undefined,
-}: {
-  client: DataClient;
-  redirectTo: string | undefined;
-}) => {
-  await client.auth.signInWithOAuth({
-    provider: 'apple',
-    options: {
-      redirectTo,
-      queryParams: {
-        scope: 'email name',
-      },
-    },
-  });
-};
-
-export const loginWithEmail = async ({
-  client,
-  email,
-  password,
-}: {
-  client: DataClient;
-  email: string;
-  password: string;
-}) => {
-  const { error } = await client.auth.signInWithPassword({
-    email,
-    password,
-  });
-
-  if (error) {
-    console.error(`Failed to login with email: ${error.message}`);
-    throw error;
-  }
-};
-
-export const logout = async ({ client }: { client: DataClient }) => {
-  await client.auth.signOut();
-};
-
-export const resetPassword = async ({
-  client,
-  email,
-  redirectTo = undefined,
-}: {
-  client: DataClient;
-  email: string;
-  redirectTo?: string;
-}) => {
-  const { error } = await client.auth.resetPasswordForEmail(email, {
-    redirectTo,
-  });
-
-  if (error) {
-    console.error(`Failed to reset password: ${error.message}`);
-    throw error;
-  }
-};
-
-export const signUpWithEmail = async ({
-  client,
-  email,
-  password,
-  redirectTo = undefined,
-}: {
-  client: DataClient;
-  email: string;
-  password: string;
-  redirectTo?: string;
-}) => {
-  const { error } = await client.auth.signUp({
-    email,
-    password,
-    options: {
-      emailRedirectTo: redirectTo,
-    },
-  });
-
-  if (error) {
-    console.error(`Failed to sign up with email: ${error.message}`);
-    throw error;
-  }
-};
-
-export const deleteAccount = async ({ client }: { client: DataClient }) => {
-  const { error } = await client.rpc('scholar_account_delete');
-  if (error) {
-    console.error(`Failed to delete account: ${error.message}`);
-    throw error;
-  }
-
-  await logout({ client });
-};

package/src/lib/bibliography.ts

@@ -1,57 +0,0 @@
-import {
-  BibliographyEntriesDTO,
-  bibliographyEntriesFromDTO,
-  BibliographyEntryItemDTO,
-  bibliographyEntryItemFromDTO,
-  DataClient,
-} from './types';
-
-export const getBibliographyEntries = async ({
-  client,
-  uuid,
-}: {
-  client: DataClient;
-  uuid: string;
-}) => {
-  const { data, error } = await client.rpc('show_bibliographies', {
-    v_work_uuid: uuid,
-  });
-  if (error) {
-    console.error(
-      `Error fetching glossary instances for work: ${uuid} `,
-      error,
-    );
-    return [];
-  }
-
-  const dto = data as BibliographyEntriesDTO;
-  return bibliographyEntriesFromDTO(dto);
-};
-
-export const getBibliographyEntry = async ({
-  client,
-  uuid,
-}: {
-  client: DataClient;
-  uuid: string;
-}) => {
-  const { data, error } = await client
-    .from('bibliographies')
-    .select(
-      `
-      uuid::uuid,
-      work_uuid::uuid,
-      bibl_html::text
-`,
-    )
-    .eq('uuid', uuid)
-    .single();
-  if (error) {
-    console.error(`Error fetching bibliography entry: ${uuid} `, error);
-    return null;
-  }
-
-  const dto = data as BibliographyEntryItemDTO;
-
-  return bibliographyEntryItemFromDTO(dto);
-};

package/src/lib/client-browser.ts

@@ -1,12 +0,0 @@
-import { createBrowserClient as createSupabaseClient } from '@supabase/ssr';
-
-export const createBrowserClient = () => {
-  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');
-  }
-
-  return createSupabaseClient(supabaseUrl, supabaseAnonKey);
-};

package/src/lib/client-server.ts

@@ -1,30 +0,0 @@
-import {
-  CookieMethodsServer,
-  createServerClient as createSupabaseClient,
-} from '@supabase/ssr';
-
-export const createServerClient = ({
-  cookies,
-}: {
-  cookies: CookieMethodsServer;
-}) => {
-  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');
-  }
-
-  const client = createSupabaseClient(supabaseUrl, supabaseAnonKey, {
-    cookies,
-  });
-
-  // NOTE: we suppress the warning about getSession being called. But is is
-  // import not to rely on this method for authorization. Rather, it is
-  // convenient for early exists in server components.
-  //
-  // @ts-expect-error - suppressGetSessionWarning is protected
-  client.auth.suppressGetSessionWarning = true;
-
-  return client;
-};

package/src/lib/client-ssr.ts

@@ -1,24 +0,0 @@
-import { createServerClient as createSupabaseClient } from './client-server';
-import { cookies } from 'next/headers';
-
-export const createServerClient = async () => {
-  const cookieStore = await cookies();
-  return createSupabaseClient({
-    cookies: {
-      getAll: () => {
-        return cookieStore.getAll();
-      },
-      setAll: (cookiesToSet) => {
-        try {
-          cookiesToSet.forEach(({ name, value, options }) =>
-            cookieStore.set(name, value, options),
-          );
-        } catch {
-          // The `setAll` method was called from a Server Component.
-          // This can be ignored if you have middleware refreshing
-          // user sessions.
-        }
-      },
-    },
-  });
-};

package/src/lib/client-token.ts

@@ -1,24 +0,0 @@
-import { createClient } from '@supabase/supabase-js';
-import type { DataClient } from './types/client';
-
-/**
- * Create a Supabase client using an access token for authentication.
- * Use this for API routes that receive tokens via Authorization header
- * instead of cookies (e.g., cross-domain requests).
- */
-export const createTokenClient = (accessToken: string): DataClient => {
-  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');
-  }
-
-  return createClient(supabaseUrl, supabaseAnonKey, {
-    global: {
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-      },
-    },
-  });
-};

package/src/lib/feedback.ts

@@ -1,71 +0,0 @@
-import { parseToh } from '@eightyfourthousand/lib-utils';
-import { NextRequest, NextResponse } from 'next/server';
-import { Resend } from 'resend';
-
-async function sendRevisionEmail({
-  toh,
-  type,
-  label,
-  body,
-}: {
-  toh: string;
-  type: string;
-  label: string;
-  body: string;
-}) {
-  const apiKey = process.env['RESEND_API_KEY'];
-  const from = process.env['FEEDBACK_SENDER'];
-  const to = process.env['FEEDBACK_RECIPIENT'];
-
-  if (!apiKey || !from || !to) {
-    throw new Error('Missing email configuration environment variables');
-  }
-
-  const resend = new Resend(apiKey);
-  const trimmedLabel = label.split('\n').join(', ').trim();
-
-  const subject = `[Revision Suggestion] ${parseToh(toh)} - ${type} ${trimmedLabel}`;
-
-  const { error } = await resend.emails.send({
-    from,
-    to,
-    subject,
-    text: body,
-  });
-
-  if (error) {
-    throw new Error(error.message);
-  }
-}
-
-export async function handleFeedbackPost(request: NextRequest) {
-  try {
-    const { toh, type, label, body } = await request.json();
-
-    if (
-      typeof toh !== 'string' ||
-      !toh.trim() ||
-      typeof type !== 'string' ||
-      !type.trim() ||
-      typeof label !== 'string' ||
-      !label.trim() ||
-      typeof body !== 'string' ||
-      !body.trim()
-    ) {
-      return NextResponse.json(
-        { error: 'All fields (toh, type, label, body) are required.' },
-        { status: 400 },
-      );
-    }
-
-    await sendRevisionEmail({ toh, type, label, body });
-
-    return NextResponse.json({ success: true });
-  } catch (error) {
-    console.error('Failed to send revision email:', error);
-    return NextResponse.json(
-      { error: 'Failed to send feedback.' },
-      { status: 500 },
-    );
-  }
-}

package/src/lib/folio.ts

@@ -1,57 +0,0 @@
-'use server';
-
-import { createServerClient } from './client-ssr';
-import { DataClient, TohokuCatalogEntry } from './types';
-import { FolioDTO, folioFromDTO } from './types/folio';
-
-type GetWorkFoliosArgs = {
-  client: DataClient;
-  uuid: string;
-  toh: TohokuCatalogEntry;
-  page?: number;
-  size?: number;
-};
-
-export const getWorkFolios = async ({
-  client,
-  uuid,
-  toh,
-  page = 0,
-  size = 10,
-}: GetWorkFoliosArgs) => {
-  const start = page * size;
-  const end = start + size - 1;
-  const { data, error } = await client
-    .from('tibetan_works_folios')
-    .select(
-      `
-      folio_uuid,
-      content::text,
-      volume_number::int4,
-      folio_number::int4,
-      side::text`,
-    )
-    .eq('work_uuid', uuid)
-    .eq('toh', toh)
-    .order('volume_number', { ascending: true })
-    .order('folio_number', { ascending: true })
-    .order('side', { ascending: true })
-    .range(start, end);
-
-  if (error) {
-    console.error('Error fetching folios:', error);
-    return [];
-  }
-
-  return data.map((dto) => folioFromDTO(dto as FolioDTO));
-};
-
-export const getFolios = async ({
-  uuid,
-  toh,
-  page = 0,
-  size = 10,
-}: Omit<GetWorkFoliosArgs, 'client'>) => {
-  const client = await createServerClient();
-  return getWorkFolios({ client, uuid, toh, page, size });
-};

package/src/lib/glossary/batch.ts

@@ -1,35 +0,0 @@
-import { DataClient } from '../types';
-
-export const getGlossaryDisplayNamesByUuids = async ({
-  client,
-  glossaryUuids,
-}: {
-  client: DataClient;
-  glossaryUuids: readonly string[];
-}): Promise<Map<string, string>> => {
-  const namesByUuid = new Map<string, string>();
-  if (glossaryUuids.length === 0) return namesByUuid;
-
-  const { data, error } = await client
-    .from('glossaries')
-    .select('uuid, names:names!name_uuid(content)')
-    .in('uuid', glossaryUuids as string[]);
-
-  if (error) {
-    console.error('Error batch loading glossary names:', error);
-    return namesByUuid;
-  }
-
-  for (const glossary of data ?? []) {
-    const names = glossary.names as unknown as
-      | { content: string }
-      | { content: string }[]
-      | null;
-    const content = Array.isArray(names) ? names[0]?.content : names?.content;
-    if (content) {
-      namesByUuid.set(glossary.uuid, content);
-    }
-  }
-
-  return namesByUuid;
-};

package/src/lib/glossary/instance.ts

@@ -1,54 +0,0 @@
-import {
-  DataClient,
-  GlossaryTermInstanceDTO,
-  GlossaryTermInstancesDTO,
-  glossaryTermInstanceFromDTO,
-} from '../types';
-
-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);
-};

package/src/lib/glossary/landing.ts

@@ -1,50 +0,0 @@
-import {
-  DataClient,
-  GlossaryLandingItem,
-  GlossaryLandingItemDTO,
-  glossaryLandingItemFromDTO,
-} 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;
-};