Fix up comparisons

Author: zackproser

src/actions/tool-actions.ts

@@ -68,21 +68,54 @@ export async function getAllTools(): Promise<Tool[]> {
 export async function getToolBySlug(slug: string): Promise<Tool | null> {
   console.log(`Fetching tool by slug: ${slug} (using Prisma)`)
   try {
-    // Convert slug back to a readable name for searching
-    const searchName = slug
+    // Generate search patterns inline to avoid dynamic import issues
+    const patterns = []
+    
+    // Original slug
+    patterns.push(slug)
+    
+    // Title case version
+    const titleCase = slug
       .split('-')
       .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-      .join(' ');
+      .join(' ')
+    patterns.push(titleCase)
+    
+    // All lowercase version
+    patterns.push(slug.replace(/-/g, ' '))
+    
+    // All uppercase version
+    patterns.push(titleCase.toUpperCase())
+    
+    // Handle common variations
+    const variations = [
+      slug.replace(/-/g, ''), // Remove all hyphens
+      slug.replace(/-/g, '_'), // Replace hyphens with underscores
+      slug.replace(/-ai$/, ' AI'), // Handle AI suffix
+      slug.replace(/-io$/, '.io'), // Handle .io domains
+    ]
 
+    patterns.push(...variations)
+    const searchPatterns = [...new Set(patterns)] // Remove duplicates
+    
+    console.log(`Search patterns for slug "${slug}":`, searchPatterns)
+    
+    // Try exact matches first, then fuzzy matches
     const tool = await prisma.tool.findFirst({
       where: { 
-        OR: [
-          { name: { equals: searchName, mode: 'insensitive' } },
-          { name: { contains: slug, mode: 'insensitive' } },
-          { name: { contains: searchName, mode: 'insensitive' } }
-        ]
+        OR: searchPatterns.flatMap(pattern => [
+          { name: { equals: pattern, mode: 'insensitive' } },
+          { name: { contains: pattern, mode: 'insensitive' } }
+        ])
       }
     });
+    
+    if (tool) {
+      console.log(`Found tool: ${tool.name} for slug: ${slug}`)
+    } else {
+      console.log(`No tool found for slug: ${slug}`)
+    }
+    
     return tool;
   } catch (error) {
     console.error("Error fetching tool by slug:", error)

src/components/dynamic-comparison-search.tsx

@@ -17,6 +17,7 @@ import {
   Code,
   DollarSign
 } from 'lucide-react'
+import { nameToSlug } from '@/utils/slug-helpers'
 
 interface DynamicComparisonSearchProps {
   tools: Tool[]
@@ -98,15 +99,15 @@ export function DynamicComparisonSearch({ tools }: DynamicComparisonSearchProps)
 
   const handleCompare = () => {
     if (selectedTool1 && selectedTool2) {
-      const tool1Slug = selectedTool1.name.toLowerCase().replace(/\s+/g, '-').replace(/[^\w-]+/g, '')
-      const tool2Slug = selectedTool2.name.toLowerCase().replace(/\s+/g, '-').replace(/[^\w-]+/g, '')
+      const tool1Slug = nameToSlug(selectedTool1.name)
+      const tool2Slug = nameToSlug(selectedTool2.name)
       router.push(`/comparisons/${tool1Slug}/vs/${tool2Slug}`)
     }
   }
 
   const handlePopularComparison = (tool1: Tool, tool2: Tool) => {
-    const tool1Slug = tool1.name.toLowerCase().replace(/\s+/g, '-').replace(/[^\w-]+/g, '')
-    const tool2Slug = tool2.name.toLowerCase().replace(/\s+/g, '-').replace(/[^\w-]+/g, '')
+    const tool1Slug = nameToSlug(tool1.name)
+    const tool2Slug = nameToSlug(tool2.name)
     router.push(`/comparisons/${tool1Slug}/vs/${tool2Slug}`)
   }
 

src/utils/slug-helpers.ts

@@ -0,0 +1,58 @@
+/**
+ * Utility functions for converting between tool names and URL-friendly slugs
+ */
+
+/**
+ * Convert a tool name to a URL-friendly slug
+ */
+export function nameToSlug(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^\w\s-]/g, '') // Remove special characters except spaces and hyphens
+    .replace(/\s+/g, '-') // Replace spaces with hyphens
+    .replace(/-+/g, '-') // Replace multiple hyphens with single hyphen
+    .trim()
+}
+
+/**
+ * Convert a URL slug back to a searchable name pattern
+ * This handles common variations and patterns
+ */
+export function slugToNamePattern(slug: string): string {
+  return slug
+    .split('-')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ')
+}
+
+/**
+ * Generate multiple search patterns from a slug to improve matching
+ */
+export function generateSearchPatterns(slug: string): string[] {
+  const patterns = []
+  
+  // Original slug
+  patterns.push(slug)
+  
+  // Title case version
+  const titleCase = slugToNamePattern(slug)
+  patterns.push(titleCase)
+  
+  // All lowercase version
+  patterns.push(slug.replace(/-/g, ' '))
+  
+  // All uppercase version
+  patterns.push(titleCase.toUpperCase())
+  
+  // Handle common variations
+  const variations = [
+    slug.replace(/-/g, ''), // Remove all hyphens
+    slug.replace(/-/g, '_'), // Replace hyphens with underscores
+    slug.replace(/-ai$/, ' AI'), // Handle AI suffix
+    slug.replace(/-io$/, '.io'), // Handle .io domains
+  ]
+  
+  patterns.push(...variations)
+  
+  return [...new Set(patterns)] // Remove duplicates
+}