@tsproxy/api 0.0.2 → 0.0.3

package/dist/{chunk-VL6QOQ2T.js → chunk-5GS3ZEPG.js}

@@ -1,5 +1,5 @@
 // src/index.ts
-import { Hono as Hono5 } from "hono";
+import { Hono as Hono7 } from "hono";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
 
@@ -81,13 +81,30 @@ function resolveCollection(config, collection, locale) {
 }
 
 // src/middleware/error-handler.ts
+var FRIENDLY_ERRORS = {
+  ECONNREFUSED: "Cannot connect to Typesense. Is it running? Start with: docker compose up -d",
+  ENOTFOUND: "Typesense host not found. Check your TYPESENSE_HOST setting.",
+  ETIMEDOUT: "Connection to Typesense timed out. Check your network and host settings.",
+  "Request failed with status code 401": "Invalid Typesense API key. Check your TYPESENSE_API_KEY.",
+  "Request failed with status code 403": "Typesense API key lacks permissions for this operation."
+};
+function getFriendlyMessage(err) {
+  for (const [key, message] of Object.entries(FRIENDLY_ERRORS)) {
+    if (err.message.includes(key)) return message;
+  }
+  return void 0;
+}
 function errorHandler(err, c) {
-  console.error(`[Error] ${err.message}`, err.stack);
+  const friendly = getFriendlyMessage(err);
+  if (friendly) {
+    console.error(`[tsproxy] ${friendly}`);
+  } else {
+    console.error(`[tsproxy] ${err.message}`);
+  }
   const status = err.status ?? err.statusCode ?? 500;
   return c.json(
     {
-      error: status === 500 ? "Internal Server Error" : err.message,
-      ...process.env["NODE_ENV"] === "development" && { stack: err.stack }
+      error: friendly || (status === 500 ? "Internal Server Error" : err.message)
     },
     status
   );
@@ -284,6 +301,25 @@ function transformAlgoliaRequestToTypesense(request, resolvedCollection) {
   if (params["sortBy"]) {
     result.sort_by = params["sortBy"];
   }
+  if (params["aroundLatLng"]) {
+    const geo = params["aroundLatLng"];
+    const radius = params["aroundRadius"] || "10000";
+    const geoField = params["geoField"] || "_geoloc";
+    const [lat, lng] = geo.split(",").map((s) => s.trim());
+    if (lat && lng) {
+      const existing = result.filter_by ? `${result.filter_by} && ` : "";
+      result.filter_by = `${existing}${geoField}:(${lat}, ${lng}, ${radius} m)`;
+      if (!result.sort_by) {
+        result.sort_by = `${geoField}(${lat}, ${lng}):asc`;
+      }
+    }
+  }
+  if (params["groupBy"]) {
+    result.group_by = params["groupBy"];
+    if (params["groupLimit"]) {
+      result.group_limit = parseInt(params["groupLimit"], 10);
+    }
+  }
   return result;
 }
 function transformHighlights(highlights, document) {
@@ -1169,10 +1205,132 @@ function createDocsRoutes() {
   return app;
 }
 
+// src/routes/suggestions.ts
+import { Hono as Hono5 } from "hono";
+function createSuggestionsRoutes(config, collectionDefs) {
+  const app = new Hono5();
+  const typesense = getTypesenseClient(config);
+  app.get("/api/suggestions", async (c) => {
+    const query = c.req.query("q") || "";
+    const collection = c.req.query("collection") || "products";
+    const limit = parseInt(c.req.query("limit") || "5", 10);
+    const locale = c.req.header("X-Locale") ?? c.req.query("locale");
+    if (!query) {
+      return c.json({ suggestions: [] });
+    }
+    const resolved = resolveCollection(config.collections, collection, locale);
+    let queryBy = "name";
+    if (collectionDefs?.[collection]) {
+      const searchable = getSearchableFields(collectionDefs[collection]);
+      if (searchable.length > 0) {
+        queryBy = searchable.join(",");
+      }
+    }
+    try {
+      const result = await typesense.collections(resolved).documents().search({
+        q: query,
+        query_by: queryBy,
+        per_page: limit,
+        prefix: "true",
+        highlight_full_fields: queryBy,
+        highlight_start_tag: "<mark>",
+        highlight_end_tag: "</mark>"
+      });
+      const suggestions = (result.hits || []).map((hit) => {
+        const doc = hit.document || {};
+        const highlights = hit.highlights || [];
+        let highlightedValue = "";
+        for (const hl of highlights) {
+          if (hl.snippet) {
+            highlightedValue = hl.snippet;
+            break;
+          }
+        }
+        return {
+          objectID: String(doc.id || ""),
+          query: String(doc[queryBy.split(",")[0]] || ""),
+          highlight: highlightedValue || String(doc[queryBy.split(",")[0]] || "")
+        };
+      });
+      return c.json({
+        suggestions,
+        query,
+        found: result.found
+      });
+    } catch (err) {
+      console.error("[suggestions] Error:", err.message);
+      return c.json({ suggestions: [], query, error: err.message });
+    }
+  });
+  return app;
+}
+
+// src/routes/analytics.ts
+import { Hono as Hono6 } from "hono";
+function createAnalyticsRoutes(config) {
+  const app = new Hono6();
+  const typesense = getTypesenseClient(config);
+  app.post("/api/analytics/click", async (c) => {
+    const body = await c.req.json();
+    if (!body.query || !body.documentId) {
+      return c.json({ error: "query and documentId are required" }, 400);
+    }
+    try {
+      await typesense.analytics.events().create({
+        type: "click",
+        name: "search_click",
+        data: {
+          q: body.query,
+          doc_id: body.documentId,
+          position: body.position || 1,
+          collection: body.collection || "products"
+        }
+      });
+      return c.json({ ok: true });
+    } catch (err) {
+      console.warn("[analytics] Click event failed:", err.message);
+      return c.json({ ok: false, error: err.message });
+    }
+  });
+  app.post("/api/analytics/conversion", async (c) => {
+    const body = await c.req.json();
+    if (!body.query || !body.documentId) {
+      return c.json({ error: "query and documentId are required" }, 400);
+    }
+    try {
+      await typesense.analytics.events().create({
+        type: "conversion",
+        name: "search_conversion",
+        data: {
+          q: body.query,
+          doc_id: body.documentId,
+          collection: body.collection || "products"
+        }
+      });
+      return c.json({ ok: true });
+    } catch (err) {
+      console.warn("[analytics] Conversion event failed:", err.message);
+      return c.json({ ok: false, error: err.message });
+    }
+  });
+  app.get("/api/analytics/popular", async (c) => {
+    const collection = c.req.query("collection") || "products";
+    const limit = parseInt(c.req.query("limit") || "10", 10);
+    try {
+      const rules = await typesense.analytics.rules().retrieve();
+      return c.json({ rules, collection, limit });
+    } catch (err) {
+      console.warn("[analytics] Popular queries failed:", err.message);
+      return c.json({ queries: [], error: err.message });
+    }
+  });
+  return app;
+}
+
 // src/index.ts
 function createApp(config, collectionDefs) {
   const cfg = config ?? loadConfig();
-  const app = new Hono5();
+  const app = new Hono7();
   app.use("*", cors());
   app.use("*", logger());
   app.onError(errorHandler);
@@ -1180,10 +1338,14 @@ function createApp(config, collectionDefs) {
   const { app: ingestApp, queue: ingestQueue } = createIngestRoutes(cfg, collectionDefs);
   const healthApp = createHealthRoutes(cfg);
   const docsApp = createDocsRoutes();
+  const suggestionsApp = createSuggestionsRoutes(cfg, collectionDefs);
+  const analyticsApp = createAnalyticsRoutes(cfg);
   app.route("/", searchApp);
   app.route("/", ingestApp);
   app.route("/", healthApp);
   app.route("/", docsApp);
+  app.route("/", suggestionsApp);
+  app.route("/", analyticsApp);
   return { app, config: cfg, searchCache, ingestQueue };
 }
 

package/dist/cli.js

@@ -2,7 +2,7 @@
 import {
   createApp,
   proxyConfigToConfig
-} from "./chunk-VL6QOQ2T.js";
+} from "./chunk-5GS3ZEPG.js";
 
 // src/cli.ts
 import { resolve } from "path";

package/dist/index.d.ts

@@ -83,6 +83,24 @@ interface FieldConfig {
 /**
  * Collection definition in the proxy config
  */
+interface SynonymDefinition {
+    /** Synonym words — all are interchangeable */
+    synonyms?: string[];
+    /** One-way: root word */
+    root?: string;
+    /** One-way: words that map to the root */
+    words?: string[];
+}
+interface CurationDefinition {
+    /** Query to match */
+    query: string;
+    /** Match type: exact or contains */
+    match?: "exact" | "contains";
+    /** Document IDs to pin to the top */
+    pinnedIds?: string[];
+    /** Document IDs to hide from results */
+    hiddenIds?: string[];
+}
 interface CollectionDefinition {
     /** Field definitions */
     fields: Record<string, FieldConfig>;
@@ -96,6 +114,10 @@ interface CollectionDefinition {
     symbolsToIndex?: string[];
     /** Enable nested fields */
     enableNestedFields?: boolean;
+    /** Synonym definitions */
+    synonyms?: Record<string, SynonymDefinition>;
+    /** Curation/pinning rules */
+    curations?: Record<string, CurationDefinition>;
 }
 /**
  * Proxy configuration file schema (tsproxy.config.ts)
@@ -375,4 +397,4 @@ declare function createApp(config?: Config, collectionDefs?: Record<string, Coll
     ingestQueue: IngestionQueue;
 };
 
-export { type AlgoliaHighlightResult, type AlgoliaHit, type AlgoliaMultiSearchRequest, type AlgoliaMultiSearchResponse, type AlgoliaSearchRequest, type AlgoliaSearchResult, type CacheStats, type CollectionDefinition, type Config, type FieldConfig, IngestionQueue, LRUCache, type ProxyConfig, type QueueStats, type TypesenseMultiSearchParams, type TypesenseMultiSearchResponse, type TypesenseSearchParams, type TypesenseSearchResponse, applyComputedFields, applyComputedFieldsBatch, createApp, defineConfig, getComputedFields, getFacetFields, getSearchableFields, getSortableFields, loadConfig, proxyConfigToConfig, resolveCollection, toTypesenseSchema, transformAlgoliaRequestToTypesense, transformMultiSearchResponse, transformTypesenseResponseToAlgolia };
+export { type AlgoliaHighlightResult, type AlgoliaHit, type AlgoliaMultiSearchRequest, type AlgoliaMultiSearchResponse, type AlgoliaSearchRequest, type AlgoliaSearchResult, type CacheStats, type CollectionDefinition, type Config, type CurationDefinition, type FieldConfig, IngestionQueue, LRUCache, type ProxyConfig, type QueueStats, type SynonymDefinition, type TypesenseMultiSearchParams, type TypesenseMultiSearchResponse, type TypesenseSearchParams, type TypesenseSearchResponse, applyComputedFields, applyComputedFieldsBatch, createApp, defineConfig, getComputedFields, getFacetFields, getSearchableFields, getSortableFields, loadConfig, proxyConfigToConfig, resolveCollection, toTypesenseSchema, transformAlgoliaRequestToTypesense, transformMultiSearchResponse, transformTypesenseResponseToAlgolia };

package/dist/index.js

@@ -16,7 +16,7 @@ import {
   transformAlgoliaRequestToTypesense,
   transformMultiSearchResponse,
   transformTypesenseResponseToAlgolia
-} from "./chunk-VL6QOQ2T.js";
+} from "./chunk-5GS3ZEPG.js";
 export {
   IngestionQueue,
   LRUCache,

package/dist/server.js

@@ -1,6 +1,6 @@
 import {
   createApp
-} from "./chunk-VL6QOQ2T.js";
+} from "./chunk-5GS3ZEPG.js";
 
 // src/server.ts
 import { serve } from "@hono/node-server";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsproxy/api",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "HonoJS proxy server for Typesense with caching, rate limiting, and ingestion queue",
   "type": "module",
   "main": "./dist/index.js",