Text Search

import { Refine } from '@refine-ai/sdk';

const refine = new Refine({
  apiKey: process.env.REFINE_API_KEY,
  organizationId: 'org_abc123',
  catalogId: 'cat_xyz789'
});

const results = await refine.search.text({
  query: 'red running shoes',
  topK: 20
});

results.results.forEach(product => {
  console.log(`${product.title} - $${product.price}`);
});

const results = await refine.search.text({
  query: 'summer dress',
  topK: 24,
  visualWeight: 0.5,
  filters: [
    { field: 'price', operator: 'gte', value: 50 },
    { field: 'price', operator: 'lte', value: 200 },
    { field: 'metadata.color', operator: 'in', value: ['red', 'blue', 'green'] },
    { field: 'stock', operator: 'gt', value: 0 }
  ],
  sortBy: {
    field: 'price',
    order: 'ascending'
  }
});

interface SearchResponse {
  results: SearchResultItem[];
  filterOptions?: FilterOption[];
  serveId: string;
  totalResults: number;
}

interface SearchResultItem {
  productId: string;
  title: string;
  price: number;
  imageUrl: string;
  metadata: Record<string, any>;
  score: number;
}

const results = await refine.search.text({ query: 'shoes', topK: 20 });

const searchContext = refine.events.trackSearch(
  'shoes',
  results.results,
  { 
    surface: 'search_results',
    totalResults: results.totalResults 
  }
);

// When user clicks a product
searchContext.trackClick(productId, position);

// When a product becomes visible
searchContext.trackView(productId, position);

// When user adds to cart
searchContext.trackAddToCart(productId);

const PAGE_SIZE = 24;
let currentPage = 0;

async function loadPage(page: number) {
  const results = await refine.search.text({
    query: 'shoes',
    topK: PAGE_SIZE,
    // Note: offset is handled server-side with pagination tokens
  });
  
  currentPage = page;
  return results;
}

import { 
  RefineValidationError, 
  RefineAuthError,
  RefineRateLimitError 
} from '@refine-ai/sdk';

try {
  const results = await refine.search.text({ query: 'shoes', topK: 20 });
} catch (error) {
  if (error instanceof RefineValidationError) {
    console.error('Invalid search parameters:', error.message);
  } else if (error instanceof RefineAuthError) {
    console.error('Check your API key');
  } else if (error instanceof RefineRateLimitError) {
    console.error('Rate limited, retry after:', error.retryAfter);
  }
}

import { Refine, RefineValidationError } from '@refine-ai/sdk';

const refine = new Refine({
  apiKey: process.env.REFINE_API_KEY,
  organizationId: 'org_abc123',
  catalogId: 'cat_xyz789'
});

async function performSearch(query: string, filters: Filter[] = []) {
  try {
    const results = await refine.search.text({
      query,
      topK: 24,
      visualWeight: 0.5,
      filters,
      sortBy: { field: 'relevance', order: 'descending' }
    });

    // Track the search
    const searchContext = refine.events.trackSearch(query, results.results, {
      surface: 'search_results',
      totalResults: results.totalResults
    });

    return {
      products: results.results,
      total: results.totalResults,
      filterOptions: results.filterOptions,
      trackClick: (productId: string, position: number) => {
        searchContext.trackClick(productId, position);
      }
    };
  } catch (error) {
    if (error instanceof RefineValidationError) {
      return { products: [], total: 0, error: 'Invalid search' };
    }
    throw error;
  }
}