@meeovi/layer-search 1.0.7 → 1.0.8

package/README.md

@@ -118,6 +118,8 @@ Example `search` config in your app:
 
 The module validates that `defaultProvider` and the referenced provider configuration exist, and that required fields for each adapter are present.
 
+Note: this repository includes a top-level `.env.example` with recommended variables for Search and other providers; you can manage layer credentials from your main app's `.env` file. See `../.env.example`.
+
 ## UI Integrations (InstantSearch / Searchkit)
 
 This layer includes bridges that let UI code use Algolia InstantSearch or Searchkit clients without coupling the UI to a particular backend provider. Use `createInstantSearchBridge` / `createSearchkitBridge` on the client, and `createSearchkitGraphQLHandler` on the server when exposing a GraphQL endpoint for Searchkit-server.
@@ -177,6 +179,35 @@ Environment variables supported (example for Meilisearch):
 - `MEILI_INDEX=products`
 - `MEILI_KEY=masterKey`
 
+Searchkit / Search provider environment variables
+
+- `SEARCHKIT_HOST` or `NUXT_PUBLIC_SEARCHKIT_HOST` — full host URL (e.g. `https://search.example.com`)
+- Alternatively compose with:
+  - `SEARCHKIT_PROTOCOL` / `NUXT_PUBLIC_SEARCHKIT_PROTOCOL` (defaults to `http`)
+  - `SEARCHKIT_HOSTNAME` / `NUXT_PUBLIC_SEARCHKIT_HOSTNAME` (e.g. `search.example.com`)
+  - `SEARCHKIT_PORT` / `NUXT_PUBLIC_SEARCHKIT_PORT` (e.g. `9200`)
+- Optional API key: `SEARCHKIT_API_KEY` or `NUXT_PUBLIC_SEARCHKIT_API_KEY`
+
+Notes:
+- Use the `NUXT_PUBLIC_` prefix for values that must be available in client-side code (public build). Keep API keys server-only when possible.
+- The plugin logs a runtime validation message on startup if search provider configuration is missing, with examples of env vars to set.
+
+Layer env conventions
+
+- All layers use the same environment lookup convention: the code checks `KEY` and falls back to `NUXT_PUBLIC_KEY` when appropriate. This lets you manage provider credentials and endpoints centrally from your main application's `.env` file.
+- Example `.env` entries in your main app to configure the Search layer:
+
+```
+SEARCHKIT_HOST=https://search.example.com
+SEARCHKIT_API_KEY=server-only-key
+# or compose:
+SEARCHKIT_PROTOCOL=https
+SEARCHKIT_HOSTNAME=search.example.com
+SEARCHKIT_PORT=9200
+```
+
+Because every layer follows this `KEY` / `NUXT_PUBLIC_KEY` pattern, you can place settings in the main app's `.env` and they will be available to the layer at runtime without editing layer files.
+
 ## Testing
 
 Use the mock adapter in tests to avoid external dependencies:

package/app/components/features/autocomplete.vue

@@ -0,0 +1,63 @@
+<template>
+	<div class="autocomplete">
+		<input
+			v-model="input"
+			@input="onInput"
+			@keydown.enter.prevent="onSelectFirst"
+			:placeholder="placeholder"
+			class="autocomplete-input"
+		/>
+		<ul v-if="suggestions.length" class="autocomplete-list">
+			<li v-for="(s, i) in suggestions" :key="i" @click="select(s)">
+				<div class="title">{{ s.title || s.name || s.label || s.id }}</div>
+				<div class="subtitle" v-if="s.description">{{ s.description }}</div>
+			</li>
+		</ul>
+	</div>
+</template>
+
+<script setup lang="ts">
+import { ref, watch } from 'vue'
+import useSearchkit from '../../composables/useSearchkit'
+
+const props = defineProps({ placeholder: { type: String, default: 'Search...' } })
+const emits = defineEmits(['select', 'input'])
+
+const { autocomplete } = useSearchkit()
+const input = ref('')
+const suggestions = ref<any[]>([])
+let timer: any = null
+
+async function onInput() {
+	emits('input', input.value)
+	clearTimeout(timer)
+	timer = setTimeout(async () => {
+		if (!input.value || input.value.length < 1) {
+			suggestions.value = []
+			return
+		}
+		suggestions.value = await autocomplete(input.value, 6)
+	}, 180)
+}
+
+function select(item: any) {
+	emits('select', item)
+	suggestions.value = []
+}
+
+function onSelectFirst() {
+	if (suggestions.value.length) select(suggestions.value[0])
+}
+
+watch(input, (v) => {
+	if (!v) suggestions.value = []
+})
+</script>
+
+<style scoped>
+.autocomplete { position: relative; }
+.autocomplete-list { position: absolute; left: 0; right: 0; background: white; z-index: 50; list-style: none; margin: 0; padding: 0; border: 1px solid #ddd; }
+.autocomplete-list li { padding: 8px; cursor: pointer; }
+.autocomplete-list li:hover { background: #f5f5f5; }
+.autocomplete-input { width: 100%; padding: 8px; border: 1px solid #ccc; }
+</style>

package/app/components/features/searchkitSearch.vue

@@ -0,0 +1,115 @@
+<template>
+  <div class="searchkit-search">
+    <div class="controls">
+      <SearchInput v-model="query" @search="onSearch" />
+      <autocomplete @input="onInput" @select="onSelect" />
+
+      <label>
+        <select v-model="ranking" @change="onRankingChange">
+          <option value="relevance">Relevance</option>
+          <option value="newest">Newest</option>
+          <option value="popularity">Popularity</option>
+        </select>
+      </label>
+
+      <label>
+        Semantic:
+        <input type="checkbox" v-model="semanticEnabled" @change="toggleSemantic" />
+      </label>
+
+      <label>
+        Per page:
+        <select v-model.number="perPage" @change="onPerPage">
+          <option :value="12">12</option>
+          <option :value="24">24</option>
+          <option :value="48">48</option>
+        </select>
+      </label>
+    </div>
+
+    <div class="filters">
+      <div v-for="(agg, key) in facets" :key="key" class="facet">
+        <strong>{{ key }}</strong>
+        <ul>
+          <li v-for="(b, idx) in bucketsFor(agg)" :key="idx">{{ b.key }} ({{ b.doc_count }})</li>
+        </ul>
+      </div>
+    </div>
+
+    <ResultList :hits="hits" :loading="loading">
+      <template #item="{ hit }">
+        <div>
+          <h3>{{ hit.title || hit.name }}</h3>
+          <p v-if="hit.description">{{ hit.description }}</p>
+          <small v-if="hit.location">{{ hit.location.lat }}, {{ hit.location.lon }}</small>
+        </div>
+      </template>
+    </ResultList>
+
+    <pagination :page="page" :totalPages="totalPages" @change="onPageChange" />
+  </div>
+</template>
+
+<script setup lang="ts">
+import { watch, computed } from 'vue'
+import useSearchkit from '../../composables/useSearchkit'
+import SearchInput from '../molecules/SearchInput.vue'
+import autocomplete from './autocomplete.vue'
+import ResultList from '../molecules/resultList.vue'
+import pagination from '../molecules/pagination.vue'
+
+const { query, hits, loading, page, perPage, facets, totalPages, search, setPage, setPerPage, setSemantic, ranking } = useSearchkit()
+
+const semanticEnabled = computed({ get: () => false, set: (v: boolean) => setSemantic(v) })
+
+function onSearch() {
+  page.value = 1
+  return search()
+}
+
+function onInput(val: string) {
+  query.value = val
+}
+
+function onSelect(item: any) {
+  // if suggestion contains a query text or id, perform targeted search
+  query.value = item.query || item.title || item.name || query.value
+  search()
+}
+
+function onPageChange(p: number) {
+  return setPage(p)
+}
+
+function onPerPage(e: any) {
+  return setPerPage(parseInt(e.target.value || '12', 10))
+}
+
+function toggleSemantic(e: Event) {
+  const target = e.target as HTMLInputElement
+  return setSemantic(target.checked)
+}
+
+function onRankingChange(e: Event) {
+  const target = e.target as HTMLSelectElement
+  ranking.value = target.value as any
+  return search()
+}
+
+function bucketsFor(agg: any) {
+  return (agg && (agg.buckets || agg.terms || agg)) || []
+}
+
+// initialize
+search()
+
+watch(query, () => {
+  // do not auto-search on every keystroke by default; controlled via SearchInput
+})
+</script>
+
+<style scoped>
+.controls { display:flex; gap:12px; align-items:center; flex-wrap:wrap }
+.filters { margin-top:12px; display:flex; gap:16px }
+.facet { background:#fafafa; padding:8px; border:1px solid #eee }
+</style>

package/app/components/molecules/pagination.vue

@@ -0,0 +1,17 @@
+<template>
+  <nav class="pagination" v-if="totalPages > 1">
+    <button :disabled="page <= 1" @click="$emit('change', page - 1)">Prev</button>
+    <span>Page {{ page }} / {{ totalPages }}</span>
+    <button :disabled="page >= totalPages" @click="$emit('change', page + 1)">Next</button>
+  </nav>
+</template>
+
+<script setup lang="ts">
+const props = defineProps({ page: { type: Number, required: true }, totalPages: { type: Number, required: true } })
+const emits = defineEmits(['change'])
+</script>
+
+<style scoped>
+.pagination { display:flex; gap:8px; align-items:center; }
+.pagination button[disabled] { opacity: 0.5 }
+</style>

package/app/components/molecules/resultList.vue

@@ -0,0 +1,25 @@
+<template>
+  <div class="result-list">
+    <div v-if="loading">Loading…</div>
+    <div v-else>
+      <div class="hits" v-if="hits.length">
+        <div v-for="(hit, idx) in hits" :key="hit._meta || idx" class="hit-item">
+          <slot name="item" :hit="hit">
+            <h3>{{ hit.title || hit.name || hit.id }}</h3>
+            <p v-if="hit.description">{{ hit.description }}</p>
+          </slot>
+        </div>
+      </div>
+      <div v-else class="no-results">No results</div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+const props = defineProps({ hits: { type: Array, default: () => [] }, loading: { type: Boolean, default: false } })
+</script>
+
+<style scoped>
+.hit-item { padding: 12px; border-bottom: 1px solid #eee; }
+.no-results { color: #777; padding: 12px; }
+</style>

package/app/composables/useSearchkit.ts

@@ -0,0 +1,217 @@
+import { ref, computed } from 'vue'
+import { useNuxtApp } from 'nuxt/app'
+
+export function useSearchkit() {
+  const nuxt = useNuxtApp() as any
+  const client: any = nuxt.$searchClient
+  const indexName: string = (nuxt.$searchIndexName as string) || 'default'
+  const helpers: any = nuxt.$searchHelpers || {}
+
+  const query = ref('')
+  const hits = ref<any[]>([])
+  const total = ref(0)
+  const loading = ref(false)
+  const page = ref(1)
+  const perPage = ref(12)
+  const sortBy = ref<string | null>(null)
+  const facets = ref<Record<string, any>>({})
+  const geo = ref<{ lat?: number; lon?: number; distanceKm?: number }>({})
+  const semantic = ref(false)
+  const ranking = ref<'relevance' | 'newest' | 'popularity' | 'custom'>('relevance')
+
+  async function search() {
+    if (!client || typeof client.search !== 'function') {
+      throw new Error('Search client is not available or does not implement `search`')
+    }
+
+    loading.value = true
+    const from = (page.value - 1) * perPage.value
+
+    // Build params — aim for compatibility with Searchkit/Elasticsearch via instantsearch client.
+    const params: any = {
+      params: {
+        q: query.value || '*',
+        size: perPage.value,
+        from,
+      },
+    }
+
+    // Sorting strategies
+    if (ranking.value === 'newest') {
+      params.params.sort = 'created_at:desc'
+    } else if (ranking.value === 'popularity') {
+      params.params.sort = 'popularity:desc'
+    } else if (sortBy.value) {
+      params.params.sort = sortBy.value
+    }
+
+    // Geo filter: translate into an Elasticsearch geo_distance filter in body
+    if (geo.value.lat && geo.value.lon && geo.value.distanceKm) {
+      params.body = params.body || {}
+      params.body.query = params.body.query || { bool: { must: [{ match_all: {} }], filter: [] } }
+      const filter = { geo_distance: { distance: `${geo.value.distanceKm}km`, location: { lat: geo.value.lat, lon: geo.value.lon } } }
+      params.body.query.bool.filter.push(filter)
+    }
+
+    // Semantic hint flag — some backends will honour this to run semantic/rerank
+    if (semantic.value) {
+      params.params.semantic = true
+    }
+
+    try {
+      const results = await client.search([{ indexName, ...params }])
+      const res = results && results[0]
+      if (!res) {
+        hits.value = []
+        total.value = 0
+        facets.value = {}
+        return
+      }
+
+      // Best-effort parsing for common instantsearch-style responses
+      const rawHits = (res.hits && res.hits.hits) || (res.hits && res.hits) || res.hits
+      let parsedHits: any[] = []
+      if (Array.isArray(rawHits)) {
+        // ES style hits.hits
+        parsedHits = rawHits.map((h: any) => (h._source ? { ...h._source, _meta: h._id } : h))
+      } else if (res.hits && res.hits.hits) {
+        parsedHits = res.hits.hits.map((h: any) => (h._source ? { ...h._source, _meta: h._id } : h))
+      } else if (res.hits) {
+        parsedHits = res.hits
+      } else {
+        parsedHits = []
+      }
+
+      total.value = (res.hits && (res.hits.total?.value ?? res.hits.total)) || res.nbHits || 0
+
+      // Aggregations / facets parsing (normalize via plugin helper when available)
+      const rawAggs = res.aggregations || res.facets || {}
+      if (helpers && typeof helpers.mapAggregations === 'function') {
+        try {
+          facets.value = helpers.mapAggregations(rawAggs)
+        } catch (e) {
+          facets.value = rawAggs
+        }
+      } else {
+        facets.value = rawAggs
+      }
+
+      // If semantic rerank is enabled, attempt to call the plugin helper to reorder results.
+      if (semantic.value && helpers && typeof helpers.semanticRerank === 'function') {
+        try {
+          const reranked = await helpers.semanticRerank(parsedHits, query.value)
+          hits.value = Array.isArray(reranked) ? reranked : parsedHits
+        } catch (e) {
+          // fallback to parsedHits on error
+          hits.value = parsedHits
+        }
+      } else {
+        hits.value = parsedHits
+      }
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function autocomplete(input: string, limit = 6) {
+    if (!client) return []
+    try {
+      // Use a small search request to act as suggestions
+      const params = {
+        params: { q: input || '*', size: limit },
+      }
+      const result = await client.search([{ indexName, ...params }])
+      const r = result && result[0]
+      const suggestionHits = (r && ((r.hits && r.hits.hits) || r.hits)) || []
+      return Array.isArray(suggestionHits)
+        ? suggestionHits.map((h: any) => (h._source ? h._source : h))
+        : []
+    } catch (e) {
+      return []
+    }
+  }
+
+  function setPage(p: number) {
+    page.value = p
+    return search()
+  }
+
+  function setPerPage(n: number) {
+    perPage.value = n
+    page.value = 1
+    return search()
+  }
+
+  function setSort(sort: string | null) {
+    sortBy.value = sort
+    return search()
+  }
+
+  function setGeo(lat: number, lon: number, distanceKm = 50) {
+    geo.value = { lat, lon, distanceKm }
+    page.value = 1
+    return search()
+  }
+
+  function setSemantic(enabled: boolean) {
+    semantic.value = enabled
+    return search()
+  }
+
+  const totalPages = computed(() => Math.max(1, Math.ceil((total.value || 0) / perPage.value)))
+
+  // Provide a normalized facets structure for consumers: { facetName: [{ key, doc_count }, ...] }
+  const normalizedFacets = computed(() => {
+    const out: Record<string, Array<{ key: string; doc_count: number }>> = {}
+    try {
+      for (const k of Object.keys(facets.value || {})) {
+        const v = (facets.value as any)[k]
+        if (!v) {
+          out[k] = []
+          continue
+        }
+        if (Array.isArray(v)) {
+          out[k] = v.map((b: any) => ({ key: b.key ?? b.value ?? String(b), doc_count: b.doc_count ?? b.count ?? 0 }))
+        } else if (v.buckets) {
+          out[k] = v.buckets.map((b: any) => ({ key: b.key ?? b.value, doc_count: b.doc_count ?? 0 }))
+        } else if (v.terms) {
+          out[k] = v.terms.map((b: any) => ({ key: b.key ?? b.value, doc_count: b.doc_count ?? 0 }))
+        } else {
+          // generic object — try to map entries
+          out[k] = Object.keys(v).map((kk) => ({ key: kk, doc_count: (v as any)[kk] }))
+        }
+      }
+    } catch (e) {
+      return {}
+    }
+    return out
+  })
+
+  return {
+    // state
+    query,
+    hits,
+    total,
+    loading,
+    page,
+    perPage,
+    sortBy,
+    facets,
+    geo,
+    semantic,
+    ranking,
+    totalPages,
+
+    // actions
+    search,
+    autocomplete,
+    setPage,
+    setPerPage,
+    setSort,
+    setGeo,
+    setSemantic,
+    normalizedFacets,
+  }
+}
+
+export default useSearchkit

package/app/plugins/search.js

@@ -9,12 +9,95 @@ export default defineNuxtPlugin((nuxtApp) => {
     indexName = getIndexName()
   } catch (e) {
     // fallback placeholder to avoid build/runtime crash when not configured
+    // Provide a clearer validation message to help users wire env vars
     // eslint-disable-next-line no-console
     console.warn('Search client not configured:', e.message || e)
+    // Helpful runtime guidance
+    // eslint-disable-next-line no-console
+    console.info('Search layer requires configuring SEARCHKIT_HOST or SEARCHKIT_HOSTNAME/SEARCHKIT_PORT (or their NUXT_PUBLIC_ variants). Example:')
+    // eslint-disable-next-line no-console
+    console.info('  SEARCHKIT_HOST=https://search.example.com')
+    // eslint-disable-next-line no-console
+    console.info('  or:')
+    // eslint-disable-next-line no-console
+    console.info('  SEARCHKIT_PROTOCOL=https')
+    // eslint-disable-next-line no-console
+    console.info('  SEARCHKIT_HOSTNAME=search.example.com')
+    // eslint-disable-next-line no-console
+    console.info('  SEARCHKIT_PORT=9200')
     searchClient = { _client: 'searchkit-fallback' }
     indexName = 'default'
   }
 
+  // Helper: normalize aggregations/ facets into { name: buckets[] }
+  function mapAggregations(aggs) {
+    const mapped = {}
+    if (!aggs) return mapped
+    for (const key of Object.keys(aggs)) {
+      const a = aggs[key]
+      if (!a) continue
+      if (Array.isArray(a)) mapped[key] = a
+      else if (a.buckets) mapped[key] = a.buckets
+      else if (a.terms) mapped[key] = a.terms
+      else mapped[key] = a
+    }
+    return mapped
+  }
+
+  // Basic suggestion helper that performs a small search to return candidate documents
+  async function suggest(q, opts = {}) {
+    if (!searchClient || typeof searchClient.search !== 'function') return []
+    const size = opts.size || 6
+    const params = { params: { q: q || '*', size } }
+    try {
+      const resArr = await searchClient.search([{ indexName, ...params }])
+      const res = resArr && resArr[0]
+      const hits = (res && ((res.hits && res.hits.hits) || res.hits)) || []
+      return Array.isArray(hits) ? hits.map((h) => (h._source ? h._source : h)) : []
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.warn('Suggest failed', e && e.message ? e.message : e)
+      return []
+    }
+  }
+
+  // Server-side semantic reranking: call embeddings API if configured, otherwise noop.
+  // Expects an embeddings API that can accept { query, docs } and return either
+  // { ranked: [ids...] } or { scores: [number...] } aligned with docs.
+  async function semanticRerank(hitsArray, queryStr) {
+    const url = process.env.NUXT_PUBLIC_EMBEDDINGS_API_URL || process.env.EMBEDDINGS_API_URL
+    const key = process.env.NUXT_PUBLIC_EMBEDDINGS_API_KEY || process.env.EMBEDDINGS_API_KEY
+    if (!url || !key) return hitsArray
+    try {
+      const docs = hitsArray.slice(0, 100).map((h) => ({ id: h._meta || h.id || h._id, text: h.title || h.name || h.description || '' }))
+      const body = { query: queryStr, docs }
+      const resp = await (globalThis.fetch || fetch)(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', authorization: `Bearer ${key}` },
+        body: JSON.stringify(body),
+      })
+      if (!resp.ok) return hitsArray
+      const json = await resp.json()
+      if (Array.isArray(json.ranked)) {
+        const idToHit = new Map(hitsArray.map((h) => [(h._meta || h.id || h._id), h]))
+        const ordered = json.ranked.map((id) => idToHit.get(id)).filter(Boolean)
+        const remaining = hitsArray.filter((h) => !ordered.includes(h))
+        return [...ordered, ...remaining]
+      }
+      if (Array.isArray(json.scores)) {
+        const paired = hitsArray.map((h, i) => ({ h, s: json.scores[i] ?? 0 }))
+        paired.sort((a, b) => b.s - a.s)
+        return paired.map((p) => p.h)
+      }
+      return hitsArray
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.warn('semanticRerank failed', e && e.message ? e.message : e)
+      return hitsArray
+    }
+  }
+
   nuxtApp.provide('searchClient', searchClient)
   nuxtApp.provide('searchIndexName', indexName)
+  nuxtApp.provide('searchHelpers', { suggest, mapAggregations, semanticRerank })
 })

package/app/utils/env.ts

@@ -0,0 +1,28 @@
+let shared: any = null
+try {
+	// Try to use the centralized shared helper at runtime when available
+	// Use require to avoid TypeScript resolving the module at compile-time for this layer project
+	// eslint-disable-next-line @typescript-eslint/no-var-requires
+	shared = require('../../../shared/app/utils/env')
+} catch (e) {
+	shared = null
+}
+
+export function getEnv(key: string, fallback?: string): string | undefined {
+	if (shared && typeof shared.getEnv === 'function') return shared.getEnv(key, fallback)
+	if (!key) return fallback
+	const direct = process.env[key]
+	if (direct !== undefined) return direct
+	const publicKey = `NUXT_PUBLIC_${key}`
+	if (process.env[publicKey] !== undefined) return process.env[publicKey]
+	return fallback
+}
+
+export function getEnvBool(key: string, fallback = false): boolean {
+	const v = getEnv(key)
+	if (v === undefined) return fallback
+	const low = String(v).toLowerCase()
+	return ['1', 'true', 'yes', 'on'].includes(low)
+}
+
+export default { getEnv, getEnvBool }

package/app/utils/search/client.ts

@@ -2,6 +2,7 @@
 // This is intentionally minimal — it throws when no configuration is present
 // so the caller can fall back gracefully.
 import type { SearchClient } from 'instantsearch.js'
+import { getEnv } from '../env'
 
 export function getIndexName(): string {
   return (
@@ -11,28 +12,42 @@ export function getIndexName(): string {
   )
 }
 
+function buildHostFromParts(): string | null {
+  const explicit = getEnv('SEARCHKIT_HOST')
+  if (explicit) return explicit
+
+  // Allow composing host from protocol/hostname/port path
+  const protocol = (getEnv('SEARCHKIT_PROTOCOL') || 'http').replace(/:\/\//, '')
+  const hostname = getEnv('SEARCHKIT_HOSTNAME')
+  const port = getEnv('SEARCHKIT_PORT')
+  if (!hostname) return null
+  return `${protocol}://${hostname}${port ? `:${port}` : ''}`
+}
+
 export function getSearchClient(): SearchClient {
-  const host = process.env.NUXT_PUBLIC_SEARCHKIT_HOST || process.env.SEARCHKIT_HOST
+  const host = buildHostFromParts()
   if (!host) {
-    throw new Error('Searchkit host not configured via SEARCHKIT_HOST or NUXT_PUBLIC_SEARCHKIT_HOST')
+    throw new Error('Searchkit host not configured via SEARCHKIT_HOST, SEARCHKIT_HOSTNAME, or NUXT_PUBLIC_SEARCHKIT_HOST')
   }
 
+  // Optionally pass an API key if configured
+  const apiKey = getEnv('SEARCHKIT_API_KEY')
+
   // Defer importing heavy searchkit/instantsearch client until runtime.
   // Consumers can replace this implementation with a provider-specific client.
   // Here we attempt to use @searchkit/instantsearch-client if available.
   // If not present, let the import fail so the plugin can fallback.
-  // The actual creation API differs between versions; adjust as needed.
   // eslint-disable-next-line @typescript-eslint/no-var-requires
   const createClient = require('@searchkit/instantsearch-client')
   if (!createClient) {
     throw new Error('@searchkit/instantsearch-client is not installed')
   }
 
-  // Create a minimal client. The factory API may vary; this is a best-effort
-  // placeholder that should be adapted to your Searchkit configuration.
-  // If your Searchkit installation exposes a helper, prefer using that.
+  // Create a minimal client. The factory API may vary; adapt to your Searchkit config.
   try {
-    return createClient({ host })
+    const opts: any = { host }
+    if (apiKey) opts.apiKey = apiKey
+    return createClient(opts)
   } catch (e: any) {
     // rethrow with context
     throw new Error('Failed to create Searchkit client: ' + (e?.message || e))

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@meeovi/layer-search",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Powerful search module for the Alternate Framework.",
-  "main": "./nuxt.config.ts",
   "keywords": [
     "meeovi",
     "search",