diff --git a/src/lib/categories.test.ts b/src/lib/categories.test.ts
new file mode 100644
index 0000000..c2bfcfa
--- /dev/null
+++ b/src/lib/categories.test.ts
@@ -0,0 +1,41 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createTestDatabase } from '../../db/test-helpers';
+import { categories } from '../../db/schema';
+import type { Database } from './db';
+import { getAllCategories } from './categories';
+
+describe('categories data-access helpers', () => {
+ let db: Database;
+
+ beforeEach(async () => {
+ db = await createTestDatabase();
+ });
+
+ it('returns all categories ordered by name', async () => {
+ // Insert in reverse alphabetical order to test ordering
+ await db.insert(categories).values({ name: 'Strategy', description: 'Strategic games' });
+ await db.insert(categories).values({ name: 'Action', description: 'Action games' });
+ await db.insert(categories).values({ name: 'Puzzle', description: 'Puzzle games' });
+
+ const all = await getAllCategories(db);
+
+ expect(all).toHaveLength(3);
+ expect(all.map((c) => c.name)).toEqual(['Action', 'Puzzle', 'Strategy']);
+ expect(all[0]).toEqual({ id: expect.any(Number), name: 'Action' });
+ });
+
+ it('returns empty array when no categories exist', async () => {
+ const all = await getAllCategories(db);
+ expect(all).toEqual([]);
+ });
+
+ it('returns only id and name fields', async () => {
+ await db.insert(categories).values({ name: 'RPG', description: 'Role-playing games' });
+
+ const all = await getAllCategories(db);
+
+ expect(all).toHaveLength(1);
+ expect(all[0]).toEqual({ id: expect.any(Number), name: 'RPG' });
+ expect(all[0]).not.toHaveProperty('description');
+ });
+});
diff --git a/src/lib/categories.ts b/src/lib/categories.ts
new file mode 100644
index 0000000..7f26efc
--- /dev/null
+++ b/src/lib/categories.ts
@@ -0,0 +1,31 @@
+/**
+ * Data-access helpers for category summary records used by Astro pages.
+ */
+
+import { asc } from 'drizzle-orm';
+import type { Database } from './db';
+import { categories } from '../../db/schema';
+import type { Category } from '../types/game';
+
+type CategorySummaryRow = {
+ id: number;
+ name: string;
+};
+
+/**
+ * Returns all categories ordered by name.
+ *
+ * @param db - Drizzle database client.
+ * @returns A list of category summaries including only `id` and `name`.
+ */
+export async function getAllCategories(db: Database): Promise
{
+ const rows = await db
+ .select({ id: categories.id, name: categories.name })
+ .from(categories)
+ .orderBy(asc(categories.name));
+
+ return rows.map((row: CategorySummaryRow) => ({
+ id: row.id,
+ name: row.name,
+ }));
+}
diff --git a/src/lib/games.test.ts b/src/lib/games.test.ts
index efea6b6..12c25e7 100644
--- a/src/lib/games.test.ts
+++ b/src/lib/games.test.ts
@@ -6,6 +6,7 @@ import {
getAllGames,
getAllGameIds,
getGameById,
+ type GameFilters,
} from './games';
async function seedGames(db: Database, count: number): Promise {
@@ -63,4 +64,199 @@ describe('games data-access helpers', () => {
await seedGames(db, 2);
expect(await getGameById(db, 99999)).toBeNull();
});
+
+ describe('filtering', () => {
+ it('filters games by single category', async () => {
+ const [cat1] = await db
+ .insert(categories)
+ .values({ name: 'Strategy' })
+ .returning({ id: categories.id });
+ const [cat2] = await db
+ .insert(categories)
+ .values({ name: 'Action' })
+ .returning({ id: categories.id });
+ const [pub] = await db
+ .insert(publishers)
+ .values({ name: 'Publisher' })
+ .returning({ id: publishers.id });
+
+ await db.insert(games).values({
+ title: 'Strategy Game',
+ description: 'A strategy game',
+ categoryId: cat1.id,
+ publisherId: pub.id,
+ });
+ await db.insert(games).values({
+ title: 'Action Game',
+ description: 'An action game',
+ categoryId: cat2.id,
+ publisherId: pub.id,
+ });
+
+ const filters: GameFilters = { categoryIds: [cat1.id] };
+ const filtered = await getAllGames(db, filters);
+
+ expect(filtered).toHaveLength(1);
+ expect(filtered[0].title).toBe('Strategy Game');
+ });
+
+ it('filters games by multiple categories', async () => {
+ const [cat1] = await db
+ .insert(categories)
+ .values({ name: 'Strategy' })
+ .returning({ id: categories.id });
+ const [cat2] = await db
+ .insert(categories)
+ .values({ name: 'Action' })
+ .returning({ id: categories.id });
+ const [cat3] = await db
+ .insert(categories)
+ .values({ name: 'Puzzle' })
+ .returning({ id: categories.id });
+ const [pub] = await db
+ .insert(publishers)
+ .values({ name: 'Publisher' })
+ .returning({ id: publishers.id });
+
+ await db.insert(games).values({
+ title: 'Strategy Game',
+ description: 'A strategy game',
+ categoryId: cat1.id,
+ publisherId: pub.id,
+ });
+ await db.insert(games).values({
+ title: 'Action Game',
+ description: 'An action game',
+ categoryId: cat2.id,
+ publisherId: pub.id,
+ });
+ await db.insert(games).values({
+ title: 'Puzzle Game',
+ description: 'A puzzle game',
+ categoryId: cat3.id,
+ publisherId: pub.id,
+ });
+
+ const filters: GameFilters = { categoryIds: [cat1.id, cat3.id] };
+ const filtered = await getAllGames(db, filters);
+
+ expect(filtered).toHaveLength(2);
+ expect(filtered.map((g) => g.title).sort()).toEqual(['Puzzle Game', 'Strategy Game']);
+ });
+
+ it('filters games by publisher', async () => {
+ const [cat] = await db
+ .insert(categories)
+ .values({ name: 'Strategy' })
+ .returning({ id: categories.id });
+ const [pub1] = await db
+ .insert(publishers)
+ .values({ name: 'Publisher One' })
+ .returning({ id: publishers.id });
+ const [pub2] = await db
+ .insert(publishers)
+ .values({ name: 'Publisher Two' })
+ .returning({ id: publishers.id });
+
+ await db.insert(games).values({
+ title: 'Game from Pub1',
+ description: 'A game',
+ categoryId: cat.id,
+ publisherId: pub1.id,
+ });
+ await db.insert(games).values({
+ title: 'Another Game from Pub1',
+ description: 'Another game',
+ categoryId: cat.id,
+ publisherId: pub1.id,
+ });
+ await db.insert(games).values({
+ title: 'Game from Pub2',
+ description: 'A game',
+ categoryId: cat.id,
+ publisherId: pub2.id,
+ });
+
+ const filters: GameFilters = { publisherId: pub1.id };
+ const filtered = await getAllGames(db, filters);
+
+ expect(filtered).toHaveLength(2);
+ expect(filtered.every((g) => g.publisher?.id === pub1.id)).toBe(true);
+ });
+
+ it('filters games by both category and publisher', async () => {
+ const [cat1] = await db
+ .insert(categories)
+ .values({ name: 'Strategy' })
+ .returning({ id: categories.id });
+ const [cat2] = await db
+ .insert(categories)
+ .values({ name: 'Action' })
+ .returning({ id: categories.id });
+ const [pub1] = await db
+ .insert(publishers)
+ .values({ name: 'Publisher One' })
+ .returning({ id: publishers.id });
+ const [pub2] = await db
+ .insert(publishers)
+ .values({ name: 'Publisher Two' })
+ .returning({ id: publishers.id });
+
+ await db.insert(games).values({
+ title: 'Strategy from Pub1',
+ description: 'A game',
+ categoryId: cat1.id,
+ publisherId: pub1.id,
+ });
+ await db.insert(games).values({
+ title: 'Action from Pub1',
+ description: 'A game',
+ categoryId: cat2.id,
+ publisherId: pub1.id,
+ });
+ await db.insert(games).values({
+ title: 'Strategy from Pub2',
+ description: 'A game',
+ categoryId: cat1.id,
+ publisherId: pub2.id,
+ });
+
+ const filters: GameFilters = { categoryIds: [cat1.id], publisherId: pub1.id };
+ const filtered = await getAllGames(db, filters);
+
+ expect(filtered).toHaveLength(1);
+ expect(filtered[0].title).toBe('Strategy from Pub1');
+ });
+
+ it('returns all games when no filters are provided', async () => {
+ await seedGames(db, 3);
+ const all = await getAllGames(db);
+ const filtered = await getAllGames(db, {});
+
+ expect(filtered).toEqual(all);
+ });
+
+ it('returns empty array when filters match no games', async () => {
+ const [cat] = await db
+ .insert(categories)
+ .values({ name: 'Strategy' })
+ .returning({ id: categories.id });
+ const [pub] = await db
+ .insert(publishers)
+ .values({ name: 'Publisher' })
+ .returning({ id: publishers.id });
+
+ await db.insert(games).values({
+ title: 'Game',
+ description: 'A game',
+ categoryId: cat.id,
+ publisherId: pub.id,
+ });
+
+ const filters: GameFilters = { categoryIds: [99999] };
+ const filtered = await getAllGames(db, filters);
+
+ expect(filtered).toEqual([]);
+ });
+ });
});
diff --git a/src/lib/games.ts b/src/lib/games.ts
index 4ed218e..0225961 100644
--- a/src/lib/games.ts
+++ b/src/lib/games.ts
@@ -1,8 +1,13 @@
-import { eq, asc } from 'drizzle-orm';
+import { eq, asc, and, inArray } from 'drizzle-orm';
import type { Database } from './db';
import { games, categories, publishers } from '../../db/schema';
import type { Game } from '../types/game';
+export interface GameFilters {
+ categoryIds?: number[];
+ publisherId?: number;
+}
+
const gameSelection = {
id: games.id,
title: games.title,
@@ -50,10 +55,26 @@ function baseGamesQuery(db: Database) {
.leftJoin(publishers, eq(games.publisherId, publishers.id));
}
-/** All games ordered by title. */
-export async function getAllGames(db: Database): Promise {
- const rows = await baseGamesQuery(db).orderBy(asc(games.title));
- return rows.map(mapGame);
+/** All games ordered by title. Optionally filter by category IDs and/or publisher ID. */
+export async function getAllGames(db: Database, filters?: GameFilters): Promise {
+ // Build filter conditions
+ const conditions = [];
+ if (filters?.categoryIds && filters.categoryIds.length > 0) {
+ conditions.push(inArray(games.categoryId, filters.categoryIds));
+ }
+ if (filters?.publisherId !== undefined) {
+ conditions.push(eq(games.publisherId, filters.publisherId));
+ }
+
+ // Build and execute query
+ const query = baseGamesQuery(db);
+ if (conditions.length > 0) {
+ const rows = await query.where(and(...conditions)).orderBy(asc(games.title));
+ return rows.map(mapGame);
+ } else {
+ const rows = await query.orderBy(asc(games.title));
+ return rows.map(mapGame);
+ }
}
/** All game ids ordered by title. */
diff --git a/src/lib/publishers.test.ts b/src/lib/publishers.test.ts
new file mode 100644
index 0000000..30bf816
--- /dev/null
+++ b/src/lib/publishers.test.ts
@@ -0,0 +1,41 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createTestDatabase } from '../../db/test-helpers';
+import { publishers } from '../../db/schema';
+import type { Database } from './db';
+import { getAllPublishers } from './publishers';
+
+describe('publishers data-access helpers', () => {
+ let db: Database;
+
+ beforeEach(async () => {
+ db = await createTestDatabase();
+ });
+
+ it('returns all publishers ordered by name', async () => {
+ // Insert in reverse alphabetical order to test ordering
+ await db.insert(publishers).values({ name: 'Zeta Games', description: 'A publisher' });
+ await db.insert(publishers).values({ name: 'Alpha Studios', description: 'A publisher' });
+ await db.insert(publishers).values({ name: 'Mega Corp', description: 'A publisher' });
+
+ const all = await getAllPublishers(db);
+
+ expect(all).toHaveLength(3);
+ expect(all.map((p) => p.name)).toEqual(['Alpha Studios', 'Mega Corp', 'Zeta Games']);
+ expect(all[0]).toEqual({ id: expect.any(Number), name: 'Alpha Studios' });
+ });
+
+ it('returns empty array when no publishers exist', async () => {
+ const all = await getAllPublishers(db);
+ expect(all).toEqual([]);
+ });
+
+ it('returns only id and name fields', async () => {
+ await db.insert(publishers).values({ name: 'Test Publisher', description: 'A test publisher' });
+
+ const all = await getAllPublishers(db);
+
+ expect(all).toHaveLength(1);
+ expect(all[0]).toEqual({ id: expect.any(Number), name: 'Test Publisher' });
+ expect(all[0]).not.toHaveProperty('description');
+ });
+});
diff --git a/src/lib/publishers.ts b/src/lib/publishers.ts
new file mode 100644
index 0000000..12723ed
--- /dev/null
+++ b/src/lib/publishers.ts
@@ -0,0 +1,31 @@
+/**
+ * Data-access helpers for publisher summary records used by Astro pages.
+ */
+
+import { asc } from 'drizzle-orm';
+import type { Database } from './db';
+import { publishers } from '../../db/schema';
+import type { Publisher } from '../types/game';
+
+type PublisherSummaryRow = {
+ id: number;
+ name: string;
+};
+
+/**
+ * Returns all publishers ordered by name.
+ *
+ * @param db - Drizzle database client.
+ * @returns A list of publisher summaries including only `id` and `name`.
+ */
+export async function getAllPublishers(db: Database): Promise {
+ const rows = await db
+ .select({ id: publishers.id, name: publishers.name })
+ .from(publishers)
+ .orderBy(asc(publishers.name));
+
+ return rows.map((row: PublisherSummaryRow) => ({
+ id: row.id,
+ name: row.name,
+ }));
+}
diff --git a/src/pages/index.astro b/src/pages/index.astro
index 5ad3cfa..0c3615d 100644
--- a/src/pages/index.astro
+++ b/src/pages/index.astro
@@ -3,12 +3,17 @@ import Layout from '../layouts/Layout.astro';
import GameCard from '../components/GameCard.astro';
import PageHero from '../components/PageHero.astro';
import EmptyState from '../components/EmptyState.astro';
+import FilterControls from '../components/FilterControls.astro';
import { getDatabase } from '../lib/db';
import { getAllGames } from '../lib/games';
+import { getAllCategories } from '../lib/categories';
+import { getAllPublishers } from '../lib/publishers';
export const prerender = true;
const games = await getAllGames(getDatabase());
+const categories = await getAllCategories(getDatabase());
+const publishers = await getAllPublishers(getDatabase());
---
@@ -18,6 +23,8 @@ const games = await getAllGames(getDatabase());
subtitle="Find your next game! And maybe even back one! Explore our collection!"
/>
+
+
Featured Games