@voltro/plugin-search 0.1.0

package/dist/index.js

@@ -0,0 +1,623 @@
+import { queryDescriptor as e, searchRpcClientImports as t } from "./rpc.js";
+import { Data as n, Effect as r } from "effect";
+import { definePlugin as i } from "@voltro/protocol";
+import { and as a, eq as o, id as s, integer as c, table as l, text as u, timestamp as d } from "@voltro/database";
+//#region src/backend.ts
+var f = class extends n.TaggedError("SearchBackendError") {}, p = (e) => Array.isArray(e) ? e : [e], m = (e, t, n) => {
+	if (Math.abs(e.length - t.length) > n) return !1;
+	if (e === t) return !0;
+	let r = t.length, i = Array.from({ length: r + 1 }, (e, t) => t);
+	for (let a = 1; a <= e.length; a++) {
+		let o = Array(r + 1);
+		o[0] = a;
+		let s = a, c = e.charCodeAt(a - 1);
+		for (let e = 1; e <= r; e++) {
+			let n = c === t.charCodeAt(e - 1) ? 0 : 1, r = Math.min((i[e] ?? 0) + 1, (o[e - 1] ?? 0) + 1, (i[e - 1] ?? 0) + n);
+			o[e] = r, r < s && (s = r);
+		}
+		if (s > n) return !1;
+		i = o;
+	}
+	return (i[r] ?? Infinity) <= n;
+}, h = (e) => e.length <= 4 ? 1 : 2, g = () => {
+	let e = /* @__PURE__ */ new Map(), t = (t) => {
+		let n = e.get(t);
+		return n || (n = /* @__PURE__ */ new Map(), e.set(t, n)), n;
+	}, n = (e, t) => {
+		let n = e[t.field];
+		switch (t.op) {
+			case "eq": return String(n) === String(t.value);
+			case "neq": return String(n) !== String(t.value);
+			case "in": return p(t.value).some((e) => String(n) === String(e));
+			case "nin": return p(t.value).every((e) => String(n) !== String(e));
+			case "gt":
+			case "gte":
+			case "lt":
+			case "lte": {
+				let [e, r] = [_(n), _(t.value)];
+				return e === void 0 || r === void 0 ? !1 : t.op === "gt" ? e > r : t.op === "gte" ? e >= r : t.op === "lt" ? e < r : e <= r;
+			}
+		}
+	}, r = (e, t) => !t || t.every((t) => n(e, t)), i = (e) => Object.entries(e).filter(([e]) => e !== "id").map(([e, t]) => [e, String(t)]), a = (e, t, n) => {
+		if (t.length === 0) return !0;
+		for (let [, r] of i(e)) {
+			let e = r.toLowerCase();
+			if (e.includes(t)) return !0;
+			if (n !== void 0 && n !== 0) {
+				let r = n === "auto" ? h(t) : n;
+				for (let n of e.split(/\s+/)) if (m(n, t, r)) return !0;
+			}
+		}
+		return !1;
+	}, o = (e, t, n) => {
+		if (t.length === 0) return {};
+		let r = n.preTag ?? "<mark>", a = n.postTag ?? "</mark>", o = n.fields && n.fields.length > 0 ? new Set(n.fields) : null, s = {}, c = new RegExp(t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi");
+		for (let [n, l] of i(e)) o && !o.has(n) || l.toLowerCase().includes(t) && (s[n] = l.replace(c, (e) => `${r}${e}${a}`));
+		return s;
+	};
+	return {
+		upsert: async (e, n) => {
+			let r = t(e);
+			for (let e of n) r.set(e.id, e);
+		},
+		remove: async (e, n) => {
+			let r = t(e);
+			for (let e of n) r.delete(e);
+		},
+		query: async (e, { q: n, limit: i, offset: s, filters: c, facets: l, highlight: u, fuzziness: d }) => {
+			let f = n.trim().toLowerCase(), p = [];
+			for (let n of t(e).values()) r(n, c) && a(n, f, d) && p.push(n);
+			let m = {};
+			if (l) for (let e of l) {
+				let t = {};
+				for (let n of p) {
+					let r = n[e];
+					if (r == null) continue;
+					let i = String(r);
+					t[i] = (t[i] ?? 0) + 1;
+				}
+				m[e] = t;
+			}
+			let h = s ?? 0;
+			return {
+				hits: (i === void 0 ? p.slice(h) : p.slice(h, h + i)).map((e) => u ? {
+					doc: e,
+					highlights: o(e, f, u)
+				} : { doc: e }),
+				facets: m
+			};
+		}
+	};
+}, _ = (e) => {
+	if (typeof e == "number") return e;
+	if (typeof e == "boolean") return +!!e;
+	if (typeof e == "string") {
+		let t = Number(e);
+		if (!Number.isNaN(t) && e.trim() !== "") return t;
+		let n = Date.parse(e);
+		return Number.isNaN(n) ? void 0 : n;
+	}
+}, v = async (e, t, n) => {
+	try {
+		return await n();
+	} catch {
+		throw new f({
+			engine: t,
+			op: "query",
+			message: `the '${t}' search backend requires the '${e}' optional dependency. Install it to enable it (e.g. \`npm i ${e}\`).`,
+			transient: !1
+		});
+	}
+}, y = (e) => {
+	let t = (e) => JSON.stringify(e);
+	switch (e.op) {
+		case "eq": return `${e.field}:=${t(e.value)}`;
+		case "neq": return `${e.field}:!=${t(e.value)}`;
+		case "gt": return `${e.field}:>${t(e.value)}`;
+		case "gte": return `${e.field}:>=${t(e.value)}`;
+		case "lt": return `${e.field}:<${t(e.value)}`;
+		case "lte": return `${e.field}:<=${t(e.value)}`;
+		case "in": return `${e.field}:[${p(e.value).map(t).join(",")}]`;
+		case "nin": return `${e.field}:!=[${p(e.value).map(t).join(",")}]`;
+	}
+}, b = (e) => {
+	let t, n = async () => (t ||= v("typesense", "typesense", () => import("typesense")).then((t) => {
+		let n = t.Client;
+		return new n({
+			nodes: [{ url: e.url ?? e.host ?? "http://localhost:8108" }],
+			apiKey: e.apiKey
+		});
+	}), t), r = (e) => e && e.length > 0 ? e.map(y).join(" && ") : void 0, i = async (e, t) => {
+		try {
+			return await t();
+		} catch (t) {
+			throw t instanceof f ? t : new f({
+				engine: "typesense",
+				op: e,
+				message: String(t?.message ?? t),
+				transient: !0
+			});
+		}
+	};
+	return {
+		upsert: (e, t) => i("upsert", async () => {
+			await (await n()).collections(e).documents().import(t, { action: "upsert" });
+		}),
+		remove: (e, t) => i("remove", async () => {
+			await (await n()).collections(e).documents().delete({ filter_by: `id:[${t.map((e) => JSON.stringify(e)).join(",")}]` });
+		}),
+		query: (e, { q: t, limit: a, offset: o, filters: s, facets: c, highlight: l, fuzziness: u, engineParams: d }) => i("query", async () => {
+			let i = await n(), f = {
+				q: t || "*",
+				query_by: "*",
+				per_page: a ?? 20,
+				...o ? { offset: o } : {},
+				...r(s) ? { filter_by: r(s) } : {},
+				...c && c.length > 0 ? { facet_by: c.join(",") } : {},
+				...l ? {
+					...l.fields && l.fields.length > 0 ? { highlight_fields: l.fields.join(",") } : { highlight_full_fields: "*" },
+					...l.preTag ? { highlight_start_tag: l.preTag } : {},
+					...l.postTag ? { highlight_end_tag: l.postTag } : {}
+				} : {},
+				...u !== void 0 && u !== "auto" ? { num_typos: Math.min(2, Math.max(0, u)) } : {},
+				...d ?? {}
+			};
+			return x(await i.collections(e).documents().search(f));
+		})
+	};
+}, x = (e) => {
+	let t = (e.hits ?? []).map((e) => {
+		let t = {};
+		for (let n of e.highlights ?? []) {
+			let e = n.snippet ?? n.value;
+			e && (t[n.field] = e);
+		}
+		return Object.keys(t).length > 0 ? {
+			doc: e.document,
+			highlights: t
+		} : { doc: e.document };
+	}), n = {};
+	for (let t of e.facet_counts ?? []) n[t.field_name] = Object.fromEntries(t.counts.map((e) => [e.value, e.count]));
+	return {
+		hits: t,
+		facets: n
+	};
+}, S = (e) => {
+	let t = (e) => JSON.stringify(e);
+	switch (e.op) {
+		case "eq": return `${e.field} = ${t(e.value)}`;
+		case "neq": return `${e.field} != ${t(e.value)}`;
+		case "gt": return `${e.field} > ${t(e.value)}`;
+		case "gte": return `${e.field} >= ${t(e.value)}`;
+		case "lt": return `${e.field} < ${t(e.value)}`;
+		case "lte": return `${e.field} <= ${t(e.value)}`;
+		case "in": return `${e.field} IN [${p(e.value).map(t).join(", ")}]`;
+		case "nin": return `${e.field} NOT IN [${p(e.value).map(t).join(", ")}]`;
+	}
+}, C = (e) => {
+	let t, n = async () => (t ||= v("meilisearch", "meilisearch", () => import("meilisearch")).then((t) => new t.MeiliSearch({
+		host: e.host ?? e.url ?? "http://localhost:7700",
+		apiKey: e.apiKey
+	})), t), r = (e) => e && e.length > 0 ? e.map(S) : void 0, i = async (e, t) => {
+		try {
+			return await t();
+		} catch (t) {
+			throw t instanceof f ? t : new f({
+				engine: "meilisearch",
+				op: e,
+				message: String(t?.message ?? t),
+				transient: !0
+			});
+		}
+	};
+	return {
+		upsert: (e, t) => i("upsert", async () => {
+			await (await n()).index(e).addDocuments(t);
+		}),
+		remove: (e, t) => i("remove", async () => {
+			await (await n()).index(e).deleteDocuments([...t]);
+		}),
+		query: (e, { q: t, limit: a, offset: o, filters: s, facets: c, highlight: l, fuzziness: u, engineParams: d }) => i("query", async () => {
+			let i = {
+				limit: a ?? 20,
+				...o ? { offset: o } : {},
+				...r(s) ? { filter: r(s) } : {},
+				...c && c.length > 0 ? { facets: [...c] } : {},
+				...l ? {
+					attributesToHighlight: l.fields && l.fields.length > 0 ? [...l.fields] : ["*"],
+					...l.preTag ? { highlightPreTag: l.preTag } : {},
+					...l.postTag ? { highlightPostTag: l.postTag } : {}
+				} : {},
+				...u === 0 ? {
+					rankingScoreThreshold: void 0,
+					typoTolerance: { enabled: !1 }
+				} : {},
+				...d ?? {}
+			};
+			return w(await (await n()).index(e).search(t, i), l);
+		})
+	};
+}, w = (e, t) => ({
+	hits: e.hits.map((e) => {
+		let { _formatted: n, ...r } = e;
+		if (t && n) {
+			let e = {};
+			for (let [t, r] of Object.entries(n)) t !== "id" && (e[t] = String(r));
+			return Object.keys(e).length > 0 ? {
+				doc: r,
+				highlights: e
+			} : { doc: r };
+		}
+		return { doc: r };
+	}),
+	facets: e.facetDistribution ?? {}
+}), T = (e) => {
+	let t = [], n = [];
+	for (let r of e ?? []) switch (r.op) {
+		case "eq":
+			t.push(`${r.field}:${r.value}`);
+			break;
+		case "neq":
+			t.push(`${r.field}:-${r.value}`);
+			break;
+		case "in":
+			t.push(p(r.value).map((e) => `${r.field}:${e}`));
+			break;
+		case "nin":
+			for (let e of p(r.value)) t.push(`${r.field}:-${e}`);
+			break;
+		case "gt":
+			n.push(`${r.field} > ${r.value}`);
+			break;
+		case "gte":
+			n.push(`${r.field} >= ${r.value}`);
+			break;
+		case "lt":
+			n.push(`${r.field} < ${r.value}`);
+			break;
+		case "lte":
+			n.push(`${r.field} <= ${r.value}`);
+			break;
+	}
+	return {
+		facetFilters: t,
+		numericFilters: n
+	};
+}, E = (e) => {
+	let t, n = async () => (t ||= v("algoliasearch", "algolia", () => import("algoliasearch")).then((t) => t.algoliasearch(e.appId ?? "", e.apiKey)), t), r = async (e, t) => {
+		try {
+			return await t();
+		} catch (t) {
+			throw t instanceof f ? t : new f({
+				engine: "algolia",
+				op: e,
+				message: String(t?.message ?? t),
+				transient: !0
+			});
+		}
+	};
+	return {
+		upsert: (e, t) => r("upsert", async () => {
+			await (await n()).saveObjects({
+				indexName: e,
+				objects: t.map((e) => ({
+					...e,
+					objectID: e.id
+				}))
+			});
+		}),
+		remove: (e, t) => r("remove", async () => {
+			await (await n()).deleteObjects({
+				indexName: e,
+				objectIDs: [...t]
+			});
+		}),
+		query: (e, { q: t, limit: i, offset: a, filters: o, facets: s, highlight: c, fuzziness: l, engineParams: u }) => r("query", async () => {
+			let { facetFilters: r, numericFilters: d } = T(o), f = {
+				query: t,
+				...a ? {
+					offset: a,
+					length: i ?? 20
+				} : { hitsPerPage: i ?? 20 },
+				...r.length > 0 ? { facetFilters: r } : {},
+				...d.length > 0 ? { numericFilters: d } : {},
+				...s && s.length > 0 ? { facets: [...s] } : {},
+				...c ? {
+					...c.fields && c.fields.length > 0 ? { attributesToHighlight: [...c.fields] } : {},
+					...c.preTag ? { highlightPreTag: c.preTag } : {},
+					...c.postTag ? { highlightPostTag: c.postTag } : {}
+				} : {},
+				...l === 0 ? { typoTolerance: !1 } : {},
+				...u ?? {}
+			};
+			return D(await (await n()).searchSingleIndex({
+				indexName: e,
+				searchParams: f
+			}), c);
+		})
+	};
+}, D = (e, t) => ({
+	hits: e.hits.map((e) => {
+		let { _highlightResult: n, ...r } = e;
+		if (t && n) {
+			let e = {};
+			for (let [t, r] of Object.entries(n)) t !== "id" && r?.value && (e[t] = r.value);
+			return Object.keys(e).length > 0 ? {
+				doc: r,
+				highlights: e
+			} : { doc: r };
+		}
+		return { doc: r };
+	}),
+	facets: e.facets ?? {}
+}), O = "_voltro_search_stats", k = () => ({
+	synced: 0,
+	removed: 0,
+	lastReindexAt: null,
+	lastReindexCount: 0
+}), A = l(O, {
+	id: s({ prefix: "sstat" }),
+	indexName: u().maxLength(191),
+	replicaId: u().maxLength(191),
+	synced: c().default(0),
+	removed: c().default(0),
+	lastReindexAt: d().nullable(),
+	lastReindexCount: c().default(0),
+	updatedAt: d()
+}).unique("bySearchStatsIndexReplica", ["indexName", "replicaId"]).index("bySearchStatsIndex", ["indexName"]), j = () => [A], M = () => {
+	let e = /* @__PURE__ */ new Map(), t = (t) => e.get(t) ?? k();
+	return {
+		bump: async (n, r) => {
+			let i = t(n);
+			e.set(n, r === "synced" ? {
+				...i,
+				synced: i.synced + 1
+			} : {
+				...i,
+				removed: i.removed + 1
+			});
+		},
+		recordReindex: async (n, r, i) => {
+			let a = t(n);
+			e.set(n, {
+				...a,
+				synced: a.synced + r,
+				lastReindexAt: i,
+				lastReindexCount: r
+			});
+		},
+		get: async (e) => t(e)
+	};
+}, N = (e) => ({
+	table: O,
+	predicate: e,
+	order: [],
+	take: void 0,
+	skip: void 0,
+	projection: void 0
+}), P = () => `sstat_${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`, F = () => process.env.VOLTRO_REPLICA_ID ?? process.env.HOSTNAME ?? process.env.POD_NAME ?? `pid_${process.pid}_${Math.random().toString(36).slice(2, 8)}`, I = 32, L = (e, t = F()) => {
+	let n = async (n) => (await e.query(N(a(o("indexName", n), o("replicaId", t)))))[0] ?? null, r = async (e) => {
+		try {
+			return await e();
+		} catch (e) {
+			throw e instanceof f ? e : new f({
+				engine: "stats",
+				op: "upsert",
+				message: String(e?.message ?? e),
+				transient: !0
+			});
+		}
+	}, i = (i, s, c) => r(async () => {
+		for (let r = 0; r < I; r++) {
+			r > 0 && await new Promise((e) => setTimeout(e, r));
+			let l = await n(i);
+			if (l) {
+				let t = Number(l.synced ?? 0), n = Number(l.removed ?? 0), r = {
+					synced: t,
+					removed: n,
+					lastReindexAt: l.lastReindexAt ? new Date(l.lastReindexAt).toISOString() : null,
+					lastReindexCount: Number(l.lastReindexCount ?? 0)
+				};
+				if (await e.updateMany("_voltro_search_stats", {
+					...s(r),
+					updatedAt: /* @__PURE__ */ new Date()
+				}, { where: a(o("id", String(l.id)), o("synced", t), o("removed", n)) }) === 1) return;
+			} else {
+				let n = P(), r = await e.insertIgnore(O, {
+					id: n,
+					indexName: i,
+					replicaId: t,
+					synced: 0,
+					removed: 0,
+					lastReindexAt: null,
+					lastReindexCount: 0,
+					updatedAt: /* @__PURE__ */ new Date(),
+					...c
+				}, { conflictColumns: ["indexName", "replicaId"] });
+				if (String(r.id) === n) return;
+			}
+		}
+		throw new f({
+			engine: "stats",
+			op: "upsert",
+			message: `search stats: contention on (${i}, ${t}) exceeded ${I} attempts`,
+			transient: !0
+		});
+	});
+	return {
+		bump: (e, t) => i(e, (e) => t === "synced" ? { synced: e.synced + 1 } : { removed: e.removed + 1 }, t === "synced" ? { synced: 1 } : { removed: 1 }),
+		recordReindex: (e, t, n) => i(e, (e) => ({
+			synced: e.synced + t,
+			lastReindexAt: new Date(n),
+			lastReindexCount: t
+		}), {
+			synced: t,
+			lastReindexAt: new Date(n),
+			lastReindexCount: t
+		}),
+		get: (t) => r(async () => {
+			let n = await e.query(N(o("indexName", t))), r = k(), i = 0, a = 0, s = null, c = 0;
+			for (let e of n) {
+				i += Number(e.synced ?? 0), a += Number(e.removed ?? 0);
+				let t = e.lastReindexAt ? new Date(e.lastReindexAt).toISOString() : null;
+				t && (s === null || t > s) && (s = t, c = Number(e.lastReindexCount ?? 0));
+			}
+			return {
+				...r,
+				synced: i,
+				removed: a,
+				lastReindexAt: s,
+				lastReindexCount: c
+			};
+		})
+	};
+}, R = (e) => {
+	if (e === void 0 || e === "memory") return g();
+	if (typeof e.query == "function") return e;
+	let t = e;
+	return t.engine === "typesense" ? b(t) : t.engine === "meilisearch" ? C(t) : t.engine === "algolia" ? E(t) : g();
+}, z = async (e, t, n) => {
+	let r = n.map((e) => t.map(e));
+	return r.length > 0 && await e.upsert(t.index, r), r.length;
+}, B = async (e, t, n) => {
+	if (n.op === "delete") {
+		let r = n.old?.id;
+		typeof r == "string" && await e.remove(t.index, [r]);
+		return;
+	}
+	n.new && await e.upsert(t.index, [t.map(n.new)]);
+}, V = (e) => {
+	if (!e || e === "memory" || typeof e.query == "function") return;
+	let t = e;
+	try {
+		return t.url || t.host ? new URL(t.url ?? t.host).host : void 0;
+	} catch {
+		return;
+	}
+}, H = (e, t, n) => {
+	let r = n ?? [];
+	return e ? t == null ? null : [...r, {
+		field: e,
+		op: "eq",
+		value: t
+	}] : r;
+}, U = (n) => {
+	let a = n.name ? `@voltro/plugin-search#${n.name}` : "@voltro/plugin-search", o = R(n.backend), s = /* @__PURE__ */ new Map();
+	for (let e of Object.values(n.indexes)) s.set(e.index, e);
+	let c = {
+		...e,
+		description: "Full-text search an index (facets/highlight/fuzzy/filters), auto-scoped to the caller tenant.",
+		execute: (e, t) => r.promise(async () => {
+			let { index: n, q: r, limit: i, offset: a, filters: c, facets: l, highlight: u, fuzziness: d, engineParams: f } = e, p = s.get(n), m = t.request.subject.tenantId ?? null, h = H(p?.tenantField, m, c);
+			if (h === null) return {
+				hits: [],
+				facets: {}
+			};
+			let g = {
+				q: r,
+				...i === void 0 ? {} : { limit: i },
+				...a === void 0 ? {} : { offset: a },
+				...h.length > 0 ? { filters: h } : {},
+				...l && l.length > 0 ? { facets: l } : {},
+				...u ? { highlight: u } : {},
+				...d === void 0 ? {} : { fuzziness: d },
+				...f ? { engineParams: f } : {}
+			};
+			return o.query(n, g);
+		})
+	}, l = V(n.backend), u = [
+		"store:changes:read",
+		"store:write",
+		"inspect:read",
+		...l ? [`network:outbound:${l}`] : []
+	], d = () => void 0, f = M(), p, m = (e) => ({
+		kind: "json",
+		data: e
+	}), h = (e, t) => ({
+		kind: "json",
+		status: e,
+		data: { error: t }
+	});
+	return i({
+		name: a,
+		description: "External search index sync (Typesense/Meilisearch/Algolia/memory) via the ChangeEvent tap + a tenant-scoped query route.",
+		permissions: u,
+		routes: [c],
+		rpcClientDescriptors: t,
+		inspectEndpoints: [{
+			method: "GET",
+			path: "/indexes",
+			description: "Configured indexes + durable, cross-replica sync stats.",
+			handler: () => r.promise(async () => {
+				let e = await Promise.all(Object.entries(n.indexes).map(async ([e, t]) => {
+					let n = await f.get(t.index);
+					return {
+						table: e,
+						index: t.index,
+						tenantField: t.tenantField ?? null,
+						...n
+					};
+				}));
+				return m({
+					indexes: e,
+					backend: typeof n.backend == "string" ? n.backend : n.backend ? "custom/vendor" : "memory"
+				});
+			})
+		}, {
+			method: "POST",
+			path: "/reindex",
+			description: "Re-seed an index from the table's current rows.",
+			handler: (e) => r.promise(async () => {
+				let t;
+				try {
+					t = JSON.parse(e.body || "{}");
+				} catch {
+					return h(400, "invalid JSON body");
+				}
+				let r = t.table ? n.indexes[t.table] : void 0;
+				if (!t.table || !r) return h(404, `no index configured for table "${t.table ?? ""}"`);
+				if (!p) return h(503, "data store not bound yet");
+				try {
+					let e = await p.query({
+						table: t.table,
+						predicate: void 0,
+						order: [],
+						take: void 0,
+						skip: void 0,
+						projection: void 0
+					}), n = await z(o, r, e);
+					return await f.recordReindex(r.index, n, (/* @__PURE__ */ new Date()).toISOString()), m({
+						ok: !0,
+						table: t.table,
+						index: r.index,
+						count: n
+					});
+				} catch (e) {
+					return h(500, e.message);
+				}
+			})
+		}],
+		extendSchema: { tables: [...j()] },
+		bindDataStore: (e) => {
+			p = e, f = L(e);
+		},
+		onChangeEvent: (e) => {
+			let t = n.indexes[e.table];
+			if (!t) return r.void;
+			let i = r.tryPromise(() => f.bump(t.index, e.op === "delete" ? "removed" : "synced")).pipe(r.catchAll((t) => r.sync(() => d("search stats bump failed", {
+				table: e.table,
+				op: e.op,
+				error: String(t)
+			})))), a = r.tryPromise(() => B(o, t, e));
+			return r.zipRight(i, a);
+		},
+		onActivate: (e) => r.sync(() => {
+			d = (t, n) => e.logger.warn(t, n), e.logger.info("search active", {
+				indexes: Object.keys(n.indexes),
+				backend: typeof n.backend == "string" ? n.backend : "custom/vendor"
+			});
+		})
+	});
+};
+//#endregion
+export { O as SEARCH_STATS_TABLE, f as SearchBackendError, E as algoliaBackend, B as applyChange, z as backfillIndex, L as dataStoreStatsStore, C as meilisearchBackend, g as memoryBackend, M as memoryStatsStore, H as scopeSearchFilters, U as searchPlugin, A as searchStatsTable, j as searchTables, b as typesenseBackend };

package/dist/rpc.d.ts

@@ -0,0 +1,47 @@
+import { ActionProcedureDescriptor } from '@voltro/protocol';
+import { PluginRpcClientDescriptor } from '@voltro/protocol';
+import { Schema } from 'effect';
+
+export declare const queryDescriptor: ActionProcedureDescriptor<"search.query", Schema.Struct<{
+    index: typeof Schema.String;
+    q: typeof Schema.String;
+    limit: Schema.optional<typeof Schema.Number>;
+    offset: Schema.optional<typeof Schema.Number>;
+    /** Clauses ANDed together — equality, range, negation, set membership. */
+    filters: Schema.optional<Schema.Array$<Schema.Struct<{
+        field: typeof Schema.String;
+        op: Schema.Literal<["eq", "neq", "gt", "gte", "lt", "lte", "in", "nin"]>;
+        value: Schema.Union<[Schema.Union<[typeof Schema.String, typeof Schema.Number, typeof Schema.Boolean]>, Schema.Array$<Schema.Union<[typeof Schema.String, typeof Schema.Number, typeof Schema.Boolean]>>]>;
+    }>>>;
+    /** Facet-count fields. */
+    facets: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    /** Matched-term highlighting. */
+    highlight: Schema.optional<Schema.Struct<{
+        fields: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        preTag: Schema.optional<typeof Schema.String>;
+        postTag: Schema.optional<typeof Schema.String>;
+    }>>;
+    /** Typo tolerance — a max edit distance (0 = exact) or `'auto'`. */
+    fuzziness: Schema.optional<Schema.Union<[typeof Schema.Number, Schema.Literal<["auto"]>]>>;
+    /** Escape hatch — forwarded verbatim to the underlying engine's search call. */
+    engineParams: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>, Schema.Struct<{
+    hits: Schema.Array$<Schema.Struct<{
+        doc: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+        highlights: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+    }>>;
+    /** field → (value → count) for the requested facets. */
+    facets: Schema.Record$<typeof Schema.String, Schema.Record$<typeof Schema.String, typeof Schema.Number>>;
+}>, typeof Schema.Never>;
+
+export declare const SearchFilterSchema: Schema.Struct<{
+    field: typeof Schema.String;
+    op: Schema.Literal<["eq", "neq", "gt", "gte", "lt", "lte", "in", "nin"]>;
+    value: Schema.Union<[Schema.Union<[typeof Schema.String, typeof Schema.Number, typeof Schema.Boolean]>, Schema.Array$<Schema.Union<[typeof Schema.String, typeof Schema.Number, typeof Schema.Boolean]>>]>;
+}>;
+
+/** Declared for the codegen (`VoltroPlugin.rpcClientDescriptors`) so each tag is
+ *  emitted into the generated client group. Kept in lockstep with the exports. */
+export declare const searchRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
+
+export { }