Files
StarPunk/starpunk/routes/search.py
T
PhilandClaude Opus 5.5 b7f8e1612c feat: articles at /article/<slug> with slugs from their titles (v2.17.0, ADR-077)
Articles (notes with a title) move from /note/<slug> to /article/<slug>;
the other prefix 301-redirects. New articles take their slug from the
title (mp-slug still wins; notes keep timestamp slugs). A Micropub update
that adds or removes a title answers 201 with the new Location.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 12:27:31 -07:00

195 lines
5.7 KiB
Python

"""
Search routes for StarPunk
Provides both API and HTML endpoints for full-text search functionality.
"""
import logging
from pathlib import Path
from flask import Blueprint, current_app, g, jsonify, render_template, request
from starpunk.search import has_fts_table, search_notes
from starpunk.utils import post_path
logger = logging.getLogger(__name__)
bp = Blueprint("search", __name__)
@bp.route("/api/search", methods=["GET"])
def api_search():
"""
Search API endpoint
Query Parameters:
q (required): Search query string
limit (optional): Results limit, default 20, max 100
offset (optional): Pagination offset, default 0
Returns:
JSON response with search results
Status Codes:
200: Success (even with 0 results)
400: Bad request (empty query)
503: Service unavailable (FTS5 not available)
"""
# Extract and validate query parameter
query = request.args.get("q", "").strip()
if not query:
return (
jsonify(
{
"error": "Missing required parameter: q",
"message": "Search query cannot be empty",
}
),
400,
)
# Parse limit with bounds checking
try:
limit = min(int(request.args.get("limit", 20)), 100)
if limit < 1:
limit = 20
except ValueError:
limit = 20
# Parse offset
try:
offset = max(int(request.args.get("offset", 0)), 0)
except ValueError:
offset = 0
# Check if user is authenticated (for unpublished notes)
# Anonymous users (g.me not set) see only published notes
published_only = not hasattr(g, "me") or g.me is None
db_path = Path(current_app.config["DATABASE_PATH"])
# Check FTS availability
if not has_fts_table(db_path):
return (
jsonify(
{
"error": "Search unavailable",
"message": "Full-text search is not configured on this server",
}
),
503,
)
try:
results = search_notes(
query=query,
db_path=db_path,
published_only=published_only,
limit=limit,
offset=offset,
)
except Exception as e:
current_app.logger.error(f"Search failed: {e}")
return (
jsonify(
{"error": "Search failed", "message": "An error occurred during search"}
),
500,
)
# Format response
response = {
"query": query,
"count": len(results),
"limit": limit,
"offset": offset,
"results": [
{
"slug": r["slug"],
"title": r["title"] or f"Note from {r['created_at'][:10]}",
"excerpt": r["snippet"], # Already has <mark> tags
"published_at": r["created_at"],
"url": post_path(r["slug"], r.get("article_title")),
}
for r in results
],
}
return jsonify(response), 200
@bp.route("/search")
def search_page():
"""
Search results HTML page
Query Parameters:
q: Search query string
offset: Pagination offset
"""
query = request.args.get("q", "").strip()
limit = 20 # Fixed for HTML view
# Parse offset
try:
offset = max(int(request.args.get("offset", 0)), 0)
except ValueError:
offset = 0
# Check authentication for unpublished notes
# Anonymous users (g.me not set) see only published notes
published_only = not hasattr(g, "me") or g.me is None
results = []
error = None
if query:
db_path = Path(current_app.config["DATABASE_PATH"])
if not has_fts_table(db_path):
error = "Full-text search is not configured on this server"
else:
try:
raw_results = search_notes(
query=query,
db_path=db_path,
published_only=published_only,
limit=limit,
offset=offset,
)
# Format results for template
# Format results and escape HTML in excerpts for safety
# FTS5 snippet() returns content with <mark> tags but doesn't escape HTML
# We need to escape it but preserve the <mark> tags
from markupsafe import escape, Markup
formatted_results = []
for r in raw_results:
# Escape the snippet but allow <mark> tags
snippet = r["snippet"]
# Simple approach: escape all HTML, then unescape our mark tags
escaped = escape(snippet)
# Replace escaped mark tags with real ones
safe_snippet = str(escaped).replace("&lt;mark&gt;", "<mark>").replace("&lt;/mark&gt;", "</mark>")
formatted_results.append({
"slug": r["slug"],
"title": r["title"] or f"Note from {r['created_at'][:10]}",
"excerpt": Markup(safe_snippet), # Mark as safe since we've escaped it ourselves
"published_at": r["created_at"],
"url": post_path(r["slug"], r.get("article_title")),
})
results = formatted_results
except Exception as e:
current_app.logger.error(f"Search failed: {e}")
error = "An error occurred during search"
return render_template(
"search.html",
query=query,
results=results,
error=error,
limit=limit,
offset=offset,
)