@open-mercato/search 0.4.2-canary-c02407ff85

package/build.mjs

@@ -0,0 +1,92 @@
+import * as esbuild from 'esbuild'
+import { glob } from 'glob'
+import { readFileSync, writeFileSync, existsSync, mkdirSync, copyFileSync } from 'node:fs'
+import { dirname, join, relative } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+const entryPoints = await glob('src/**/*.{ts,tsx}', {
+  ignore: ['**/__tests__/**', '**/*.test.ts', '**/*.test.tsx']
+})
+
+// Plugin to add .js extension to relative imports
+const addJsExtension = {
+  name: 'add-js-extension',
+  setup(build) {
+    build.onEnd(async (result) => {
+      if (result.errors.length > 0) return
+      const outputFiles = await glob('dist/**/*.js')
+      for (const file of outputFiles) {
+        const fileDir = dirname(file)
+        let content = readFileSync(file, 'utf-8')
+        // Add .js to relative imports that don't have an extension
+        content = content.replace(
+          /from\s+["'](\.[^"']+)["']/g,
+          (match, path) => {
+            if (path.endsWith('.js') || path.endsWith('.json')) return match
+            // Check if it's a directory with index.js
+            const resolvedPath = join(fileDir, path)
+            if (existsSync(resolvedPath) && existsSync(join(resolvedPath, 'index.js'))) {
+              return `from "${path}/index.js"`
+            }
+            return `from "${path}.js"`
+          }
+        )
+        content = content.replace(
+          /import\s*\(\s*["'](\.[^"']+)["']\s*\)/g,
+          (match, path) => {
+            if (path.endsWith('.js') || path.endsWith('.json')) return match
+            // Check if it's a directory with index.js
+            const resolvedPath = join(fileDir, path)
+            if (existsSync(resolvedPath) && existsSync(join(resolvedPath, 'index.js'))) {
+              return `import("${path}/index.js")`
+            }
+            return `import("${path}.js")`
+          }
+        )
+        // Handle side-effect imports: import "./path" (no from clause)
+        content = content.replace(
+          /import\s+["'](\.[^"']+)["'];/g,
+          (match, path) => {
+            if (path.endsWith('.js') || path.endsWith('.json')) return match
+            // Check if it's a directory with index.js
+            const resolvedPath = join(fileDir, path)
+            if (existsSync(resolvedPath) && existsSync(join(resolvedPath, 'index.js'))) {
+              return `import "${path}/index.js";`
+            }
+            return `import "${path}.js";`
+          }
+        )
+        writeFileSync(file, content)
+      }
+    })
+  }
+}
+
+const outdir = join(__dirname, 'dist')
+
+await esbuild.build({
+  entryPoints,
+  outdir,
+  outbase: join(__dirname, 'src'),
+  format: 'esm',
+  platform: 'node',
+  target: 'node18',
+  sourcemap: true,
+  jsx: 'automatic',
+  plugins: [addJsExtension],
+})
+
+// Copy JSON files from src to dist (esbuild doesn't handle non-entry JSON files)
+const jsonFiles = await glob(join(__dirname, 'src/**/*.json'), {
+  ignore: ['**/node_modules/**']
+})
+for (const jsonFile of jsonFiles) {
+  const relativePath = relative(join(__dirname, 'src'), jsonFile)
+  const destPath = join(outdir, relativePath)
+  mkdirSync(dirname(destPath), { recursive: true })
+  copyFileSync(jsonFile, destPath)
+}
+
+console.log('search built successfully')

package/dist/di.js

@@ -0,0 +1,157 @@
+import { asValue } from "awilix";
+import { SearchService } from "./service.js";
+import { TokenSearchStrategy } from "./strategies/token.strategy.js";
+import { VectorSearchStrategy } from "./strategies/vector.strategy.js";
+import { FullTextSearchStrategy } from "./strategies/fulltext.strategy.js";
+import { createFulltextDriver } from "./fulltext/drivers/index.js";
+import { SearchIndexer } from "./indexer/search-indexer.js";
+import { createPresenterEnricher } from "./lib/presenter-enricher.js";
+function shouldExcludeEncryptedFields() {
+  const raw = (process.env.SEARCH_EXCLUDE_ENCRYPTED_FIELDS ?? "").toLowerCase();
+  return raw === "1" || raw === "true" || raw === "yes" || raw === "on";
+}
+function createEncryptionMapResolver(knex) {
+  const cache = /* @__PURE__ */ new Map();
+  const CACHE_TTL_MS = 5 * 60 * 1e3;
+  return async (entityId) => {
+    const cached = cache.get(entityId);
+    if (cached && cached.expiresAt > Date.now()) {
+      return cached.entries;
+    }
+    try {
+      const rows = await knex("encryption_maps").select("fields_json").where("entity_id", entityId).where("is_active", true).whereNull("deleted_at").first();
+      const fieldsJson = rows?.fields_json;
+      const entries = Array.isArray(fieldsJson) ? fieldsJson.map((f) => ({
+        field: f.field,
+        hashField: f.hashField ?? null
+      })) : [];
+      cache.set(entityId, { entries, expiresAt: Date.now() + CACHE_TTL_MS });
+      return entries;
+    } catch {
+      return [];
+    }
+  };
+}
+function registerSearchModule(container, options) {
+  const strategies = [];
+  if (!options?.skipTokens) {
+    try {
+      const em = container.resolve("em");
+      const knex = em.getConnection().getKnex();
+      strategies.push(new TokenSearchStrategy(knex));
+    } catch {
+    }
+  }
+  if (!options?.skipVector) {
+    try {
+      const embeddingService = container.resolve("vectorEmbeddingService");
+      const drivers = container.resolve("vectorDrivers");
+      const primaryDriver = drivers?.[0];
+      if (embeddingService && primaryDriver) {
+        strategies.push(new VectorSearchStrategy(embeddingService, primaryDriver));
+      }
+    } catch {
+    }
+  }
+  const entityConfigMap = /* @__PURE__ */ new Map();
+  for (const moduleConfig of options?.moduleConfigs ?? []) {
+    for (const entityConfig of moduleConfig.entities) {
+      if (entityConfig.enabled !== false) {
+        entityConfigMap.set(entityConfig.entityId, entityConfig);
+      }
+    }
+  }
+  if (!options?.skipFulltext) {
+    let encryptionMapResolver;
+    if (shouldExcludeEncryptedFields()) {
+      try {
+        const em = container.resolve("em");
+        const knex = em.getConnection().getKnex();
+        encryptionMapResolver = createEncryptionMapResolver(knex);
+      } catch {
+      }
+    }
+    const fulltextDriver = createFulltextDriver({
+      fieldPolicyResolver: (entityId) => {
+        const config = entityConfigMap.get(entityId);
+        return config?.fieldPolicy;
+      },
+      encryptionMapResolver
+    });
+    if (fulltextDriver) {
+      strategies.push(new FullTextSearchStrategy(fulltextDriver));
+    }
+  }
+  const defaultStrategies = options?.defaultStrategies ?? determineDefaultStrategies(strategies);
+  let queryEngine;
+  try {
+    queryEngine = container.resolve("queryEngine");
+  } catch {
+  }
+  let encryptionService = null;
+  try {
+    encryptionService = container.resolve("tenantEncryptionService");
+  } catch {
+  }
+  let presenterEnricher;
+  try {
+    const em = container.resolve("em");
+    const knex = em.getConnection().getKnex();
+    presenterEnricher = createPresenterEnricher(knex, entityConfigMap, queryEngine, encryptionService);
+  } catch {
+  }
+  const searchService = new SearchService({
+    strategies,
+    defaultStrategies,
+    fallbackStrategy: "tokens",
+    mergeConfig: options?.mergeConfig ?? {
+      duplicateHandling: "highest_score",
+      strategyWeights: {
+        fulltext: 1.2,
+        vector: 1,
+        tokens: 0.8
+      }
+    },
+    presenterEnricher
+  });
+  const moduleConfigs = options?.moduleConfigs ?? [];
+  let fulltextQueue;
+  try {
+    fulltextQueue = container.resolve("fulltextIndexQueue");
+  } catch {
+  }
+  let vectorQueue;
+  try {
+    vectorQueue = container.resolve("vectorIndexQueue");
+  } catch {
+  }
+  const searchIndexer = new SearchIndexer(searchService, moduleConfigs, {
+    queryEngine,
+    fulltextQueue,
+    vectorQueue
+  });
+  container.register({
+    searchService: asValue(searchService),
+    searchStrategies: asValue(strategies),
+    searchIndexer: asValue(searchIndexer)
+  });
+}
+function determineDefaultStrategies(strategies) {
+  const available = new Set(strategies.map((s) => s.id));
+  const defaults = [];
+  if (available.has("fulltext")) defaults.push("fulltext");
+  if (available.has("vector")) defaults.push("vector");
+  if (available.has("tokens")) defaults.push("tokens");
+  return defaults.length > 0 ? defaults : ["tokens"];
+}
+function addSearchStrategy(container, strategy) {
+  const service = container.resolve("searchService");
+  service.registerStrategy(strategy);
+  const strategies = container.resolve("searchStrategies");
+  strategies.push(strategy);
+}
+export {
+  addSearchStrategy,
+  registerSearchModule
+};
+//# sourceMappingURL=di.js.map

package/dist/di.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/di.ts"],
+  "sourcesContent": ["import { asValue } from 'awilix'\nimport type { Knex } from 'knex'\nimport { SearchService } from './service'\nimport { TokenSearchStrategy } from './strategies/token.strategy'\nimport { VectorSearchStrategy, type EmbeddingService } from './strategies/vector.strategy'\nimport { FullTextSearchStrategy } from './strategies/fulltext.strategy'\nimport { createFulltextDriver } from './fulltext/drivers'\nimport { SearchIndexer } from './indexer/search-indexer'\nimport type {\n  SearchStrategy,\n  ResultMergeConfig,\n  SearchModuleConfig,\n  SearchFieldPolicy,\n  SearchEntityConfig,\n  PresenterEnricherFn,\n} from './types'\nimport type { VectorDriver } from './vector/types'\nimport type { QueryEngine } from '@open-mercato/shared/lib/query/types'\nimport type { EntityId } from '@open-mercato/shared/modules/entities'\nimport type { Queue } from '@open-mercato/queue'\nimport type { FulltextIndexJobPayload } from './queue/fulltext-indexing'\nimport type { VectorIndexJobPayload } from './queue/vector-indexing'\nimport type { EncryptionMapEntry } from './lib/field-policy'\nimport type { TenantDataEncryptionService } from '@open-mercato/shared/lib/encryption/tenantDataEncryptionService'\nimport { createPresenterEnricher } from './lib/presenter-enricher'\n\n/**\n * Check if encrypted fields should be excluded from search indexing.\n * Controlled by SEARCH_EXCLUDE_ENCRYPTED_FIELDS environment variable.\n * Default: false (index all fields including decrypted data)\n */\nfunction shouldExcludeEncryptedFields(): boolean {\n  const raw = (process.env.SEARCH_EXCLUDE_ENCRYPTED_FIELDS ?? '').toLowerCase()\n  return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on'\n}\n\n/**\n * Create an encryption map resolver that queries the database.\n * Falls back to empty array if query fails.\n */\nfunction createEncryptionMapResolver(\n  knex: Knex,\n): (entityId: EntityId) => Promise<EncryptionMapEntry[]> {\n  // Cache encryption maps per entity to avoid repeated queries\n  const cache = new Map<string, { entries: EncryptionMapEntry[]; expiresAt: number }>()\n  const CACHE_TTL_MS = 5 * 60 * 1000 // 5 minutes\n\n  return async (entityId: EntityId): Promise<EncryptionMapEntry[]> => {\n    const cached = cache.get(entityId)\n    if (cached && cached.expiresAt > Date.now()) {\n      return cached.entries\n    }\n\n    try {\n      const rows = await knex('encryption_maps')\n        .select('fields_json')\n        .where('entity_id', entityId)\n        .where('is_active', true)\n        .whereNull('deleted_at')\n        .first()\n\n      const fieldsJson = rows?.fields_json\n      const entries: EncryptionMapEntry[] = Array.isArray(fieldsJson)\n        ? fieldsJson.map((f: { field: string; hashField?: string | null }) => ({\n            field: f.field,\n            hashField: f.hashField ?? null,\n          }))\n        : []\n\n      cache.set(entityId, { entries, expiresAt: Date.now() + CACHE_TTL_MS })\n      return entries\n    } catch {\n      // Query failed, return empty array (don't exclude any fields)\n      return []\n    }\n  }\n}\n\n/**\n * Container interface - minimal subset needed for registration.\n */\nexport interface SearchContainer {\n  resolve<T = unknown>(name: string): T\n  register(registrations: Record<string, unknown>): void\n}\n\n/**\n * Configuration options for search module registration.\n */\nexport type SearchModuleOptions = {\n  /** Override default strategies to use */\n  defaultStrategies?: string[]\n  /** Override merge configuration */\n  mergeConfig?: ResultMergeConfig\n  /** Skip token strategy registration */\n  skipTokens?: boolean\n  /** Skip vector strategy registration */\n  skipVector?: boolean\n  /** Skip fulltext strategy registration */\n  skipFulltext?: boolean\n  /** Module configurations (from generated/search.generated.ts) */\n  moduleConfigs?: SearchModuleConfig[]\n}\n\n/**\n * Register the search module in the DI container.\n *\n * This creates and registers:\n * - SearchService instance\n * - All configured search strategies\n *\n * @param container - Awilix container\n * @param options - Optional configuration overrides\n */\nexport function registerSearchModule(\n  container: SearchContainer,\n  options?: SearchModuleOptions,\n): void {\n  const strategies: SearchStrategy[] = []\n\n  // Token strategy (always available unless explicitly skipped)\n  if (!options?.skipTokens) {\n    try {\n      const em = container.resolve<{ getConnection: () => { getKnex: () => Knex } }>('em')\n      const knex = em.getConnection().getKnex()\n      strategies.push(new TokenSearchStrategy(knex))\n    } catch {\n      // knex not available via em, skipping TokenSearchStrategy\n    }\n  }\n\n  // Vector strategy (requires embedding service and driver)\n  // Note: We register even if not currently available - availability is checked at search time\n  // via isAvailable(). The embedding config may be loaded later from the database.\n  if (!options?.skipVector) {\n    try {\n      const embeddingService = container.resolve<EmbeddingService>('vectorEmbeddingService')\n      const drivers = container.resolve<VectorDriver[]>('vectorDrivers')\n      const primaryDriver = drivers?.[0]\n\n      if (embeddingService && primaryDriver) {\n        strategies.push(new VectorSearchStrategy(embeddingService, primaryDriver))\n      }\n    } catch {\n      // Vector module not available, skipping VectorSearchStrategy\n    }\n  }\n\n  // Build entity config map for field policy resolution\n  const entityConfigMap = new Map<EntityId, SearchEntityConfig>()\n  for (const moduleConfig of (options?.moduleConfigs ?? [])) {\n    for (const entityConfig of moduleConfig.entities) {\n      if (entityConfig.enabled !== false) {\n        entityConfigMap.set(entityConfig.entityId as EntityId, entityConfig)\n      }\n    }\n  }\n\n  // Fulltext strategy (requires driver configuration, e.g., MEILISEARCH_HOST)\n  if (!options?.skipFulltext) {\n    // Build encryption map resolver if SEARCH_EXCLUDE_ENCRYPTED_FIELDS is enabled\n    let encryptionMapResolver: ((entityId: EntityId) => Promise<EncryptionMapEntry[]>) | undefined\n    if (shouldExcludeEncryptedFields()) {\n      try {\n        const em = container.resolve<{ getConnection: () => { getKnex: () => Knex } }>('em')\n        const knex = em.getConnection().getKnex()\n        encryptionMapResolver = createEncryptionMapResolver(knex)\n      } catch {\n        // Knex not available, encrypted field filtering disabled\n      }\n    }\n\n    const fulltextDriver = createFulltextDriver({\n      fieldPolicyResolver: (entityId: EntityId): SearchFieldPolicy | undefined => {\n        const config = entityConfigMap.get(entityId)\n        return config?.fieldPolicy\n      },\n      encryptionMapResolver,\n    })\n\n    if (fulltextDriver) {\n      strategies.push(new FullTextSearchStrategy(fulltextDriver))\n    }\n  }\n\n  // Determine default strategies based on what's available\n  const defaultStrategies = options?.defaultStrategies ?? determineDefaultStrategies(strategies)\n\n  // Try to resolve queryEngine for reindex support and presenter enrichment\n  let queryEngine: QueryEngine | undefined\n  try {\n    queryEngine = container.resolve<QueryEngine>('queryEngine')\n  } catch {\n    // QueryEngine not available, reindex will be disabled\n  }\n\n  // Resolve encryption service for decrypting presenter data\n  let encryptionService: TenantDataEncryptionService | null = null\n  try {\n    encryptionService = container.resolve<TenantDataEncryptionService>('tenantEncryptionService')\n  } catch {\n    // Encryption service not available, presenters won't be decrypted\n  }\n\n  // Create presenter enricher for database-based presenter resolution\n  let presenterEnricher: PresenterEnricherFn | undefined\n  try {\n    const em = container.resolve<{ getConnection: () => { getKnex: () => Knex } }>('em')\n    const knex = em.getConnection().getKnex()\n    presenterEnricher = createPresenterEnricher(knex, entityConfigMap, queryEngine, encryptionService)\n  } catch {\n    // knex not available, presenter enrichment disabled\n  }\n\n  // Create search service\n  const searchService = new SearchService({\n    strategies,\n    defaultStrategies,\n    fallbackStrategy: 'tokens',\n    mergeConfig: options?.mergeConfig ?? {\n      duplicateHandling: 'highest_score',\n      strategyWeights: {\n        fulltext: 1.2,\n        vector: 1.0,\n        tokens: 0.8,\n      },\n    },\n    presenterEnricher,\n  })\n\n  // Create search indexer with module configs\n  const moduleConfigs = options?.moduleConfigs ?? []\n\n  // Try to resolve fulltextIndexQueue for queue-based reindexing\n  let fulltextQueue: Queue<FulltextIndexJobPayload> | undefined\n  try {\n    fulltextQueue = container.resolve<Queue<FulltextIndexJobPayload>>('fulltextIndexQueue')\n  } catch {\n    // Queue not available, queue-based fulltext reindex will be disabled\n  }\n\n  // Try to resolve vectorIndexQueue for queue-based vector reindexing\n  let vectorQueue: Queue<VectorIndexJobPayload> | undefined\n  try {\n    vectorQueue = container.resolve<Queue<VectorIndexJobPayload>>('vectorIndexQueue')\n  } catch {\n    // Queue not available, queue-based vector reindex will be disabled\n  }\n\n  const searchIndexer = new SearchIndexer(searchService, moduleConfigs, {\n    queryEngine,\n    fulltextQueue,\n    vectorQueue,\n  })\n\n  // Register in container\n  container.register({\n    searchService: asValue(searchService),\n    searchStrategies: asValue(strategies),\n    searchIndexer: asValue(searchIndexer),\n  })\n}\n\n/**\n * Determine default strategy order based on available strategies.\n * Prefers fulltext > vector > tokens.\n */\nfunction determineDefaultStrategies(strategies: SearchStrategy[]): string[] {\n  const available = new Set(strategies.map((s) => s.id))\n  const defaults: string[] = []\n\n  if (available.has('fulltext')) defaults.push('fulltext')\n  if (available.has('vector')) defaults.push('vector')\n  if (available.has('tokens')) defaults.push('tokens')\n\n  return defaults.length > 0 ? defaults : ['tokens']\n}\n\n/**\n * Helper to add a custom strategy to an existing SearchService.\n *\n * @param container - DI container\n * @param strategy - Strategy to add\n */\nexport function addSearchStrategy(container: SearchContainer, strategy: SearchStrategy): void {\n  const service = container.resolve<SearchService>('searchService')\n  service.registerStrategy(strategy)\n\n  const strategies = container.resolve<SearchStrategy[]>('searchStrategies')\n  strategies.push(strategy)\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/fulltext/drivers/index.js

@@ -0,0 +1,21 @@
+import { createMeilisearchDriver } from "./meilisearch/index.js";
+import { createMeilisearchDriver as createMeilisearchDriver2 } from "./meilisearch/index.js";
+function createFulltextDriver(options) {
+  const meilisearchHost = options?.meilisearch?.host ?? process.env.MEILISEARCH_HOST;
+  if (meilisearchHost) {
+    return createMeilisearchDriver({
+      host: meilisearchHost,
+      apiKey: options?.meilisearch?.apiKey ?? process.env.MEILISEARCH_API_KEY,
+      indexPrefix: options?.meilisearch?.indexPrefix ?? process.env.MEILISEARCH_INDEX_PREFIX,
+      encryptionMapResolver: options?.encryptionMapResolver,
+      fieldPolicyResolver: options?.fieldPolicyResolver,
+      defaultLimit: options?.defaultLimit
+    });
+  }
+  return null;
+}
+export {
+  createFulltextDriver,
+  createMeilisearchDriver2 as createMeilisearchDriver
+};
+//# sourceMappingURL=index.js.map

package/dist/fulltext/drivers/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/fulltext/drivers/index.ts"],
+  "sourcesContent": ["import type { FullTextSearchDriver, FullTextSearchDriverConfig } from '../types'\nimport { createMeilisearchDriver } from './meilisearch'\n\nexport { createMeilisearchDriver, type MeilisearchDriverOptions } from './meilisearch'\n\nexport type FulltextDriverFactoryOptions = FullTextSearchDriverConfig & {\n  meilisearch?: {\n    host?: string\n    apiKey?: string\n    indexPrefix?: string\n  }\n  algolia?: {\n    appId?: string\n    apiKey?: string\n    indexPrefix?: string\n  }\n}\n\nexport function createFulltextDriver(\n  options?: FulltextDriverFactoryOptions\n): FullTextSearchDriver | null {\n  const meilisearchHost = options?.meilisearch?.host ?? process.env.MEILISEARCH_HOST\n\n  if (meilisearchHost) {\n    return createMeilisearchDriver({\n      host: meilisearchHost,\n      apiKey: options?.meilisearch?.apiKey ?? process.env.MEILISEARCH_API_KEY,\n      indexPrefix: options?.meilisearch?.indexPrefix ?? process.env.MEILISEARCH_INDEX_PREFIX,\n      encryptionMapResolver: options?.encryptionMapResolver,\n      fieldPolicyResolver: options?.fieldPolicyResolver,\n      defaultLimit: options?.defaultLimit,\n    })\n  }\n\n  // Future: Add Algolia, Elasticsearch, Typesense drivers here\n  // if (options?.algolia?.appId || process.env.ALGOLIA_APP_ID) {\n  //   return createAlgoliaDriver({ ... })\n  // }\n\n  return null\n}\n"],
+  "mappings": "AACA,SAAS,+BAA+B;AAExC,SAAS,2BAAAA,gCAA8D;AAehE,SAAS,qBACd,SAC6B;AAC7B,QAAM,kBAAkB,SAAS,aAAa,QAAQ,QAAQ,IAAI;AAElE,MAAI,iBAAiB;AACnB,WAAO,wBAAwB;AAAA,MAC7B,MAAM;AAAA,MACN,QAAQ,SAAS,aAAa,UAAU,QAAQ,IAAI;AAAA,MACpD,aAAa,SAAS,aAAa,eAAe,QAAQ,IAAI;AAAA,MAC9D,uBAAuB,SAAS;AAAA,MAChC,qBAAqB,SAAS;AAAA,MAC9B,cAAc,SAAS;AAAA,IACzB,CAAC;AAAA,EACH;AAOA,SAAO;AACT;",
+  "names": ["createMeilisearchDriver"]
+}

package/dist/fulltext/drivers/meilisearch/index.js

@@ -0,0 +1,320 @@
+import { MeiliSearch } from "meilisearch";
+import { extractSearchableFields } from "../../../lib/field-policy.js";
+function createMeilisearchDriver(options) {
+  const host = options?.host ?? process.env.MEILISEARCH_HOST ?? "";
+  const apiKey = options?.apiKey ?? process.env.MEILISEARCH_API_KEY ?? "";
+  const indexPrefix = options?.indexPrefix ?? process.env.MEILISEARCH_INDEX_PREFIX ?? "om";
+  const defaultLimit = options?.defaultLimit ?? 20;
+  const encryptionMapResolver = options?.encryptionMapResolver;
+  const fieldPolicyResolver = options?.fieldPolicyResolver;
+  let client = null;
+  const initializedIndexes = /* @__PURE__ */ new Set();
+  const initializingIndexes = /* @__PURE__ */ new Map();
+  function getClient() {
+    if (!client) {
+      client = new MeiliSearch({ host, apiKey });
+    }
+    return client;
+  }
+  function buildIndexName(tenantId) {
+    const sanitized = tenantId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return `${indexPrefix}_${sanitized}`;
+  }
+  function escapeFilterValue(value) {
+    return value.replace(/["\\]/g, "\\$&");
+  }
+  function buildFilters(options2) {
+    const filters = [];
+    if (options2.organizationId) {
+      filters.push(`_organizationId = "${escapeFilterValue(options2.organizationId)}"`);
+    }
+    if (options2.entityTypes?.length) {
+      const entityFilter = options2.entityTypes.map((t) => `"${escapeFilterValue(t)}"`).join(", ");
+      filters.push(`_entityId IN [${entityFilter}]`);
+    }
+    return filters;
+  }
+  async function doEnsureIndex(indexName) {
+    const meiliClient = getClient();
+    try {
+      await meiliClient.createIndex(indexName, { primaryKey: "_id" });
+    } catch (error) {
+      const meilisearchError = error;
+      if (meilisearchError.code !== "index_already_exists") {
+        throw error;
+      }
+    }
+    const index = meiliClient.index(indexName);
+    await index.updateSettings({
+      searchableAttributes: ["*"],
+      filterableAttributes: ["_entityId", "_organizationId"],
+      sortableAttributes: ["_indexedAt"],
+      typoTolerance: {
+        enabled: true,
+        minWordSizeForTypos: {
+          oneTypo: 4,
+          twoTypos: 8
+        }
+      }
+    });
+    initializedIndexes.add(indexName);
+  }
+  async function ensureIndex(indexName) {
+    if (initializedIndexes.has(indexName)) {
+      return;
+    }
+    const existingPromise = initializingIndexes.get(indexName);
+    if (existingPromise) {
+      return existingPromise;
+    }
+    const initPromise = doEnsureIndex(indexName);
+    initializingIndexes.set(indexName, initPromise);
+    try {
+      await initPromise;
+    } finally {
+      initializingIndexes.delete(indexName);
+    }
+  }
+  async function prepareDocument(doc) {
+    const excludeEncrypted = Boolean(encryptionMapResolver);
+    const encryptedFields = encryptionMapResolver ? await encryptionMapResolver(doc.entityId) : [];
+    const fieldPolicy = fieldPolicyResolver?.(doc.entityId);
+    const searchableFields = extractSearchableFields(doc.fields, {
+      encryptedFields,
+      fieldPolicy
+    });
+    let presenter = doc.presenter;
+    let links = doc.links;
+    if (excludeEncrypted) {
+      if (presenter) {
+        presenter = {
+          ...presenter,
+          title: "",
+          // Will be enriched at search time
+          subtitle: void 0
+          // Will be enriched at search time
+        };
+      }
+      if (links && links.length > 0) {
+        links = links.map((link) => ({
+          ...link,
+          label: link.kind === "primary" ? "Open" : "View"
+          // Generic labels
+        }));
+      }
+    }
+    return {
+      _id: doc.recordId,
+      _entityId: doc.entityId,
+      _organizationId: doc.organizationId,
+      _presenter: presenter,
+      _url: doc.url,
+      _links: links,
+      _indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...searchableFields
+    };
+  }
+  const driver = {
+    id: "meilisearch",
+    async ensureReady() {
+    },
+    async isHealthy() {
+      if (!host) {
+        return false;
+      }
+      try {
+        const meiliClient = getClient();
+        await meiliClient.health();
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async search(query, options2) {
+      const meiliClient = getClient();
+      const indexName = buildIndexName(options2.tenantId);
+      try {
+        const index = meiliClient.index(indexName);
+        const filters = buildFilters(options2);
+        const response = await index.search(query, {
+          limit: options2.limit ?? defaultLimit,
+          offset: options2.offset,
+          filter: filters.length > 0 ? filters.join(" AND ") : void 0,
+          showRankingScore: true
+        });
+        return response.hits.map((hit) => ({
+          recordId: hit._id,
+          entityId: hit._entityId,
+          score: hit._rankingScore ?? 0.5,
+          presenter: hit._presenter,
+          url: hit._url,
+          links: hit._links,
+          metadata: hit._metadata
+        }));
+      } catch (error) {
+        const meilisearchError = error;
+        if (meilisearchError.code === "index_not_found") {
+          return [];
+        }
+        throw error;
+      }
+    },
+    async index(doc) {
+      const meiliClient = getClient();
+      const indexName = buildIndexName(doc.tenantId);
+      await ensureIndex(indexName);
+      const document = await prepareDocument(doc);
+      const index = meiliClient.index(indexName);
+      await index.addDocuments([document], { primaryKey: "_id" });
+    },
+    async delete(recordId, tenantId) {
+      const meiliClient = getClient();
+      const indexName = buildIndexName(tenantId);
+      try {
+        const index = meiliClient.index(indexName);
+        await index.deleteDocument(recordId);
+      } catch (error) {
+        const meilisearchError = error;
+        if (meilisearchError.code === "index_not_found") {
+          return;
+        }
+        throw error;
+      }
+    },
+    async bulkIndex(docs) {
+      if (docs.length === 0) return;
+      const byTenant = /* @__PURE__ */ new Map();
+      for (const doc of docs) {
+        const list = byTenant.get(doc.tenantId) ?? [];
+        list.push(doc);
+        byTenant.set(doc.tenantId, list);
+      }
+      const meiliClient = getClient();
+      for (const [tenantId, tenantDocs] of byTenant) {
+        const indexName = buildIndexName(tenantId);
+        await ensureIndex(indexName);
+        const documents = await Promise.all(tenantDocs.map(prepareDocument));
+        const index = meiliClient.index(indexName);
+        await index.addDocuments(documents, { primaryKey: "_id" });
+      }
+    },
+    async purge(entityId, tenantId) {
+      const meiliClient = getClient();
+      const indexName = buildIndexName(tenantId);
+      try {
+        const index = meiliClient.index(indexName);
+        await index.deleteDocuments({
+          filter: `_entityId = "${entityId}"`
+        });
+      } catch (error) {
+        const meilisearchError = error;
+        if (meilisearchError.code === "index_not_found") {
+          return;
+        }
+        throw error;
+      }
+    },
+    async clearIndex(tenantId) {
+      const meiliClient = getClient();
+      const indexName = buildIndexName(tenantId);
+      try {
+        const index = meiliClient.index(indexName);
+        await index.deleteAllDocuments();
+      } catch (error) {
+        const meilisearchError = error;
+        if (meilisearchError.code === "index_not_found") {
+          return;
+        }
+        throw error;
+      }
+    },
+    async recreateIndex(tenantId) {
+      const meiliClient = getClient();
+      const indexName = buildIndexName(tenantId);
+      initializedIndexes.delete(indexName);
+      try {
+        await meiliClient.deleteIndex(indexName);
+      } catch (error) {
+        const meilisearchError = error;
+        if (meilisearchError.code !== "index_not_found") {
+          throw error;
+        }
+      }
+      await ensureIndex(indexName);
+    },
+    async getDocuments(ids, tenantId) {
+      const result = /* @__PURE__ */ new Map();
+      if (ids.length === 0) return result;
+      const meiliClient = getClient();
+      const indexName = buildIndexName(tenantId);
+      try {
+        const index = meiliClient.index(indexName);
+        const recordIds = ids.map((id) => id.recordId);
+        const documents = await index.getDocuments({
+          filter: `_id IN [${recordIds.map((id) => `"${id}"`).join(", ")}]`,
+          limit: recordIds.length
+        });
+        for (const doc of documents.results) {
+          const hit = doc;
+          const key = `${hit._entityId}:${hit._id}`;
+          result.set(key, {
+            recordId: hit._id,
+            entityId: hit._entityId,
+            score: 0,
+            presenter: hit._presenter,
+            url: hit._url,
+            links: hit._links
+          });
+        }
+      } catch {
+      }
+      return result;
+    },
+    async getIndexStats(tenantId) {
+      const meiliClient = getClient();
+      const indexName = buildIndexName(tenantId);
+      try {
+        const index = meiliClient.index(indexName);
+        const stats = await index.getStats();
+        return {
+          numberOfDocuments: stats.numberOfDocuments,
+          isIndexing: stats.isIndexing,
+          fieldDistribution: stats.fieldDistribution
+        };
+      } catch (error) {
+        const meilisearchError = error;
+        if (meilisearchError.code === "index_not_found") {
+          return null;
+        }
+        throw error;
+      }
+    },
+    async getEntityCounts(tenantId) {
+      const meiliClient = getClient();
+      const indexName = buildIndexName(tenantId);
+      try {
+        const index = meiliClient.index(indexName);
+        const searchResult = await index.search("", {
+          limit: 0,
+          facets: ["_entityId"]
+        });
+        const facetDistribution = searchResult.facetDistribution?._entityId;
+        if (!facetDistribution) {
+          return {};
+        }
+        return facetDistribution;
+      } catch (error) {
+        const meilisearchError = error;
+        if (meilisearchError.code === "index_not_found") {
+          return null;
+        }
+        throw error;
+      }
+    }
+  };
+  return driver;
+}
+export {
+  createMeilisearchDriver
+};
+//# sourceMappingURL=index.js.map