/** * In-memory fake of the Meilisearch SDK surface area exercised by * `createSearchClient`. Sufficient for unit and worker-integration tests * without spinning up a container. */ import type { MeiliFactory } from "./client.js"; interface FakeIndex { documents: Map>; settings: Record; primaryKey: string; } export interface InMemoryMeiliOptions { readonly healthStatus?: "available" | "unavailable"; readonly throwOnHealthCheck?: boolean; readonly throwOnSearch?: boolean; readonly throwOnIndex?: boolean; } export interface InMemoryMeiliState { readonly indexes: ReadonlyMap; options: InMemoryMeiliOptions; } export function createInMemoryMeili(options: InMemoryMeiliOptions = {}): { factory: MeiliFactory; state: InMemoryMeiliState; setOption(key: K, value: InMemoryMeiliOptions[K]): void; } { const indexes = new Map(); const mutable: { options: InMemoryMeiliOptions } = { options: { ...options } }; const factory: MeiliFactory = () => ({ async createIndex(uid, opts) { if (mutable.options.throwOnIndex) throw new Error("meili offline"); if (indexes.has(uid)) { const error = new Error("index_already_exists") as Error & { code: string }; error.code = "index_already_exists"; throw error; } indexes.set(uid, { documents: new Map(), settings: {}, primaryKey: opts.primaryKey }); }, index(uid) { const ensureIndex = (): FakeIndex => { let idx = indexes.get(uid); if (!idx) { idx = { documents: new Map(), settings: {}, primaryKey: "id" }; indexes.set(uid, idx); } return idx; }; return { async updateSettings(input) { ensureIndex().settings = { ...ensureIndex().settings, ...input }; }, async search(query, opts) { if (mutable.options.throwOnSearch) { const err = new Error("meilisearch search failed") as Error & { code: string }; err.code = "ECONNREFUSED"; throw err; } const idx = ensureIndex(); const lowered = query.toLowerCase(); const filter = typeof opts.filter === "string" ? opts.filter : Array.isArray(opts.filter) ? opts.filter.join(" AND ") : ""; const tenantId = extractTenantFromFilter(filter); const limit = typeof opts.limit === "number" ? opts.limit : 20; const offset = typeof opts.offset === "number" ? opts.offset : 0; const hits: Record[] = []; for (const doc of idx.documents.values()) { if (tenantId !== undefined && doc.tenantId !== tenantId) continue; if (lowered.length > 0 && !documentMatches(doc, lowered)) continue; hits.push(doc); } return { hits: hits.slice(offset, offset + limit) as unknown as readonly (Record & { id: string | number })[], estimatedTotalHits: hits.length, processingTimeMs: 0, limit, offset, }; }, async addDocuments(documents) { const idx = ensureIndex(); for (const doc of documents) { const id = doc[idx.primaryKey]; if (typeof id === "string" || typeof id === "number") { idx.documents.set(id, doc); } } }, async deleteDocuments(input: readonly (string | number)[] | { filter: string }) { const idx = ensureIndex(); if (Array.isArray(input)) { for (const id of input) idx.documents.delete(id); return; } const filter = (input as { filter: string }).filter; const tenantId = extractTenantFromFilter(filter); if (tenantId === undefined) return; for (const [id, doc] of idx.documents) { if (doc.tenantId === tenantId) idx.documents.delete(id); } }, }; }, async health() { if (mutable.options.throwOnHealthCheck) throw new Error("meilisearch unhealthy"); return { status: mutable.options.healthStatus ?? "available" }; }, }); return { factory, state: { indexes, get options() { return mutable.options; } }, setOption(key, value) { mutable.options = { ...mutable.options, [key]: value }; }, }; } function documentMatches(doc: Record, lowered: string): boolean { for (const value of Object.values(doc)) { if (typeof value === "string" && value.toLowerCase().includes(lowered)) return true; if (Array.isArray(value)) { for (const item of value) { if (typeof item === "string" && item.toLowerCase().includes(lowered)) return true; } } } return false; } function extractTenantFromFilter(filter: string): string | undefined { const match = /tenantId\s*=\s*"([^"]+)"/u.exec(filter); return match ? match[1] : undefined; }