feat: Enable Moonboard climb saving to PostgreSQL database

packages/backend/src/__tests__/graphql-resolvers.test.ts

@@ -233,7 +233,7 @@ describe('GraphQL Resolver Input Validation', () => {
             climbUuid: 'test-uuid',
           },
         },
-        'Board name must be kilter or tension',
+        'Board name must be kilter, tension, or moonboard',
       );
     });
   });
@@ -330,7 +330,7 @@ describe('GraphQL Resolver Input Validation', () => {
             },
           },
         },
-        'Board name must be kilter, tension',
+        'Board name must be kilter, tension, or moonboard',
       );
     });
   });

packages/backend/src/db/queries/climbs/create-climb-filters.ts

@@ -62,6 +62,7 @@
 
   // Base conditions for filtering climbs that don't reference the product sizes table
   const baseConditions: SQL[] = [
+    eq(tables.climbs.boardType, params.board_name),
     eq(tables.climbs.layoutId, params.layout_id),
     eq(tables.climbs.isListed, true),
     eq(tables.climbs.isDraft, false),
@@ -71,7 +72,7 @@
   // Size-specific conditions using pre-fetched static edge values
   // This eliminates the need for a JOIN on product_sizes in the main query
   const sizeConditions: SQL[] = [
     sql`${tables.climbs.edgeLeft} > ${sizeEdges.edgeLeft}`,
     sql`${tables.climbs.edgeRight} < ${sizeEdges.edgeRight}`,
     sql`${tables.climbs.edgeBottom} > ${sizeEdges.edgeBottom}`,
     sql`${tables.climbs.edgeTop} < ${sizeEdges.edgeTop}`,
@@ -244,6 +245,7 @@
     // For use in the subquery with left join
     getClimbStatsJoinConditions: () => [
       eq(tables.climbStats.climbUuid, tables.climbs.uuid),
+      eq(tables.climbStats.boardType, params.board_name),
       eq(tables.climbStats.angle, params.angle),
     ],
 

packages/backend/src/db/queries/climbs/get-climb.ts

@@ -31,6 +31,11 @@
     7: { name: 'FINISH', displayColor: '#FF0000', color: '#FF0000' },
     8: { name: 'FOOT', displayColor: '#FF00FF', color: '#FF00FF' },
   },
+  moonboard: {
+    42: { name: 'STARTING', color: '#00FF00', displayColor: '#44FF44' },
+    43: { name: 'HAND', color: '#0000FF', displayColor: '#4444FF' },
+    44: { name: 'FINISH', color: '#FF0000', displayColor: '#FF3333' },
+  },
 };
 
 // Warned hold states to avoid log spam
@@ -87,7 +92,7 @@
   const tables = getBoardTables(params.board_name);
 
   try {
     const result = await db
       .select({
         uuid: tables.climbs.uuid,
         setter_username: tables.climbs.setterUsername,
@@ -104,14 +109,18 @@
       .from(tables.climbs)
       .leftJoin(
         tables.climbStats,
-        sql`${tables.climbStats.climbUuid} = ${tables.climbs.uuid} AND ${tables.climbStats.angle} = ${params.angle}`
+        sql`${tables.climbStats.climbUuid} = ${tables.climbs.uuid}
+        AND ${tables.climbStats.boardType} = ${params.board_name}
+        AND ${tables.climbStats.angle} = ${params.angle}`
       )
       .leftJoin(
         tables.difficultyGrades,
-        sql`${tables.difficultyGrades.difficulty} = ROUND(${tables.climbStats.displayDifficulty}::numeric)`
+        sql`${tables.difficultyGrades.difficulty} = ROUND(${tables.climbStats.displayDifficulty}::numeric)
+        AND ${tables.difficultyGrades.boardType} = ${params.board_name}`
       )
       .where(
-        sql`${tables.climbs.layoutId} = ${params.layout_id}
+        sql`${tables.climbs.boardType} = ${params.board_name}
+        AND ${tables.climbs.layoutId} = ${params.layout_id}
         AND ${tables.climbs.uuid} = ${params.climb_uuid}
         AND ${tables.climbs.framesCount} = 1`
       )

packages/backend/src/db/queries/climbs/search-climbs.ts

@@ -1,4 +1,4 @@
-import { eq, desc, sql, and, getTableName } from 'drizzle-orm';
+import { eq, desc, sql, and } from 'drizzle-orm';
 import { db } from '../../client';
 import { getBoardTables, type BoardName } from '../util/table-select';
 import { createClimbFilters, type ClimbSearchParams, type ParsedBoardRouteParameters } from './create-climb-filters';
@@ -37,6 +37,11 @@ const HOLD_STATE_MAP: Record<
     7: { name: 'FINISH', displayColor: '#FF0000', color: '#FF0000' },
     8: { name: 'FOOT', displayColor: '#FF00FF', color: '#FF00FF' },
   },
+  moonboard: {
+    42: { name: 'STARTING', color: '#00FF00', displayColor: '#44FF44' },
+    43: { name: 'HAND', color: '#0000FF', displayColor: '#4444FF' },
+    44: { name: 'FINISH', color: '#FF0000', displayColor: '#FF3333' },
+  },
 };
 
 
@@ -92,7 +97,6 @@ export const searchClimbs = async (
   const filters = createClimbFilters(tables, params, searchParams, sizeEdges, userId);
 
   // Define sort columns with explicit SQL expressions where needed
-  const climbStatsTable = getTableName(boardClimbStats);
   const allowedSortColumns: Record<string, ReturnType<typeof sql>> = {
     ascents: sql`${tables.climbStats.ascensionistCount}`,
     difficulty: sql`ROUND(${tables.climbStats.displayDifficulty}::numeric, 0)`,
@@ -101,7 +105,7 @@ export const searchClimbs = async (
     // Popular: sum of ascents across ALL angles for this climb (using unified table)
     popular: sql`(
       SELECT COALESCE(SUM(cs.ascensionist_count), 0)
-      FROM ${sql.identifier(climbStatsTable)} cs
+      FROM ${boardClimbStats} cs
       WHERE cs.board_type = ${params.board_name} AND cs.climb_uuid = ${tables.climbs.uuid}
     )`,
   };
@@ -148,7 +152,10 @@ export const searchClimbs = async (
       .leftJoin(tables.climbStats, and(...filters.getClimbStatsJoinConditions()))
       .leftJoin(
         tables.difficultyGrades,
-        eq(tables.difficultyGrades.difficulty, sql`ROUND(${tables.climbStats.displayDifficulty}::numeric)`),
+        and(
+          eq(tables.difficultyGrades.difficulty, sql`ROUND(${tables.climbStats.displayDifficulty}::numeric)`),
+          eq(tables.difficultyGrades.boardType, params.board_name),
+        ),
       )
       .where(and(...whereConditions))
       .orderBy(

packages/backend/src/db/queries/util/product-sizes-data.ts

@@ -56,6 +56,10 @@ export const PRODUCT_SIZES: Record<BoardName, Record<number, ProductSizeData>> =
     8: { id: 8, name: '12 high x 8 wide', description: '', edgeLeft: -44, edgeRight: 44, edgeBottom: 0, edgeTop: 144, productId: 5 },
     9: { id: 9, name: '10 high x 8 wide', description: '', edgeLeft: -44, edgeRight: 44, edgeBottom: 0, edgeTop: 120, productId: 5 },
   },
+  // MoonBoard has a single fixed size: 11 columns (A-K) x 18 rows
+  moonboard: {
+    1: { id: 1, name: 'Standard', description: '11x18 Grid', edgeLeft: 0, edgeRight: 11, edgeBottom: 0, edgeTop: 18, productId: 1 },
+  },
 };
 
 /**

packages/backend/src/db/queries/util/table-select.ts

@@ -16,8 +16,10 @@ import {
   boardWalls,
   boardTags,
 } from '@boardsesh/db';
+import type { BoardName } from '@boardsesh/shared-schema';
+import { SUPPORTED_BOARDS } from '@boardsesh/shared-schema';
 
-export type BoardName = 'kilter' | 'tension';
+export type { BoardName };
 
 // Unified tables - all queries should filter by board_type
 export const UNIFIED_TABLES = {
@@ -58,21 +60,23 @@ export function getUnifiedTable<K extends keyof UnifiedTableSet>(
  * @returns True if the board name is valid
  */
 export function isValidBoardName(boardName: string): boardName is BoardName {
-  return boardName === 'kilter' || boardName === 'tension';
+  return SUPPORTED_BOARDS.includes(boardName as BoardName);
 }
 
 /**
  * Extended board name type that includes moonboard for unified tables
+ * @deprecated BoardName now includes moonboard, use BoardName instead
  */
-export type UnifiedBoardName = BoardName | 'moonboard';
+export type UnifiedBoardName = BoardName;
 
 /**
  * Check if a board name is valid for unified tables (includes moonboard)
  * @param boardName The name to check
  * @returns True if the board name is valid for unified tables
+ * @deprecated Use isValidBoardName instead - it now includes moonboard
  */
 export function isValidUnifiedBoardName(boardName: string): boardName is UnifiedBoardName {
-  return boardName === 'kilter' || boardName === 'tension' || boardName === 'moonboard';
+  return isValidBoardName(boardName);
 }
 
 // =============================================================================

packages/backend/src/graphql/resolvers/climbs/queries.ts

@@ -1,4 +1,5 @@
-import type { ClimbSearchInput, ConnectionContext } from '@boardsesh/shared-schema';
+import type { ClimbSearchInput, ConnectionContext, BoardName } from '@boardsesh/shared-schema';
+import { SUPPORTED_BOARDS } from '@boardsesh/shared-schema';
 import type { ClimbSearchParams, ParsedBoardRouteParameters } from '../../../db/queries/climbs/index';
 import { getClimbByUuid } from '../../../db/queries/climbs/index';
 import { getSizeEdges } from '../../../db/queries/util/product-sizes-data';
@@ -20,7 +21,7 @@ export const climbQueries = {
 
     // Validate board name
     if (!isValidBoardName(input.boardName)) {
-      throw new Error(`Invalid board name: ${input.boardName}. Must be 'kilter' or 'tension'`);
+      throw new Error(`Invalid board name: ${input.boardName}. Must be one of: ${SUPPORTED_BOARDS.join(', ')}`);
     }
 
     // Get size edges for filtering
@@ -34,7 +35,7 @@ export const climbQueries = {
 
     // Build route parameters
     const params: ParsedBoardRouteParameters = {
-      board_name: input.boardName as 'kilter' | 'tension',
+      board_name: input.boardName as BoardName,
       layout_id: input.layoutId,
       size_id: input.sizeId,
       set_ids: setIds,
@@ -89,7 +90,7 @@ export const climbQueries = {
     validateInput(BoardNameSchema, boardName, 'boardName');
 
     if (!isValidBoardName(boardName)) {
-      throw new Error(`Invalid board name: ${boardName}. Must be 'kilter' or 'tension'`);
+      throw new Error(`Invalid board name: ${boardName}. Must be one of: ${SUPPORTED_BOARDS.join(', ')}`);
     }
 
     // Validate all parameters
@@ -101,7 +102,7 @@ export const climbQueries = {
     if (DEBUG) console.log('[climb] Fetching:', { boardName, layoutId, sizeId, setIds, angle, climbUuid });
 
     const climb = await getClimbByUuid({
-      board_name: boardName as 'kilter' | 'tension',
+      board_name: boardName as BoardName,
       layout_id: layoutId,
       size_id: sizeId,
       angle,

packages/backend/src/graphql/resolvers/playlists/queries.ts

@@ -1,5 +1,6 @@
 import { eq, and, inArray, desc, sql, or, isNull, asc } from 'drizzle-orm';
-import type { ConnectionContext, Climb } from '@boardsesh/shared-schema';
+import type { ConnectionContext, Climb, BoardName } from '@boardsesh/shared-schema';
+import { SUPPORTED_BOARDS } from '@boardsesh/shared-schema';
 import { db } from '../../../db/client';
 import * as dbSchema from '@boardsesh/db/schema';
 import { requireAuthenticated, validateInput } from '../shared/helpers';
@@ -17,7 +18,7 @@ import type { LitUpHoldsMap, HoldState } from '@boardsesh/shared-schema';
 // Hold state mapping for converting frames string to lit up holds map
 type HoldColor = string;
 type HoldCode = number;
-type BoardName = 'kilter' | 'tension';
+// BoardName is imported from @boardsesh/shared-schema
 
 const HOLD_STATE_MAP: Record<
   BoardName,
@@ -43,6 +44,12 @@ const HOLD_STATE_MAP: Record<
     7: { name: 'FINISH', displayColor: '#FF0000', color: '#FF0000' },
     8: { name: 'FOOT', displayColor: '#FF00FF', color: '#FF00FF' },
   },
+  // MoonBoard uses a different hold format - holds are identified by grid position
+  moonboard: {
+    1: { name: 'STARTING', color: '#00FF00' },
+    2: { name: 'HAND', color: '#0000FF' },
+    3: { name: 'FINISH', color: '#FF0000' },
+  },
 };
 
 function convertLitUpHoldsStringToMap(litUpHolds: string, board: BoardName): Record<number, LitUpHoldsMap> {
@@ -290,7 +297,7 @@ export const playlistQueries = {
 
     // Validate board name
     if (!isValidBoardName(boardName)) {
-      throw new Error(`Invalid board name: ${boardName}. Must be 'kilter' or 'tension'`);
+      throw new Error(`Invalid board name: ${boardName}. Must be one of: ${SUPPORTED_BOARDS.join(', ')}`);
     }
 
     // Get size edges for filtering
@@ -361,19 +368,26 @@ export const playlistQueries = {
       .from(dbSchema.playlistClimbs)
       .innerJoin(
         tables.climbs,
-        eq(tables.climbs.uuid, dbSchema.playlistClimbs.climbUuid)
+        and(
+          eq(tables.climbs.uuid, dbSchema.playlistClimbs.climbUuid),
+          eq(tables.climbs.boardType, boardName)
+        )
       )
       .leftJoin(
         tables.climbStats,
         and(
           eq(tables.climbStats.climbUuid, dbSchema.playlistClimbs.climbUuid),
+          eq(tables.climbStats.boardType, boardName),
           // Use the route angle (from input) to fetch stats for the current board angle
           eq(tables.climbStats.angle, input.angle)
         )
       )
       .leftJoin(
         tables.difficultyGrades,
-        eq(tables.difficultyGrades.difficulty, sql`ROUND(${tables.climbStats.displayDifficulty}::numeric)`)
+        and(
+          eq(tables.difficultyGrades.difficulty, sql`ROUND(${tables.climbStats.displayDifficulty}::numeric)`),
+          eq(tables.difficultyGrades.boardType, boardName)
+        )
       )
       .where(eq(dbSchema.playlistClimbs.playlistId, playlistId))
       .orderBy(asc(dbSchema.playlistClimbs.position), asc(dbSchema.playlistClimbs.addedAt))

packages/backend/src/graphql/resolvers/ticks/queries.ts

@@ -1,5 +1,6 @@
 import { eq, and, desc, inArray, sql, count } from 'drizzle-orm';
-import type { ConnectionContext } from '@boardsesh/shared-schema';
+import type { ConnectionContext, BoardName } from '@boardsesh/shared-schema';
+import { SUPPORTED_BOARDS } from '@boardsesh/shared-schema';
 import { db } from '../../../db/client';
 import * as dbSchema from '@boardsesh/db/schema';
 import { requireAuthenticated, validateInput } from '../shared/helpers';
@@ -315,13 +316,13 @@ export const tickQueries = {
         boardType: tick.boardType,
         layoutId,
         angle: tick.angle,
-        isMirror: tick.isMirror,
+        isMirror: tick.isMirror ?? false,
         status: tick.status,
         attemptCount: tick.attemptCount,
         quality: tick.quality,
         difficulty: tick.difficulty,
         difficultyName,
-        isBenchmark: tick.isBenchmark,
+        isBenchmark: tick.isBenchmark ?? false,
         comment: tick.comment || '',
         climbedAt: tick.climbedAt,
         frames,
@@ -336,10 +337,10 @@ export const tickQueries = {
           boardType: tick.boardType,
           layoutId,
           angle: tick.angle,
-          isMirror: tick.isMirror,
+          isMirror: tick.isMirror ?? false,
           frames,
           difficultyName,
-          isBenchmark: tick.isBenchmark,
+          isBenchmark: tick.isBenchmark ?? false,
           date,
           items: [],
           flashCount: 0,
@@ -423,7 +424,7 @@ export const tickQueries = {
       return { totalDistinctClimbs: 0, layoutStats: [] };
     }
 
-    const boardTypes = ['kilter', 'tension'] as const;
+    const boardTypes = SUPPORTED_BOARDS;
     const layoutStatsMap: Record<string, {
       boardType: string;
       layoutId: number | null;
@@ -432,7 +433,7 @@ export const tickQueries = {
     const allClimbUuids = new Set<string>();
 
     // Helper function to fetch stats for a single board type
-    const fetchBoardStats = async (boardType: 'kilter' | 'tension') => {
+    const fetchBoardStats = async (boardType: BoardName) => {
       // Run both queries in parallel for this board type
       const [gradeResults, distinctClimbs] = await Promise.all([
         // Get distinct climb counts grouped by layoutId and difficulty using SQL aggregation