@open-mercato/search 0.4.2-canary-c02407ff85

package/dist/indexer/search-indexer.js

@@ -0,0 +1,848 @@
+import { searchDebug, searchDebugWarn, searchError } from "../lib/debug.js";
+const MAX_PAGES = 1e4;
+class SearchIndexer {
+  constructor(searchService, moduleConfigs, options) {
+    this.searchService = searchService;
+    this.moduleConfigs = moduleConfigs;
+    this.entityConfigMap = /* @__PURE__ */ new Map();
+    this.queryEngine = options?.queryEngine;
+    this.fulltextQueue = options?.fulltextQueue;
+    this.vectorQueue = options?.vectorQueue;
+    for (const moduleConfig of moduleConfigs) {
+      for (const entityConfig of moduleConfig.entities) {
+        if (entityConfig.enabled !== false) {
+          this.entityConfigMap.set(entityConfig.entityId, entityConfig);
+        }
+      }
+    }
+  }
+  /**
+   * Get the entity config for a given entity ID.
+   */
+  getEntityConfig(entityId) {
+    return this.entityConfigMap.get(entityId);
+  }
+  /**
+   * Get all configured entity configs.
+   */
+  getAllEntityConfigs() {
+    return Array.from(this.entityConfigMap.values());
+  }
+  /**
+   * Check if an entity is configured for search indexing.
+   */
+  isEntityEnabled(entityId) {
+    const config = this.entityConfigMap.get(entityId);
+    return config?.enabled !== false;
+  }
+  /**
+   * Index a record in the search service.
+   */
+  async indexRecord(params) {
+    const config = this.entityConfigMap.get(params.entityId);
+    if (!config || config.enabled === false) {
+      return;
+    }
+    const buildContext = {
+      record: params.record,
+      customFields: params.customFields ?? {},
+      organizationId: params.organizationId,
+      tenantId: params.tenantId,
+      queryEngine: this.queryEngine
+    };
+    let text;
+    let presenter;
+    let url;
+    let links;
+    let checksumSource;
+    if (config.buildSource) {
+      try {
+        const source = await config.buildSource(buildContext);
+        if (source) {
+          text = source.text;
+          if (source.presenter) presenter = source.presenter;
+          if (source.links) links = source.links;
+          if (source.checksumSource !== void 0) checksumSource = source.checksumSource;
+        }
+      } catch (error) {
+        searchDebugWarn("SearchIndexer", "buildSource failed", {
+          entityId: params.entityId,
+          recordId: params.recordId,
+          error: error instanceof Error ? error.message : error
+        });
+      }
+    }
+    if (!presenter && config.formatResult) {
+      try {
+        const result = await config.formatResult(buildContext);
+        if (result) presenter = result;
+      } catch (error) {
+        searchDebugWarn("SearchIndexer", "formatResult failed", {
+          entityId: params.entityId,
+          recordId: params.recordId,
+          error: error instanceof Error ? error.message : error
+        });
+      }
+    }
+    if (!url && config.resolveUrl) {
+      try {
+        const result = await config.resolveUrl(buildContext);
+        if (result) url = result;
+      } catch (error) {
+        searchDebugWarn("SearchIndexer", "resolveUrl failed", {
+          entityId: params.entityId,
+          recordId: params.recordId,
+          error: error instanceof Error ? error.message : error
+        });
+      }
+    }
+    if (!links && config.resolveLinks) {
+      try {
+        const result = await config.resolveLinks(buildContext);
+        if (result) links = result;
+      } catch (error) {
+        searchDebugWarn("SearchIndexer", "resolveLinks failed", {
+          entityId: params.entityId,
+          recordId: params.recordId,
+          error: error instanceof Error ? error.message : error
+        });
+      }
+    }
+    const indexableRecord = {
+      entityId: params.entityId,
+      recordId: params.recordId,
+      tenantId: params.tenantId,
+      organizationId: params.organizationId,
+      fields: params.record,
+      presenter,
+      url,
+      links,
+      text,
+      checksumSource
+    };
+    await this.searchService.index(indexableRecord);
+  }
+  /**
+   * Index a record by ID (loads the record from database first).
+   * Used by workers that only have record identifiers.
+   */
+  async indexRecordById(params) {
+    if (!this.queryEngine) {
+      return { action: "skipped", reason: "queryEngine not available" };
+    }
+    const config = this.entityConfigMap.get(params.entityId);
+    if (!config || config.enabled === false) {
+      return { action: "skipped", reason: "entity not configured" };
+    }
+    try {
+      const result = await this.queryEngine.query(params.entityId, {
+        tenantId: params.tenantId,
+        organizationId: params.organizationId ?? void 0,
+        filters: { id: params.recordId },
+        includeCustomFields: true,
+        page: { page: 1, pageSize: 1 }
+      });
+      const record = result.items[0];
+      if (!record) {
+        return { action: "skipped", reason: "record not found" };
+      }
+      const customFields = {};
+      for (const [key, value] of Object.entries(record)) {
+        if (key.startsWith("cf:") || key.startsWith("cf_")) {
+          customFields[key.slice(3)] = value;
+        }
+      }
+      await this.indexRecord({
+        entityId: params.entityId,
+        recordId: params.recordId,
+        tenantId: params.tenantId,
+        organizationId: params.organizationId,
+        record,
+        customFields
+      });
+      return { action: "indexed" };
+    } catch (error) {
+      searchError("SearchIndexer", "Failed to load record for indexing", {
+        entityId: params.entityId,
+        recordId: params.recordId,
+        error: error instanceof Error ? error.message : error
+      });
+      throw error;
+    }
+  }
+  /**
+   * Delete a record from the search index.
+   */
+  async deleteRecord(params) {
+    await this.searchService.delete(params.entityId, params.recordId, params.tenantId);
+  }
+  /**
+   * Purge all records of an entity type from the search index.
+   */
+  async purgeEntity(params) {
+    await this.searchService.purge(params.entityId, params.tenantId);
+  }
+  /**
+   * Reindex an entity via all configured strategies (including vector).
+   * This is the general reindex method that works with all search strategies.
+   */
+  async reindexEntity(params) {
+    if (!this.queryEngine) {
+      return {
+        success: false,
+        entitiesProcessed: 0,
+        recordsIndexed: 0,
+        errors: [{ entityId: params.entityId, error: "Query engine not available" }]
+      };
+    }
+    const config = this.entityConfigMap.get(params.entityId);
+    if (!config || config.enabled === false) {
+      return {
+        success: false,
+        entitiesProcessed: 0,
+        recordsIndexed: 0,
+        errors: [{ entityId: params.entityId, error: "Entity not configured for search" }]
+      };
+    }
+    const result = {
+      success: true,
+      entitiesProcessed: 1,
+      recordsIndexed: 0,
+      errors: []
+    };
+    if (params.purgeFirst) {
+      try {
+        await this.searchService.purge(params.entityId, params.tenantId);
+      } catch (error) {
+        searchDebugWarn("SearchIndexer", "Failed to purge entity before reindex", {
+          entityId: params.entityId,
+          error: error instanceof Error ? error.message : error
+        });
+      }
+    }
+    let page = 1;
+    const pageSize = 200;
+    let hasMore = true;
+    while (hasMore && page <= MAX_PAGES) {
+      try {
+        const queryResult = await this.queryEngine.query(params.entityId, {
+          tenantId: params.tenantId,
+          organizationId: params.organizationId ?? void 0,
+          includeCustomFields: true,
+          page: { page, pageSize }
+        });
+        const items = queryResult.items;
+        if (items.length === 0) {
+          hasMore = false;
+          break;
+        }
+        const { records } = await this.buildIndexableRecords(
+          params.entityId,
+          params.tenantId,
+          params.organizationId ?? null,
+          items,
+          config
+        );
+        for (const record of records) {
+          try {
+            await this.searchService.index(record);
+            result.recordsIndexed++;
+          } catch (error) {
+            searchDebugWarn("SearchIndexer", "Failed to index record", {
+              entityId: params.entityId,
+              recordId: record.recordId,
+              error: error instanceof Error ? error.message : error
+            });
+          }
+        }
+        page++;
+        hasMore = items.length === pageSize;
+      } catch (error) {
+        result.success = false;
+        result.errors.push({
+          entityId: params.entityId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        break;
+      }
+    }
+    return result;
+  }
+  /**
+   * Reindex all enabled entities via all configured strategies.
+   */
+  async reindexAll(params) {
+    const result = {
+      success: true,
+      entitiesProcessed: 0,
+      recordsIndexed: 0,
+      errors: []
+    };
+    const enabledEntities = this.listEnabledEntities();
+    for (const entityId of enabledEntities) {
+      const entityResult = await this.reindexEntity({
+        entityId,
+        tenantId: params.tenantId,
+        organizationId: params.organizationId,
+        purgeFirst: params.purgeFirst
+      });
+      result.entitiesProcessed++;
+      result.recordsIndexed += entityResult.recordsIndexed;
+      result.errors.push(...entityResult.errors);
+      if (!entityResult.success) {
+        result.success = false;
+      }
+    }
+    return result;
+  }
+  /**
+   * Bulk index multiple records.
+   */
+  async bulkIndexRecords(params) {
+    const indexableRecords = [];
+    for (const param of params) {
+      const config = this.entityConfigMap.get(param.entityId);
+      if (!config || config.enabled === false) {
+        continue;
+      }
+      const buildContext = {
+        record: param.record,
+        customFields: param.customFields ?? {},
+        organizationId: param.organizationId,
+        tenantId: param.tenantId
+      };
+      let presenter;
+      if (config.formatResult) {
+        try {
+          const result = await config.formatResult(buildContext);
+          if (result) presenter = result;
+        } catch {
+        }
+      }
+      let url;
+      if (config.resolveUrl) {
+        try {
+          const result = await config.resolveUrl(buildContext);
+          if (result) url = result;
+        } catch {
+        }
+      }
+      let links;
+      if (config.resolveLinks) {
+        try {
+          const result = await config.resolveLinks(buildContext);
+          if (result) links = result;
+        } catch {
+        }
+      }
+      indexableRecords.push({
+        entityId: param.entityId,
+        recordId: param.recordId,
+        tenantId: param.tenantId,
+        organizationId: param.organizationId,
+        fields: param.record,
+        presenter,
+        url,
+        links
+      });
+    }
+    if (indexableRecords.length > 0) {
+      await this.searchService.bulkIndex(indexableRecords);
+    }
+  }
+  /**
+   * List all enabled entity IDs from the module configurations.
+   */
+  listEnabledEntities() {
+    return Array.from(this.entityConfigMap.keys());
+  }
+  /**
+   * Get the fulltext strategy from the search service.
+   */
+  getFulltextStrategy() {
+    const strategy = this.searchService.getStrategy("fulltext");
+    if (!strategy) return void 0;
+    return strategy;
+  }
+  /**
+   * Reindex a single entity type to fulltext search.
+   * This fetches all records from the database and re-indexes them to fulltext only.
+   *
+   * When `useQueue` is true, batches are enqueued for background processing by workers.
+   * When `useQueue` is false (default), batches are indexed directly (blocking).
+   */
+  async reindexEntityToFulltext(params) {
+    const result = {
+      success: true,
+      entitiesProcessed: 0,
+      recordsIndexed: 0,
+      recordsDropped: 0,
+      jobsEnqueued: 0,
+      errors: []
+    };
+    const fulltext = this.getFulltextStrategy();
+    if (!fulltext) {
+      result.success = false;
+      result.errors.push({ entityId: params.entityId, error: "Fulltext strategy not available" });
+      return result;
+    }
+    if (params.useQueue && !this.fulltextQueue) {
+      result.success = false;
+      result.errors.push({ entityId: params.entityId, error: "Fulltext queue not configured for queue-based reindexing" });
+      return result;
+    }
+    if (!this.queryEngine) {
+      result.success = false;
+      result.errors.push({ entityId: params.entityId, error: "QueryEngine not available for reindexing" });
+      return result;
+    }
+    const config = this.entityConfigMap.get(params.entityId);
+    if (!config) {
+      result.success = false;
+      result.errors.push({ entityId: params.entityId, error: "Entity not configured for search" });
+      return result;
+    }
+    try {
+      params.onProgress?.({
+        entityId: params.entityId,
+        phase: "starting",
+        processed: 0
+      });
+      if (params.recreateIndex !== false) {
+        await fulltext.recreateIndex(params.tenantId);
+      }
+      const pageSize = 200;
+      let page = 1;
+      let totalProcessed = 0;
+      let jobsEnqueued = 0;
+      for (; ; ) {
+        params.onProgress?.({
+          entityId: params.entityId,
+          phase: "fetching",
+          processed: totalProcessed
+        });
+        try {
+          const queryResult = await this.queryEngine.query(params.entityId, {
+            tenantId: params.tenantId,
+            organizationId: params.organizationId ?? void 0,
+            page: { page, pageSize }
+          });
+          if (!queryResult.items.length) {
+            break;
+          }
+          params.onProgress?.({
+            entityId: params.entityId,
+            phase: "indexing",
+            processed: totalProcessed,
+            total: queryResult.total
+          });
+          const { records: indexableRecords, dropped } = await this.buildIndexableRecords(
+            params.entityId,
+            params.tenantId,
+            params.organizationId ?? null,
+            queryResult.items,
+            config
+          );
+          result.recordsDropped = (result.recordsDropped ?? 0) + dropped;
+          if (indexableRecords.length > 0) {
+            if (params.useQueue && this.fulltextQueue) {
+              await this.fulltextQueue.enqueue({
+                jobType: "batch-index",
+                tenantId: params.tenantId,
+                organizationId: params.organizationId,
+                records: indexableRecords.map((r) => ({ entityId: r.entityId, recordId: r.recordId }))
+              });
+              jobsEnqueued += 1;
+              totalProcessed += indexableRecords.length;
+            } else {
+              try {
+                await fulltext.bulkIndex(indexableRecords);
+                totalProcessed += indexableRecords.length;
+              } catch (indexError) {
+                const errorMsg = indexError instanceof Error ? indexError.message : String(indexError);
+                result.errors.push({
+                  entityId: params.entityId,
+                  error: `Batch ${page} failed: ${errorMsg}`
+                });
+              }
+            }
+          }
+          if (queryResult.items.length < pageSize) {
+            break;
+          }
+          page += 1;
+          if (page > MAX_PAGES) {
+            break;
+          }
+        } catch (queryError) {
+          const errorMsg = queryError instanceof Error ? queryError.message : String(queryError);
+          result.errors.push({
+            entityId: params.entityId,
+            error: `Query failed: ${errorMsg}`
+          });
+          break;
+        }
+      }
+      result.entitiesProcessed = 1;
+      result.recordsIndexed = totalProcessed;
+      result.jobsEnqueued = jobsEnqueued;
+      params.onProgress?.({
+        entityId: params.entityId,
+        phase: "complete",
+        processed: totalProcessed,
+        total: totalProcessed
+      });
+    } catch (error) {
+      result.success = false;
+      result.errors.push({
+        entityId: params.entityId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    return result;
+  }
+  /**
+   * Reindex all enabled entities to fulltext search.
+   *
+   * When `useQueue` is true, batches are enqueued for background processing by workers.
+   * When `useQueue` is false (default), batches are indexed directly (blocking).
+   */
+  async reindexAllToFulltext(params) {
+    const result = {
+      success: true,
+      entitiesProcessed: 0,
+      recordsIndexed: 0,
+      recordsDropped: 0,
+      jobsEnqueued: 0,
+      errors: []
+    };
+    const fulltext = this.getFulltextStrategy();
+    if (!fulltext) {
+      result.success = false;
+      result.errors.push({ entityId: "all", error: "Fulltext strategy not available" });
+      return result;
+    }
+    if (params.recreateIndex !== false) {
+      await fulltext.recreateIndex(params.tenantId);
+    }
+    const entities = this.listEnabledEntities();
+    for (const entityId of entities) {
+      const entityResult = await this.reindexEntityToFulltext({
+        entityId,
+        tenantId: params.tenantId,
+        organizationId: params.organizationId,
+        recreateIndex: false,
+        // Already recreated above
+        onProgress: params.onProgress,
+        useQueue: params.useQueue
+      });
+      result.entitiesProcessed += entityResult.entitiesProcessed;
+      result.recordsIndexed += entityResult.recordsIndexed;
+      result.recordsDropped = (result.recordsDropped ?? 0) + (entityResult.recordsDropped ?? 0);
+      result.jobsEnqueued = (result.jobsEnqueued ?? 0) + (entityResult.jobsEnqueued ?? 0);
+      result.errors.push(...entityResult.errors);
+      if (!entityResult.success) {
+        result.success = false;
+      }
+    }
+    return result;
+  }
+  /**
+   * Reindex a single entity type to vector search.
+   * This fetches all records from the database and enqueues them for vector indexing.
+   *
+   * When `useQueue` is true (default), record IDs are enqueued for background processing by workers.
+   * When `useQueue` is false, records are indexed directly (blocking).
+   */
+  async reindexEntityToVector(params) {
+    searchDebug("SearchIndexer", "reindexEntityToVector called", {
+      entityId: params.entityId,
+      tenantId: params.tenantId,
+      organizationId: params.organizationId,
+      useQueue: params.useQueue,
+      purgeFirst: params.purgeFirst
+    });
+    const result = {
+      success: true,
+      entitiesProcessed: 0,
+      recordsIndexed: 0,
+      recordsDropped: 0,
+      jobsEnqueued: 0,
+      errors: []
+    };
+    if (params.useQueue !== false && !this.vectorQueue) {
+      result.success = false;
+      result.errors.push({ entityId: params.entityId, error: "Vector queue not configured for queue-based reindexing" });
+      return result;
+    }
+    if (!this.queryEngine) {
+      result.success = false;
+      result.errors.push({ entityId: params.entityId, error: "QueryEngine not available for reindexing" });
+      return result;
+    }
+    const config = this.entityConfigMap.get(params.entityId);
+    if (!config) {
+      result.success = false;
+      result.errors.push({ entityId: params.entityId, error: "Entity not configured for search" });
+      return result;
+    }
+    try {
+      params.onProgress?.({
+        entityId: params.entityId,
+        phase: "starting",
+        processed: 0
+      });
+      if (params.purgeFirst) {
+        try {
+          await this.searchService.purge(params.entityId, params.tenantId);
+        } catch (error) {
+          searchDebugWarn("SearchIndexer", "Failed to purge entity before vector reindex", {
+            entityId: params.entityId,
+            error: error instanceof Error ? error.message : error
+          });
+        }
+      }
+      const pageSize = 200;
+      let page = 1;
+      let totalProcessed = 0;
+      let jobsEnqueued = 0;
+      for (; ; ) {
+        params.onProgress?.({
+          entityId: params.entityId,
+          phase: "fetching",
+          processed: totalProcessed
+        });
+        const queryResult = await this.queryEngine.query(params.entityId, {
+          tenantId: params.tenantId,
+          organizationId: params.organizationId ?? void 0,
+          page: { page, pageSize }
+        });
+        if (!queryResult.items.length) break;
+        params.onProgress?.({
+          entityId: params.entityId,
+          phase: "indexing",
+          processed: totalProcessed,
+          total: queryResult.total
+        });
+        const batchRecords = [];
+        for (const item of queryResult.items) {
+          const recordId = String(item.id ?? "");
+          if (!recordId) {
+            result.recordsDropped = (result.recordsDropped ?? 0) + 1;
+            continue;
+          }
+          batchRecords.push({
+            entityId: params.entityId,
+            recordId
+          });
+        }
+        if (batchRecords.length > 0) {
+          if (params.useQueue !== false && this.vectorQueue) {
+            await this.vectorQueue.enqueue({
+              jobType: "batch-index",
+              tenantId: params.tenantId,
+              organizationId: params.organizationId ?? null,
+              records: batchRecords
+            });
+            jobsEnqueued += 1;
+            totalProcessed += batchRecords.length;
+            searchDebug("SearchIndexer", "Enqueued batch for vector indexing", {
+              entityId: params.entityId,
+              batchSize: batchRecords.length,
+              jobsEnqueued,
+              totalProcessed
+            });
+          } else {
+            for (const { entityId, recordId } of batchRecords) {
+              try {
+                await this.indexRecordById({
+                  entityId,
+                  recordId,
+                  tenantId: params.tenantId,
+                  organizationId: params.organizationId
+                });
+                totalProcessed++;
+              } catch (error) {
+                searchDebugWarn("SearchIndexer", "Failed to index record to vector", {
+                  entityId,
+                  recordId,
+                  error: error instanceof Error ? error.message : error
+                });
+              }
+            }
+          }
+        }
+        if (queryResult.items.length < pageSize) break;
+        page += 1;
+        if (page > MAX_PAGES) {
+          searchDebugWarn("SearchIndexer", "Reached MAX_PAGES limit, stopping pagination", {
+            entityId: params.entityId,
+            maxPages: MAX_PAGES,
+            totalProcessed
+          });
+          break;
+        }
+      }
+      result.entitiesProcessed = 1;
+      result.recordsIndexed = totalProcessed;
+      result.jobsEnqueued = jobsEnqueued;
+      params.onProgress?.({
+        entityId: params.entityId,
+        phase: "complete",
+        processed: totalProcessed,
+        total: totalProcessed
+      });
+    } catch (error) {
+      result.success = false;
+      result.errors.push({
+        entityId: params.entityId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    return result;
+  }
+  /**
+   * Reindex all enabled entities to vector search.
+   *
+   * When `useQueue` is true (default), batches are enqueued for background processing by workers.
+   * When `useQueue` is false, batches are indexed directly (blocking).
+   */
+  async reindexAllToVector(params) {
+    const result = {
+      success: true,
+      entitiesProcessed: 0,
+      recordsIndexed: 0,
+      recordsDropped: 0,
+      jobsEnqueued: 0,
+      errors: []
+    };
+    const entities = this.listEnabledEntities();
+    for (const entityId of entities) {
+      const entityResult = await this.reindexEntityToVector({
+        entityId,
+        tenantId: params.tenantId,
+        organizationId: params.organizationId,
+        onProgress: params.onProgress,
+        useQueue: params.useQueue,
+        purgeFirst: params.purgeFirst
+      });
+      result.entitiesProcessed += entityResult.entitiesProcessed;
+      result.recordsIndexed += entityResult.recordsIndexed;
+      result.recordsDropped = (result.recordsDropped ?? 0) + (entityResult.recordsDropped ?? 0);
+      result.jobsEnqueued = (result.jobsEnqueued ?? 0) + (entityResult.jobsEnqueued ?? 0);
+      result.errors.push(...entityResult.errors);
+      if (!entityResult.success) {
+        result.success = false;
+      }
+    }
+    return result;
+  }
+  /**
+   * Build IndexableRecords from raw query results.
+   * Returns records and count of dropped items (missing id or other validation failures).
+   */
+  async buildIndexableRecords(entityId, tenantId, organizationId, items, config) {
+    const records = [];
+    let dropped = 0;
+    if (items.length > 0) {
+      searchDebug("SearchIndexer", "Sample item structure", {
+        entityId,
+        sampleKeys: Object.keys(items[0]),
+        sampleId: items[0].id,
+        hasId: "id" in items[0],
+        firstName: items[0].first_name,
+        lastName: items[0].last_name,
+        preferredName: items[0].preferred_name,
+        sampleItem: JSON.stringify(items[0]).slice(0, 500)
+      });
+    }
+    for (const item of items) {
+      const recordId = String(item.id ?? "");
+      if (!recordId) {
+        searchDebugWarn("SearchIndexer", "Skipping item without id", { entityId, itemKeys: Object.keys(item) });
+        dropped++;
+        continue;
+      }
+      const customFields = {};
+      for (const [key, value] of Object.entries(item)) {
+        if (key.startsWith("cf:") || key.startsWith("cf_")) {
+          const cfKey = key.slice(3);
+          customFields[cfKey] = value;
+        }
+      }
+      const buildContext = {
+        record: item,
+        customFields,
+        organizationId,
+        tenantId,
+        queryEngine: this.queryEngine
+      };
+      let text;
+      let presenter;
+      let url;
+      let links;
+      let checksumSource;
+      if (config.buildSource) {
+        try {
+          const source = await config.buildSource(buildContext);
+          if (source) {
+            text = source.text;
+            if (source.presenter) presenter = source.presenter;
+            if (source.links) links = source.links;
+            if (source.checksumSource !== void 0) checksumSource = source.checksumSource;
+          }
+        } catch (err) {
+          searchDebugWarn("SearchIndexer", "buildSource failed", {
+            entityId,
+            recordId,
+            error: err instanceof Error ? err.message : err
+          });
+        }
+      }
+      if (!presenter && config.formatResult) {
+        try {
+          const result = await config.formatResult(buildContext);
+          if (result) presenter = result;
+        } catch {
+        }
+      }
+      if (!url && config.resolveUrl) {
+        try {
+          const result = await config.resolveUrl(buildContext);
+          if (result) url = result;
+        } catch {
+        }
+      }
+      if (!links && config.resolveLinks) {
+        try {
+          const result = await config.resolveLinks(buildContext);
+          if (result) links = result;
+        } catch {
+        }
+      }
+      records.push({
+        entityId,
+        recordId,
+        tenantId,
+        organizationId,
+        fields: item,
+        presenter,
+        url,
+        links,
+        text,
+        checksumSource
+      });
+    }
+    searchDebug("SearchIndexer", "Finished building records", {
+      entityId,
+      inputCount: items.length,
+      outputCount: records.length,
+      dropped
+    });
+    return { records, dropped };
+  }
+}
+export {
+  SearchIndexer
+};
+//# sourceMappingURL=search-indexer.js.map