@meeovi/layer-search 1.1.3 → 1.1.4

package/app/components/molecules/SearchInput.vue

@@ -0,0 +1,40 @@
+<template>
+  <div class="search-input">
+    <input
+      :placeholder="placeholder"
+      :value="modelValue"
+      @input="onInput"
+      @keydown.enter.prevent="onEnter"
+      class="search-input-field"
+    />
+    <button @click="onSearch" class="search-input-button">Search</button>
+  </div>
+</template>
+
+<script setup lang="ts">
+const props = defineProps({
+  modelValue: { type: String, default: '' },
+  placeholder: { type: String, default: 'Search...' },
+})
+const emit = defineEmits(['update:modelValue', 'search'])
+
+function onInput(e: Event) {
+  const v = (e.target as HTMLInputElement).value
+  emit('update:modelValue', v)
+  emit('input', v)
+}
+
+function onEnter() {
+  emit('search')
+}
+
+function onSearch() {
+  emit('search')
+}
+</script>
+
+<style scoped>
+.search-input { display:flex; gap:8px; align-items:center }
+.search-input-field { padding:8px; border:1px solid #ccc; }
+.search-input-button { padding:8px 12px }
+</style>

package/app/components/molecules/pagination.vue

@@ -0,0 +1,21 @@
+<template>
+  <div class="pagination">
+    <button :disabled="page <= 1" @click="change(page - 1)">Prev</button>
+    <span class="page-info">Page {{ page }} / {{ totalPages }}</span>
+    <button :disabled="page >= totalPages" @click="change(page + 1)">Next</button>
+  </div>
+</template>
+
+<script setup lang="ts">
+const props = defineProps({ page: { type: Number, default: 1 }, totalPages: { type: Number, default: 1 } })
+const emit = defineEmits(['change'])
+
+function change(p: number) {
+  emit('change', p)
+}
+</script>
+
+<style scoped>
+.pagination { display:flex; gap:12px; align-items:center }
+.page-info { font-weight:600 }
+</style>

package/app/components/molecules/resultList.vue

@@ -0,0 +1,48 @@
+<template>
+    <div class="result-list">
+        <div v-if="loading" class="loading">Loading…</div>
+        <div v-else>
+            <div v-if="!hits || hits.length === 0" class="empty">No results</div>
+            <div v-else>
+                <div v-for="(hit, idx) in hits" :key="idx" class="result-item">
+                    <slot name="item" :hit="hit">
+                        <pre>{{ hit }}</pre>
+                    </slot>
+                </div>
+            </div>
+        </div>
+    </div>
+</template>
+
+<script setup lang="ts">
+    const props = defineProps({
+        hits: {
+            type: (Array as any) as () => Array<any>,
+            default: () => []
+        },
+        loading: {
+            type: Boolean,
+            default: false
+        }
+    })
+</script>
+
+<style scoped>
+    .result-list {
+        display: block
+    }
+
+    .result-item {
+        padding: 12px;
+        border-bottom: 1px solid #eee
+    }
+
+    .loading {
+        padding: 12px
+    }
+
+    .empty {
+        padding: 12px;
+        color: #666
+    }
+</style>

package/app/composables/useSearchkit.ts

@@ -1,4 +1,5 @@
 import { ref, computed } from 'vue'
+export type SearchHit = Record<string, any>
 import { useNuxtApp } from 'nuxt/app'
 
 export function useSearchkit() {
@@ -8,7 +9,7 @@ export function useSearchkit() {
   const helpers: any = nuxt.$searchHelpers || {}
 
   const query = ref('')
-  const hits = ref<any[]>([])
+  const hits = ref<SearchHit[]>([])
   const total = ref(0)
   const loading = ref(false)
   const page = ref(1)

package/app/plugin/searchClient.ts

@@ -0,0 +1,108 @@
+import { defineNuxtPlugin, useRuntimeConfig } from 'nuxt/app'
+
+export default defineNuxtPlugin(() => {
+  const config = useRuntimeConfig() as any
+  const endpoint: string | undefined = config.search?.endpoint || process.env.SEARCH_ENDPOINT
+  const indexName: string = config.search?.indexName || process.env.SEARCH_INDEX_NAME || 'default'
+
+  // Simple helpers that consumers may rely on
+  const helpers = {
+    mapAggregations(aggs: any) {
+      return aggs || {}
+    },
+    async semanticRerank(hits: any[], _query: string) {
+      // no-op rerank: return input
+      return hits
+    },
+  }
+
+  // HTTP-backed ES-compatible client when endpoint is configured
+  const httpClient = endpoint
+    ? {
+        async search(requests: Array<any>) {
+          const base = endpoint.replace(/\/+$/, '')
+          return Promise.all(
+            requests.map(async (req: any) => {
+              const idx = req.indexName || indexName
+              // Build a basic ES query body from params
+              let body: any = {}
+
+              // If params contains q/size/from, map to simple query_string
+              if (req.params) {
+                const p = req.params
+                const q = (p.q || (p.params && p.params.q)) || '*'
+                const size = p.size || (p.params && p.params.size) || 10
+                const from = p.from || 0
+                if (!req.body) body = {}
+                if (q && q !== '*') {
+                  body.query = { query_string: { query: q } }
+                } else if (!req.body) {
+                  body.query = { match_all: {} }
+                }
+                body.size = size
+                body.from = from
+              }
+
+              if (req.body) {
+                body = { ...body, ...req.body }
+              }
+
+              // fetch with retries and exponential backoff
+              async function fetchWithRetry(url: string, init: RequestInit, retries = 2, backoff = 200): Promise<any> {
+                try {
+                  const res = await fetch(url, init)
+                  if (!res.ok) {
+                    const text = await res.text().catch(() => '')
+                    if (retries > 0) {
+                      await new Promise((r) => setTimeout(r, backoff))
+                      return fetchWithRetry(url, init, retries - 1, backoff * 2)
+                    }
+                    return { hits: [], error: `HTTP ${res.status}: ${text}` }
+                  }
+                  return await res.json()
+                } catch (err) {
+                  if (retries > 0) {
+                    await new Promise((r) => setTimeout(r, backoff))
+                    return fetchWithRetry(url, init, retries - 1, backoff * 2)
+                  }
+                  return { hits: [], error: String(err) }
+                }
+              }
+
+              const resJson = await fetchWithRetry(`${base}/${encodeURIComponent(idx)}/_search`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify(body),
+              })
+              // Ensure a consistent shape on error
+              if (!resJson) return { hits: [] }
+              return resJson
+            })
+          )
+        },
+      }
+    : null
+
+  // In-memory fallback client for environments without an endpoint
+  const stubClient = {
+    async search(requests: Array<any>) {
+      return requests.map((req: any) => {
+        const q = (req.params && (req.params.q || (req.params.params && req.params.params.q))) || '*'
+        const hits = [
+          { _source: { title: q && q !== '*' ? `Result for ${q}` : 'Sample result', description: 'Stubbed result' } },
+        ]
+        return { hits: { hits }, aggregations: {}, nbHits: hits.length }
+      })
+    },
+  }
+
+  const client = httpClient || stubClient
+
+  return {
+    provide: {
+      $searchClient: client,
+      $searchIndexName: indexName,
+      $searchHelpers: helpers,
+    },
+  }
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meeovi/layer-search",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "Powerful search module for the Alternate Framework.",
   "keywords": [
     "meeovi",