Search & live queries

import { useQuery, useMutation } from '@topgunbuild/react';

interface Todo {
  text: string;
  completed: boolean;
  createdAt: number;
}

export function ActiveTodos() {
  // Subscribe to incomplete todos, sorted newest first
  const { data: todos, loading, error } = useQuery<Todo>('todos', {
    where: { completed: false },
    sort: { createdAt: 'desc' },
    limit: 50,
  });

  const { update } = useMutation<Todo>('todos');

  if (loading) return <p>Loading...</p>;
  if (error) return <p>Error: {error.message}</p>;

  return (
    <ul>
      {todos.map(todo => (
        <li key={todo._key}>
          <input
            type="checkbox"
            checked={todo.completed}
            onChange={() => update(todo._key, { completed: true })}
          />
          {todo.text}
        </li>
      ))}
    </ul>
  );
}

import { TopGunClient } from '@topgunbuild/client';
import { IDBAdapter } from '@topgunbuild/adapters';

const client = new TopGunClient({
  serverUrl: 'ws://localhost:8080',
  storage: new IDBAdapter(),
});

await client.start();

const handle = client.query('orders', {
  where: { status: 'pending' },
  sort: { createdAt: 'desc' },
  limit: 20,
});

const unsubscribe = handle.subscribe((results) => {
  console.log('Pending orders:', results.length);
  // results is QueryResultItem<T>[] — each item carries _key
});

// Stop receiving updates when done
unsubscribe();

import { Predicates } from '@topgunbuild/client';
import { useQuery } from '@topgunbuild/react';

interface Product {
  name: string;
  price: number;
  category: string;
  inStock: boolean;
}

export function AffordableElectronics() {
  const { data: products } = useQuery<Product>('products', {
    predicate: Predicates.and(
      Predicates.greaterThan('price', 10),
      Predicates.lessThanOrEqual('price', 200),
      Predicates.equal('category', 'electronics'),
      Predicates.equal('inStock', true),
    ),
    sort: { price: 'asc' },
  });

  return (
    <ul>
      {products.map(p => (
        <li key={p._key}>{p.name} — ${p.price}</li>
      ))}
    </ul>
  );
}

import {
  IndexedLWWMap,
  simpleAttribute,
  HLC,
} from '@topgunbuild/core';

interface Article {
  title: string;
  body: string;
  author: string;
}

const hlc = new HLC('node-1');
const articles = new IndexedLWWMap<string, Article>(hlc);

// Add an inverted index on the 'title' field
const titleAttr = simpleAttribute<Article, string>('title', a => a.title);
articles.addInvertedIndex(titleAttr);

// Index a document
articles.set('a1', {
  title: 'Introduction to Machine Learning',
  body: 'Machine learning is a subset of artificial intelligence.',
  author: 'Alice',
});

articles.set('a2', {
  title: 'Deep Learning Tutorial',
  body: 'Deep learning uses many-layer neural networks.',
  author: 'Bob',
});

// Token search — O(K) lookup
const results = articles.queryValues({
  type: 'contains',
  attribute: 'title',
  value: 'learning',
});
// Returns both articles ('learning' appears in both titles)

// AND semantics: all tokens must match
const narrowed = articles.queryValues({
  type: 'contains',
  attribute: 'title',
  value: 'machine learning',  // "machine" AND "learning"
});
// Returns only a1

import {
  IndexedLWWMap,
  simpleAttribute,
  HLC,
} from '@topgunbuild/core';
import { Predicates } from '@topgunbuild/client';
import { useQuery } from '@topgunbuild/react';

interface Product {
  name: string;
  category: string;
  price: number;
  inStock: boolean;
}

// Use IndexedLWWMap for text search + getMap for reactive queries
// Approach: predicate query first (from useQuery), then apply text filter client-side
// OR: use IndexedLWWMap directly for in-memory search without server round-trip

const hlc = new HLC('node-search');
const productIndex = new IndexedLWWMap<string, Product>(hlc);

const nameAttr = simpleAttribute<Product, string>('name', p => p.name);
productIndex.addInvertedIndex(nameAttr);

function searchProducts(query: string, maxPrice: number) {
  // Step 1: text search — returns products whose name contains the query tokens
  const textMatches = productIndex.queryValues({
    type: 'contains',
    attribute: 'name',
    value: query,
  });

  // Step 2: filter by price client-side (or use a predicate query on the server map)
  return textMatches.filter(p => p.price <= maxPrice && p.inStock);
}

// In React: use useQuery for the reactive layer + run text search on the result set
export function ProductSearch() {
  const [searchTerm, setSearchTerm] = React.useState('');

  const { data: products } = useQuery<Product>('products', {
    predicate: Predicates.and(
      Predicates.equal('inStock', true),
      Predicates.lessThanOrEqual('price', 500),
    ),
  });

  const filtered = React.useMemo(() => {
    if (!searchTerm) return products;
    const lower = searchTerm.toLowerCase();
    return products.filter(p => p.name.toLowerCase().includes(lower));
  }, [products, searchTerm]);

  return (
    <div>
      <input value={searchTerm} onChange={e => setSearchTerm(e.target.value)} placeholder="Search..." />
      <ul>{filtered.map(p => <li key={p._key}>{p.name} — ${p.price}</li>)}</ul>
    </div>
  );
}