@endora-commerce/mod-search 0.100.0

package/dist/backend/services/search-indexer.js

@@ -0,0 +1,670 @@
+import { Meilisearch } from 'meilisearch';
+import { resolveAttribute, SYSTEM_ATTRIBUTE_SCOPES, } from '@endora-commerce/contracts';
+import { SalesChannel } from '@endora-commerce/platform/kernel';
+import { DEFAULT_INDEX_TASK_TIMEOUT_SECONDS, SEARCH_SETTING_CODES } from '../../manifest.js';
+/**
+ * SearchIndexer (T067 — initial offline path).
+ *
+ * Pushes the public product surface into a Meilisearch index per Sales
+ * Channel. Today the storefront catalog list still runs through Postgres
+ * (`catalog-query.service.ts`); the index is consumed once T068
+ * (`search-query.service.ts`) ships. Until then this indexer is the
+ * groundwork — populating it on every catalog mutation keeps the index
+ * fresh so the cut-over is a single-line change in the read path.
+ *
+ * The indexer is intentionally idempotent: each call upserts every
+ * product into the channel index and reapplies the searchable / filterable /
+ * sortable settings — the first two derived from the live `product_attributes`
+ * rows, the third fixed by {@link SORTABLE_ATTRIBUTES}. Re-running it after a
+ * shape change is the right way to reindex, and the only way to add a document
+ * field that was not written before.
+ */
+const FALLBACK_LOCALE = 'en-US';
+/**
+ * How many member ids one `listEntityIdsForChannel` page carries. The accessor
+ * is paginated and defaults to 100; a full channel reindex wants the whole
+ * assortment, so the pages are walked to `total` — the shape `seo`'s sitemap
+ * generator settled on for the same read.
+ */
+const MEMBERSHIP_PAGE_SIZE = 500;
+/**
+ * The document fields a channel index may be sorted on — issue #287.
+ *
+ * Meilisearch refuses a sort on any field outside `sortableAttributes`, and
+ * this indexer never called `updateSortableAttributes`, so the setting was `[]`
+ * on all five live indexes and `name:asc` came back as `invalid_search_sort`.
+ * Three of the four sorts the listing contract offers were therefore answered
+ * by the unreachable-index fallback — correct results, re-read from the very
+ * Postgres query the index exists to spare, under a log line that called a
+ * healthy engine unavailable.
+ *
+ * The declaration is single on purpose: this constant is what the indexer
+ * applies to every index **and** the alphabet `buildSort` may emit (its return
+ * type is built from it). A sort token cannot be added on the query side
+ * without appearing here, which is the only structural guarantee that stops
+ * the two halves drifting apart again.
+ *
+ * Every entry costs index size and settings-update time, so this is the sorts
+ * the contract actually offers, not a list of fields that might one day be
+ * sorted on. `updatedAt` is deliberately absent: no sort token names it, it is
+ * the freshness marker rather than an ordering, and it is what `-createdAt`
+ * used to be mistranslated into.
+ */
+export const SORTABLE_ATTRIBUTES = ['createdAt', 'name'];
+/**
+ * The default wait, in milliseconds. Derived from the manifest so the constant
+ * and the Setting's default cannot drift into two answers.
+ */
+export const DEFAULT_INDEX_TASK_TIMEOUT_MS = DEFAULT_INDEX_TASK_TIMEOUT_SECONDS * 1000;
+/**
+ * A Meilisearch task came back in a state that is not `succeeded`.
+ *
+ * This error exists because `waitForTask` **does not throw for a task that
+ * failed** — it resolves, carrying `status: 'failed'` and Meilisearch's own
+ * `error` object. Every one of this file's twelve waits discarded that value,
+ * so a refused document batch, a rejected settings update and an applied one
+ * were the same thing to the caller: `reindexChannel` went on to report a
+ * document count for an index Meilisearch had written nothing into.
+ */
+export class SearchIndexTaskFailed extends Error {
+    taskUid;
+    what;
+    status;
+    /** Meilisearch's own error code, e.g. `missing_document_id`. */
+    meilisearchCode;
+    constructor(args) {
+        super(`Meilisearch ${args.what} (task ${args.taskUid}) came back "${args.status}"` +
+            (args.meilisearchCode ? ` [${args.meilisearchCode}]` : '') +
+            (args.detail ? `: ${args.detail}` : ''));
+        this.name = 'SearchIndexTaskFailed';
+        this.taskUid = args.taskUid;
+        this.what = args.what;
+        this.status = args.status;
+        this.meilisearchCode = args.meilisearchCode;
+    }
+}
+/**
+ * The wait expired. The task is **still running** — Meilisearch was never told
+ * to stop, because giving up on a wait cancels nothing.
+ *
+ * It is a separate error from {@link SearchIndexTaskFailed} on purpose, and the
+ * separation is the point of the repair rather than a nicety: the two arrive at
+ * an operator with opposite remedies. This one says "the queue outlasted the
+ * wait — raise `search.index_task_timeout_seconds`, or let the instance drain";
+ * the other says "the write was refused, and here is what Meilisearch said".
+ * Under the client's 5000 ms default these were one symptom, and it was the
+ * benign one that was raised while the malignant one was silent.
+ */
+export class SearchIndexTaskStillRunning extends Error {
+    taskUid;
+    what;
+    timeoutMs;
+    constructor(args) {
+        super(`Meilisearch ${args.what} (task ${args.taskUid}) is still running after ` +
+            `${args.timeoutMs} ms. The task was not cancelled and may yet succeed. If this ` +
+            `instance is busy or the catalogue is large, raise ` +
+            `"${SEARCH_SETTING_CODES.INDEX_TASK_TIMEOUT_SECONDS}".`);
+        this.name = 'SearchIndexTaskStillRunning';
+        this.taskUid = args.taskUid;
+        this.what = args.what;
+        this.timeoutMs = args.timeoutMs;
+    }
+}
+/**
+ * Wait for one Meilisearch task and give its three outcomes three names.
+ *
+ * This is the **only** place this module awaits a task, which is what makes the
+ * timeout one number rather than eleven literals, and what makes the
+ * failed-status check impossible to forget at the thirteenth call site.
+ *
+ * `tolerate` names Meilisearch error codes that are an expected, benign outcome
+ * for **this** wait, and it is deliberately a per-call argument rather than a
+ * blanket leniency: the one caller that needs it is `ensureIndex`, whose
+ * `index_already_exists` is another process having created the index first —
+ * which satisfies the postcondition rather than violating it.
+ */
+export async function awaitIndexTask(tasks, task, what, timeoutMs, tolerate = []) {
+    let settled;
+    try {
+        settled = await tasks.waitForTask(task.taskUid, { timeout: timeoutMs });
+    }
+    catch (error) {
+        // Matched on `name` rather than on the class: this module holds no value
+        // import of the client's error types, and the name is what the client sets.
+        if (error instanceof Error && error.name === 'MeilisearchTaskTimeOutError') {
+            throw new SearchIndexTaskStillRunning({
+                taskUid: task.taskUid,
+                what,
+                timeoutMs,
+            });
+        }
+        // Anything else — an unreachable host, an auth refusal — is not this
+        // function's to interpret and is not swallowed.
+        throw error;
+    }
+    if (settled.status === 'succeeded')
+        return;
+    const code = settled.error?.code;
+    if (code !== undefined && tolerate.includes(code))
+        return;
+    throw new SearchIndexTaskFailed({
+        taskUid: task.taskUid,
+        what,
+        status: settled.status,
+        meilisearchCode: code,
+        detail: settled.error?.message,
+    });
+}
+export class SearchIndexer {
+    client;
+    locale;
+    attributeRead;
+    products;
+    categories;
+    channelMembership;
+    resolveTaskTimeoutMs;
+    constructor(options) {
+        const host = options.meilisearchHost ??
+            process.env['MEILISEARCH_URL'] ??
+            'http://localhost:7700';
+        const apiKey = options.meilisearchApiKey ??
+            process.env['MEILISEARCH_API_KEY'] ??
+            undefined;
+        this.client = new Meilisearch(apiKey ? { host, apiKey } : { host });
+        this.locale = options.locale ?? FALLBACK_LOCALE;
+        this.attributeRead = options.attributeRead;
+        this.products = options.products;
+        this.categories = options.categories;
+        this.channelMembership = options.channelMembership;
+        this.resolveTaskTimeoutMs =
+            options.resolveTaskTimeoutMs ?? (async () => DEFAULT_INDEX_TASK_TIMEOUT_MS);
+    }
+    /**
+     * Every Meilisearch task this module waits for goes through here — see
+     * {@link awaitIndexTask} for why the wait has one home and three outcomes.
+     */
+    async awaitTask(task, what, tolerate = []) {
+        await awaitIndexTask(this.client.tasks, task, what, await this.resolveTaskTimeoutMs(), tolerate);
+    }
+    /**
+     * Drop + recreate the channel index, reapply the searchable / filterable /
+     * sortable settings, then push every product visible in that channel.
+     * Returns counts so callers can log a summary.
+     */
+    async reindexChannel(em, channel) {
+        const indexUid = indexUidFor(channel);
+        const index = await this.ensureIndex(indexUid);
+        // The membership accessor answers which products the channel carries; the
+        // publishable narrowing that used to ride along in the same join is now
+        // `isPublishable`, the one predicate the incremental upsert already used.
+        // Two owners, two reads, one definition of publishable.
+        const memberIds = await this.channelMemberProductIds(channel.id);
+        const products = (await this.products.findByIds(memberIds)).filter(isPublishable);
+        const productIds = products.map((p) => p.id);
+        // Feature 068 — an inactive category must not survive in the indexed
+        // `categorySlugs`, or it keeps working as a storefront PLP filter.
+        const categoryRows = await this.categories.listAssignmentsForProducts(productIds, {
+            activeOnly: true,
+        });
+        const categoriesByProduct = new Map();
+        for (const row of categoryRows) {
+            const list = categoriesByProduct.get(row.productId) ?? [];
+            list.push({ id: row.categoryId, slug: row.slug });
+            categoriesByProduct.set(row.productId, list);
+        }
+        // Feature 012 / FR-035 — pre-load every searchable select-style
+        // attribute and its option labels so buildDocument() can render the
+        // per-locale text for each product's selected value(s).
+        const optionLookup = await this.loadSearchableOptionLookup(em, this.locale);
+        // Feature 022 — fetch every override row for this batch of products
+        // in one query, then bucket by productId. Each document is built
+        // with the channel's defaultLanguage so per-(channel, language)
+        // overrides for system Name / Description flow through.
+        const overrideRows = await this.products.listValueOverridesByProductIds(productIds);
+        const overridesByProduct = new Map();
+        for (const row of overrideRows) {
+            const list = overridesByProduct.get(row.productId) ?? [];
+            list.push(row);
+            overridesByProduct.set(row.productId, list);
+        }
+        const documents = products.map((p) => buildDocument(p, categoriesByProduct.get(p.id) ?? [], this.locale, optionLookup, {
+            overrides: overridesByProduct.get(p.id) ?? [],
+            channelId: channel.id,
+            languageCode: channel.defaultLanguage,
+        }));
+        // Wipe the index first so removed-from-channel products disappear from
+        // search. The offline reindex contract is "the index after this call
+        // exactly mirrors Postgres for this channel". Event-driven incremental
+        // reindex is a separate code path that can upsert without wiping.
+        const wipeTask = await index.deleteAllDocuments();
+        // O(the corpus being dropped). A wait that expires here is the worst of the
+        // twelve: the documents are already gone and the push below never runs, so
+        // an index that was merely slow is left empty.
+        await this.awaitTask(wipeTask, `wipe of ${indexUid}`);
+        // The settings go in while the index is empty, and that ordering is the
+        // whole reason they moved here from after the document push (issue #287).
+        // A settings update re-indexes the corpus it lands on, so on an empty
+        // index it is instant and can be awaited without risking the task-wait
+        // timeout a large channel would blow through — and awaiting it is what
+        // makes this method's postcondition true on return. Applied afterwards,
+        // every sorted query in the window between the document task settling and
+        // the settings task settling was answered `invalid_search_sort` and
+        // degraded to Postgres.
+        const { searchable, filterable } = await this.attributeSettings();
+        const settingsTasks = await Promise.all([
+            index.updateSearchableAttributes(searchable),
+            index.updateFilterableAttributes(filterable),
+            index.updateSortableAttributes([...SORTABLE_ATTRIBUTES]),
+        ]);
+        for (const task of settingsTasks) {
+            // O(1) by construction — this is the ordering the comment above is about.
+            // The wait is still not free: it queues behind whatever else the instance
+            // is doing, which is the term no site here controls.
+            await this.awaitTask(task, `index settings for ${indexUid}`);
+        }
+        if (documents.length > 0) {
+            const task = await index.addDocuments(documents, { primaryKey: 'id' });
+            // Wait for the task to settle so the documents are queryable when
+            // this method returns. Production callers (event-driven reindex)
+            // could fire-and-forget; the offline reindex CLI + tests both want
+            // the synchronous guarantee.
+            await this.awaitTask(task, `${documents.length}-document push to ${indexUid}`);
+        }
+        return {
+            indexUid,
+            documentCount: documents.length,
+            searchableAttributes: searchable,
+            filterableAttributes: filterable,
+            sortableAttributes: [...SORTABLE_ATTRIBUTES],
+        };
+    }
+    /**
+     * Incremental upsert of a single product into every channel index that
+     * publishes it. Used by the event-driven subscriber. Performs no index
+     * wipe and no setting changes — just a per-channel `addDocuments` (Meili
+     * upsert semantics) for the channels the product currently belongs to,
+     * plus a `deleteDocument` from any channel index it was removed from.
+     *
+     * Returns the channel codes that were touched so callers can log a
+     * one-line summary.
+     */
+    async upsertProduct(em, productId) {
+        const product = await this.products.findById(productId);
+        if (!product)
+            return [];
+        const channels = await em.find(SalesChannel, {});
+        const linkedChannelIds = new Set((await this.channelMembership.listChannelsForEntity('product', productId)).map((c) => c.id));
+        // Feature 068 — same activation filter as the full reindex.
+        const categoryRows = await this.categories.listAssignmentsForProducts([productId], {
+            activeOnly: true,
+        });
+        const categories = categoryRows.map((r) => ({ id: r.categoryId, slug: r.slug }));
+        // Feature 012 / FR-035 — same per-locale option-label projection
+        // used by the offline reindex. Per-product upsert is incremental,
+        // so we only build the lookup once per call.
+        const optionLookup = await this.loadSearchableOptionLookup(em, this.locale);
+        // Feature 022 — per-channel overrides for system Name / Description.
+        // Fetch once; the resolver then runs per (channel, channel.defaultLanguage).
+        const overrides = await this.products.listValueOverridesByProductIds([productId]);
+        const publishable = isPublishable(product);
+        const touched = [];
+        for (const channel of channels) {
+            const indexUid = indexUidFor(channel);
+            const index = await this.ensureIndex(indexUid);
+            if (linkedChannelIds.has(channel.id) && publishable) {
+                const document = buildDocument(product, categories, this.locale, optionLookup, {
+                    overrides,
+                    channelId: channel.id,
+                    languageCode: channel.defaultLanguage,
+                });
+                const task = await index.addDocuments([document], { primaryKey: 'id' });
+                await this.awaitTask(task, `upsert of product ${productId} into ${indexUid}`);
+            }
+            else {
+                // Either unlinked or no longer publishable — make sure the doc is gone.
+                const task = await index.deleteDocument(productId);
+                await this.awaitTask(task, `removal of product ${productId} from ${indexUid}`);
+            }
+            touched.push(channel.code);
+        }
+        return touched;
+    }
+    /**
+     * Feature 068 — re-index every product assigned to a category or any of its
+     * descendants. Called on `category.updated.v1`: a renamed or deactivated
+     * category changes the `categorySlugs` projection of its products, and a
+     * stale projection keeps a hidden category working as a PLP filter.
+     *
+     * The subtree walk and the de-duplication both belong to `catalog`, which
+     * owns `categories` and `product_categories`; this module used to run the
+     * recursive query itself. Returns the number of products re-indexed.
+     */
+    async reindexCategorySubtree(em, categoryId) {
+        const productIds = await this.categories.listProductIdsInSubtree(categoryId);
+        for (const productId of productIds) {
+            await this.upsertProduct(em, productId);
+        }
+        return productIds.length;
+    }
+    /**
+     * Drop a product from every channel index. Called on
+     * `product.archived.v1` and on hard delete.
+     */
+    async deleteProduct(em, productId) {
+        const channels = await em.find(SalesChannel, {});
+        const touched = [];
+        for (const channel of channels) {
+            const indexUid = indexUidFor(channel);
+            const index = await this.ensureIndex(indexUid);
+            const task = await index.deleteDocument(productId);
+            await this.awaitTask(task, `deletion of product ${productId} from ${indexUid}`);
+            touched.push(channel.code);
+        }
+        return touched;
+    }
+    /**
+     * Re-apply searchable + filterable attribute settings on every channel
+     * index, derived from the live `product_attributes` rows. Called on
+     * `attribute.updated.v1` so a flipped `isFilterable` / `isSearchable`
+     * propagates without a full reindex.
+     *
+     * It reapplies {@link SORTABLE_ATTRIBUTES} too, which is what lets an index
+     * built before issue #287 regain `name` sorting without waiting for a full
+     * reindex — the documents already carry the field. `createdAt` does not: a
+     * field that was never written has to be reindexed in.
+     */
+    async refreshAttributeSettings(em) {
+        const channels = await em.find(SalesChannel, {});
+        // Feature 012 — keep `searchableOptions` in the searchable list so
+        // toggling isSearchable on a select-style attribute takes effect
+        // without a full reindex. The aggregated field stays in the index
+        // documents from the previous reindex; settings refresh just opts
+        // it back into the search rank.
+        const { searchable, filterable } = await this.attributeSettings();
+        const touched = [];
+        for (const channel of channels) {
+            const indexUid = indexUidFor(channel);
+            const index = await this.ensureIndex(indexUid);
+            const searchableTask = await index.updateSearchableAttributes(searchable);
+            const filterableTask = await index.updateFilterableAttributes(filterable);
+            const sortableTask = await index.updateSortableAttributes([...SORTABLE_ATTRIBUTES]);
+            // Settings updates are async tasks; wait so callers reading the
+            // settings immediately after see the new values.
+            // Unlike the identical-looking three in `reindexChannel`, these land on
+            // a **populated** index, and a settings update re-indexes the corpus it
+            // lands on — so these are O(corpus) where those are O(1). It is the
+            // sharpest illustration of why the old per-site literals were not a
+            // considered set: the three cheapest waits and the three most expensive
+            // ones both took the client default by omission.
+            await this.awaitTask(searchableTask, `searchable attributes for ${indexUid}`);
+            await this.awaitTask(filterableTask, `filterable attributes for ${indexUid}`);
+            await this.awaitTask(sortableTask, `sortable attributes for ${indexUid}`);
+            touched.push(channel.code);
+        }
+        return touched;
+    }
+    async reindexAllChannels(em) {
+        const channels = await em.find(SalesChannel, {});
+        const results = [];
+        for (const channel of channels) {
+            const summary = await this.reindexChannel(em, channel);
+            results.push({
+                channelCode: channel.code,
+                indexUid: summary.indexUid,
+                documentCount: summary.documentCount,
+            });
+        }
+        return results;
+    }
+    /**
+     * Attach a Meilisearch embedder to a single channel index — feature 006 / T026.
+     *
+     * Wires Meilisearch's hybrid lexical + semantic search ("AI-augmented
+     * search"). Once attached, queries automatically blend keyword and
+     * vector scoring; the storefront does not change behaviour beyond
+     * ranking. We register the embedder under the well-known name
+     * `default` so callers do not have to thread the name through.
+     *
+     * Uses the `openAi` embedder source — accepts a custom `url`, so it
+     * works against any OpenAI-compatible endpoint (OpenAI itself, Azure
+     * OpenAI, Ollama's OpenAI shim, etc.). When the operator needs a
+     * non-OpenAI-shaped provider, the manifest can later expose
+     * `search.llm.embedder_source` with a discriminated union; out of
+     * scope for the MVP toggle.
+     */
+    async attachEmbedderForChannel(channelCode, config) {
+        const indexUid = indexUidFor({ code: channelCode });
+        const index = await this.ensureIndex(indexUid);
+        const task = await index.updateEmbedders({
+            default: {
+                source: 'openAi',
+                url: config.url,
+                apiKey: config.apiKey,
+                model: config.model,
+            },
+        });
+        // This site and `detachEmbedderForChannel` were the two that already
+        // carried a literal, `{ timeout: 30_000 }`, for the stated reason that
+        // Meilisearch may validate the embedder URL server-side. The reason was
+        // right and the remedy was local: nine sibling waits kept the 5 s default
+        // for no reason at all. Both now take the module-wide value, which is
+        // larger than the 30 s they asked for, so neither loses anything.
+        await this.awaitTask(task, `embedder attach on ${indexUid}`);
+    }
+    /**
+     * Detach the embedder from a single channel index — feature 006 / T026.
+     * Reverses {@link attachEmbedderForChannel} so the channel falls back
+     * to plain lexical ranking.
+     */
+    async detachEmbedderForChannel(channelCode) {
+        const indexUid = indexUidFor({ code: channelCode });
+        const index = await this.ensureIndex(indexUid);
+        const task = await index.resetEmbedders();
+        await this.awaitTask(task, `embedder detach on ${indexUid}`);
+    }
+    /**
+     * Feature 012 / FR-035 — build a per-call lookup of (attributeKey,
+     * value) → resolved per-locale option label, restricted to attributes
+     * that are isSearchable AND of a select-style type. Used by
+     * buildDocument() to fill the `searchableOptions` array on each
+     * indexed document so storefront search hits the customer-visible
+     * label, not the raw option value.
+     *
+     * The lookup is constructed in two queries (attribute set + option
+     * set) so the per-product loop stays O(1).
+     */
+    async loadSearchableOptionLookup(_em, locale) {
+        // Feature 061 — the option labels come from the composed view (backed by
+        // `custom_field_options`), restricted to isSearchable select-style
+        // attributes; no raw SQL against catalog storage.
+        const out = new Map();
+        const attrs = (await this.attributeRead.listByFlag('isSearchable')).filter((a) => a.valueType === 'select' || a.valueType === 'enum' || a.valueType === 'multiselect');
+        if (attrs.length === 0)
+            return out;
+        for (const attr of attrs) {
+            let bucket = out.get(attr.key);
+            if (!bucket) {
+                bucket = new Map();
+                out.set(attr.key, bucket);
+            }
+            for (const o of attr.options) {
+                const labelMap = o.label ?? {};
+                const rendered = labelMap[locale] ??
+                    labelMap[FALLBACK_LOCALE] ??
+                    Object.values(labelMap)[0] ??
+                    o.labelDefault ??
+                    o.value;
+                bucket.set(o.value, rendered);
+            }
+        }
+        return out;
+    }
+    /** Feature 061 — derive per-index searchable/filterable settings from the view. */
+    async attributeSettings() {
+        const attributes = await this.attributeRead.listAll();
+        // Feature 012 — `searchableOptions` is the rendered per-locale option
+        // label aggregator for every isSearchable select-style attribute. It
+        // joins the customer's mental model ("brass") with the operator's
+        // canonical option value ("brass_001" / "Mosiądz").
+        const searchable = ['name', 'sku', 'description', 'searchableOptions'];
+        const filterable = ['categoryIds', 'categorySlugs', 'visibility', 'status'];
+        for (const attr of attributes) {
+            const path = `attributes.${attr.key}`;
+            if (attr.isSearchable)
+                searchable.push(path);
+            if (attr.isFilterable)
+                filterable.push(path);
+        }
+        return { searchable, filterable };
+    }
+    async ensureIndex(uid) {
+        try {
+            return await this.client.getIndex(uid);
+        }
+        catch {
+            const task = await this.client.createIndex(uid, { primaryKey: 'id' });
+            // `index_already_exists` is tolerated, and it is the one site in this
+            // file where a failed task is an expected outcome rather than a defect:
+            // this method is a check-then-create with no lock, so two processes
+            // indexing the same channel both miss `getIndex` and both create. The
+            // loser's task fails and the index is there, which is the whole
+            // postcondition. Measured: a second `createIndex` returns a task with
+            // `status: 'failed'`, `code: 'index_already_exists'`.
+            await this.awaitTask(task, `index create for ${uid}`, ['index_already_exists']);
+            return this.client.getIndex(uid);
+        }
+    }
+    /**
+     * Every product id the channel carries, not the first page of them.
+     * `listEntityIdsForChannel` is paginated and a full reindex wants the whole
+     * assortment, so the pages are walked to `total`. `total` is re-read on each
+     * call and the loop is bounded by it, so a concurrent membership write cannot
+     * spin it — the shape `seo`'s sitemap generator settled on for this read.
+     */
+    async channelMemberProductIds(channelId) {
+        const ids = new Set();
+        for (let page = 0;; page += 1) {
+            const { entityIds, total } = await this.channelMembership.listEntityIdsForChannel(channelId, 'product', page, MEMBERSHIP_PAGE_SIZE);
+            for (const id of entityIds)
+                ids.add(id);
+            if (entityIds.length === 0 || ids.size >= total)
+                return [...ids];
+        }
+    }
+}
+/**
+ * What a channel index carries. Archived and soft-deleted rows are excluded
+ * here and not by `CatalogProductLookupOptions`, whose `activeOnly` covers
+ * `status` and `deletedAt` but not `archivedAt` — and an archived product must
+ * not stay searchable.
+ */
+function isPublishable(product) {
+    return product.status === 'active' && !product.deletedAt && !product.archivedAt;
+}
+export function indexUidFor(channel) {
+    return `products_${channel.code.replace(/[^a-z0-9_]/gi, '_').toLowerCase()}`;
+}
+function buildDocument(product, categories, locale, searchableOptionLookup, resolverInputs) {
+    // Feature 022 — when resolver inputs are supplied, route the system
+    // Name / Description through the four-step fallback chain so
+    // per-(channel, language) overrides are visible in search. When not
+    // supplied (legacy callers), fall back to plain locale-pick.
+    let name = pickLocale(product.name, locale);
+    let description = pickLocale(product.description, locale);
+    if (resolverInputs) {
+        const overrideRows = resolverInputs.overrides.map((o) => ({
+            attributeKey: o.attributeKey,
+            channelId: o.channelId,
+            languageCode: o.languageCode ?? null,
+            value: o.value,
+        }));
+        const ctx = {
+            channelId: resolverInputs.channelId,
+            languageCode: resolverInputs.languageCode,
+            primaryLanguage: resolverInputs.languageCode,
+        };
+        const resolvedName = resolveAttribute({
+            attributeKey: 'name',
+            baseline: product.name,
+            overrides: overrideRows,
+            scope: SYSTEM_ATTRIBUTE_SCOPES.name,
+            ctx,
+        });
+        const resolvedDesc = resolveAttribute({
+            attributeKey: 'description',
+            baseline: product.description,
+            overrides: overrideRows,
+            scope: SYSTEM_ATTRIBUTE_SCOPES.description,
+            ctx,
+        });
+        if (typeof resolvedName.value === 'string' && resolvedName.value.length > 0) {
+            name = resolvedName.value;
+        }
+        if (typeof resolvedDesc.value === 'string' && resolvedDesc.value.length > 0) {
+            description = resolvedDesc.value;
+        }
+    }
+    const attrs = {};
+    // Feature 012 — collect resolved per-locale option labels for every
+    // searchable select-style attribute the product carries a value for.
+    const searchableOptions = [];
+    for (const [key, value] of Object.entries(product.attributeValues)) {
+        if (value === null || value === undefined) {
+            attrs[key] = null;
+            continue;
+        }
+        const optionLabels = searchableOptionLookup.get(key);
+        if (Array.isArray(value)) {
+            // multiselect — array of option values.
+            if (optionLabels) {
+                for (const item of value) {
+                    const rendered = optionLabels.get(String(item));
+                    if (rendered)
+                        searchableOptions.push(rendered);
+                }
+            }
+            // Persist the raw shape too so non-search filtering still works
+            // (Meilisearch tolerates JSON-string fallback per the comment
+            // in the original implementation).
+            attrs[key] = JSON.stringify(value);
+            continue;
+        }
+        if (typeof value === 'string' ||
+            typeof value === 'number' ||
+            typeof value === 'boolean') {
+            attrs[key] = value;
+            if (optionLabels && typeof value === 'string') {
+                const rendered = optionLabels.get(value);
+                if (rendered)
+                    searchableOptions.push(rendered);
+            }
+            continue;
+        }
+        // Fall through for unexpected shapes — coerce to JSON string so the
+        // document still upserts. The query layer can ignore these.
+        attrs[key] = JSON.stringify(value);
+    }
+    // We also surface `categorySlugs` so the typed contract layer can filter
+    // by `categorySlug` without a join.
+    return {
+        id: product.id,
+        sku: product.sku,
+        name,
+        description,
+        type: product.type,
+        status: product.status,
+        visibility: product.visibility,
+        slug: product.slug,
+        primaryAssetUrl: null,
+        categoryIds: categories.map((c) => c.id),
+        categorySlugs: categories.map((c) => c.slug),
+        attributes: attrs,
+        searchableOptions,
+        createdAt: product.createdAt.getTime(),
+        updatedAt: product.updatedAt.getTime(),
+    };
+}
+function pickLocale(value, locale) {
+    return (value[locale] ?? value[FALLBACK_LOCALE] ?? Object.values(value)[0] ?? '');
+}
+//# sourceMappingURL=search-indexer.js.map