Deploy backend update Tue Jan 20 17:02:56 CET 2026

src/controllers/trackController.ts

@@ -6,6 +6,35 @@ import { TrackFeature, TrackFeatureCollection } from '../types/types';
  * TrackController - Handles HTTP requests for public ski tracks
  */
 export class TrackController {
+    private static parseOptionalString(value: unknown): string | undefined {
+        if (typeof value !== 'string') return undefined;
+        const trimmed = value.trim();
+        if (!trimmed || trimmed === 'undefined' || trimmed === 'null') return undefined;
+        return trimmed;
+    }
+
+    private static normalizeStringList(values: unknown[]): string[] | undefined {
+        const normalized = values
+            .filter((v): v is string => typeof v === 'string')
+            .map(v => v.trim().toLowerCase())
+            .filter(v => v.length > 0 && v !== 'undefined' && v !== 'null');
+
+        if (normalized.length === 0) return undefined;
+        return Array.from(new Set(normalized));
+    }
+
+    private static parseActivitiesParam(value: unknown): string[] | undefined {
+        if (Array.isArray(value)) {
+            return TrackController.normalizeStringList(value);
+        }
+
+        if (typeof value === 'string') {
+            return TrackController.normalizeStringList(value.split(','));
+        }
+
+        return undefined;
+    }
+
     /**
      * GET /api/tracks
      * Fetch all public tracks with optional location filtering and pagination
@@ -19,16 +48,19 @@ export class TrackController {
             // Prepare filters for DB query
             const filters: { activities?: string[], searchQuery?: string, difficulty?: string } = {};
             
-            if (activities) {
-                filters.activities = (activities as string).split(',').map(a => a.trim().toLowerCase());
+            const parsedActivities = TrackController.parseActivitiesParam(activities);
+            if (parsedActivities) {
+                filters.activities = parsedActivities;
             }
-            
-            if (q) {
-                filters.searchQuery = q as string;
+
+            const parsedQuery = TrackController.parseOptionalString(q);
+            if (parsedQuery) {
+                filters.searchQuery = parsedQuery;
             }
 
-            if (difficulty) {
-                filters.difficulty = difficulty as string;
+            const parsedDifficulty = TrackController.parseOptionalString(difficulty);
+            if (parsedDifficulty) {
+                filters.difficulty = parsedDifficulty;
             }
 
             // Pagination (must be applied at DB level to avoid huge Supabase egress)

src/models/TrackModel.ts

@@ -6,6 +6,87 @@ import { Track } from '../types/types';
  * These are read-only tracks imported from OpenSkiData
  */
 export class TrackModel {
+    private static buildWhere(conditions: any[]): any {
+        if (!conditions.length) return sql``;
+
+        let where = sql`WHERE ${conditions[0]}`;
+        for (let i = 1; i < conditions.length; i++) {
+            where = sql`${where} AND ${conditions[i]}`;
+        }
+        return where;
+    }
+
+    private static buildFilterConditions(filters: {
+        activities?: string[];
+        searchQuery?: string;
+        difficulty?: string;
+    }): any[] {
+        const { activities, searchQuery, difficulty } = filters;
+
+        const conditions: any[] = [];
+
+        if (activities && activities.length > 0) {
+            // uses is TEXT[], so we can use the overlap operator &&
+            // IMPORTANT: Use sql.array so postgres.js treats this as a single text[] parameter.
+            conditions.push(sql`uses && ${sql.array(activities, 25)}`);
+        }
+
+        if (searchQuery) {
+            const pattern = `%${searchQuery}%`;
+            conditions.push(sql`(name ILIKE ${pattern} OR description ILIKE ${pattern})`);
+        }
+
+        if (difficulty) {
+            conditions.push(sql`difficulty = ${difficulty}`);
+        }
+
+        return conditions;
+    }
+
+    private static buildLocationConditions(location?: {
+        lat: number;
+        lng: number;
+        radiusKm: number;
+    }): any[] {
+        if (!location) return [];
+        if (!Number.isFinite(location.lat) || !Number.isFinite(location.lng) || !Number.isFinite(location.radiusKm)) return [];
+
+        const conditions: any[] = [];
+        const radiusKm = Math.max(0, location.radiusKm);
+        const lat = location.lat;
+        const lng = location.lng;
+
+        // Cheap pre-filter: bounding box (helps avoid doing trig on every row)
+        const deltaLat = radiusKm / 111.0;
+        const cosLat = Math.cos((lat * Math.PI) / 180);
+        const deltaLng = cosLat === 0 ? 180 : radiusKm / (111.0 * Math.max(0.000001, cosLat));
+
+        const minLat = lat - deltaLat;
+        const maxLat = lat + deltaLat;
+        const minLng = lng - deltaLng;
+        const maxLng = lng + deltaLng;
+
+        // JSONB GeoJSON: first coordinate is [lng, lat]
+        conditions.push(sql`((path->'coordinates'->0->>1)::float8 BETWEEN ${minLat} AND ${maxLat})`);
+        conditions.push(sql`((path->'coordinates'->0->>0)::float8 BETWEEN ${minLng} AND ${maxLng})`);
+
+        // Exact circle filter using the first coordinate
+        conditions.push(sql`
+            (
+                6371 * 2 * asin(
+                    sqrt(
+                        power(sin(radians((${lat} - ((path->'coordinates'->0->>1)::float8))) / 2)), 2)
+                        + cos(radians(${lat}))
+                          * cos(radians(((path->'coordinates'->0->>1)::float8)))
+                          * power(sin(radians((${lng} - ((path->'coordinates'->0->>0)::float8))) / 2)), 2)
+                    )
+                )
+            ) <= ${radiusKm}
+        `);
+
+        return conditions;
+    }
+
     /**
      * Find all tracks in the database
      */
@@ -49,27 +130,8 @@ export class TrackModel {
             searchQuery?: string;
         }
     ): Promise<Track[]> {
-        const { activities, searchQuery } = filters;
-        
-        const conditions = [];
-        
-        if (activities && activities.length > 0) {
-             // uses is TEXT[], so we can use the overlap operator &&
-             conditions.push(sql`uses && ${activities}`);
-        }
-        
-        if (searchQuery) {
-            const pattern = `%${searchQuery}%`;
-            conditions.push(sql`(name ILIKE ${pattern} OR description ILIKE ${pattern})`);
-        }
-        
-        let where = sql``;
-        if (conditions.length > 0) {
-            where = sql`WHERE ${conditions[0]}`;
-            for (let i = 1; i < conditions.length; i++) {
-                where = sql`${where} AND ${conditions[i]}`;
-            }
-        }
+        const conditions = TrackModel.buildFilterConditions(filters);
+        const where = TrackModel.buildWhere(conditions);
 
         const tracks = await sql<Track[]>`
             SELECT 
@@ -123,66 +185,13 @@ export class TrackModel {
             radiusKm: number;
         }
     ): Promise<{ tracks: Track[]; total: number }> {
-        const { activities, searchQuery, difficulty } = filters;
         const { limit, offset } = pagination;
+        const conditions = [
+            ...TrackModel.buildFilterConditions(filters),
+            ...TrackModel.buildLocationConditions(location),
+        ];
 
-        const conditions = [];
-
-        if (activities && activities.length > 0) {
-            // uses is TEXT[], so we can use the overlap operator &&
-            conditions.push(sql`uses && ${activities}`);
-        }
-
-        if (searchQuery) {
-            const pattern = `%${searchQuery}%`;
-            conditions.push(sql`(name ILIKE ${pattern} OR description ILIKE ${pattern})`);
-        }
-
-        if (difficulty) {
-            conditions.push(sql`difficulty = ${difficulty}`);
-        }
-
-        if (location && Number.isFinite(location.lat) && Number.isFinite(location.lng) && Number.isFinite(location.radiusKm)) {
-            const radiusKm = Math.max(0, location.radiusKm);
-            const lat = location.lat;
-            const lng = location.lng;
-
-            // Cheap pre-filter: bounding box (helps avoid doing trig on every row)
-            const deltaLat = radiusKm / 111.0;
-            const cosLat = Math.cos((lat * Math.PI) / 180);
-            const deltaLng = cosLat === 0 ? 180 : radiusKm / (111.0 * Math.max(0.000001, cosLat));
-
-            const minLat = lat - deltaLat;
-            const maxLat = lat + deltaLat;
-            const minLng = lng - deltaLng;
-            const maxLng = lng + deltaLng;
-
-            // JSONB GeoJSON: first coordinate is [lng, lat]
-            conditions.push(sql`((path->'coordinates'->0->>1)::float8 BETWEEN ${minLat} AND ${maxLat})`);
-            conditions.push(sql`((path->'coordinates'->0->>0)::float8 BETWEEN ${minLng} AND ${maxLng})`);
-
-            // Exact circle filter using the first coordinate (same logic as the controller previously used)
-            conditions.push(sql`
-                (
-                    6371 * 2 * asin(
-                        sqrt(
-                            power(sin(radians((${lat} - ((path->'coordinates'->0->>1)::float8))) / 2)), 2)
-                            + cos(radians(${lat}))
-                              * cos(radians(((path->'coordinates'->0->>1)::float8)))
-                              * power(sin(radians((${lng} - ((path->'coordinates'->0->>0)::float8))) / 2)), 2)
-                        )
-                    )
-                ) <= ${radiusKm}
-            `);
-        }
-
-        let where = sql``;
-        if (conditions.length > 0) {
-            where = sql`WHERE ${conditions[0]}`;
-            for (let i = 1; i < conditions.length; i++) {
-                where = sql`${where} AND ${conditions[i]}`;
-            }
-        }
+        const where = TrackModel.buildWhere(conditions);
 
         type TrackRow = Track & { total_count: number };