Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/search/src/query.extra.test.ts
T
2026-07-08 16:15:37 +02:00

289 lines
9.5 KiB
TypeScript

import { describe, expect, it, vi } from "vitest";
import type {
IndexHandle,
IndexSearchOptions,
SearchClient,
SearchDocument,
SearchHits,
} from "./client.js";
import { bulkIndex, searchInIndex, searchWithFallback } from "./query.js";
import { kbArticlesIndex } from "./schemas/index.js";
const ORIGINAL_PRIMARY_KEY_FIELD = "__hivegridOriginalPrimaryKey";
/**
* Minimal SearchClient fake that records the (query, options) handed to
* the underlying index handle and returns a caller-supplied result. Lets
* the tests assert the exact filter / attribute strings query.ts builds
* without depending on the in-memory fake's filter interpretation.
*/
function capturingClient(result?: SearchHits): {
client: SearchClient;
calls: Array<{ query: string; options: IndexSearchOptions }>;
} {
const calls: Array<{ query: string; options: IndexSearchOptions }> = [];
const searchResult: SearchHits = result ?? { hits: [], estimatedTotalHits: 0, processingTimeMs: 0 };
const client = {
index<TDocument extends SearchDocument = SearchDocument>(): IndexHandle<TDocument> {
return {
async ensure() {},
async search(query: string, options: IndexSearchOptions) {
calls.push({ query, options });
return searchResult as SearchHits<TDocument>;
},
async upsert() {},
async delete() {},
async deleteByFilter() {},
};
},
async health() {
return { status: "available" as const };
},
} satisfies SearchClient;
return { client, calls };
}
function throwingClient(error: unknown): SearchClient {
return {
index<TDocument extends SearchDocument = SearchDocument>(): IndexHandle<TDocument> {
return {
async ensure() {},
async search(): Promise<SearchHits<TDocument>> {
throw error;
},
async upsert() {},
async delete() {},
async deleteByFilter() {},
};
},
async health() {
return { status: "available" as const };
},
};
}
describe("searchInIndex — filter construction", () => {
it("escapes quotes and backslashes in the tenantId so the filter cannot be broken out of", async () => {
const { client, calls } = capturingClient();
await searchInIndex({ client, schema: kbArticlesIndex, tenantId: 'a"b\\c', query: "x" });
// Backslash -> \\ then quote -> \" → the value stays inside one quoted token.
expect(calls[0]?.options.filter).toBe('tenantId = "a\\"b\\\\c"');
});
it("AND-merges an array of extra filters and drops blank entries", async () => {
const { client, calls } = capturingClient();
await searchInIndex({
client,
schema: kbArticlesIndex,
tenantId: "t1",
query: "x",
options: { extraFilters: ["isPublished = true", " ", 'language = "de"'] },
});
expect(calls[0]?.options.filter).toBe(
'tenantId = "t1" AND (isPublished = true) AND (language = "de")'
);
});
it("falls back to the bare tenant filter when every array entry is blank", async () => {
const { client, calls } = capturingClient();
await searchInIndex({
client,
schema: kbArticlesIndex,
tenantId: "t1",
query: "x",
options: { extraFilters: [" ", ""] },
});
expect(calls[0]?.options.filter).toBe('tenantId = "t1"');
});
it("falls back to the bare tenant filter for a blank single extra filter", async () => {
const { client, calls } = capturingClient();
await searchInIndex({
client,
schema: kbArticlesIndex,
tenantId: "t1",
query: "x",
options: { extraFilters: " " },
});
expect(calls[0]?.options.filter).toBe('tenantId = "t1"');
});
it("defaults a missing query to an empty string", async () => {
const { client, calls } = capturingClient();
await searchInIndex({
client,
schema: kbArticlesIndex,
tenantId: "t1",
query: undefined as unknown as string,
});
expect(calls[0]?.query).toBe("");
});
});
describe("searchInIndex — attributesToRetrieve handling", () => {
it("augments attributesToRetrieve with the primary key and internal field, deduped", async () => {
const { client, calls } = capturingClient();
await searchInIndex({
client,
schema: kbArticlesIndex,
tenantId: "t1",
query: "x",
// "id" duplicates the primaryKey to exercise the de-dup path.
options: { attributesToRetrieve: ["title", "id"] },
});
expect(calls[0]?.options.attributesToRetrieve).toEqual([
"title",
"id",
ORIGINAL_PRIMARY_KEY_FIELD,
]);
});
it("leaves attributesToRetrieve untouched when the wildcard is requested", async () => {
const { client, calls } = capturingClient();
await searchInIndex({
client,
schema: kbArticlesIndex,
tenantId: "t1",
query: "x",
options: { attributesToRetrieve: ["*"] },
});
expect(calls[0]?.options.attributesToRetrieve).toEqual(["*"]);
});
it("strips the internal extraFilters key before handing options to the client", async () => {
const { client, calls } = capturingClient();
await searchInIndex({
client,
schema: kbArticlesIndex,
tenantId: "t1",
query: "x",
options: { extraFilters: "isPublished = true", limit: 3 },
});
expect(calls[0]?.options).not.toHaveProperty("extraFilters");
expect(calls[0]?.options.limit).toBe(3);
});
});
describe("searchInIndex — primary-key restoration", () => {
it("returns the document unchanged when it carries no internal primary-key field", async () => {
const { client } = capturingClient({
hits: [{ document: { id: "raw-id", tenantId: "t1", title: "X" } }],
estimatedTotalHits: 1,
processingTimeMs: 0,
});
const res = await searchInIndex({ client, schema: kbArticlesIndex, tenantId: "t1", query: "x" });
expect(res.hits[0]?.document).toEqual({ id: "raw-id", tenantId: "t1", title: "X" });
});
it("restores the original domain id from the internal field", async () => {
const { client } = capturingClient({
hits: [{ document: { id: "t1:raw", tenantId: "t1", [ORIGINAL_PRIMARY_KEY_FIELD]: "raw" } }],
estimatedTotalHits: 1,
processingTimeMs: 0,
});
const res = await searchInIndex({ client, schema: kbArticlesIndex, tenantId: "t1", query: "x" });
expect(res.hits[0]?.document).toEqual({ id: "raw", tenantId: "t1" });
expect(ORIGINAL_PRIMARY_KEY_FIELD in (res.hits[0]?.document ?? {})).toBe(false);
});
it("drops the internal field but keeps the scoped id when the original is not a primitive", async () => {
const { client } = capturingClient({
hits: [
{
document: {
id: "t1:raw",
tenantId: "t1",
title: "X",
[ORIGINAL_PRIMARY_KEY_FIELD]: { nested: true },
},
},
],
estimatedTotalHits: 1,
processingTimeMs: 0,
});
const res = await searchInIndex({ client, schema: kbArticlesIndex, tenantId: "t1", query: "x" });
expect(res.hits[0]?.document).toEqual({ id: "t1:raw", tenantId: "t1", title: "X" });
expect(ORIGINAL_PRIMARY_KEY_FIELD in (res.hits[0]?.document ?? {})).toBe(false);
});
});
describe("bulkIndex — input validation", () => {
it("surfaces a clear error when a document is missing its primary key", async () => {
const { client } = capturingClient();
await expect(
bulkIndex({
client,
schema: kbArticlesIndex,
tenantId: "t1",
documents: [
{ tenantId: "t1", title: "no id" } as unknown as SearchDocument,
],
})
).rejects.toThrow(/missing primary key/);
});
});
describe("searchWithFallback — connectivity detection", () => {
const fallbackResult: SearchHits = {
hits: [{ document: { id: "fb", tenantId: "t1" } }],
estimatedTotalHits: 1,
processingTimeMs: 0,
};
const fallback = () => Promise.resolve(fallbackResult);
it("falls back when the error matches only by its name", async () => {
const error = Object.assign(new Error("boom"), { name: "MeiliSearchCommunicationError" });
const res = await searchWithFallback({
client: throwingClient(error),
schema: kbArticlesIndex,
tenantId: "t1",
query: "x",
fallback,
});
expect(res.hits[0]?.document.id).toBe("fb");
});
it("falls back when the error matches only by its message", async () => {
const error = { message: "fetch failed" };
const res = await searchWithFallback({
client: throwingClient(error),
schema: kbArticlesIndex,
tenantId: "t1",
query: "x",
fallback,
});
expect(res.hits[0]?.document.id).toBe("fb");
});
it("rethrows a non-connectivity error and never invokes the fallback", async () => {
const onFallback = vi.fn();
const spied = vi.fn(fallback);
await expect(
searchWithFallback({
client: throwingClient(new Error("validation failed: bad filter syntax")),
schema: kbArticlesIndex,
tenantId: "t1",
query: "x",
fallback: spied,
onFallback,
})
).rejects.toThrow(/validation failed/);
expect(spied).not.toHaveBeenCalled();
expect(onFallback).not.toHaveBeenCalled();
});
it("rethrows when the thrown value is not an object", async () => {
const spied = vi.fn(fallback);
await expect(
searchWithFallback({
client: throwingClient("string error"),
schema: kbArticlesIndex,
tenantId: "t1",
query: "x",
fallback: spied,
})
).rejects.toBe("string error");
expect(spied).not.toHaveBeenCalled();
});
});