Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/worker/src/jobs/search-indexer.test.ts
T

578 lines
19 KiB
TypeScript

import { describe, expect, it, vi } from "vitest";
import { createSearchClient, crmContactsIndex, kbArticlesIndex, rowsIndex, searchInIndex, usersIndex } from "@toolctrl/search";
import { createInMemoryMeili } from "@toolctrl/search/testing";
import { runSearchIndexerJob, SearchIndexerJobError, parseSearchIndexJob } from "./search-indexer.js";
import { createSearchIndexerBulkPagers, registeredSearchIndexerBulkPagerNames } from "./search-indexer-bulk-pagers.js";
function makeClient() {
const meili = createInMemoryMeili();
const client = createSearchClient({ url: "http://memory", meiliFactory: meili.factory });
return { meili, client };
}
describe("parseSearchIndexJob", () => {
it("rejects unknown actions", () => {
expect(() => parseSearchIndexJob({ payload: { action: "rename", indexName: "kb-articles", tenantId: "t" } })).toThrow(SearchIndexerJobError);
});
it("rejects missing tenantId in payload", () => {
expect(() => parseSearchIndexJob({ payload: { action: "upsert", indexName: "kb-articles" } })).toThrow(/tenantId/);
});
it("accepts a well-formed upsert envelope", () => {
const parsed = parseSearchIndexJob({
outboxEventId: "evt_1",
tenantId: "t1",
eventType: "search.index.kb.upsert",
payload: { action: "upsert", indexName: "kb-articles", tenantId: "t1", document: { id: "a", tenantId: "t1", title: "X" } },
});
expect(parsed.payload.action).toBe("upsert");
expect(parsed.outboxEventId).toBe("evt_1");
});
it("rejects envelope and payload tenant mismatches", () => {
for (const payload of [
{ action: "upsert", indexName: "kb-articles", tenantId: "t2", document: { id: "a", tenantId: "t2", title: "X" } },
{ action: "delete", indexName: "kb-articles", tenantId: "t2", documentId: "a" },
{ action: "bulk-reindex", indexName: "kb-articles", tenantId: "t2" },
]) {
expect(() =>
parseSearchIndexJob({
outboxEventId: "evt_1",
tenantId: "t1",
eventType: "search.index.kb.upsert",
payload,
})
).toThrow(/tenantId mismatch/);
}
});
});
describe("runSearchIndexerJob", () => {
it("upserts a document and isolates it to the tenant", async () => {
const { client } = makeClient();
const data = {
eventType: "search.index.kb.upsert",
tenantId: "t1",
payload: {
action: "upsert",
indexName: kbArticlesIndex.name,
tenantId: "t1",
document: { id: "a", tenantId: "t1", title: "Hello" },
},
};
const result = await runSearchIndexerJob(data, { searchClient: client });
expect(result).toMatchObject({ action: "upsert", documentsAffected: 1, tenantId: "t1" });
const hits = await searchInIndex({ client, schema: kbArticlesIndex, tenantId: "t1", query: "Hello" });
expect(hits.hits.map((h) => h.document.id)).toEqual(["a"]);
const other = await searchInIndex({ client, schema: kbArticlesIndex, tenantId: "t2", query: "Hello" });
expect(other.hits).toHaveLength(0);
});
it("deletes a document", async () => {
const { client } = makeClient();
await runSearchIndexerJob(
{
eventType: "search.index.kb.upsert",
tenantId: "t1",
payload: { action: "upsert", indexName: kbArticlesIndex.name, tenantId: "t1", document: { id: "a", tenantId: "t1", title: "Hi" } },
},
{ searchClient: client }
);
const result = await runSearchIndexerJob(
{
eventType: "search.index.kb.delete",
tenantId: "t1",
payload: { action: "delete", indexName: kbArticlesIndex.name, tenantId: "t1", documentId: "a" },
},
{ searchClient: client }
);
expect(result.action).toBe("delete");
const hits = await searchInIndex({ client, schema: kbArticlesIndex, tenantId: "t1", query: "Hi" });
expect(hits.hits).toHaveLength(0);
});
it("runs bulk-reindex via the supplied pager", async () => {
const { client } = makeClient();
const pager = vi
.fn()
.mockResolvedValueOnce({
documents: [
{ id: "1", tenantId: "t1", title: "Doc 1" },
{ id: "2", tenantId: "t1", title: "Doc 2" },
],
nextCursor: "cursor-1",
})
.mockResolvedValueOnce({ documents: [{ id: "3", tenantId: "t1", title: "Doc 3" }], nextCursor: null });
const result = await runSearchIndexerJob(
{
eventType: "search.index.kb.bulk-reindex",
tenantId: "t1",
payload: { action: "bulk-reindex", indexName: kbArticlesIndex.name, tenantId: "t1" },
},
{
searchClient: client,
bulkPagers: { [kbArticlesIndex.name]: pager },
bulkPageSize: 2,
}
);
expect(result).toMatchObject({ action: "bulk-reindex", documentsAffected: 3, tenantId: "t1" });
expect(pager).toHaveBeenCalledTimes(2);
});
it("fails bulk-reindex when the pager cursor does not advance", async () => {
const { client } = makeClient();
const pager = vi
.fn()
.mockResolvedValueOnce({
documents: [{ id: "1", tenantId: "t1", title: "Doc 1" }],
nextCursor: "cursor-1",
})
.mockResolvedValueOnce({
documents: [{ id: "2", tenantId: "t1", title: "Doc 2" }],
nextCursor: "cursor-1",
});
await expect(
runSearchIndexerJob(
{
eventType: "search.index.kb.bulk-reindex",
tenantId: "t1",
payload: { action: "bulk-reindex", indexName: kbArticlesIndex.name, tenantId: "t1" },
},
{
searchClient: client,
bulkPagers: { [kbArticlesIndex.name]: pager },
bulkPageSize: 1,
}
)
).rejects.toMatchObject({ code: "BULK_PAGER_STALLED" });
expect(pager).toHaveBeenCalledTimes(2);
});
it("fails bulk-reindex when maxBulkPages is reached before completion", async () => {
const { client } = makeClient();
const pager = vi.fn().mockResolvedValueOnce({
documents: [{ id: "1", tenantId: "t1", title: "Doc 1" }],
nextCursor: "cursor-1",
});
await expect(
runSearchIndexerJob(
{
eventType: "search.index.kb.bulk-reindex",
tenantId: "t1",
payload: { action: "bulk-reindex", indexName: kbArticlesIndex.name, tenantId: "t1" },
},
{
searchClient: client,
bulkPagers: { [kbArticlesIndex.name]: pager },
bulkPageSize: 1,
maxBulkPages: 1,
}
)
).rejects.toMatchObject({ code: "BULK_REINDEX_INCOMPLETE" });
expect(pager).toHaveBeenCalledTimes(1);
});
it("replaces the tenant slice during bulk-reindex", async () => {
const { client } = makeClient();
await runSearchIndexerJob(
{
eventType: "search.index.kb.upsert",
tenantId: "t1",
payload: { action: "upsert", indexName: kbArticlesIndex.name, tenantId: "t1", document: { id: "stale", tenantId: "t1", title: "Stale Doc" } },
},
{ searchClient: client }
);
await runSearchIndexerJob(
{
eventType: "search.index.kb.upsert",
tenantId: "t2",
payload: { action: "upsert", indexName: kbArticlesIndex.name, tenantId: "t2", document: { id: "stale", tenantId: "t2", title: "Other Tenant" } },
},
{ searchClient: client }
);
const result = await runSearchIndexerJob(
{
eventType: "search.index.kb.bulk-reindex",
tenantId: "t1",
payload: { action: "bulk-reindex", indexName: kbArticlesIndex.name, tenantId: "t1" },
},
{
searchClient: client,
bulkPagers: {
[kbArticlesIndex.name]: vi.fn().mockResolvedValueOnce({
documents: [{ id: "fresh", tenantId: "t1", title: "Fresh Doc" }],
nextCursor: null,
}),
},
}
);
expect(result).toMatchObject({ action: "bulk-reindex", documentsAffected: 1, tenantId: "t1" });
await expect(searchInIndex({ client, schema: kbArticlesIndex, tenantId: "t1", query: "Stale" })).resolves.toMatchObject({ hits: [] });
await expect(searchInIndex({ client, schema: kbArticlesIndex, tenantId: "t1", query: "Fresh" })).resolves.toMatchObject({ hits: [{ document: expect.objectContaining({ id: "fresh" }) }] });
await expect(searchInIndex({ client, schema: kbArticlesIndex, tenantId: "t2", query: "Other" })).resolves.toMatchObject({ hits: [{ document: expect.objectContaining({ id: "stale" }) }] });
});
it("throws when bulk-reindex has no pager registered for the index", async () => {
const { client } = makeClient();
await expect(
runSearchIndexerJob(
{
eventType: "search.index.kb.bulk-reindex",
tenantId: "t1",
payload: { action: "bulk-reindex", indexName: kbArticlesIndex.name, tenantId: "t1" },
},
{ searchClient: client }
)
).rejects.toThrow(SearchIndexerJobError);
});
it("registers a kb-articles bulk pager that maps tenant-scoped documents", async () => {
const findMany = vi.fn(async () => [
{
id: "article_1",
knowledgeBaseId: "kb_1",
slug: "hello",
title: "Hello",
description: "Summary",
contentPublishedAsText: "Published text",
language: "en",
publishedAt: new Date("2026-01-02T03:04:05.000Z"),
createdAt: new Date("2026-01-01T00:00:00.000Z"),
updatedAt: null,
knowledgeBase: { tenantId: "tenant_1" },
},
]);
const pagers = createSearchIndexerBulkPagers({
prisma: fakeSearchPagerPrisma({ knowledgeBaseArticle: { findMany } }),
});
const result = await pagers[kbArticlesIndex.name]?.({
indexName: kbArticlesIndex.name,
tenantId: "tenant_1",
cursor: "article_0",
pageSize: 1,
});
expect(registeredSearchIndexerBulkPagerNames).toContain(kbArticlesIndex.name);
expect(findMany).toHaveBeenCalledWith(
expect.objectContaining({
where: { id: { gt: "article_0" }, knowledgeBase: { tenantId: "tenant_1" } },
take: 1,
})
);
expect(result?.documents).toEqual([
expect.objectContaining({
id: "article_1",
tenantId: "tenant_1",
knowledgeBaseId: "kb_1",
summary: "Summary",
content: "Published text",
isPublished: true,
}),
]);
expect(result?.nextCursor).toBe("article_1");
});
it("defensively filters kb-article bulk pager rows by tenant and terminates short pages", async () => {
const findMany = vi.fn(async () => [
{
id: "article_1",
knowledgeBaseId: "kb_1",
slug: "hello",
title: "Hello",
description: "Summary",
contentPublishedAsText: "Published text",
language: "de",
publishedAt: "2026-01-02T03:04:05.000Z",
createdAt: new Date("2026-01-01T00:00:00.000Z"),
updatedAt: new Date("2026-01-03T00:00:00.000Z"),
knowledgeBase: { tenantId: "tenant_1" },
},
{
id: "article_2",
knowledgeBaseId: "kb_2",
slug: "other",
title: "Other",
description: "Other summary",
contentPublishedAsText: "Other text",
language: "en",
publishedAt: null,
createdAt: new Date("2026-01-01T00:00:00.000Z"),
updatedAt: null,
knowledgeBase: { tenantId: "tenant_2" },
},
]);
const pagers = createSearchIndexerBulkPagers({
prisma: fakeSearchPagerPrisma({ knowledgeBaseArticle: { findMany } }),
});
const result = await pagers[kbArticlesIndex.name]?.({
indexName: kbArticlesIndex.name,
tenantId: "tenant_1",
cursor: null,
pageSize: 3,
});
expect(findMany).toHaveBeenCalledWith(
expect.objectContaining({
where: { knowledgeBase: { tenantId: "tenant_1" } },
orderBy: { id: "asc" },
take: 3,
})
);
expect(result?.documents).toEqual([
expect.objectContaining({
id: "article_1",
tenantId: "tenant_1",
language: "de",
createdAt: "2026-01-01T00:00:00.000Z",
updatedAt: "2026-01-03T00:00:00.000Z",
publishedAt: "2026-01-02T03:04:05.000Z",
}),
]);
expect(result?.nextCursor).toBeNull();
});
it("registers a rows bulk pager that maps searchable tenant rows", async () => {
const findRows = vi.fn(async () => [
makeSearchRow({
id: "row_1",
tenantId: "tenant_1",
entityName: "account",
values: {
name: "Acme",
status: "active",
hiddenNumber: 42,
},
}),
]);
const pagers = createSearchIndexerBulkPagers({
prisma: fakeSearchPagerPrisma({ row: { findMany: findRows } }),
});
const result = await pagers[rowsIndex.name]?.({
indexName: rowsIndex.name,
tenantId: "tenant_1",
cursor: "row_0",
pageSize: 1,
});
expect(registeredSearchIndexerBulkPagerNames).toContain(rowsIndex.name);
expect(findRows).toHaveBeenCalledWith(
expect.objectContaining({
where: { id: { gt: "row_0" }, tenantId: "tenant_1", deletedAt: null },
take: 1,
})
);
expect(result?.documents).toEqual([
expect.objectContaining({
id: "row_1",
tenantId: "tenant_1",
entityId: "entity_1",
entityName: "account",
folio: 7,
searchable: "Acme \n active",
createdById: "user_1",
}),
]);
expect(result?.nextCursor).toBe("row_1");
});
it("registers a crm-contacts bulk pager from contact rows only", async () => {
const findRows = vi.fn(async () => [
makeSearchRow({
id: "contact_1",
tenantId: "tenant_1",
entityName: "contact",
values: {
firstName: "Ada",
lastName: "Lovelace",
email: "ada@example.test",
company: "Analytical Engines",
jobTitle: "Founder",
status: "customer",
},
}),
makeSearchRow({
id: "contact_2",
tenantId: "tenant_2",
entityName: "contact",
values: { firstName: "Other" },
}),
]);
const pagers = createSearchIndexerBulkPagers({
prisma: fakeSearchPagerPrisma({ row: { findMany: findRows } }),
});
const result = await pagers[crmContactsIndex.name]?.({
indexName: crmContactsIndex.name,
tenantId: "tenant_1",
cursor: null,
pageSize: 3,
});
expect(registeredSearchIndexerBulkPagerNames).toContain(crmContactsIndex.name);
expect(findRows).toHaveBeenCalledWith(
expect.objectContaining({
where: { tenantId: "tenant_1", deletedAt: null, entity: { name: "contact" } },
orderBy: { id: "asc" },
take: 3,
})
);
expect(result?.documents).toEqual([
expect.objectContaining({
id: "contact_1",
tenantId: "tenant_1",
firstName: "Ada",
lastName: "Lovelace",
email: "ada@example.test",
company: "Analytical Engines",
jobTitle: "Founder",
status: "customer",
ownerId: "user_1",
}),
]);
expect(result?.nextCursor).toBeNull();
});
it("registers a users bulk pager from tenant memberships", async () => {
const findTenantUsers = vi.fn(async () => [
{
id: "tenant_user_1",
tenantId: "tenant_1",
userId: "user_1",
type: 1,
status: 2,
user: {
id: "user_1",
createdAt: new Date("2026-01-01T00:00:00.000Z"),
email: "ada@example.test",
firstName: "Ada",
lastName: "Lovelace",
active: true,
admin: { userId: "user_1" },
logs: [{ createdAt: new Date("2026-01-03T00:00:00.000Z") }],
},
},
{
id: "tenant_user_2",
tenantId: "tenant_2",
userId: "user_2",
type: 2,
status: 2,
user: {
id: "user_2",
createdAt: new Date("2026-01-01T00:00:00.000Z"),
email: "other@example.test",
firstName: "Other",
lastName: "Tenant",
active: true,
admin: null,
logs: [],
},
},
]);
const pagers = createSearchIndexerBulkPagers({
prisma: fakeSearchPagerPrisma({ tenantUser: { findMany: findTenantUsers } }),
});
const result = await pagers[usersIndex.name]?.({
indexName: usersIndex.name,
tenantId: "tenant_1",
cursor: "tenant_user_0",
pageSize: 2,
});
expect(registeredSearchIndexerBulkPagerNames).toContain(usersIndex.name);
expect(findTenantUsers).toHaveBeenCalledWith(
expect.objectContaining({
where: { id: { gt: "tenant_user_0" }, tenantId: "tenant_1" },
orderBy: { id: "asc" },
take: 2,
})
);
expect(result?.documents).toEqual([
expect.objectContaining({
id: "user_1",
tenantId: "tenant_1",
firstName: "Ada",
lastName: "Lovelace",
email: "ada@example.test",
type: 1,
admin: true,
active: true,
createdAt: "2026-01-01T00:00:00.000Z",
lastLoginAt: "2026-01-03T00:00:00.000Z",
}),
]);
expect(result?.nextCursor).toBe("tenant_user_2");
});
it("rejects payload pointing at an unknown index", async () => {
const { client } = makeClient();
await expect(
runSearchIndexerJob(
{
eventType: "search.index.unknown.upsert",
tenantId: "t1",
payload: { action: "upsert", indexName: "does-not-exist", tenantId: "t1", document: { id: "a", tenantId: "t1" } },
},
{ searchClient: client }
)
).rejects.toThrow(/unknown search index/);
});
});
function fakeSearchPagerPrisma(overrides: Partial<Parameters<typeof createSearchIndexerBulkPagers>[0]["prisma"]>) {
return {
knowledgeBaseArticle: { findMany: vi.fn(async () => []) },
row: { findMany: vi.fn(async () => []) },
tenantUser: { findMany: vi.fn(async () => []) },
...overrides,
} as Parameters<typeof createSearchIndexerBulkPagers>[0]["prisma"];
}
function makeSearchRow(input: {
id: string;
tenantId: string;
entityName: string;
values: Record<string, string | number | boolean>;
}) {
const properties = Object.keys(input.values).map((name, index) => ({
id: `property_${name}`,
name,
type: typeof input.values[name] === "string" ? (name === "hiddenNumber" ? 0 : 1) : 0,
order: index,
}));
return {
id: input.id,
tenantId: input.tenantId,
entityId: "entity_1",
folio: 7,
createdByUserId: "user_1",
createdAt: new Date("2026-01-01T00:00:00.000Z"),
updatedAt: new Date("2026-01-02T00:00:00.000Z"),
deletedAt: null,
entity: {
name: input.entityName,
properties,
},
values: properties.map((property) => {
const value = input.values[property.name];
return {
propertyId: property.id,
textValue: typeof value === "string" ? value : null,
numberValue: typeof value === "number" ? value : null,
dateValue: null,
booleanValue: typeof value === "boolean" ? value : null,
property,
};
}),
};
}