@tsproxy/api 0.0.1

package/dist/chunk-VL6QOQ2T.js

@@ -0,0 +1,1208 @@
+// src/index.ts
+import { Hono as Hono5 } from "hono";
+import { cors } from "hono/cors";
+import { logger } from "hono/logger";
+
+// src/config.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+function loadCollectionsConfig() {
+  const envConfig = process.env["COLLECTIONS_CONFIG"];
+  if (envConfig) {
+    try {
+      return JSON.parse(envConfig);
+    } catch {
+      console.warn("Failed to parse COLLECTIONS_CONFIG env var, using empty config");
+    }
+  }
+  try {
+    const filePath = resolve(process.cwd(), "collections.json");
+    const content = readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+  }
+  return { collections: {} };
+}
+function requiredEnv(name, fallback) {
+  const value = process.env[name] ?? fallback;
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${name}`);
+  }
+  return value;
+}
+function optionalEnv(name, fallback) {
+  return process.env[name] ?? fallback;
+}
+function numEnv(name, fallback) {
+  const value = process.env[name];
+  if (!value) return fallback;
+  const parsed = parseInt(value, 10);
+  return isNaN(parsed) ? fallback : parsed;
+}
+function loadConfig() {
+  return {
+    typesense: {
+      host: optionalEnv("TYPESENSE_HOST", "localhost"),
+      port: numEnv("TYPESENSE_PORT", 8108),
+      protocol: optionalEnv("TYPESENSE_PROTOCOL", "http"),
+      apiKey: requiredEnv("TYPESENSE_API_KEY")
+    },
+    proxy: {
+      port: numEnv("PROXY_PORT", 3e3),
+      apiKey: requiredEnv("PROXY_API_KEY", "")
+    },
+    cache: {
+      ttl: numEnv("CACHE_TTL", 60),
+      maxSize: numEnv("CACHE_MAX_SIZE", 1e3)
+    },
+    queue: {
+      concurrency: numEnv("QUEUE_CONCURRENCY", 5),
+      maxSize: numEnv("QUEUE_MAX_SIZE", 1e4),
+      ...process.env["REDIS_HOST"] ? {
+        redis: {
+          host: optionalEnv("REDIS_HOST", "localhost"),
+          port: numEnv("REDIS_PORT", 6379)
+        }
+      } : {}
+    },
+    rateLimit: {
+      search: numEnv("RATE_LIMIT_SEARCH", 100),
+      ingest: numEnv("RATE_LIMIT_INGEST", 30)
+    },
+    collections: loadCollectionsConfig()
+  };
+}
+function resolveCollection(config, collection, locale) {
+  const collectionConfig = config.collections[collection];
+  if (!collectionConfig?.locales || !locale) {
+    return collection;
+  }
+  return collectionConfig.locales[locale] ?? collection;
+}
+
+// src/middleware/error-handler.ts
+function errorHandler(err, c) {
+  console.error(`[Error] ${err.message}`, err.stack);
+  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 }
+    },
+    status
+  );
+}
+
+// src/routes/search.ts
+import { Hono } from "hono";
+
+// src/lib/cache.ts
+var LRUCache = class {
+  cache;
+  maxSize;
+  ttl;
+  hits = 0;
+  misses = 0;
+  constructor(options) {
+    this.maxSize = options.maxSize;
+    this.ttl = options.ttl * 1e3;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.misses++;
+      return void 0;
+    }
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      this.misses++;
+      return void 0;
+    }
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+    this.hits++;
+    return entry.value;
+  }
+  set(key, value) {
+    this.cache.delete(key);
+    while (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, {
+      value,
+      expiresAt: Date.now() + this.ttl
+    });
+  }
+  invalidate(key) {
+    if (key) {
+      this.cache.delete(key);
+    } else {
+      this.cache.clear();
+    }
+  }
+  stats() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache) {
+      if (now > entry.expiresAt) {
+        this.cache.delete(key);
+      }
+    }
+    const total = this.hits + this.misses;
+    return {
+      size: this.cache.size,
+      maxSize: this.maxSize,
+      ttl: this.ttl / 1e3,
+      hits: this.hits,
+      misses: this.misses,
+      hitRate: total === 0 ? 0 : this.hits / total
+    };
+  }
+};
+
+// src/lib/transform.ts
+function parseAlgoliaParams(params) {
+  if (!params) return {};
+  if (typeof params === "object") {
+    const result2 = {};
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0 || value === null) continue;
+      result2[key] = typeof value === "string" ? value : JSON.stringify(value);
+    }
+    return result2;
+  }
+  const result = {};
+  const searchParams = new URLSearchParams(params);
+  for (const [key, value] of searchParams.entries()) {
+    result[key] = value;
+  }
+  return result;
+}
+function transformAlgoliaFilters(facetFilters, numericFilters, filters) {
+  const parts = [];
+  if (filters) {
+    parts.push(filters);
+  }
+  if (facetFilters) {
+    try {
+      const parsed = JSON.parse(facetFilters);
+      const conditions = [];
+      for (const filter of parsed) {
+        if (Array.isArray(filter)) {
+          const orParts = filter.map(parseOneFacetFilter).filter(Boolean);
+          if (orParts.length > 0) {
+            conditions.push(`(${orParts.join(" || ")})`);
+          }
+        } else {
+          const part = parseOneFacetFilter(filter);
+          if (part) conditions.push(part);
+        }
+      }
+      if (conditions.length > 0) {
+        parts.push(conditions.join(" && "));
+      }
+    } catch {
+    }
+  }
+  if (numericFilters) {
+    try {
+      const parsed = JSON.parse(numericFilters);
+      const conditions = parsed.map((f) => {
+        const match = f.match(/^(\w+)\s*(>=|<=|>|<|=|!=)\s*(.+)$/);
+        if (match) {
+          const [, field, op, val] = match;
+          return `${field}:${op}${val}`;
+        }
+        return null;
+      }).filter(Boolean);
+      if (conditions.length > 0) {
+        parts.push(conditions.join(" && "));
+      }
+    } catch {
+    }
+  }
+  return parts.length > 0 ? parts.join(" && ") : void 0;
+}
+function parseOneFacetFilter(filter) {
+  const negated = filter.startsWith("-");
+  const clean = negated ? filter.slice(1) : filter;
+  const colonIdx = clean.indexOf(":");
+  if (colonIdx === -1) return null;
+  const field = clean.slice(0, colonIdx);
+  const value = clean.slice(colonIdx + 1);
+  if (negated) {
+    return `${field}:!=${value}`;
+  }
+  return `${field}:=${value}`;
+}
+function transformAlgoliaRequestToTypesense(request, resolvedCollection) {
+  const params = parseAlgoliaParams(request.params);
+  const query = params["query"] ?? "";
+  const hitsPerPage = parseInt(params["hitsPerPage"] ?? "20", 10);
+  const page = parseInt(params["page"] ?? "0", 10);
+  const result = {
+    collection: resolvedCollection,
+    q: query || "*",
+    per_page: hitsPerPage,
+    page: page + 1,
+    // Algolia is 0-based, Typesense is 1-based
+    highlight_start_tag: "<mark>",
+    highlight_end_tag: "</mark>"
+  };
+  if (params["facets"]) {
+    try {
+      const facets = JSON.parse(params["facets"]);
+      if (facets.length > 0) {
+        result.facet_by = facets.join(",");
+      }
+    } catch {
+      result.facet_by = params["facets"];
+    }
+  }
+  if (params["maxValuesPerFacet"]) {
+    result.max_facet_values = parseInt(params["maxValuesPerFacet"], 10);
+  }
+  const filterBy = transformAlgoliaFilters(
+    params["facetFilters"],
+    params["numericFilters"],
+    params["filters"]
+  );
+  if (filterBy) {
+    result.filter_by = filterBy;
+  }
+  if (params["restrictSearchableAttributes"]) {
+    try {
+      const attrs = JSON.parse(params["restrictSearchableAttributes"]);
+      result.query_by = attrs.join(",");
+    } catch {
+      result.query_by = params["restrictSearchableAttributes"];
+    }
+  }
+  if (params["sortBy"]) {
+    result.sort_by = params["sortBy"];
+  }
+  return result;
+}
+function transformHighlights(highlights, document) {
+  const result = {};
+  for (const [key, value] of Object.entries(document)) {
+    if (key === "id") continue;
+    result[key] = {
+      value: String(value ?? ""),
+      matchLevel: "none",
+      matchedWords: []
+    };
+  }
+  if (highlights) {
+    for (const hl of highlights) {
+      const snippetValue = hl.snippet ?? hl.value ?? "";
+      const matchedTokens = hl.matched_tokens ?? [];
+      if (hl.snippets && hl.snippets.length > 0) {
+        const firstSnippet = hl.snippets[0];
+        if (firstSnippet) {
+          result[hl.field] = {
+            value: firstSnippet.value,
+            matchLevel: (firstSnippet.matched_tokens?.length ?? 0) > 0 ? "full" : "none",
+            matchedWords: firstSnippet.matched_tokens ?? []
+          };
+          continue;
+        }
+      }
+      result[hl.field] = {
+        value: snippetValue,
+        matchLevel: matchedTokens.length > 0 ? "full" : "none",
+        matchedWords: matchedTokens
+      };
+    }
+  }
+  return result;
+}
+function transformHit(hit) {
+  const document = hit.document;
+  const id = document["id"];
+  return {
+    ...document,
+    objectID: String(id ?? ""),
+    _highlightResult: transformHighlights(hit.highlights, document)
+  };
+}
+function transformFacets(facetCounts) {
+  const facets = {};
+  const facetsStats = {};
+  if (!facetCounts) {
+    return { facets, facets_stats: facetsStats };
+  }
+  for (const facet of facetCounts) {
+    const values = {};
+    for (const count of facet.counts) {
+      values[count.value] = count.count;
+    }
+    facets[facet.field_name] = values;
+    if (facet.stats) {
+      facetsStats[facet.field_name] = facet.stats;
+    }
+  }
+  return { facets, facets_stats: facetsStats };
+}
+function transformTypesenseResponseToAlgolia(tsResponse, originalRequest) {
+  const params = parseAlgoliaParams(originalRequest.params);
+  const hitsPerPage = parseInt(params["hitsPerPage"] ?? "20", 10);
+  const page = parseInt(params["page"] ?? "0", 10);
+  const query = params["query"] ?? "";
+  const hits = (tsResponse.hits ?? []).map(transformHit);
+  const { facets, facets_stats } = transformFacets(tsResponse.facet_counts);
+  const nbHits = tsResponse.found ?? 0;
+  const nbPages = nbHits > 0 ? Math.ceil(nbHits / hitsPerPage) : 0;
+  const paramsString = typeof originalRequest.params === "string" ? originalRequest.params : new URLSearchParams(Object.entries(params)).toString();
+  return {
+    hits,
+    nbHits,
+    page,
+    nbPages,
+    hitsPerPage,
+    processingTimeMS: tsResponse.search_time_ms,
+    query,
+    params: paramsString,
+    facets,
+    facets_stats,
+    exhaustiveNbHits: true
+  };
+}
+function transformMultiSearchResponse(tsResponse, originalRequests) {
+  return {
+    results: tsResponse.results.map((result, i) => {
+      const originalRequest = originalRequests[i];
+      if (!originalRequest) {
+        return transformTypesenseResponseToAlgolia(result, { indexName: "", params: "" });
+      }
+      return transformTypesenseResponseToAlgolia(result, originalRequest);
+    })
+  };
+}
+
+// src/lib/typesense.ts
+import { Client } from "typesense";
+var client = null;
+function getTypesenseClient(config) {
+  if (!client) {
+    client = new Client({
+      nodes: [
+        {
+          host: config.typesense.host,
+          port: config.typesense.port,
+          protocol: config.typesense.protocol
+        }
+      ],
+      apiKey: config.typesense.apiKey,
+      connectionTimeoutSeconds: 5
+    });
+  }
+  return client;
+}
+
+// src/proxy-config.ts
+function defineConfig(config) {
+  return config;
+}
+function proxyConfigToConfig(proxyConfig) {
+  const collectionsConfig = { collections: {} };
+  if (proxyConfig.collections) {
+    for (const [name, def] of Object.entries(proxyConfig.collections)) {
+      if (def.locales && def.locales.length > 0) {
+        const localeMap = {};
+        for (const locale of def.locales) {
+          localeMap[locale] = `${name}_${locale}`;
+        }
+        collectionsConfig.collections[name] = { locales: localeMap };
+      } else {
+        collectionsConfig.collections[name] = {};
+      }
+    }
+  }
+  return {
+    typesense: {
+      host: proxyConfig.typesense?.host || process.env["TYPESENSE_HOST"] || "localhost",
+      port: proxyConfig.typesense?.port || parseInt(process.env["TYPESENSE_PORT"] || "8108", 10),
+      protocol: proxyConfig.typesense?.protocol || process.env["TYPESENSE_PROTOCOL"] || "http",
+      apiKey: proxyConfig.typesense?.apiKey || process.env["TYPESENSE_API_KEY"] || ""
+    },
+    proxy: {
+      port: proxyConfig.server?.port || parseInt(process.env["PROXY_PORT"] || "3000", 10),
+      apiKey: proxyConfig.server?.apiKey || process.env["PROXY_API_KEY"] || ""
+    },
+    cache: {
+      ttl: proxyConfig.cache?.ttl ?? parseInt(process.env["CACHE_TTL"] || "60", 10),
+      maxSize: proxyConfig.cache?.maxSize ?? parseInt(process.env["CACHE_MAX_SIZE"] || "1000", 10)
+    },
+    queue: {
+      concurrency: proxyConfig.queue?.concurrency ?? parseInt(process.env["QUEUE_CONCURRENCY"] || "5", 10),
+      maxSize: proxyConfig.queue?.maxSize ?? parseInt(process.env["QUEUE_MAX_SIZE"] || "10000", 10),
+      ...proxyConfig.queue?.redis || process.env["REDIS_HOST"] ? {
+        redis: {
+          host: proxyConfig.queue?.redis?.host || process.env["REDIS_HOST"] || "localhost",
+          port: proxyConfig.queue?.redis?.port || parseInt(process.env["REDIS_PORT"] || "6379", 10)
+        }
+      } : {}
+    },
+    rateLimit: {
+      search: proxyConfig.rateLimit?.search ?? parseInt(process.env["RATE_LIMIT_SEARCH"] || "100", 10),
+      ingest: proxyConfig.rateLimit?.ingest ?? parseInt(process.env["RATE_LIMIT_INGEST"] || "30", 10)
+    },
+    collections: collectionsConfig
+  };
+}
+function getSearchableFields(def) {
+  return Object.entries(def.fields).filter(([_, field]) => field.searchable).map(([name]) => name);
+}
+function getFacetFields(def) {
+  return Object.entries(def.fields).filter(([_, field]) => field.facet).map(([name]) => name);
+}
+function getSortableFields(def) {
+  return Object.entries(def.fields).filter(([_, field]) => field.sortable).map(([name]) => name);
+}
+function toTypesenseSchema(name, def) {
+  return {
+    name,
+    fields: Object.entries(def.fields).map(([fieldName, field]) => {
+      const f = {
+        name: fieldName,
+        type: field.type
+      };
+      if (field.facet) f.facet = true;
+      if (field.optional) f.optional = true;
+      if (field.sortable && !["int32", "int64", "float", "bool"].includes(field.type)) {
+        f.sort = true;
+      }
+      if (field.infix) f.infix = true;
+      if (field.locale) f.locale = field.locale;
+      return f;
+    }),
+    ...def.defaultSortBy ? { default_sorting_field: def.defaultSortBy } : {},
+    ...def.tokenSeparators ? { token_separators: def.tokenSeparators } : {},
+    ...def.symbolsToIndex ? { symbols_to_index: def.symbolsToIndex } : {},
+    ...def.enableNestedFields ? { enable_nested_fields: true } : {}
+  };
+}
+function getComputedFields(def) {
+  return Object.entries(def.fields).filter(([_, field]) => field.compute !== void 0).map(([name, field]) => ({ name, compute: field.compute }));
+}
+function applyComputedFields(doc, collectionDef, locale) {
+  const computedFields = getComputedFields(collectionDef);
+  if (computedFields.length === 0) return doc;
+  const result = { ...doc };
+  for (const { name, compute } of computedFields) {
+    try {
+      result[name] = compute(result, locale);
+    } catch (error) {
+      console.warn(`Computed field '${name}' failed:`, error);
+    }
+  }
+  return result;
+}
+function applyComputedFieldsBatch(docs, collectionDef, locale) {
+  const computedFields = getComputedFields(collectionDef);
+  if (computedFields.length === 0) return docs;
+  return docs.map((doc) => applyComputedFields(doc, collectionDef, locale));
+}
+
+// src/routes/search.ts
+function createSearchRoutes(config, collectionDefs) {
+  const app = new Hono();
+  const cache = new LRUCache({ maxSize: config.cache.maxSize, ttl: config.cache.ttl });
+  const typesense = getTypesenseClient(config);
+  const rateLimitMap = /* @__PURE__ */ new Map();
+  const rateLimit = config.rateLimit.search;
+  function checkRateLimit(ip) {
+    const now = Date.now();
+    const entry = rateLimitMap.get(ip);
+    if (!entry || now > entry.resetAt) {
+      rateLimitMap.set(ip, { count: 1, resetAt: now + 6e4 });
+      return true;
+    }
+    if (entry.count >= rateLimit) {
+      return false;
+    }
+    entry.count++;
+    return true;
+  }
+  app.post("/api/search", async (c) => {
+    const ip = c.req.header("x-forwarded-for") ?? c.req.header("x-real-ip") ?? "unknown";
+    if (!checkRateLimit(ip)) {
+      return c.json({ error: "Rate limit exceeded" }, 429);
+    }
+    const body = await c.req.json();
+    if (!body.requests || !Array.isArray(body.requests)) {
+      return c.json({ error: "Invalid request: 'requests' array is required" }, 400);
+    }
+    const locale = c.req.header("X-Locale") ?? c.req.query("locale") ?? void 0;
+    const cacheKey = JSON.stringify({ requests: body.requests, locale });
+    const cached = cache.get(cacheKey);
+    if (cached) {
+      return c.json(cached);
+    }
+    const searches = body.requests.map((req) => {
+      const resolvedCollection = resolveCollection(config.collections, req.indexName, locale);
+      const tsParams = transformAlgoliaRequestToTypesense(req, resolvedCollection);
+      if (!tsParams.query_by && collectionDefs) {
+        const def = collectionDefs[req.indexName];
+        if (def) {
+          const searchableFields = getSearchableFields(def);
+          if (searchableFields.length > 0) {
+            tsParams.query_by = searchableFields.join(",");
+          }
+        }
+      }
+      return tsParams;
+    });
+    let tsResponse;
+    try {
+      tsResponse = await typesense.multiSearch.perform(
+        { searches },
+        {}
+      );
+    } catch (err) {
+      console.error("[search] Typesense request failed:", err.message);
+      return c.json({ error: "Search backend unavailable" }, 502);
+    }
+    const errors = [];
+    for (const result of tsResponse.results) {
+      if ("error" in result && result.error) {
+        errors.push(String(result.error));
+      }
+    }
+    const algoliaResponse = transformMultiSearchResponse(tsResponse, body.requests);
+    if (errors.length > 0) {
+      algoliaResponse._errors = errors;
+    }
+    if (errors.length === 0) {
+      cache.set(cacheKey, algoliaResponse);
+    }
+    return c.json(algoliaResponse);
+  });
+  return { app, cache };
+}
+
+// src/routes/ingest.ts
+import { Hono as Hono2 } from "hono";
+
+// src/lib/queue.ts
+import { Queue, Worker } from "bullmq";
+var IngestionQueue = class {
+  concurrency;
+  maxSize;
+  backend = "memory";
+  // BullMQ (Redis) state
+  bullQueue = null;
+  bullWorker = null;
+  jobHandlers = /* @__PURE__ */ new Map();
+  // In-memory fallback state
+  memPending = [];
+  memActiveCount = 0;
+  memCompletedCount = 0;
+  memFailedCount = 0;
+  constructor(options) {
+    this.concurrency = options.concurrency;
+    this.maxSize = options.maxSize;
+    if (options.redis) {
+      this.initRedis(options.redis);
+    }
+  }
+  initRedis(redis) {
+    const connection = {
+      host: redis.host || "localhost",
+      port: redis.port || 6379
+    };
+    try {
+      this.bullQueue = new Queue("tsproxy:ingest", { connection });
+      this.bullWorker = new Worker(
+        "tsproxy:ingest",
+        async (job) => {
+          const handler = this.jobHandlers.get(job.id);
+          if (!handler) {
+            throw new Error(`No handler for job ${job.id}`);
+          }
+          try {
+            const result = await handler.fn();
+            handler.resolve(result);
+            return result;
+          } catch (err) {
+            handler.reject(err);
+            throw err;
+          } finally {
+            this.jobHandlers.delete(job.id);
+          }
+        },
+        { connection, concurrency: this.concurrency }
+      );
+      this.bullWorker.on("error", (err) => {
+        console.warn("[queue] BullMQ worker error, falling back to memory:", err.message);
+        this.fallbackToMemory();
+      });
+      this.bullQueue.on("error", (err) => {
+        console.warn("[queue] BullMQ queue error, falling back to memory:", err.message);
+        this.fallbackToMemory();
+      });
+      this.backend = "redis";
+      console.log(`[queue] Using Redis at ${connection.host}:${connection.port}`);
+    } catch (err) {
+      console.warn("[queue] Failed to connect to Redis, using in-memory queue:", err.message);
+      this.backend = "memory";
+    }
+  }
+  fallbackToMemory() {
+    if (this.backend === "memory") return;
+    this.backend = "memory";
+    for (const [, handler] of this.jobHandlers) {
+      handler.reject(new Error("Queue backend switched to memory"));
+    }
+    this.jobHandlers.clear();
+    this.bullWorker?.close().catch(() => {
+    });
+    this.bullQueue?.close().catch(() => {
+    });
+    this.bullWorker = null;
+    this.bullQueue = null;
+    console.log("[queue] Fell back to in-memory queue");
+  }
+  async enqueue(fn) {
+    if (this.backend === "redis" && this.bullQueue) {
+      return this.enqueueRedis(fn);
+    }
+    return this.enqueueMemory(fn);
+  }
+  async enqueueRedis(fn) {
+    const count = await this.bullQueue.getJobCountByTypes("waiting", "active");
+    if (count >= this.maxSize) {
+      const error = new Error("Queue is full");
+      error.status = 429;
+      throw error;
+    }
+    return new Promise((resolve2, reject) => {
+      const jobId = `ingest-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      this.jobHandlers.set(jobId, {
+        fn,
+        resolve: resolve2,
+        reject
+      });
+      this.bullQueue.add("ingest", {}, { jobId }).catch((err) => {
+        this.jobHandlers.delete(jobId);
+        reject(err);
+      });
+    });
+  }
+  async enqueueMemory(fn) {
+    if (this.memPending.length >= this.maxSize) {
+      const error = new Error("Queue is full");
+      error.status = 429;
+      throw error;
+    }
+    return new Promise((resolve2, reject) => {
+      this.memPending.push({
+        fn,
+        resolve: resolve2,
+        reject
+      });
+      this.processMemory();
+    });
+  }
+  async stats() {
+    if (this.backend === "redis" && this.bullQueue) {
+      const counts = await this.bullQueue.getJobCounts("waiting", "active", "completed", "failed");
+      return {
+        pending: counts.waiting || 0,
+        active: counts.active || 0,
+        completed: counts.completed || 0,
+        failed: counts.failed || 0,
+        maxSize: this.maxSize,
+        concurrency: this.concurrency,
+        backend: "redis"
+      };
+    }
+    return {
+      pending: this.memPending.length,
+      active: this.memActiveCount,
+      completed: this.memCompletedCount,
+      failed: this.memFailedCount,
+      maxSize: this.maxSize,
+      concurrency: this.concurrency,
+      backend: "memory"
+    };
+  }
+  async close() {
+    await this.bullWorker?.close();
+    await this.bullQueue?.close();
+  }
+  processMemory() {
+    while (this.memActiveCount < this.concurrency && this.memPending.length > 0) {
+      const item = this.memPending.shift();
+      if (!item) break;
+      this.memActiveCount++;
+      item.fn().then((result) => {
+        this.memCompletedCount++;
+        item.resolve(result);
+      }).catch((error) => {
+        this.memFailedCount++;
+        item.reject(error);
+      }).finally(() => {
+        this.memActiveCount--;
+        this.processMemory();
+      });
+    }
+  }
+};
+
+// src/middleware/auth.ts
+function authMiddleware(proxyApiKey) {
+  return async (c, next) => {
+    if (!proxyApiKey) {
+      return c.json({ error: "Server misconfiguration: PROXY_API_KEY not set" }, 500);
+    }
+    const apiKey = c.req.header("X-API-Key");
+    if (!apiKey) {
+      return c.json({ error: "Missing X-API-Key header" }, 401);
+    }
+    if (apiKey !== proxyApiKey) {
+      return c.json({ error: "Invalid API key" }, 401);
+    }
+    await next();
+  };
+}
+
+// src/routes/ingest.ts
+function createIngestRoutes(config, collectionDefs) {
+  const app = new Hono2();
+  const queue = new IngestionQueue({
+    concurrency: config.queue.concurrency,
+    maxSize: config.queue.maxSize,
+    redis: config.queue.redis
+  });
+  const typesense = getTypesenseClient(config);
+  const rateLimitMap = /* @__PURE__ */ new Map();
+  const rateLimit = config.rateLimit.ingest;
+  function checkRateLimit(ip) {
+    const now = Date.now();
+    const entry = rateLimitMap.get(ip);
+    if (!entry || now > entry.resetAt) {
+      rateLimitMap.set(ip, { count: 1, resetAt: now + 6e4 });
+      return true;
+    }
+    if (entry.count >= rateLimit) {
+      return false;
+    }
+    entry.count++;
+    return true;
+  }
+  app.use("/api/ingest/*", authMiddleware(config.proxy.apiKey));
+  app.use("/api/ingest/:collection/documents/*", async (c, next) => {
+    const ip = c.req.header("x-forwarded-for") ?? c.req.header("x-real-ip") ?? "unknown";
+    if (!checkRateLimit(ip)) {
+      return c.json({ error: "Rate limit exceeded" }, 429);
+    }
+    await next();
+  });
+  app.use("/api/ingest/:collection/documents", async (c, next) => {
+    if (c.req.method === "POST" || c.req.method === "DELETE") {
+      const ip = c.req.header("x-forwarded-for") ?? c.req.header("x-real-ip") ?? "unknown";
+      if (!checkRateLimit(ip)) {
+        return c.json({ error: "Rate limit exceeded" }, 429);
+      }
+    }
+    await next();
+  });
+  function getLocale(c) {
+    return c.req.header("X-Locale") ?? c.req.query("locale") ?? void 0;
+  }
+  function getCollectionDef(collectionName) {
+    return collectionDefs?.[collectionName];
+  }
+  function processDoc(doc, collectionName, locale) {
+    const def = getCollectionDef(collectionName);
+    if (!def) return doc;
+    return applyComputedFields(doc, def, locale);
+  }
+  function processDocs(docs, collectionName, locale) {
+    const def = getCollectionDef(collectionName);
+    if (!def) return docs;
+    return applyComputedFieldsBatch(docs, def, locale);
+  }
+  app.post("/api/ingest/:collection/documents", async (c) => {
+    const collectionName = c.req.param("collection");
+    if (!collectionName) {
+      return c.json({ error: "Collection name is required" }, 400);
+    }
+    const locale = getLocale(c);
+    const resolved = resolveCollection(config.collections, collectionName, locale);
+    const body = await c.req.json();
+    const processed = processDoc(body, collectionName, locale);
+    const result = await queue.enqueue(async () => {
+      return typesense.collections(resolved).documents().upsert(processed);
+    });
+    return c.json(result, 201);
+  });
+  app.post("/api/ingest/:collection/documents/import", async (c) => {
+    const collectionName = c.req.param("collection");
+    if (!collectionName) {
+      return c.json({ error: "Collection name is required" }, 400);
+    }
+    const locale = getLocale(c);
+    const resolved = resolveCollection(config.collections, collectionName, locale);
+    const documents = await c.req.json();
+    if (!Array.isArray(documents)) {
+      return c.json({ error: "Request body must be a JSON array" }, 400);
+    }
+    const processed = processDocs(documents, collectionName, locale);
+    const result = await queue.enqueue(async () => {
+      return typesense.collections(resolved).documents().import(processed, { action: "upsert" });
+    });
+    return c.json(result);
+  });
+  app.patch("/api/ingest/:collection/documents/:id", async (c) => {
+    const collectionName = c.req.param("collection");
+    const docId = c.req.param("id");
+    if (!collectionName || !docId) {
+      return c.json({ error: "Collection name and document ID are required" }, 400);
+    }
+    const locale = getLocale(c);
+    const resolved = resolveCollection(config.collections, collectionName, locale);
+    const body = await c.req.json();
+    const processed = processDoc(body, collectionName, locale);
+    const result = await queue.enqueue(async () => {
+      return typesense.collections(resolved).documents(docId).update(processed);
+    });
+    return c.json(result);
+  });
+  app.delete("/api/ingest/:collection/documents/:id", async (c) => {
+    const collectionName = c.req.param("collection");
+    const docId = c.req.param("id");
+    if (!collectionName || !docId) {
+      return c.json({ error: "Collection name and document ID are required" }, 400);
+    }
+    const locale = getLocale(c);
+    const resolved = resolveCollection(config.collections, collectionName, locale);
+    const result = await queue.enqueue(async () => {
+      return typesense.collections(resolved).documents(docId).delete();
+    });
+    return c.json(result);
+  });
+  app.delete("/api/ingest/:collection/documents", async (c) => {
+    const collectionName = c.req.param("collection");
+    if (!collectionName) {
+      return c.json({ error: "Collection name is required" }, 400);
+    }
+    const filterBy = c.req.query("filter_by");
+    if (!filterBy) {
+      return c.json({ error: "filter_by query parameter is required" }, 400);
+    }
+    const locale = getLocale(c);
+    const resolved = resolveCollection(config.collections, collectionName, locale);
+    const result = await queue.enqueue(async () => {
+      return typesense.collections(resolved).documents().delete({ filter_by: filterBy });
+    });
+    return c.json(result);
+  });
+  app.get("/api/ingest/queue/status", async (c) => {
+    return c.json(await queue.stats());
+  });
+  return { app, queue };
+}
+
+// src/routes/health.ts
+import { Hono as Hono3 } from "hono";
+function createHealthRoutes(config) {
+  const app = new Hono3();
+  const typesense = getTypesenseClient(config);
+  app.get("/api/health", async (c) => {
+    let typesenseStatus = "error";
+    let typesenseMessage = "";
+    try {
+      const health = await typesense.health.retrieve();
+      typesenseStatus = health.ok ? "ok" : "error";
+    } catch (err) {
+      typesenseMessage = err instanceof Error ? err.message : "Unknown error";
+    }
+    let redisStatus = "not_configured";
+    let redisMessage = "";
+    if (config.queue.redis) {
+      const { host, port } = config.queue.redis;
+      try {
+        const net = await import("net");
+        await new Promise((resolve2, reject) => {
+          const socket = net.createConnection({ host, port }, () => {
+            socket.end();
+            resolve2();
+          });
+          socket.on("error", reject);
+          socket.setTimeout(2e3, () => {
+            socket.destroy();
+            reject(new Error("Connection timeout"));
+          });
+        });
+        redisStatus = "ok";
+      } catch (err) {
+        redisStatus = "error";
+        redisMessage = err instanceof Error ? err.message : "Unknown error";
+      }
+    }
+    const allOk = typesenseStatus === "ok" && redisStatus !== "error";
+    const status = allOk ? 200 : 503;
+    return c.json(
+      {
+        status: allOk ? "healthy" : "degraded",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        proxy: { status: "ok" },
+        typesense: {
+          status: typesenseStatus,
+          host: `${config.typesense.protocol}://${config.typesense.host}:${config.typesense.port}`,
+          ...typesenseMessage && { error: typesenseMessage }
+        },
+        redis: {
+          status: redisStatus,
+          ...config.queue.redis && {
+            host: `${config.queue.redis.host}:${config.queue.redis.port}`
+          },
+          ...redisMessage && { error: redisMessage }
+        }
+      },
+      status
+    );
+  });
+  return app;
+}
+
+// src/routes/docs.ts
+import { Hono as Hono4 } from "hono";
+var OPENAPI_SPEC = {
+  openapi: "3.1.0",
+  info: {
+    title: "Typesense Proxy API",
+    description: "A proxy server for Typesense with Algolia-compatible search, caching, rate limiting, and ingestion queue.",
+    version: "0.1.0"
+  },
+  paths: {
+    "/api/search": {
+      post: {
+        summary: "Multi-search (Algolia-compatible)",
+        description: "Accepts Algolia InstantSearch multi-search format, transforms to Typesense, and returns Algolia-formatted results.",
+        tags: ["Search"],
+        parameters: [
+          {
+            name: "X-Locale",
+            in: "header",
+            description: "Locale for multilingual collection routing",
+            schema: { type: "string" }
+          },
+          {
+            name: "locale",
+            in: "query",
+            description: "Locale for multilingual collection routing (alternative to header)",
+            schema: { type: "string" }
+          }
+        ],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                required: ["requests"],
+                properties: {
+                  requests: {
+                    type: "array",
+                    items: {
+                      type: "object",
+                      required: ["indexName", "params"],
+                      properties: {
+                        indexName: { type: "string", description: "Collection/index name" },
+                        params: { type: "string", description: "URL-encoded search parameters" }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        responses: {
+          "200": { description: "Algolia-formatted search results" },
+          "429": { description: "Rate limit exceeded" }
+        }
+      }
+    },
+    "/api/ingest/{collection}/documents": {
+      post: {
+        summary: "Upsert a single document",
+        tags: ["Ingest"],
+        security: [{ apiKey: [] }],
+        parameters: [
+          { name: "collection", in: "path", required: true, schema: { type: "string" } },
+          { name: "X-Locale", in: "header", schema: { type: "string" } }
+        ],
+        requestBody: {
+          required: true,
+          content: { "application/json": { schema: { type: "object" } } }
+        },
+        responses: {
+          "201": { description: "Document upserted" },
+          "401": { description: "Unauthorized" },
+          "429": { description: "Rate limit or queue full" }
+        }
+      },
+      delete: {
+        summary: "Delete documents by filter",
+        tags: ["Ingest"],
+        security: [{ apiKey: [] }],
+        parameters: [
+          { name: "collection", in: "path", required: true, schema: { type: "string" } },
+          { name: "filter_by", in: "query", required: true, schema: { type: "string" } }
+        ],
+        responses: {
+          "200": { description: "Documents deleted" },
+          "401": { description: "Unauthorized" }
+        }
+      }
+    },
+    "/api/ingest/{collection}/documents/import": {
+      post: {
+        summary: "Bulk import documents",
+        tags: ["Ingest"],
+        security: [{ apiKey: [] }],
+        parameters: [
+          { name: "collection", in: "path", required: true, schema: { type: "string" } }
+        ],
+        requestBody: {
+          required: true,
+          content: { "application/json": { schema: { type: "array", items: { type: "object" } } } }
+        },
+        responses: {
+          "200": { description: "Import results" },
+          "401": { description: "Unauthorized" }
+        }
+      }
+    },
+    "/api/ingest/{collection}/documents/{id}": {
+      patch: {
+        summary: "Partial update a document",
+        tags: ["Ingest"],
+        security: [{ apiKey: [] }],
+        parameters: [
+          { name: "collection", in: "path", required: true, schema: { type: "string" } },
+          { name: "id", in: "path", required: true, schema: { type: "string" } }
+        ],
+        requestBody: {
+          required: true,
+          content: { "application/json": { schema: { type: "object" } } }
+        },
+        responses: {
+          "200": { description: "Document updated" },
+          "401": { description: "Unauthorized" }
+        }
+      },
+      delete: {
+        summary: "Delete a single document",
+        tags: ["Ingest"],
+        security: [{ apiKey: [] }],
+        parameters: [
+          { name: "collection", in: "path", required: true, schema: { type: "string" } },
+          { name: "id", in: "path", required: true, schema: { type: "string" } }
+        ],
+        responses: {
+          "200": { description: "Document deleted" },
+          "401": { description: "Unauthorized" }
+        }
+      }
+    },
+    "/api/ingest/queue/status": {
+      get: {
+        summary: "Get ingestion queue status",
+        tags: ["Ingest"],
+        security: [{ apiKey: [] }],
+        responses: {
+          "200": { description: "Queue statistics" },
+          "401": { description: "Unauthorized" }
+        }
+      }
+    },
+    "/api/health": {
+      get: {
+        summary: "Health check",
+        tags: ["System"],
+        responses: {
+          "200": { description: "System healthy" },
+          "503": { description: "System degraded" }
+        }
+      }
+    }
+  },
+  components: {
+    securitySchemes: {
+      apiKey: {
+        type: "apiKey",
+        in: "header",
+        name: "X-API-Key"
+      }
+    }
+  }
+};
+function createDocsRoutes() {
+  const app = new Hono4();
+  app.get("/api/openapi.json", (c) => {
+    return c.json(OPENAPI_SPEC);
+  });
+  app.get("/api/docs", (c) => {
+    const html = `<!DOCTYPE html>
+<html>
+<head>
+  <title>Typesense Proxy API - Documentation</title>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+</head>
+<body>
+  <script id="api-reference" data-url="/api/openapi.json"></script>
+  <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
+</body>
+</html>`;
+    return c.html(html);
+  });
+  return app;
+}
+
+// src/index.ts
+function createApp(config, collectionDefs) {
+  const cfg = config ?? loadConfig();
+  const app = new Hono5();
+  app.use("*", cors());
+  app.use("*", logger());
+  app.onError(errorHandler);
+  const { app: searchApp, cache: searchCache } = createSearchRoutes(cfg, collectionDefs);
+  const { app: ingestApp, queue: ingestQueue } = createIngestRoutes(cfg, collectionDefs);
+  const healthApp = createHealthRoutes(cfg);
+  const docsApp = createDocsRoutes();
+  app.route("/", searchApp);
+  app.route("/", ingestApp);
+  app.route("/", healthApp);
+  app.route("/", docsApp);
+  return { app, config: cfg, searchCache, ingestQueue };
+}
+
+export {
+  loadConfig,
+  resolveCollection,
+  LRUCache,
+  transformAlgoliaRequestToTypesense,
+  transformTypesenseResponseToAlgolia,
+  transformMultiSearchResponse,
+  defineConfig,
+  proxyConfigToConfig,
+  getSearchableFields,
+  getFacetFields,
+  getSortableFields,
+  toTypesenseSchema,
+  getComputedFields,
+  applyComputedFields,
+  applyComputedFieldsBatch,
+  IngestionQueue,
+  createApp
+};