Audio availability

src/db/schema.ts

@@ -226,6 +226,7 @@ export const bibles = pgTable(
     abbreviation: varchar('abbreviation', { length: 50 }).notNull().unique(),
     provider: bibleProviderEnum('provider').notNull().default('dbl'),
     externalId: varchar('external_id', { length: 255 }),
+    hasAudio: boolean('has_audio').notNull().default(false),
     createdAt: timestamp('created_at').defaultNow(),
     updatedAt: timestamp('updated_at')
       .defaultNow()
@@ -298,6 +299,7 @@ export const bible_books = pgTable(
     bookId: integer('book_id')
       .notNull()
       .references(() => books.id),
+    hasAudio: boolean('has_audio').notNull().default(false),
     createdAt: timestamp('created_at').defaultNow(),
     updatedAt: timestamp('updated_at')
       .defaultNow()

src/domains/bible-books/bible-books.repository.ts

@@ -13,6 +13,7 @@ import type { BibleBook, BibleBookWithDetails, CreateBibleBookInput } from './bi
 const bibleBookSelect = {
   bibleId: bible_books.bibleId,
   bookId: bible_books.bookId,
+  hasAudio: bible_books.hasAudio,
   createdAt: bible_books.createdAt,
   updatedAt: bible_books.updatedAt,
   book: {

src/domains/bible-books/bible-books.service.ts

@@ -14,6 +14,7 @@ function toDetailResponse(record: BibleBookWithDetails): BibleBookDetailResponse
   return {
     bibleId: record.bibleId,
     bookId: record.bookId,
+    hasAudio: record.hasAudio,
     createdAt: record.createdAt ? record.createdAt.toISOString() : null,
     updatedAt: record.updatedAt ? record.updatedAt.toISOString() : null,
     book: {
@@ -32,6 +33,7 @@ function toResponse(record: BibleBook): BibleBookResponse {
   return {
     bibleId: record.bibleId,
     bookId: record.bookId,
+    hasAudio: record.hasAudio,
     createdAt: record.createdAt ? record.createdAt.toISOString() : null,
     updatedAt: record.updatedAt ? record.updatedAt.toISOString() : null,
   };

src/domains/bible-books/bible-books.types.ts

@@ -12,13 +12,15 @@ export const createBibleBookSchema = z.object({
 export const bibleBookResponseSchema = z.object({
   bibleId: z.number().int(),
   bookId: z.number().int(),
+  hasAudio: z.boolean(),
   createdAt: z.string().nullable(),
   updatedAt: z.string().nullable(),
 });
 
 export const bibleBookDetailResponseSchema = z.object({
   bibleId: z.number().int(),
   bookId: z.number().int(),
+  hasAudio: z.boolean(),
   createdAt: z.string().nullable(),
   updatedAt: z.string().nullable(),
   book: z.object({

src/domains/bibles/bibles.repository.ts

@@ -84,6 +84,7 @@ export interface DblBibleUpsertInput {
   abbreviation: string;
   provider: 'dbl';
   externalId: string;
+  hasAudio: boolean;
 }
 
 export interface DblBibleUpsertSummary {
@@ -118,6 +119,7 @@ export async function upsertFromDbl(
               name: sql`excluded.name`,
               abbreviation: sql`excluded.abbreviation`,
               languageId: sql`excluded.language_id`,
+              hasAudio: sql`excluded.has_audio`,
               updatedAt: sql`now()`,
             },
           })

src/domains/bibles/bibles.service.ts

@@ -12,6 +12,7 @@ function toBibleResponse(bible: Bible): BibleResponse {
     name: bible.name,
     abbreviation: bible.abbreviation,
     languageId: bible.languageId,
+    hasAudio: bible.hasAudio,
   };
 }
 

src/domains/bibles/bibles.types.ts

@@ -13,6 +13,7 @@ export const bibleResponseSchema = z.object({
   name: z.string(),
   abbreviation: z.string(),
   languageId: z.number().int(),
+  hasAudio: z.boolean(),
 });
 
 export type BibleResponse = z.infer<typeof bibleResponseSchema>;

src/domains/bibles/sync/dbl-bible-sync.test.ts

@@ -30,6 +30,7 @@ function bible(overrides: {
   langId: string;
   abbreviation?: string;
   abbreviationLocal?: string;
+  audioBibles?: { id: string }[];
 }): DblBibleSummary {
   return {
     id: overrides.id,
@@ -44,6 +45,7 @@ function bible(overrides: {
       script: 'Latin',
       scriptDirection: 'LTR',
     },
+    audioBibles: overrides.audioBibles,
   } as DblBibleSummary;
 }
 
@@ -59,6 +61,7 @@ function fakeClient(bibles: DblBibleSummary[]): DblClient {
     getVerse: vi.fn(),
     getPassage: vi.fn(),
     getAudioChapter: vi.fn(),
+    getAudioBibleBooks: vi.fn(),
   };
 }
 
@@ -154,4 +157,22 @@ describe('syncBiblesFromDbl', () => {
       expect.objectContaining({ languageId: 100, externalId: 'b2', abbreviation: 'B2A' }),
     ]);
   });
+
+  it('correctly maps hasAudio to true if audioBibles exist, false otherwise', async () => {
+    mockUpsertFromDbl.mockResolvedValue(ok({ inserted: 2, updated: 0 }));
+    const client = fakeClient([
+      bible({ id: 'b1', langId: 'eng', audioBibles: [{ id: 'ab1' }] }),
+      bible({ id: 'b2', langId: 'eng', audioBibles: [] }),
+      bible({ id: 'b3', langId: 'eng' }), // audioBibles undefined
+    ]);
+
+    const result = await syncBiblesFromDbl(client);
+
+    expect(result.ok).toBe(true);
+    expect(mockUpsertFromDbl).toHaveBeenCalledWith([
+      expect.objectContaining({ externalId: 'b1', hasAudio: true }),
+      expect.objectContaining({ externalId: 'b2', hasAudio: false }),
+      expect.objectContaining({ externalId: 'b3', hasAudio: false }),
+    ]);
+  });
 });

src/domains/bibles/sync/dbl-bible-sync.ts

@@ -84,13 +84,15 @@ export async function syncBiblesFromDbl(
     // If this Bible was already synced, reuse its stored abbreviation and name
     // to avoid regenerating collision suffixes on every re-sync.
     const existing = existingByExternalId.get(bible.id);
+    const hasAudio = !!(bible.audioBibles && bible.audioBibles.length > 0);
     if (existing) {
       rows.push({
         languageId,
         name: existing.name,
         abbreviation: existing.abbreviation,
         provider: 'dbl',
         externalId: bible.id,
+        hasAudio,
       });
       continue;
     }
@@ -129,6 +131,7 @@ export async function syncBiblesFromDbl(
       abbreviation: abbrev,
       provider: 'dbl',
       externalId: bible.id,
+      hasAudio,
     });
   }
 

src/domains/books/books.repository.ts

@@ -1,4 +1,4 @@
-import { eq, inArray } from 'drizzle-orm';
+import { and, eq, inArray } from 'drizzle-orm';
 
 import type { Result } from '@/lib/types';
 
@@ -190,3 +190,54 @@ export async function upsertFromDbl(
     return err(ErrorCode.INTERNAL_ERROR);
   }
 }
+
+/**
+ * Updates `has_audio` on `bible_books` rows for a given Bible.
+ *
+ * Sets `has_audio = true` for books whose code is in `audioBookCodes`,
+ * and `has_audio = false` for all other books of that Bible.
+ */
+export async function updateAudioAvailability(
+  bibleId: number,
+  audioBookCodes: string[]
+): Promise<Result<{ updated: number }>> {
+  try {
+    let updated = 0;
+
+    await db.transaction(async (tx) => {
+      // Resolve book codes to IDs
+      const audioBookRows =
+        audioBookCodes.length > 0
+          ? await tx.select({ id: books.id }).from(books).where(inArray(books.code, audioBookCodes))
+          : [];
+      const audioBookIds = new Set(audioBookRows.map((b) => b.id));
+
+      // Fetch all bible_book rows for this Bible
+      const allLinks = await tx
+        .select({ bookId: bible_books.bookId, hasAudio: bible_books.hasAudio })
+        .from(bible_books)
+        .where(eq(bible_books.bibleId, bibleId));
+
+      // Update rows that need changing
+      for (const link of allLinks) {
+        const shouldHaveAudio = audioBookIds.has(link.bookId);
+        if (link.hasAudio !== shouldHaveAudio) {
+          await tx
+            .update(bible_books)
+            .set({ hasAudio: shouldHaveAudio })
+            .where(and(eq(bible_books.bibleId, bibleId), eq(bible_books.bookId, link.bookId)));
+          updated++;
+        }
+      }
+    });
+
+    return ok({ updated });
+  } catch (error) {
+    logger.error({
+      cause: error,
+      message: 'Failed to update audio availability',
+      context: { bibleId, audioBookCodeCount: audioBookCodes.length },
+    });
+    return err(ErrorCode.INTERNAL_ERROR);
+  }
+}

src/domains/books/sync/dbl-book-sync.test.ts

@@ -6,7 +6,8 @@ import type { DblBook } from '@/lib/services/dbl/dbl.types';
 
 import { ErrorCode, ok } from '@/lib/types';
 
-import { syncBooksFromDbl } from './dbl-book-sync';
+import * as booksRepo from '../books.repository';
+import { syncAudioAvailability, syncBooksFromDbl } from './dbl-book-sync';
 
 const { mockUpsertFromDbl, mockGetAllBibles } = vi.hoisted(() => ({
   mockUpsertFromDbl: vi.fn(),
@@ -15,6 +16,7 @@ const { mockUpsertFromDbl, mockGetAllBibles } = vi.hoisted(() => ({
 
 vi.mock('../books.repository', () => ({
   upsertFromDbl: mockUpsertFromDbl,
+  updateAudioAvailability: vi.fn(),
 }));
 
 vi.mock('@/domains/bibles/bibles.repository', () => ({
@@ -27,6 +29,8 @@ function fakeClient(responses: Record<string, DblBook[]>): DblClient {
       if (responses[bibleId]) return Promise.resolve(ok(responses[bibleId]));
       return Promise.resolve({ ok: false, error: { code: ErrorCode.INTERNAL_ERROR } });
     }),
+    getBible: vi.fn(),
+    getAudioBibleBooks: vi.fn(),
   } as unknown as DblClient;
 }
 
@@ -73,3 +77,52 @@ describe('syncBooksFromDbl', () => {
     ]);
   });
 });
+
+describe('syncAudioAvailability', () => {
+  beforeEach(() => {
+    vi.mocked(booksRepo.updateAudioAvailability).mockResolvedValue(ok({ updated: 1 }));
+  });
+
+  it('skips bibles without audio', async () => {
+    mockGetAllBibles.mockResolvedValue(
+      ok([{ id: 1, externalId: 'b1', provider: 'dbl', hasAudio: false }] as Bible[])
+    );
+    const client = fakeClient({});
+    const result = await syncAudioAvailability(client);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.data.totalBiblesProcessed).toBe(0);
+    }
+    expect(client.getBible).not.toHaveBeenCalled();
+  });
+
+  it('fetches audio bibles and updates availability for bibles with audio', async () => {
+    mockGetAllBibles.mockResolvedValue(
+      ok([{ id: 1, externalId: 'b1', provider: 'dbl', hasAudio: true }] as Bible[])
+    );
+    const client = fakeClient({});
+    vi.mocked(client.getBible).mockResolvedValue(
+      ok({ audioBibles: [{ id: 'ab1' }, { id: 'ab2' }] } as any)
+    );
+    vi.mocked(client.getAudioBibleBooks).mockImplementation(async (audioId) => {
+      if (audioId === 'ab1') return ok([{ id: 'GEN' }] as any);
+      if (audioId === 'ab2') return ok([{ id: 'EXO' }] as any);
+      return ok([]);
+    });
+
+    const result = await syncAudioAvailability(client);
+
+    expect(result.ok).toBe(true);
+    expect(client.getBible).toHaveBeenCalledWith('b1');
+    expect(client.getAudioBibleBooks).toHaveBeenCalledWith('ab1');
+    expect(client.getAudioBibleBooks).toHaveBeenCalledWith('ab2');
+
+    // Set doesn't guarantee order, so we check the set of elements
+    const updateCall = vi.mocked(booksRepo.updateAudioAvailability).mock.calls[0];
+    expect(updateCall[0]).toBe(1);
+    expect(updateCall[1]).toContain('GEN');
+    expect(updateCall[1]).toContain('EXO');
+    expect(updateCall[1]).toHaveLength(2);
+  });
+});