+
+
+---
+### Try searching for:
+* *Will Smith movies with aliens and guns*
+* *a cool sci-fi movie similar to Interstellar*
+* *mind-bending thrillers directed by Christopher Nolan*
+* *heartwarming animations about family*
+"""
+ await cl.Message(content=content).send()
+
+@cl.on_message
+async def main(message: cl.Message):
+ user_query = message.content.strip()
+ if not user_query:
+ return
+
+ # ------------------------------------------------------------------
+ # Step 1 — Parse query into hard filters + semantic theme
+ # ------------------------------------------------------------------
+ async with cl.Step(name="Parsing query") as step:
+ step.input = user_query
+ parsed = parse_query(user_query)
+
+ semantic_query = parsed.get("semantic_query")
+ if not semantic_query or str(semantic_query).lower().strip() in ("null", "none"):
+ semantic_query = user_query
+ filters = parsed.get("filters", {})
+ filter_by = build_filter_string(filters, user_query)
+
+ active_filters = {k: v for k, v in filters.items() if v}
+ filter_summary = f"Filters: {active_filters}" if active_filters else "No hard filters detected."
+ step.output = f"Semantic query: '{semantic_query}'\n{filter_summary}"
+
+ # ------------------------------------------------------------------
+ # Step 2 — Embed semantic query + run Typesense hybrid search
+ # ------------------------------------------------------------------
+ async with cl.Step(name="Searching movie database") as step:
+ # Embed only the semantic/thematic part of the query
+ query_vector = model.encode(semantic_query).tolist()
+
+ # Build Typesense search request
+ # k:20 retrieves more candidates; flat_search_cutoff:20 forces exact ranking
+ # when the filtered set is small (e.g. only 20 Will Smith movies exist)
+ search_params = {
+ 'collection': 'movies',
+ 'q': '*',
+ 'vector_query': f'embedding:([{",".join(map(str, query_vector))}], k:20, flat_search_cutoff: 20)'
+ }
+
+ # Attach hard filters if present — this narrows candidates BEFORE vector ranking
+ if filter_by:
+ search_params['filter_by'] = filter_by
+
+ try:
+ search_requests = {'searches': [search_params]}
+ response = client.multi_search.perform(search_requests, {})
+ search_results = response['results'][0]
+ hits = search_results.get("hits", [])[:5] # Top 5 from the broader k:20 pool
+ step.input = f"Semantic: '{semantic_query}' | filter_by: {filter_by or 'None'}"
+ step.output = f"Found {len(hits)} matching documents in Typesense."
+ except Exception as e:
+ step.output = f"Error during vector search: {e}"
+ await cl.Message(content=f"❌ Error performing search: {e}").send()
+ return
+
+ if not hits:
+ # Provide a helpful message if filters were too restrictive
+ no_result_msg = f"Sorry, I couldn't find any movies matching: *\"{user_query}\"*"
+ if filter_by:
+ no_result_msg += f"\n\n> ℹ️ Search was filtered by: `{filter_by}`. Try rephrasing if this seems too strict."
+ await cl.Message(content=no_result_msg).send()
+ return
+
+ # ------------------------------------------------------------------
+ # Step 3 — Enrich results with MOTN watch providers + posters
+ # ------------------------------------------------------------------
+ async with cl.Step(name="Retrieving streaming availability") as step:
+
+ movies = []
+
+ # Run MOTN info fetches in parallel
+ with ThreadPoolExecutor(max_workers=len(hits)) as executor:
+ # Map future to corresponding hit document
+ future_to_hit = {}
+ for hit in hits:
+ doc = hit.get("document", {})
+ movie_id = doc.get("id")
+ future = executor.submit(fetch_motn_info.invoke, {"movie_id": movie_id})
+ future_to_hit[future] = hit
+
+ # Retrieve results in order of submissions
+ for future in future_to_hit:
+ hit = future_to_hit[future]
+ doc = hit.get("document", {})
+ try:
+ motn_info = future.result()
+ except Exception as e:
+ print(f"[WARNING] Failed to fetch parallel MOTN info: {e}")
+ motn_info = {
+ "poster_url": None,
+ "watch_providers": {"streaming": [], "rent": [], "buy": []}
+ }
+
+ movie_item = {
+ "title": doc.get("title"),
+ "overview": doc.get("overview"),
+ "genres": doc.get("genres", []),
+ "release_year": doc.get("release_year"),
+ "cast": doc.get("cast", []),
+ "director": doc.get("director"),
+ "poster_url": motn_info["poster_url"],
+ "watch_providers": motn_info["watch_providers"],
+ "score": hit.get("vector_distance")
+ }
+ movies.append(movie_item)
+
+ step.output = f"Fetched watch providers and poster details for {len(movies)} movies in parallel."
+
+ # ------------------------------------------------------------------
+ # Step 4 — Format and send final response
+ # ------------------------------------------------------------------
+ response_content = "### Here are movies that I recommend:\n\n"
+
+ for movie in movies:
+ providers = movie.get("watch_providers", {})
+ streaming = providers.get("streaming", [])
+ rent = providers.get("rent", [])
+
+ stream_str = ", ".join(streaming) if streaming else "Not available on subscription streaming"
+ rent_str = ", ".join(rent[:4]) if rent else "Not listed"
+
+ response_content += f"#### 🎥 {movie['title']} ({movie.get('release_year', 'N/A')})\n"
+
+ if movie.get("poster_url"):
+ response_content += f"\n\n"
+
+ response_content += f"**Director:** {movie.get('director', 'Unknown')} | **Genres:** {', '.join(movie.get('genres', []))}\n"
+ response_content += f"**Cast:** {', '.join(movie.get('cast', []))}\n"
+ response_content += f"**Relevance Score:** {(1 - movie['score']):.3f}\n"
+ response_content += f"**Synopsis:** {movie['overview']}\n\n"
+ response_content += f"📺 **Stream (US):** {stream_str}\n"
+ response_content += f"💳 **Rent/Buy:** {rent_str}\n\n"
+ response_content += "---\n\n"
+
+ await cl.Message(content=response_content).send()
diff --git a/typesense-langchain-ai-search/app/services/__init__.py b/typesense-langchain-ai-search/app/services/__init__.py
new file mode 100644
index 0000000..835aae3
--- /dev/null
+++ b/typesense-langchain-ai-search/app/services/__init__.py
@@ -0,0 +1 @@
+# Marks app/services directory as package
diff --git a/typesense-langchain-ai-search/app/services/motn.py b/typesense-langchain-ai-search/app/services/motn.py
new file mode 100644
index 0000000..56bb838
--- /dev/null
+++ b/typesense-langchain-ai-search/app/services/motn.py
@@ -0,0 +1,106 @@
+import time
+import requests
+from app.core.env import get_env
+from urllib3.util import Retry
+from requests.adapters import HTTPAdapter
+
+from langchain_core.tools import tool
+
+def _make_motn_session() -> requests.Session:
+ """Creates a fresh Movie of the Night session with retry strategy"""
+ session = requests.Session()
+ session.headers.update({
+ "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+ "accept": "application/json"
+ })
+ retry_strategy = Retry(
+ total=3,
+ backoff_factor=1.0,
+ status_forcelist=[429, 500, 502, 503, 504],
+ allowed_methods=["GET"],
+ raise_on_status=False
+ )
+ adapter = HTTPAdapter(max_retries=retry_strategy)
+ session.mount("https://", adapter)
+ session.mount("http://", adapter)
+ return session
+
+def _motn_get(url: str, headers: dict, max_retries: int = 3) -> requests.Response | None:
+ """
+ GET with manual retry for ConnectionResetError.
+ Creates a fresh session per retry instead of reusing a potentially
+ stale pooled connection.
+ """
+ for attempt in range(max_retries):
+ session = _make_motn_session()
+ try:
+ resp = session.get(url, headers=headers, timeout=8)
+ return resp
+ except (ConnectionError, requests.exceptions.ConnectionError) as e:
+ if attempt < max_retries - 1:
+ wait = 1.0 * (attempt + 1)
+ print(f"[MOTN] Connection reset on attempt {attempt + 1}, retrying in {wait}s...")
+ time.sleep(wait)
+ else:
+ print(f"[MOTN] All {max_retries} attempts failed for {url}: {e}")
+ return None
+ finally:
+ session.close()
+ return None
+
+@tool
+def fetch_motn_info(movie_id: str) -> dict:
+ """Fetches watch providers (streaming/rent/buy) and poster paths from the Movie of the Night API using the movie's TMDB ID."""
+ motn_key = get_env("MOTN_API_KEY")
+ info = {
+ "poster_url": None,
+ "watch_providers": {
+ "streaming": [],
+ "rent": [],
+ "buy": []
+ }
+ }
+
+ print(f"[MOTN] Fetching info for movie_id={movie_id}")
+
+ if not motn_key or motn_key == "1234":
+ return info
+
+ headers = {
+ "X-API-Key": motn_key
+ }
+
+ try:
+ url = f"https://api.movieofthenight.com/v4/shows/movie/{movie_id}"
+ resp = _motn_get(url, headers)
+ if resp and resp.status_code == 200:
+ data = resp.json()
+
+ # Fetch poster
+ image_set = data.get("imageSet", {})
+ vertical_poster = image_set.get("verticalPoster", {})
+ info["poster_url"] = vertical_poster.get("w480") or vertical_poster.get("w360") or vertical_poster.get("original")
+
+ # Fetch watch providers for US
+ streaming_options = data.get("streamingOptions", {})
+ us_providers = streaming_options.get("us", [])
+
+ for provider in us_providers:
+ service_name = provider.get("service", {}).get("name", "")
+ stream_type = provider.get("type", "")
+
+ if stream_type == "subscription":
+ info["watch_providers"]["streaming"].append(service_name)
+ elif stream_type == "rent":
+ info["watch_providers"]["rent"].append(service_name)
+ elif stream_type == "buy":
+ info["watch_providers"]["buy"].append(service_name)
+
+ # Deduplicate provider lists
+ for k in info["watch_providers"]:
+ info["watch_providers"][k] = list(set(info["watch_providers"][k]))
+
+ except Exception as e:
+ print(f"[WARNING] Failed to fetch MOTN info for movie {movie_id}: {e}")
+
+ return info
diff --git a/typesense-langchain-ai-search/requirements.txt b/typesense-langchain-ai-search/requirements.txt
new file mode 100644
index 0000000..8c0a565
--- /dev/null
+++ b/typesense-langchain-ai-search/requirements.txt
@@ -0,0 +1,10 @@
+pandas
+typesense
+sentence-transformers
+langchain
+langchain-openai
+fastapi
+uvicorn
+requests
+python-dotenv
+chainlit
\ No newline at end of file
diff --git a/typesense-langchain-ai-search/seed.py b/typesense-langchain-ai-search/seed.py
new file mode 100644
index 0000000..4958c55
--- /dev/null
+++ b/typesense-langchain-ai-search/seed.py
@@ -0,0 +1,175 @@
+import os
+import json
+import pandas as pd
+import torch
+import typesense
+from dotenv import load_dotenv
+from app.core.typesense import client
+from app.core.models import model, EMBEDDING_DIM
+
+def parse_genres(x):
+ try:
+ if pd.isna(x) or not x:
+ return []
+ data = json.loads(x)
+ return [item['name'] for item in data]
+ except Exception:
+ return []
+
+def parse_cast(x):
+ try:
+ if pd.isna(x) or not x:
+ return []
+ data = json.loads(x)
+ # Limit to top 3 cast members to save memory
+ return [item['name'] for item in data[:3]]
+ except Exception:
+ return []
+
+def parse_director(x):
+ try:
+ if pd.isna(x) or not x:
+ return ""
+ data = json.loads(x)
+ for item in data:
+ if item.get('job') == 'Director':
+ return item.get('name', '')
+ return ""
+ except Exception:
+ return ""
+
+def parse_year(x):
+ try:
+ if pd.isna(x) or not x:
+ return None
+ parts = str(x).split('-')
+ if len(parts) > 0 and parts[0].isdigit():
+ return int(parts[0])
+ return None
+ except Exception:
+ return None
+
+def main():
+ # 1. Load the Datasets
+ print("Loading TMDB CSV files...")
+ movies_path = "data/tmdb_5000_movies.csv"
+ credits_path = "data/tmdb_5000_credits.csv"
+
+ if not os.path.exists(movies_path) or not os.path.exists(credits_path):
+ print("Error: CSV files not found in data/ folder!")
+ return
+
+ movies_df = pd.read_csv(movies_path)
+ credits_df = pd.read_csv(credits_path)
+
+ # Keep only the essential columns before merging to minimize RAM usage
+ movies_df = movies_df[['id', 'title', 'overview', 'genres', 'release_date']]
+ credits_df = credits_df[['movie_id', 'cast', 'crew']]
+
+ # Merge on movie ID
+ print("Merging datasets...")
+ df = pd.merge(movies_df, credits_df, left_on='id', right_on='movie_id')
+
+ # Process and clean fields
+ print("Processing and cleaning movie metadata...")
+ df['genres'] = df['genres'].apply(parse_genres)
+ df['cast'] = df['cast'].apply(parse_cast)
+ df['director'] = df['crew'].apply(parse_director)
+ df['release_year'] = df['release_date'].apply(parse_year)
+
+ # Fill missing values
+ df['overview'] = df['overview'].fillna("")
+ df['title'] = df['title'].fillna("")
+
+ # Drop columns no longer needed
+ df = df.drop(columns=['release_date', 'movie_id', 'crew'])
+
+ # 2. Create or Recreate Typesense Collection
+ print("Setting up Typesense collection schema...")
+ schema = {
+ 'name': 'movies',
+ 'fields': [
+ {'name': 'id', 'type': 'string'},
+ {'name': 'title', 'type': 'string'},
+ {'name': 'overview', 'type': 'string', 'optional': True},
+ {'name': 'genres', 'type': 'string[]', 'facet': True, 'optional': True},
+ {'name': 'release_year', 'type': 'int32', 'facet': True, 'sort': True, 'optional': True},
+ {'name': 'cast', 'type': 'string[]', 'facet': True, 'optional': True},
+ {'name': 'director', 'type': 'string', 'facet': True, 'optional': True},
+ {'name': 'embedding', 'type': 'float[]', 'num_dim': EMBEDDING_DIM}
+ ]
+ }
+
+ try:
+ client.collections['movies'].delete()
+ print("Deleted existing 'movies' collection.")
+ except Exception:
+ pass
+
+ client.collections.create(schema)
+ print("Created 'movies' collection.")
+
+ # 4. Generate Embeddings and Seed Data
+ print("Generating embeddings and seeding collection...")
+ documents = []
+ total_movies = len(df)
+
+ for i, row in df.iterrows():
+ # Build text string to represent the movie semantically
+ genres_str = ", ".join(row['genres']) if row['genres'] else ""
+ cast_str = ", ".join(row['cast']) if row['cast'] else ""
+
+ texts = []
+ texts.append(f"Title: {row['title']}")
+ if row['overview']:
+ texts.append(f"Overview: {row['overview']}")
+ if genres_str:
+ texts.append(f"Genres: {genres_str}")
+ if cast_str:
+ texts.append(f"Cast: {cast_str}")
+ if row['director']:
+ texts.append(f"Director: {row['director']}")
+
+ doc_text = ". ".join(texts) + "."
+
+ # Prepare Typesense document
+ doc = {
+ 'id': str(row['id']),
+ 'title': str(row['title']),
+ 'overview': str(row['overview']),
+ 'genres': list(row['genres']),
+ 'cast': list(row['cast']),
+ 'director': str(row['director'])
+ }
+
+ if row['release_year'] is not None and not pd.isna(row['release_year']):
+ doc['release_year'] = int(row['release_year'])
+
+ # We store the text to encode along with doc to batch encode them
+ documents.append((doc, doc_text))
+
+ # Batch encode and insert
+ batch_size = 100
+ for idx in range(0, len(documents), batch_size):
+ batch = documents[idx:idx + batch_size]
+ batch_docs = [item[0] for item in batch]
+ batch_texts = [item[1] for item in batch]
+
+ # Encode the texts
+ embeddings = model.encode(batch_texts, normalize_embeddings=True)
+
+ # Add embeddings to documents
+ for doc, emb in zip(batch_docs, embeddings):
+ doc['embedding'] = emb.tolist()
+
+ # Import to Typesense
+ try:
+ client.collections['movies'].documents.import_(batch_docs, {'action': 'upsert'})
+ print(f"Seeded {min(idx + batch_size, total_movies)} / {total_movies} movies...")
+ except Exception as e:
+ print(f"Error seeding batch starting at index {idx}: {e}")
+
+ print("Data ingestion complete!")
+
+if __name__ == "__main__":
+ main()
diff --git a/typesense-node-drizzle-full-text-search/README.md b/typesense-node-drizzle-full-text-search/README.md
new file mode 100644
index 0000000..e0d9edb
--- /dev/null
+++ b/typesense-node-drizzle-full-text-search/README.md
@@ -0,0 +1,54 @@
+# Typesense Node.js Drizzle ORM Full-Text Search App
+
+A production-ready RESTful search API built with Node.js, Express, Drizzle ORM, PostgreSQL, and Typesense.
+
+This application maintains PostgreSQL as the primary source of truth while keeping Typesense synchronously and asynchronously updated to handle fast, typo-tolerant full-text searches.
+
+## Features
+- **Drizzle ORM Integration**: High performance, strongly-typed PostgreSQL queries.
+- **Batched Incremental Sync**: Handles millions of rows without memory bloat using cursor-based pagination.
+- **Soft Delete Support**: Properly handles `deleted_at` fields and purges ghosts from Typesense.
+- **Cron Jobs**: Background worker keeps the database and Typesense index synchronized automatically.
+
+## Prerequisites
+- Node.js v18+
+- Docker
+
+## Setup & Running
+
+1. **Start Typesense and PostgreSQL:**
+```bash
+docker run -d -p 8108:8108 \
+ -v "$(pwd)"/typesense-data:/data \
+ typesense/typesense:27.1 \
+ --data-dir /data \
+ --api-key=xyz \
+ --enable-cors
+
+docker run -d \
+ --name local_postgres \
+ -e POSTGRES_USER=admin \
+ -e POSTGRES_PASSWORD=admin123 \
+ -e POSTGRES_DB=testdb \
+ -p 5432:5432 \
+ postgres:16
+```
+
+2. **Install dependencies:**
+```bash
+npm install
+```
+
+3. **Generate and Run Migrations:**
+Generate Drizzle migrations from `src/db/schema.ts` and push them to the database.
+```bash
+npx drizzle-kit generate
+npx drizzle-kit push
+```
+
+4. **Start the application:**
+```bash
+npm run dev
+```
+
+The app will connect to PostgreSQL, initialize Typesense schemas, perform a startup sync (if needed), start the cron worker, and bind to `http://localhost:3002`.
diff --git a/typesense-node-drizzle-full-text-search/drizzle.config.ts b/typesense-node-drizzle-full-text-search/drizzle.config.ts
new file mode 100644
index 0000000..789f7a2
--- /dev/null
+++ b/typesense-node-drizzle-full-text-search/drizzle.config.ts
@@ -0,0 +1,11 @@
+import { defineConfig } from 'drizzle-kit';
+import 'dotenv/config';
+
+export default defineConfig({
+ schema: './src/db/schema.ts',
+ out: './drizzle',
+ dialect: 'postgresql',
+ dbCredentials: {
+ url: process.env.DATABASE_URL!,
+ },
+});
diff --git a/typesense-node-drizzle-full-text-search/drizzle/0000_aromatic_spiral.sql b/typesense-node-drizzle-full-text-search/drizzle/0000_aromatic_spiral.sql
new file mode 100644
index 0000000..a35661c
--- /dev/null
+++ b/typesense-node-drizzle-full-text-search/drizzle/0000_aromatic_spiral.sql
@@ -0,0 +1,12 @@
+CREATE TABLE "books" (
+ "id" serial PRIMARY KEY NOT NULL,
+ "title" varchar(255) NOT NULL,
+ "authors" json DEFAULT '[]' NOT NULL,
+ "publication_year" integer,
+ "average_rating" numeric(3, 2),
+ "image_url" varchar(255),
+ "ratings_count" integer,
+ "created_at" timestamp DEFAULT now() NOT NULL,
+ "updated_at" timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL,
+ "deleted_at" timestamp
+);
diff --git a/typesense-node-drizzle-full-text-search/drizzle/meta/0000_snapshot.json b/typesense-node-drizzle-full-text-search/drizzle/meta/0000_snapshot.json
new file mode 100644
index 0000000..aa834f0
--- /dev/null
+++ b/typesense-node-drizzle-full-text-search/drizzle/meta/0000_snapshot.json
@@ -0,0 +1,95 @@
+{
+ "id": "527348cf-95fc-4d6b-bb93-7beac078119f",
+ "prevId": "00000000-0000-0000-0000-000000000000",
+ "version": "7",
+ "dialect": "postgresql",
+ "tables": {
+ "public.books": {
+ "name": "books",
+ "schema": "",
+ "columns": {
+ "id": {
+ "name": "id",
+ "type": "serial",
+ "primaryKey": true,
+ "notNull": true
+ },
+ "title": {
+ "name": "title",
+ "type": "varchar(255)",
+ "primaryKey": false,
+ "notNull": true
+ },
+ "authors": {
+ "name": "authors",
+ "type": "json",
+ "primaryKey": false,
+ "notNull": true,
+ "default": "'[]'"
+ },
+ "publication_year": {
+ "name": "publication_year",
+ "type": "integer",
+ "primaryKey": false,
+ "notNull": false
+ },
+ "average_rating": {
+ "name": "average_rating",
+ "type": "numeric(3, 2)",
+ "primaryKey": false,
+ "notNull": false
+ },
+ "image_url": {
+ "name": "image_url",
+ "type": "varchar(255)",
+ "primaryKey": false,
+ "notNull": false
+ },
+ "ratings_count": {
+ "name": "ratings_count",
+ "type": "integer",
+ "primaryKey": false,
+ "notNull": false
+ },
+ "created_at": {
+ "name": "created_at",
+ "type": "timestamp",
+ "primaryKey": false,
+ "notNull": true,
+ "default": "now()"
+ },
+ "updated_at": {
+ "name": "updated_at",
+ "type": "timestamp",
+ "primaryKey": false,
+ "notNull": true,
+ "default": "CURRENT_TIMESTAMP"
+ },
+ "deleted_at": {
+ "name": "deleted_at",
+ "type": "timestamp",
+ "primaryKey": false,
+ "notNull": false
+ }
+ },
+ "indexes": {},
+ "foreignKeys": {},
+ "compositePrimaryKeys": {},
+ "uniqueConstraints": {},
+ "policies": {},
+ "checkConstraints": {},
+ "isRLSEnabled": false
+ }
+ },
+ "enums": {},
+ "schemas": {},
+ "sequences": {},
+ "roles": {},
+ "policies": {},
+ "views": {},
+ "_meta": {
+ "columns": {},
+ "schemas": {},
+ "tables": {}
+ }
+}
\ No newline at end of file
diff --git a/typesense-node-drizzle-full-text-search/drizzle/meta/_journal.json b/typesense-node-drizzle-full-text-search/drizzle/meta/_journal.json
new file mode 100644
index 0000000..8ba891d
--- /dev/null
+++ b/typesense-node-drizzle-full-text-search/drizzle/meta/_journal.json
@@ -0,0 +1,13 @@
+{
+ "version": "7",
+ "dialect": "postgresql",
+ "entries": [
+ {
+ "idx": 0,
+ "version": "7",
+ "when": 1777712202767,
+ "tag": "0000_aromatic_spiral",
+ "breakpoints": true
+ }
+ ]
+}
\ No newline at end of file
diff --git a/typesense-node-drizzle-full-text-search/package.json b/typesense-node-drizzle-full-text-search/package.json
new file mode 100644
index 0000000..caeb1ec
--- /dev/null
+++ b/typesense-node-drizzle-full-text-search/package.json
@@ -0,0 +1,34 @@
+{
+ "name": "typesense-node-drizzle-full-text-search",
+ "version": "1.0.0",
+ "main": "index.js",
+ "scripts": {
+ "dev": "ts-node-dev --respawn --transpile-only src/server.ts",
+ "db:generate": "drizzle-kit generate",
+ "db:push": "drizzle-kit push",
+ "test": "echo \"Error: no test specified\" && exit 1"
+ },
+ "keywords": [],
+ "author": "",
+ "license": "ISC",
+ "description": "",
+ "dependencies": {
+ "cors": "^2.8.6",
+ "dotenv": "^17.4.2",
+ "drizzle-orm": "^0.45.2",
+ "express": "^5.2.1",
+ "node-cron": "^4.2.1",
+ "pg": "^8.20.0",
+ "typesense": "^3.0.6"
+ },
+ "devDependencies": {
+ "@types/cors": "^2.8.19",
+ "@types/express": "^5.0.6",
+ "@types/node": "^25.6.0",
+ "@types/node-cron": "^3.0.11",
+ "@types/pg": "^8.20.0",
+ "drizzle-kit": "^0.31.10",
+ "ts-node-dev": "^2.0.0",
+ "typescript": "^6.0.3"
+ }
+}
diff --git a/typesense-node-drizzle-full-text-search/src/config/database.ts b/typesense-node-drizzle-full-text-search/src/config/database.ts
new file mode 100644
index 0000000..55c64ff
--- /dev/null
+++ b/typesense-node-drizzle-full-text-search/src/config/database.ts
@@ -0,0 +1,12 @@
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { Pool } from 'pg';
+import { env } from './env';
+import * as schema from '../db/schema';
+
+// Create a pg pool
+const pool = new Pool({
+ connectionString: env.DATABASE_URL,
+});
+
+// Create the Drizzle instance
+export const db = drizzle(pool, { schema });
diff --git a/typesense-node-drizzle-full-text-search/src/config/env.ts b/typesense-node-drizzle-full-text-search/src/config/env.ts
new file mode 100644
index 0000000..8d7fc44
--- /dev/null
+++ b/typesense-node-drizzle-full-text-search/src/config/env.ts
@@ -0,0 +1,27 @@
+import * as dotenv from 'dotenv';
+dotenv.config();
+
+const requiredEnvs = [
+ 'DATABASE_URL',
+ 'TYPESENSE_HOST',
+ 'TYPESENSE_PORT',
+ 'TYPESENSE_PROTOCOL',
+ 'TYPESENSE_API_KEY',
+ 'TYPESENSE_COLLECTION',
+] as const;
+
+for (const env of requiredEnvs) {
+ if (!process.env[env]) {
+ throw new Error(`Missing required environment variable: ${env}`);
+ }
+}
+
+export const env = {
+ PORT: process.env.PORT || 3000,
+ DATABASE_URL: process.env.DATABASE_URL!,
+ TYPESENSE_HOST: process.env.TYPESENSE_HOST!,
+ TYPESENSE_PORT: parseInt(process.env.TYPESENSE_PORT!, 10),
+ TYPESENSE_PROTOCOL: process.env.TYPESENSE_PROTOCOL!,
+ TYPESENSE_API_KEY: process.env.TYPESENSE_API_KEY!,
+ TYPESENSE_COLLECTION: process.env.TYPESENSE_COLLECTION!,
+};
diff --git a/typesense-node-drizzle-full-text-search/src/db/schema.ts b/typesense-node-drizzle-full-text-search/src/db/schema.ts
new file mode 100644
index 0000000..4ed7b77
--- /dev/null
+++ b/typesense-node-drizzle-full-text-search/src/db/schema.ts
@@ -0,0 +1,18 @@
+import { pgTable, serial, varchar, json, integer, decimal, timestamp } from 'drizzle-orm/pg-core';
+import { sql } from 'drizzle-orm';
+
+export const books = pgTable('books', {
+ id: serial('id').primaryKey(),
+ title: varchar('title', { length: 255 }).notNull(),
+ authors: json('authors').default('[]').notNull(),
+ publicationYear: integer('publication_year'),
+ averageRating: decimal('average_rating', { precision: 3, scale: 2 }),
+ imageUrl: varchar('image_url', { length: 255 }),
+ ratingsCount: integer('ratings_count'),
+ createdAt: timestamp('created_at').defaultNow().notNull(),
+ updatedAt: timestamp('updated_at').default(sql`CURRENT_TIMESTAMP`).$onUpdate(() => sql`CURRENT_TIMESTAMP`).notNull(),
+ deletedAt: timestamp('deleted_at'),
+});
+
+export type Book = typeof books.$inferSelect;
+export type NewBook = typeof books.$inferInsert;
diff --git a/typesense-node-drizzle-full-text-search/src/routes/books.ts b/typesense-node-drizzle-full-text-search/src/routes/books.ts
new file mode 100644
index 0000000..60885d6
--- /dev/null
+++ b/typesense-node-drizzle-full-text-search/src/routes/books.ts
@@ -0,0 +1,137 @@
+import { Router, type Request, type Response } from 'express';
+import { db } from '../config/database';
+import { books, type Book } from '../db/schema';
+import { eq, isNull, count } from 'drizzle-orm';
+import { typesenseClient } from '../search/client';
+import { BOOKS_COLLECTION_NAME } from '../search/collections';
+
+const router = Router();
+
+const syncBookToTypesense = async (book: Book) => {
+ try {
+ const authorsArray = Array.isArray(book.authors) ? book.authors : [book.authors];
+
+ const document = {
+ id: book.id.toString(),
+ title: book.title,
+ authors: authorsArray as string[],
+ publication_year: book.publicationYear || 0,
+ average_rating: book.averageRating ? Number(book.averageRating) : 0,
+ image_url: book.imageUrl || '',
+ ratings_count: book.ratingsCount || 0,
+ };
+
+ await typesenseClient.collections(BOOKS_COLLECTION_NAME).documents().upsert(document);
+ } catch (err) {
+ console.error(`Failed to sync book ${book.id} to Typesense:`, err);
+ throw err;
+ }
+};
+
+const deleteBookFromTypesense = async (id: number) => {
+ try {
+ await typesenseClient.collections(BOOKS_COLLECTION_NAME).documents(id.toString()).delete();
+ } catch (err) {
+ console.error(`Failed to delete book ${id} from Typesense`, err);
+ }
+};
+
+router.get('/', async (req: Request, res: Response) => {
+ const page = parseInt(req.query.page as string || '1', 10);
+ const limit = parseInt(req.query.limit as string || '10', 10);
+ const offset = (page - 1) * limit;
+
+ try {
+ const totalCountRes = await db.select({ value: count() }).from(books).where(isNull(books.deletedAt));
+ const totalCount = totalCountRes[0].value;
+
+ const rows = await db.select()
+ .from(books)
+ .where(isNull(books.deletedAt))
+ .limit(limit)
+ .offset(offset)
+ .orderBy(books.id);
+
+ res.json({
+ total: totalCount,
+ page,
+ limit,
+ data: rows
+ });
+ } catch (error) {
+ console.error(error);
+ res.status(500).json({ error: 'Failed to fetch books' });
+ }
+});
+
+router.get('/:id', async (req: Request, res: Response) => {
+ try {
+ const bookId = parseInt(req.params.id as string);
+ const result = await db.select().from(books).where(eq(books.id, bookId));
+ const book = result.find(b => b.deletedAt === null);
+
+ if (!book) {
+ return res.status(404).json({ error: 'Book not found' });
+ }
+ res.json(book);
+ } catch (error) {
+ res.status(500).json({ error: 'Failed to fetch book' });
+ }
+});
+
+router.post('/', async (req: Request, res: Response) => {
+ try {
+ const result = await db.insert(books).values(req.body).returning();
+ const book = result[0];
+
+ await syncBookToTypesense(book);
+
+ res.status(201).json(book);
+ } catch (error) {
+ res.status(400).json({ error: (error as Error).message });
+ }
+});
+
+router.put('/:id', async (req: Request, res: Response) => {
+ try {
+ const bookId = parseInt(req.params.id as string);
+ const existing = await db.select().from(books).where(eq(books.id, bookId));
+
+ if (existing.length === 0 || existing[0].deletedAt !== null) {
+ return res.status(404).json({ error: 'Book not found' });
+ }
+
+ const updated = await db.update(books)
+ .set({ ...req.body, updatedAt: new Date() })
+ .where(eq(books.id, bookId))
+ .returning();
+
+ const updatedBook = updated[0];
+ await syncBookToTypesense(updatedBook);
+
+ res.json(updatedBook);
+ } catch (error) {
+ res.status(400).json({ error: (error as Error).message });
+ }
+});
+
+router.delete('/:id', async (req: Request, res: Response) => {
+ try {
+ const bookId = parseInt(req.params.id as string);
+ const existing = await db.select().from(books).where(eq(books.id, bookId));
+
+ if (existing.length === 0 || existing[0].deletedAt !== null) {
+ return res.status(404).json({ error: 'Book not found' });
+ }
+
+ await db.update(books).set({ deletedAt: new Date(), updatedAt: new Date() }).where(eq(books.id, bookId));
+
+ await deleteBookFromTypesense(bookId);
+
+ res.status(204).send();
+ } catch (error) {
+ res.status(500).json({ error: (error as Error).message });
+ }
+});
+
+export default router;
diff --git a/typesense-node-drizzle-full-text-search/src/routes/search.ts b/typesense-node-drizzle-full-text-search/src/routes/search.ts
new file mode 100644
index 0000000..eb08614
--- /dev/null
+++ b/typesense-node-drizzle-full-text-search/src/routes/search.ts
@@ -0,0 +1,44 @@
+import { Router, type Request, type Response } from 'express';
+import { typesenseClient } from '../search/client';
+import { BOOKS_COLLECTION_NAME } from '../search/collections';
+import { runFullSync } from '../search/sync';
+
+const router = Router();
+
+// Perform search
+router.get('/search', async (req: Request, res: Response) => {
+ const { q, query_by, ...otherParams } = req.query;
+
+ if (!q || !query_by) {
+ return res.status(400).json({ error: 'Missing required query parameters: q and query_by' });
+ }
+
+ try {
+ const searchResults = await typesenseClient
+ .collections(BOOKS_COLLECTION_NAME)
+ .documents()
+ .search({
+ q: q as string,
+ query_by: query_by as string,
+ ...otherParams,
+ });
+
+ res.json(searchResults);
+ } catch (error) {
+ console.error('Search error:', error);
+ res.status(500).json({ error: 'Search failed' });
+ }
+});
+
+// Manual Sync endpoint
+router.post('/sync', async (req: Request, res: Response) => {
+ try {
+ await runFullSync();
+ res.json({ message: 'Sync completed successfully' });
+ } catch (error) {
+ console.error('Sync failed:', error);
+ res.status(500).json({ error: 'Sync failed' });
+ }
+});
+
+export default router;
diff --git a/typesense-node-drizzle-full-text-search/src/search/client.ts b/typesense-node-drizzle-full-text-search/src/search/client.ts
new file mode 100644
index 0000000..b8c403d
--- /dev/null
+++ b/typesense-node-drizzle-full-text-search/src/search/client.ts
@@ -0,0 +1,16 @@
+import { Client } from 'typesense';
+import { env } from '../config/env';
+
+export const typesenseClient = new Client({
+ nodes: [
+ {
+ host: env.TYPESENSE_HOST,
+ port: env.TYPESENSE_PORT,
+ protocol: env.TYPESENSE_PROTOCOL,
+ },
+ ],
+ apiKey: env.TYPESENSE_API_KEY,
+ connectionTimeoutSeconds: 5,
+ retryIntervalSeconds: 1,
+ numRetries: 3,
+});
diff --git a/typesense-node-drizzle-full-text-search/src/search/collections.ts b/typesense-node-drizzle-full-text-search/src/search/collections.ts
new file mode 100644
index 0000000..e3a4489
--- /dev/null
+++ b/typesense-node-drizzle-full-text-search/src/search/collections.ts
@@ -0,0 +1,33 @@
+import { typesenseClient } from './client';
+import { env } from '../config/env';
+import type { CollectionCreateSchema } from 'typesense/lib/Typesense/Collections';
+
+export const BOOKS_COLLECTION_NAME = env.TYPESENSE_COLLECTION;
+
+export async function initializeTypesense() {
+ const schema: CollectionCreateSchema = {
+ name: BOOKS_COLLECTION_NAME,
+ fields: [
+ { name: 'title', type: 'string', facet: false },
+ { name: 'authors', type: 'string[]', facet: true },
+ { name: 'publication_year', type: 'int32', facet: true },
+ { name: 'average_rating', type: 'float', facet: true },
+ { name: 'image_url', type: 'string', facet: false },
+ { name: 'ratings_count', type: 'int32', facet: true },
+ ],
+ default_sorting_field: 'ratings_count',
+ };
+
+ try {
+ await typesenseClient.collections(BOOKS_COLLECTION_NAME).retrieve();
+ console.log(`Collection '${BOOKS_COLLECTION_NAME}' already exists.`);
+ } catch (error: any) {
+ if (error.httpStatus === 404) {
+ console.log(`Collection '${BOOKS_COLLECTION_NAME}' not found. Creating...`);
+ await typesenseClient.collections().create(schema);
+ console.log(`Collection '${BOOKS_COLLECTION_NAME}' created successfully.`);
+ } else {
+ throw error;
+ }
+ }
+}
diff --git a/typesense-node-drizzle-full-text-search/src/search/sync.ts b/typesense-node-drizzle-full-text-search/src/search/sync.ts
new file mode 100644
index 0000000..908de12
--- /dev/null
+++ b/typesense-node-drizzle-full-text-search/src/search/sync.ts
@@ -0,0 +1,188 @@
+import { db } from '../config/database';
+import { books, type Book } from '../db/schema';
+import { typesenseClient } from './client';
+import { BOOKS_COLLECTION_NAME } from './collections';
+import { eq, gt, isNull, and, isNotNull, desc } from 'drizzle-orm';
+
+export let lastSyncTime: Date = new Date(0);
+
+const BATCH_SIZE = 1000;
+
+const mapBookToTypesense = (b: Book) => ({
+ id: b.id.toString(),
+ title: b.title,
+ authors: (Array.isArray(b.authors) ? b.authors : [b.authors]) as string[],
+ publication_year: b.publicationYear || 0,
+ average_rating: b.averageRating ? Number(b.averageRating) : 0,
+ image_url: b.imageUrl || '',
+ ratings_count: b.ratingsCount || 0,
+});
+
+export async function runFullSync() {
+ console.log('Running full sync...');
+ let lastId = 0;
+ let hasMore = true;
+ let totalProcessed = 0;
+
+ while (hasMore) {
+ let fetchedBooks: Book[];
+ try {
+ fetchedBooks = await db.select()
+ .from(books)
+ .where(
+ and(
+ gt(books.id, lastId),
+ isNull(books.deletedAt)
+ )
+ )
+ .limit(BATCH_SIZE)
+ .orderBy(books.id);
+ } catch (err) {
+ console.error('Database error during full sync fetching:', err);
+ break;
+ }
+
+ if (fetchedBooks.length === 0) {
+ hasMore = false;
+ break;
+ }
+
+ lastId = fetchedBooks[fetchedBooks.length - 1].id;
+ const documents = fetchedBooks.map(mapBookToTypesense);
+
+ try {
+ await typesenseClient.collections(BOOKS_COLLECTION_NAME).documents().import(documents, { action: 'upsert' });
+ totalProcessed += documents.length;
+ console.log(`Full sync: Processed ${totalProcessed} books.`);
+ } catch (err) {
+ console.error('Error importing documents during full sync', err);
+ break;
+ }
+ }
+
+ lastSyncTime = new Date();
+ console.log('Full sync completed.');
+}
+
+export async function runIncrementalSync() {
+ console.log(`Running incremental sync since ${lastSyncTime.toISOString()}...`);
+
+ // 1. Process newly created or updated books in batches
+ let lastUpsertId = 0;
+ let hasMoreUpserts = true;
+ let totalUpserted = 0;
+
+ while (hasMoreUpserts) {
+ let updatedBooks: Book[];
+ try {
+ updatedBooks = await db.select()
+ .from(books)
+ .where(
+ and(
+ gt(books.updatedAt, lastSyncTime),
+ isNull(books.deletedAt),
+ gt(books.id, lastUpsertId)
+ )
+ )
+ .limit(BATCH_SIZE)
+ .orderBy(books.id);
+ } catch (err) {
+ console.error('Database error during incremental sync upsert fetching:', err);
+ break;
+ }
+
+ if (updatedBooks.length === 0) {
+ hasMoreUpserts = false;
+ break;
+ }
+
+ lastUpsertId = updatedBooks[updatedBooks.length - 1].id;
+ const documents = updatedBooks.map(mapBookToTypesense);
+
+ try {
+ await typesenseClient.collections(BOOKS_COLLECTION_NAME).documents().import(documents, { action: 'upsert' });
+ totalUpserted += documents.length;
+ } catch (err) {
+ console.error('Error upserting documents in incremental sync', err);
+ break;
+ }
+ }
+
+ if (totalUpserted > 0) {
+ console.log(`Incremental sync: Upserted ${totalUpserted} books.`);
+ }
+
+ // 2. Process soft-deleted books in batches
+ let lastDeleteId = 0;
+ let hasMoreDeletes = true;
+ let totalDeleted = 0;
+
+ while (hasMoreDeletes) {
+ let deletedBooks: Book[];
+ try {
+ deletedBooks = await db.select()
+ .from(books)
+ .where(
+ and(
+ gt(books.updatedAt, lastSyncTime),
+ isNotNull(books.deletedAt),
+ gt(books.id, lastDeleteId)
+ )
+ )
+ .limit(BATCH_SIZE)
+ .orderBy(books.id);
+ } catch (err) {
+ console.error('Database error during incremental sync delete fetching:', err);
+ break;
+ }
+
+ if (deletedBooks.length === 0) {
+ hasMoreDeletes = false;
+ break;
+ }
+
+ lastDeleteId = deletedBooks[deletedBooks.length - 1].id;
+ const ids = deletedBooks.map(b => b.id.toString());
+
+ try {
+ await typesenseClient.collections(BOOKS_COLLECTION_NAME).documents().delete({
+ filter_by: `id:=[${ids.join(',')}]`
+ });
+ totalDeleted += deletedBooks.length;
+ } catch (err) {
+ console.error('Error deleting documents in incremental sync', err);
+ break;
+ }
+ }
+
+ if (totalDeleted > 0) {
+ console.log(`Incremental sync: Deleted ${totalDeleted} books from Typesense.`);
+ }
+
+ lastSyncTime = new Date();
+ console.log('Incremental sync completed.');
+}
+
+export async function determineAndRunStartupSync() {
+ try {
+ const searchStats = await typesenseClient.collections(BOOKS_COLLECTION_NAME).retrieve();
+ const docCount = searchStats.num_documents;
+
+ if (docCount === 0) {
+ await runFullSync();
+ } else {
+ const latestBook = await db.select()
+ .from(books)
+ .orderBy(desc(books.updatedAt))
+ .limit(1);
+
+ if (latestBook.length > 0 && latestBook[0].updatedAt) {
+ lastSyncTime = latestBook[0].updatedAt;
+ }
+
+ await runIncrementalSync();
+ }
+ } catch (error) {
+ console.error('Error during startup sync:', error);
+ }
+}
diff --git a/typesense-node-drizzle-full-text-search/src/search/worker.ts b/typesense-node-drizzle-full-text-search/src/search/worker.ts
new file mode 100644
index 0000000..dd35a01
--- /dev/null
+++ b/typesense-node-drizzle-full-text-search/src/search/worker.ts
@@ -0,0 +1,24 @@
+import cron from 'node-cron';
+import { runIncrementalSync } from './sync';
+
+let isSyncRunning = false;
+
+export function startBackgroundSyncWorker() {
+ console.log('Starting background sync worker (every 60 seconds)...');
+
+ cron.schedule('*/60 * * * * *', async () => {
+ if (isSyncRunning) {
+ console.log('Sync already running, skipping this interval.');
+ return;
+ }
+
+ isSyncRunning = true;
+ try {
+ await runIncrementalSync();
+ } catch (err) {
+ console.error('Error during background incremental sync:', err);
+ } finally {
+ isSyncRunning = false;
+ }
+ });
+}
diff --git a/typesense-node-drizzle-full-text-search/src/server.ts b/typesense-node-drizzle-full-text-search/src/server.ts
new file mode 100644
index 0000000..6e94f16
--- /dev/null
+++ b/typesense-node-drizzle-full-text-search/src/server.ts
@@ -0,0 +1,41 @@
+import express from 'express';
+import cors from 'cors';
+import { env } from './config/env';
+import { initializeTypesense } from './search/collections';
+import { determineAndRunStartupSync } from './search/sync';
+import { startBackgroundSyncWorker } from './search/worker';
+
+import booksRouter from './routes/books';
+import searchRouter from './routes/search';
+
+const app = express();
+
+app.use(cors());
+app.use(express.json());
+
+// Routes
+app.use('/books', booksRouter);
+app.use('/', searchRouter);
+
+async function startServer() {
+ try {
+ console.log('PostgreSQL database config loaded via Drizzle.');
+
+ console.log('Initializing Typesense...');
+ await initializeTypesense();
+
+ console.log('Running startup sync...');
+ await determineAndRunStartupSync();
+
+ startBackgroundSyncWorker();
+
+ app.listen(env.PORT, () => {
+ console.log(`Server is running on http://localhost:${env.PORT}`);
+ });
+ } catch (error) {
+ console.error('Failed to start server:', error);
+ process.exit(1);
+ }
+}
+
+startServer();
diff --git a/typesense-node-drizzle-full-text-search/tsconfig.json b/typesense-node-drizzle-full-text-search/tsconfig.json
new file mode 100644
index 0000000..5dbd728
--- /dev/null
+++ b/typesense-node-drizzle-full-text-search/tsconfig.json
@@ -0,0 +1,14 @@
+{
+ "compilerOptions": {
+ "target": "ES2022",
+ "module": "Node16",
+ "moduleResolution": "Node16",
+ "esModuleInterop": true,
+ "strict": true,
+ "skipLibCheck": true,
+ "forceConsistentCasingInFileNames": true,
+ "outDir": "./dist",
+ "rootDir": "./src"
+ },
+ "include": ["src/**/*"]
+}
diff --git a/typesense-node-prisma-full-text-search/.env.example b/typesense-node-prisma-full-text-search/.env.example
new file mode 100644
index 0000000..9b6d483
--- /dev/null
+++ b/typesense-node-prisma-full-text-search/.env.example
@@ -0,0 +1,15 @@
+# Server Configuration
+PORT=3000
+
+# Database Configuration
+DB_HOST=localhost
+DB_USER=postgres
+DB_PASSWORD=password
+DB_NAME=typesense_books
+DB_PORT=5432
+
+# Typesense Configuration
+TYPESENSE_HOST=localhost
+TYPESENSE_PORT=8108
+TYPESENSE_PROTOCOL=http
+TYPESENSE_API_KEY=xyz
diff --git a/typesense-node-prisma-full-text-search/.gitignore b/typesense-node-prisma-full-text-search/.gitignore
new file mode 100644
index 0000000..126419d
--- /dev/null
+++ b/typesense-node-prisma-full-text-search/.gitignore
@@ -0,0 +1,5 @@
+node_modules
+# Keep environment variables out of version control
+.env
+
+/src/generated/prisma
diff --git a/typesense-node-prisma-full-text-search/README.md b/typesense-node-prisma-full-text-search/README.md
new file mode 100644
index 0000000..652bfc0
--- /dev/null
+++ b/typesense-node-prisma-full-text-search/README.md
@@ -0,0 +1,231 @@
+# Node.js Express Full-Text Search with Typesense
+
+A production-ready RESTful search API built with Node.js, Express, PostgreSQL (Prisma), and Typesense. Features full-text search, CRUD operations, real-time async indexing, and background sync workers.
+
+## Tech Stack
+
+- Node.js
+- Express
+- PostgreSQL with Prisma ORM
+- Typesense
+- TypeScript
+- Docker
+
+## Prerequisites
+
+- Node.js v18+ installed
+- Docker (for Typesense and PostgreSQL)
+- Basic knowledge of REST APIs and SQL
+
+## Quick Start
+
+### 1. Clone the repository
+
+```bash
+git clone https://github.com/typesense/code-samples.git
+cd typesense-node-prisma-full-text-search
+```
+
+### 2. Install dependencies
+
+```bash
+npm install
+```
+
+### 3. Start Typesense and PostgreSQL
+
+Run Typesense and PostgreSQL using Docker:
+
+```bash
+# Start Typesense (replace TYPESENSE_VERSION with the latest from https://typesense.org/docs/guide/install-typesense.html)
+docker run -d \
+ -p 8108:8108 \
+ -v typesense-data:/data \
+ typesense/typesense:27.1 \
+ --data-dir /data \
+ --api-key=xyz \
+ --enable-cors
+
+# Start PostgreSQL
+docker run -d \
+ -p 5432:5432 \
+ -e POSTGRES_USER=postgres \
+ -e POSTGRES_PASSWORD=password \
+ -e POSTGRES_DB=typesense_books \
+ -v postgres-data:/var/lib/postgresql/data \
+ postgres:15
+```
+
+### 4. Set up environment variables
+
+Create a `.env` file in the project root by copying `.env.example`:
+
+```bash
+cp .env.example .env
+```
+
+### 5. Project Structure
+
+```text
+├── prisma/
+│ └── schema.prisma # Prisma schema and model definitions
+├── src/
+│ ├── config/
+│ │ ├── database.ts # Prisma Client instantiation
+│ │ └── env.ts # Environment variable validation
+│ ├── routes/
+│ │ ├── books.ts # CRUD endpoints for books
+│ │ └── search.ts # Search and sync endpoints
+│ ├── search/
+│ │ ├── client.ts # Typesense client initialization
+│ │ ├── collections.ts # Typesense collection schema
+│ │ ├── sync.ts # Sync logic (incremental, full, soft delete)
+│ │ └── worker.ts # Background sync worker
+│ └── server.ts # Main application entry point
+├── package.json
+├── tsconfig.json
+└── .env
+```
+
+### 6. Database Migrations
+
+**Development Environment:**
+When building out your schema or making changes during development, use the `db push` command. It pushes your schema state directly to the database without generating history:
+```bash
+npx prisma db push
+```
+
+**Production Environment:**
+For production, you should use Prisma Migrate to generate and apply consistent database migrations.
+Generate a migration (run this in dev when ready):
+```bash
+npx prisma migrate dev --name init_books
+```
+Apply migrations safely in production (e.g., during your CI/CD pipeline):
+```bash
+npx prisma migrate deploy
+```
+
+### 7. Start the development server
+
+```bash
+npm run dev
+```
+
+The server will automatically restart when you make changes to any TypeScript file.
+
+Open [http://localhost:3000](http://localhost:3000) in your browser.
+
+### 8. API Endpoints
+
+#### Search
+
+```bash
+GET /search?q=AI Powered Movie Search
+ +%sveltekit.body%
+
+
diff --git a/typesense-sveltekit-search-app/src/lib/components/BookCard.svelte b/typesense-sveltekit-search-app/src/lib/components/BookCard.svelte
new file mode 100644
index 0000000..b533fdd
--- /dev/null
+++ b/typesense-sveltekit-search-app/src/lib/components/BookCard.svelte
@@ -0,0 +1,150 @@
+
+
+
+
+
+
diff --git a/typesense-sveltekit-search-app/src/lib/components/BookList.svelte b/typesense-sveltekit-search-app/src/lib/components/BookList.svelte
new file mode 100644
index 0000000..c1994a2
--- /dev/null
+++ b/typesense-sveltekit-search-app/src/lib/components/BookList.svelte
@@ -0,0 +1,59 @@
+
+
+{#if !searchService.hasSearched}
+
+ {#if book.image_url && !imageError}
+ 
imageError = true}
+ />
+ {:else}
+
+
+
+ No Cover
+
+ {/if}
+
+
+{book.title}
+By: {book.authors?.join(", ") || 'Unknown Author'}
+ {#if book.publication_year} +Published: {book.publication_year}
+ {/if} + +
+ Loading search client...
+
+{:else}
+ {#if searchService.hits.length === 0}
+
+ {#if searchService.query}
+ No books found. Try a different search term.
+ {:else}
+ Start typing to search for books.
+ {/if}
+
+ {:else}
+
+ {#each searchService.hits as book (book.objectID || book.id)}
+
+ {/if}
+{/if}
+
+
diff --git a/typesense-sveltekit-search-app/src/lib/components/GithubIcon.svelte b/typesense-sveltekit-search-app/src/lib/components/GithubIcon.svelte
new file mode 100644
index 0000000..ae6f8e1
--- /dev/null
+++ b/typesense-sveltekit-search-app/src/lib/components/GithubIcon.svelte
@@ -0,0 +1,16 @@
+
+
+
diff --git a/typesense-sveltekit-search-app/src/lib/components/Heading.svelte b/typesense-sveltekit-search-app/src/lib/components/Heading.svelte
new file mode 100644
index 0000000..bfbb539
--- /dev/null
+++ b/typesense-sveltekit-search-app/src/lib/components/Heading.svelte
@@ -0,0 +1,135 @@
+
+
+
+
+
+
+ SvelteKit Search Bar
+
+ powered by{' '}
+
+ typesense|
+ {' '}
+ &
+
+
+
+
+
diff --git a/typesense-sveltekit-search-app/src/lib/components/SvelteLogo.svelte b/typesense-sveltekit-search-app/src/lib/components/SvelteLogo.svelte
new file mode 100644
index 0000000..f8edd5b
--- /dev/null
+++ b/typesense-sveltekit-search-app/src/lib/components/SvelteLogo.svelte
@@ -0,0 +1,15 @@
+
+
+
diff --git a/typesense-sveltekit-search-app/src/lib/instantSearchAdapter.ts b/typesense-sveltekit-search-app/src/lib/instantSearchAdapter.ts
new file mode 100644
index 0000000..b37a7f9
--- /dev/null
+++ b/typesense-sveltekit-search-app/src/lib/instantSearchAdapter.ts
@@ -0,0 +1,26 @@
+import {
+ PUBLIC_TYPESENSE_API_KEY,
+ PUBLIC_TYPESENSE_HOST,
+ PUBLIC_TYPESENSE_PORT,
+ PUBLIC_TYPESENSE_PROTOCOL,
+} from '$env/static/public';
+import TypesenseInstantsearchAdapter from 'typesense-instantsearch-adapter';
+
+export const typesenseInstantSearchAdapter = new TypesenseInstantsearchAdapter({
+ server: {
+ apiKey: PUBLIC_TYPESENSE_API_KEY || '1234',
+ nodes: [
+ {
+ host: PUBLIC_TYPESENSE_HOST || 'localhost',
+ port: parseInt(PUBLIC_TYPESENSE_PORT || '8108'),
+ protocol: PUBLIC_TYPESENSE_PROTOCOL || 'http',
+ },
+ ],
+ },
+ additionalSearchParameters: {
+ query_by: 'title,authors',
+ query_by_weights: '4,2',
+ num_typos: 1,
+ sort_by: 'ratings_count:desc',
+ },
+});
diff --git a/typesense-sveltekit-search-app/src/lib/searchService.svelte.ts b/typesense-sveltekit-search-app/src/lib/searchService.svelte.ts
new file mode 100644
index 0000000..017f175
--- /dev/null
+++ b/typesense-sveltekit-search-app/src/lib/searchService.svelte.ts
@@ -0,0 +1,69 @@
+import { PUBLIC_TYPESENSE_INDEX } from '$env/static/public';
+import { typesenseInstantSearchAdapter } from '$lib/instantSearchAdapter';
+import instantsearch from 'instantsearch.js';
+import connectHits from 'instantsearch.js/es/connectors/hits/connectHits';
+import connectSearchBox from 'instantsearch.js/es/connectors/search-box/connectSearchBox';
+import type { Book } from './types';
+
+export class SearchService {
+ hits = $state
+
diff --git a/typesense-sveltekit-search-app/src/routes/+page.ts b/typesense-sveltekit-search-app/src/routes/+page.ts
new file mode 100644
index 0000000..a3d1578
--- /dev/null
+++ b/typesense-sveltekit-search-app/src/routes/+page.ts
@@ -0,0 +1 @@
+export const ssr = false;
diff --git a/typesense-sveltekit-search-app/src/routes/layout.css b/typesense-sveltekit-search-app/src/routes/layout.css
new file mode 100644
index 0000000..1c4d2a8
--- /dev/null
+++ b/typesense-sveltekit-search-app/src/routes/layout.css
@@ -0,0 +1,2 @@
+@import 'tailwindcss';
+@plugin '@tailwindcss/typography';
diff --git a/typesense-sveltekit-search-app/static/favicon.png b/typesense-sveltekit-search-app/static/favicon.png
new file mode 100644
index 0000000..f42ec19
Binary files /dev/null and b/typesense-sveltekit-search-app/static/favicon.png differ
diff --git a/typesense-sveltekit-search-app/static/robots.txt b/typesense-sveltekit-search-app/static/robots.txt
new file mode 100644
index 0000000..b6dd667
--- /dev/null
+++ b/typesense-sveltekit-search-app/static/robots.txt
@@ -0,0 +1,3 @@
+# allow crawling everything by default
+User-agent: *
+Disallow:
diff --git a/typesense-sveltekit-search-app/svelte.config.js b/typesense-sveltekit-search-app/svelte.config.js
new file mode 100644
index 0000000..0c3412e
--- /dev/null
+++ b/typesense-sveltekit-search-app/svelte.config.js
@@ -0,0 +1,17 @@
+import adapter from '@sveltejs/adapter-auto';
+
+/** @type {import('@sveltejs/kit').Config} */
+const config = {
+ compilerOptions: {
+ // Force runes mode for the project, except for libraries. Can be removed in svelte 6.
+ runes: ({ filename }) => (filename.split(/[/\\]/).includes('node_modules') ? undefined : true)
+ },
+ kit: {
+ // adapter-auto only supports some environments, see https://svelte.dev/docs/kit/adapter-auto for a list.
+ // If your environment is not supported, or you settled on a specific environment, switch out the adapter.
+ // See https://svelte.dev/docs/kit/adapters for more information about adapters.
+ adapter: adapter()
+ }
+};
+
+export default config;
diff --git a/typesense-sveltekit-search-app/tsconfig.json b/typesense-sveltekit-search-app/tsconfig.json
new file mode 100644
index 0000000..2c2ed3c
--- /dev/null
+++ b/typesense-sveltekit-search-app/tsconfig.json
@@ -0,0 +1,20 @@
+{
+ "extends": "./.svelte-kit/tsconfig.json",
+ "compilerOptions": {
+ "rewriteRelativeImportExtensions": true,
+ "allowJs": true,
+ "checkJs": true,
+ "esModuleInterop": true,
+ "forceConsistentCasingInFileNames": true,
+ "resolveJsonModule": true,
+ "skipLibCheck": true,
+ "sourceMap": true,
+ "strict": true,
+ "moduleResolution": "bundler"
+ }
+ // Path aliases are handled by https://svelte.dev/docs/kit/configuration#alias
+ // except $lib which is handled by https://svelte.dev/docs/kit/configuration#files
+ //
+ // To make changes to top-level options such as include and exclude, we recommend extending
+ // the generated config; see https://svelte.dev/docs/kit/configuration#typescript
+}
diff --git a/typesense-sveltekit-search-app/vite.config.ts b/typesense-sveltekit-search-app/vite.config.ts
new file mode 100644
index 0000000..4bc0e08
--- /dev/null
+++ b/typesense-sveltekit-search-app/vite.config.ts
@@ -0,0 +1,10 @@
+import tailwindcss from '@tailwindcss/vite';
+import { sveltekit } from '@sveltejs/kit/vite';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+ plugins: [tailwindcss(), sveltekit()],
+ ssr: {
+ noExternal: ['typesense-instantsearch-adapter']
+ }
+});
diff --git a/typesense-swift-search/.gitignore b/typesense-swift-search/.gitignore
new file mode 100644
index 0000000..7c4bb42
--- /dev/null
+++ b/typesense-swift-search/.gitignore
@@ -0,0 +1,45 @@
+# Xcode
+#
+# gitignore contributors: remember to update Global/Xcode.gitignore, Objective-C.gitignore & Swift.gitignore
+
+## User settings
+xcuserdata/
+
+## compatibility with Xcode 8 and earlier (ignoring not only xcworkspace but also xcworkspace/xcuserdata)
+*.xcworkspace/
+
+## Xcode 8 and earlier
+*.xcuserstate
+
+## build state
+build/
+DerivedData/
+
+## Other
+*.hmap
+*.ipa
+*.dSYM.zip
+*.dSYM
+
+# Swift Package Manager
+#
+# Add this line if you want to avoid checking in source code from Swift Package Manager dependencies.
+# Packages/
+# Package.resolved
+# .build/
+
+# CocoaPods
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# Pods/
+
+# Carthage
+#
+# Add this line if you want to avoid checking in build files from Carthage dependencies.
+# Carthage/Build
+
+# Mac OS X
+.DS_Store
diff --git a/typesense-swift-search/typesense-swift-search.xcodeproj/project.pbxproj b/typesense-swift-search/typesense-swift-search.xcodeproj/project.pbxproj
new file mode 100644
index 0000000..a2f3368
--- /dev/null
+++ b/typesense-swift-search/typesense-swift-search.xcodeproj/project.pbxproj
@@ -0,0 +1,360 @@
+// !$*UTF8*$!
+{
+ archiveVersion = 1;
+ classes = {
+ };
+ objectVersion = 77;
+ objects = {
+
+/* Begin PBXFileReference section */
+ 84B32B942FBB0FE600CCFCF8 /* typesense-swift-search.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "typesense-swift-search.app"; sourceTree = BUILT_PRODUCTS_DIR; };
+/* End PBXFileReference section */
+
+/* Begin PBXFileSystemSynchronizedRootGroup section */
+ 84B32B962FBB0FE600CCFCF8 /* typesense-swift-search */ = {
+ isa = PBXFileSystemSynchronizedRootGroup;
+ path = "typesense-swift-search";
+ sourceTree = "
+
+