@eightyfourthousand/data-access 2026.3.0

package/.babelrc

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

package/.eslintrc.json

@@ -0,0 +1,18 @@
+{
+  "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

@@ -0,0 +1,7 @@
+# data-access
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test data-access` to execute the unit tests via [Jest](https://jestjs.io).

package/jest.config.ts

@@ -0,0 +1,10 @@
+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/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@eightyfourthousand/data-access",
+  "version": "2026.3.0",
+  "description": "Shared data access clients, DTO mappers, and domain types for 84000 applications.",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/84000/84000-apps.git",
+    "directory": "libs/data-access"
+  },
+  "homepage": "https://github.com/84000/84000-apps",
+  "bugs": {
+    "url": "https://github.com/84000/84000-apps/issues"
+  },
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@eightyfourthousand/lib-utils": "^2026.3.0"
+  },
+  "peerDependencies": {
+    "next": "^16.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "sideEffects": false,
+  "keywords": [],
+  "author": ""
+}

package/project.json

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

@@ -0,0 +1,18 @@
+export * from './lib/auth';
+export * from './lib/bibliography';
+export * from './lib/canon';
+export * from './lib/client-browser';
+export * from './lib/client-server';
+export * from './lib/client-token';
+export * from './lib/folio';
+export * from './lib/glossary';
+export * from './lib/imprint';
+export * from './lib/panel-url';
+export * from './lib/library';
+export * from './lib/passage';
+export * from './lib/projects';
+export * from './lib/publications';
+export * from './lib/storage';
+export * from './lib/types';
+export * from './lib/local-storage';
+export * from './lib/use-bookmark';

package/src/lib/auth.ts

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

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

@@ -0,0 +1,111 @@
+import {
+  CanonDTO,
+  CanonDetailDTO,
+  CanonNode,
+  CanonWorksDTO,
+  DataClient,
+  canonDetailFromDTO,
+  canonNodeFromDTO,
+  canonTreeFromDTOs,
+  caononWorksFromDTO,
+} from './types';
+
+export const getCanonSections = async ({
+  client,
+}: {
+  client: DataClient;
+}): Promise<CanonNode[]> => {
+  const { data, error } = await client.rpc('scholar_canon_get_all');
+
+  if (error) {
+    console.error('Error fetching canon sections:', error);
+    return [];
+  }
+
+  return data.map((item: CanonDTO) => canonNodeFromDTO(item));
+};
+
+export const getCanonTree = async ({ client }: { client: DataClient }) => {
+  const { data, error } = await client.rpc('scholar_canon_get_all');
+
+  if (error) {
+    console.error('Error fetching canon tree:', error);
+    return null;
+  }
+
+  return canonTreeFromDTOs(data as CanonDTO[]);
+};
+
+export const getCanonSection = async ({
+  client,
+  uuid,
+}: {
+  client: DataClient;
+  uuid: string;
+}) => {
+  const { data, error } = await client.rpc('scholar_canon_get_detail', {
+    uuid_input: uuid,
+  });
+
+  if (error) {
+    console.error('Error fetching canon section:', error);
+    return null;
+  }
+
+  return canonDetailFromDTO(data[0] as CanonDetailDTO);
+};
+
+export const getCanonWorks = async ({
+  client,
+  uuids,
+}: {
+  client: DataClient;
+  uuids: string[];
+}) => {
+  const { data, error } = await client
+    .rpc('scholar_canon_get_works', {
+      uuids_input: uuids,
+    })
+    .single();
+
+  if (error) {
+    console.error('Error fetching canon works:', error);
+    return null;
+  }
+
+  return caononWorksFromDTO(data as CanonWorksDTO);
+};
+
+/** Travers the canon tree to find a node by its UUID */
+export const findNodeByUuid = (
+  head: CanonNode[],
+  uuid: string,
+): CanonNode | null => {
+  for (const node of head) {
+    if (node.uuid === uuid) {
+      return node;
+    }
+    if (node.children) {
+      const found = findNodeByUuid(node.children, uuid);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+};
+
+/** Flatten the canon tree into a list of nodes */
+export const flattenCanonTree = (head: CanonNode): CanonNode[] => {
+  const flatList: CanonNode[] = [head];
+
+  const traverse = (node: CanonNode) => {
+    flatList.push(node);
+    if (node.children) {
+      node.children.forEach(traverse);
+    }
+  };
+
+  head.children?.forEach(traverse);
+  return flatList;
+};

package/src/lib/client-browser.ts

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

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

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

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

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