@mframework/layer-search 0.0.1

package/app/composables/adapter/types.ts

@@ -0,0 +1,21 @@
+import type { BuiltSearchQuery } from '../core/QueryBuilder'
+
+export interface MeeoviSearchItem {
+  id: string
+  title: string
+  description?: string
+  price?: number
+  [key: string]: any
+}
+
+export type MeeoviSearchAdapter = {
+  id?: string
+  type?: string
+  config?: any
+  search(query: BuiltSearchQuery | any): Promise<{
+    items: MeeoviSearchItem[]
+    total: number
+    page?: number
+    pageSize?: number
+  }>
+}

package/app/composables/bridges/instantsearch.ts

@@ -0,0 +1,21 @@
+import type { SearchManager } from '../core/SearchManager'
+import type { MeeoviSearchItem } from '../adapter/types'
+
+export function createInstantSearchBridge(manager: SearchManager) {
+  return {
+    async searchFunction(helper: any) {
+      manager.context.setQuery(helper.state.query || '')
+      manager.context.setPage(helper.state.page || 1)
+      // map filters if needed from helper.state
+
+      return manager.search().then((result: any) => {
+        helper.setResults({
+          hits: result.items,
+          nbHits: result.total,
+          page: result.page - 1,
+          hitsPerPage: result.pageSize
+        })
+      })
+    }
+  }
+}

package/app/composables/bridges/react.ts

@@ -0,0 +1,39 @@
+import { useState, useCallback } from 'react'
+import type { SearchManager } from '../core/SearchManager'
+
+// React bridge: accept a SearchManager instance to stay adapter-agnostic.
+export function useReactSearch(manager?: SearchManager) {
+  if (!manager) throw new Error('SearchManager instance is required for React bridge')
+
+  const [query, setQuery] = useState(manager.context.state.query)
+  const [page, setPage] = useState(manager.context.state.page)
+  const [pageSize, setPageSize] = useState(manager.context.state.pageSize)
+  const [results, setResults] = useState<any[]>([])
+  const [total, setTotal] = useState(0)
+  const [loading, setLoading] = useState(false)
+
+  const search = useCallback(async () => {
+    setLoading(true)
+    manager.context.setQuery(query)
+    manager.context.setPage(page)
+    manager.context.setPageSize(pageSize)
+
+    const res = await manager.search()
+    setResults(res.items)
+    setTotal(res.total)
+    setLoading(false)
+  }, [query, page, pageSize, manager])
+
+  return {
+    query,
+    setQuery,
+    page,
+    setPage,
+    pageSize,
+    setPageSize,
+    results,
+    total,
+    loading,
+    search
+  }
+}

package/app/composables/bridges/searchkit-server.ts

@@ -0,0 +1,51 @@
+import { graphql, buildSchema } from 'graphql'
+import type { SearchManager } from '../core/SearchManager'
+
+const schema = buildSchema(`
+  type Hit { id: ID, title: String, description: String, price: Float }
+  type SearchResult {
+    items: [Hit]
+    total: Int
+    page: Int
+    pageSize: Int
+  }
+  type Query {
+    search(term: String, page: Int, pageSize: Int, filters: String): SearchResult
+  }
+`)
+
+function parseFilters(filters?: string) {
+  if (!filters) return {}
+  const entries = String(filters).split(' AND ').map((s) => s.split(':'))
+  return Object.fromEntries(entries.map(([k, v]) => [k, v?.replace(/^"|"$/g, '')]))
+}
+
+export function createSearchkitGraphQLHandler(manager: SearchManager) {
+  const root: any = {
+    search: async ({ term, page, pageSize, filters }: any) => {
+      manager.context.setQuery(term || '')
+      manager.context.setPage(page || 1)
+      manager.context.setPageSize(pageSize || manager.context.state.pageSize)
+      if (filters) {
+        manager.context.state.filters = parseFilters(filters) as any
+      }
+
+      const res = await manager.search()
+
+      return {
+        items: res.items,
+        total: res.total,
+        page: res.page,
+        pageSize: res.pageSize
+      }
+    }
+  }
+
+  return async function handler(req: any, res: any) {
+    const { query, variables } = req.body || {}
+    const result = await graphql({ schema, source: query, rootValue: root, variableValues: variables })
+    res.json(result)
+  }
+}
+
+export default createSearchkitGraphQLHandler

package/app/composables/bridges/searchkit.ts

@@ -0,0 +1,88 @@
+import type { SearchManager } from '../core/SearchManager'
+import type { BuiltSearchQuery } from '../core/QueryBuilder'
+
+type InstantSearchRequest = {
+  indexName: string
+  params: Record<string, any>
+}
+
+type InstantSearchResult = {
+  results: {
+    hits: any[]
+    nbHits: number
+    page: number
+    hitsPerPage: number
+  }
+}
+
+function mapRequestToQuery(params: Record<string, any>, existing?: Partial<BuiltSearchQuery>) {
+  const q: Partial<BuiltSearchQuery> = existing ?? {}
+
+  if (typeof params.query === 'string') q.term = params.query
+  if (typeof params.page === 'number') q.page = params.page + 1 // instantsearch pages are 0-based
+  if (typeof params.hitsPerPage === 'number') q.pageSize = params.hitsPerPage
+
+  // Map simple filters from InstantSearch `facets` or `filters` param
+  if (params.filters && typeof params.filters === 'string') {
+    // basic parsing: "field:value AND other:value"
+    const entries = params.filters.split(' AND ').map((s: string) => s.split(':'))
+    q.filters = Object.fromEntries(entries.map(([k, v]) => [k, (v ?? '').replace(/^"|"$/g, '')]))
+  }
+
+  return q as BuiltSearchQuery
+}
+
+export function createSearchkitBridge(manager: SearchManager) {
+  return {
+    // InstantSearch client "search" method
+    async search(requests: InstantSearchRequest[]): Promise<InstantSearchResult[]> {
+      // Support single-index or multi-index by mapping each request to a search call
+      const results: InstantSearchResult[] = []
+
+      for (const req of requests) {
+        const params = req.params || {}
+
+        const built = mapRequestToQuery(params)
+
+        // apply to manager context
+        manager.context.setQuery(built.term || '')
+        manager.context.setPage(built.page || 1)
+        manager.context.setPageSize(built.pageSize || manager.context.state.pageSize)
+        if (built.filters) {
+          // clear and set simple filters
+          manager.context.state.filters = built.filters as any
+        }
+
+        const res = await manager.search()
+
+        results.push({
+          results: {
+            hits: res.items,
+            nbHits: res.total,
+            page: (res.page || 1) - 1,
+            hitsPerPage: res.pageSize || manager.context.state.pageSize
+          }
+        })
+      }
+
+      return results
+    },
+
+    // Minimal support for Searchkit/InstantSearch facet search
+    async searchForFacetValues(indexName: string, params: any) {
+      // Map to a query with term for facet matching
+      const built = mapRequestToQuery({ query: params.facetQuery })
+
+      manager.context.setQuery(built.term || '')
+      manager.context.setPage(1)
+      const res = await manager.search()
+
+      return {
+        facetHits: (res.items || []).map((item: any) => ({ value: item[params.attribute], count: 0 })),
+        exhaustiveFacetsCount: true
+      }
+    }
+  }
+}
+
+export default createSearchkitBridge

package/app/composables/bridges/vue.ts

@@ -0,0 +1,38 @@
+import { ref, computed } from 'vue'
+import type { SearchManager } from '../core/SearchManager'
+
+// Vue bridge: accept a SearchManager instance to stay adapter-agnostic.
+export function useSearch(manager?: SearchManager) {
+  if (!manager) throw new Error('SearchManager instance is required for Vue bridge')
+  const mgr = manager as SearchManager
+
+  const query = ref(mgr.context.state.query)
+  const page = ref(mgr.context.state.page)
+  const pageSize = ref(mgr.context.state.pageSize)
+
+  const results = ref<any[]>([])
+  const total = ref(0)
+  const loading = ref(false)
+
+  async function run() {
+    loading.value = true
+    mgr.context.setQuery(query.value)
+    mgr.context.setPage(page.value)
+    mgr.context.setPageSize(pageSize.value)
+
+    const res = await mgr.search()
+    results.value = res.items
+    total.value = res.total
+    loading.value = false
+  }
+
+  return {
+    query,
+    page,
+    pageSize,
+    results: computed(() => results.value),
+    total: computed(() => total.value),
+    loading: computed(() => loading.value),
+    search: run
+  }
+}

package/app/composables/cli.ts

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import searchModule from './module'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+async function run() {
+  const [,, command, arg] = process.argv
+
+  const defaultProvider = process.env.SEARCH_PROVIDER === 'meilisearch' ? 'meilisearch' : 'opensearch'
+
+  // Minimal CLI behaviour: prefer direct provider endpoints via env vars
+  const provider = defaultProvider
+  let search: any = null
+  // If a provider-specific client is available via env vars, use it; otherwise exit.
+  if (provider === 'meilisearch' && process.env.MEILI_HOST) {
+    search = { id: 'search:meilisearch', type: 'search' }
+  } else if (provider === 'opensearch' && process.env.OPENSEARCH_ENDPOINT) {
+    search = { id: 'search:opensearch', type: 'search' }
+  }
+
+  if (!search) {
+    console.error('No search provider configured via environment')
+    process.exit(1)
+  }
+
+  if (command === 'warmup') {
+    console.log('Warming up search provider...')
+    await search.search({ term: 'warmup' })
+    console.log('Warmup complete')
+    return
+  }
+
+  if (command === 'index') {
+    if (!arg) {
+      console.error('Missing file path: meeovi-search index <file.json>')
+      process.exit(1)
+    }
+
+    const filePath = path.resolve(process.cwd(), arg)
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'))
+
+    console.log(`Indexing ${data.length} items...`)
+
+    if (search.id === 'search:opensearch') {
+      // TODO: implement bulk indexing
+    }
+
+    if (search.id === 'search:meilisearch') {
+      await fetch(`${process.env.MEILI_HOST}/indexes/${process.env.MEILI_INDEX}/documents`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${process.env.MEILI_KEY}`
+        },
+        body: JSON.stringify(data)
+      })
+    }
+
+    console.log('Indexing complete')
+    return
+  }
+
+  console.log(`Unknown command: ${command}`)
+}
+
+run()

package/app/composables/config/schema.ts

@@ -0,0 +1,16 @@
+export interface SearchModuleConfig {
+  defaultProvider: 'opensearch' | 'meilisearch'
+  providers: Record<string, unknown>
+}
+
+export function validateSearchConfig(config: SearchModuleConfig) {
+  if (!config.defaultProvider) {
+    throw new Error('[@mframework/search] Missing defaultProvider')
+  }
+
+  if (!config.providers[config.defaultProvider]) {
+    throw new Error(
+      `[@mframework/search] Provider "${config.defaultProvider}" not found in config.providers`
+    )
+  }
+}

package/app/composables/config.ts

@@ -0,0 +1,20 @@
+
+export interface SearchConfig {
+  searchProvider: string
+  searchUrl?: string
+  apiKey?: string
+}
+
+let config: SearchConfig = {
+  searchProvider: 'searchkit',
+  searchUrl: '',
+  apiKey: ''
+}
+
+export function setSearchConfig(newConfig: Partial<SearchConfig>) {
+  config = { ...config, ...newConfig }
+}
+
+export function getSearchConfig(): SearchConfig {
+  return config
+}

package/app/composables/core/Facets.ts

@@ -0,0 +1,9 @@
+export const Facets = {
+  terms(field: string) {
+    return { type: 'terms', field }
+  },
+
+  range(field: string, ranges: { from?: number; to?: number }[]) {
+    return { type: 'range', field, ranges }
+  }
+}

package/app/composables/core/Filters.ts

@@ -0,0 +1,13 @@
+export const Filters = {
+  term(field: string, value: string) {
+    return { type: 'term', field, value }
+  },
+
+  range(field: string, min?: number, max?: number) {
+    return { type: 'range', field, min, max }
+  },
+
+  boolean(field: string, value: boolean) {
+    return { type: 'boolean', field, value }
+  }
+}

package/app/composables/core/Pipeline.ts

@@ -0,0 +1,20 @@
+export class SearchPipeline {
+  private before: ((q: any) => any)[] = []
+  private after: ((r: any) => any)[] = []
+
+  useBefore(fn: (query: any) => any) {
+    this.before.push(fn)
+  }
+
+  useAfter(fn: (result: any) => any) {
+    this.after.push(fn)
+  }
+
+  runBefore(query: any) {
+    return this.before.reduce((q, fn) => fn(q), query)
+  }
+
+  runAfter(result: any) {
+    return this.after.reduce((r, fn) => fn(r), result)
+  }
+}

package/app/composables/core/QueryBuilder.ts

@@ -0,0 +1,27 @@
+import { SearchContext } from './SearchContext'
+
+export interface BuiltSearchQuery {
+  term: string
+  page: number
+  pageSize: number
+  sort?: string
+  filters: Record<string, any>
+}
+
+export class QueryBuilder {
+  private context: SearchContext
+
+  constructor(context: SearchContext) {
+    this.context = context
+  }
+
+  build(): BuiltSearchQuery {
+    return {
+      term: this.context.state.query,
+      page: this.context.state.page,
+      pageSize: this.context.state.pageSize,
+      sort: this.context.state.sort,
+      filters: this.context.state.filters
+    }
+  }
+}

package/app/composables/core/SearchContext.ts

@@ -0,0 +1,54 @@
+export interface SearchContextState {
+  query: string
+  page: number
+  pageSize: number
+  sort?: string
+  filters: Record<string, any>
+}
+
+export class SearchContext {
+  state: SearchContextState
+
+  constructor(initial?: Partial<SearchContextState>) {
+    this.state = {
+      query: '',
+      page: 1,
+      pageSize: 20,
+      filters: {},
+      ...initial
+    }
+  }
+
+  setQuery(query: string) {
+    this.state.query = query
+  }
+
+  setPage(page: number) {
+    this.state.page = page
+  }
+
+  setPageSize(size: number) {
+    this.state.pageSize = size
+  }
+
+  setSort(sort: string | undefined) {
+    this.state.sort = sort
+  }
+
+  setFilter(key: string, value: any) {
+    this.state.filters[key] = value
+  }
+
+  removeFilter(key: string) {
+    delete this.state.filters[key]
+  }
+
+  reset() {
+    this.state = {
+      query: '',
+      page: 1,
+      pageSize: 20,
+      filters: {}
+    }
+  }
+}

package/app/composables/core/SearchManager.ts

@@ -0,0 +1,26 @@
+import { SearchContext, type SearchContextState } from './SearchContext'
+import { QueryBuilder } from './QueryBuilder'
+import { SearchPipeline } from './Pipeline'
+
+export class SearchManager {
+  context: SearchContext
+  pipeline: SearchPipeline
+  adapter: any
+
+  constructor(adapter: any, initial?: Partial<SearchContextState>) {
+    this.context = new SearchContext(initial)
+    this.pipeline = new SearchPipeline()
+    this.adapter = adapter
+  }
+
+  async search() {
+    const builder = new QueryBuilder(this.context)
+    let query = builder.build()
+
+    query = this.pipeline.runBefore(query)
+
+    const result = await this.adapter.search(query as any)
+
+    return this.pipeline.runAfter(result)
+  }
+}

package/app/composables/events.ts

@@ -0,0 +1,5 @@
+// Search-specific event types
+export interface SearchEvents {
+  'search:query': { term: string }
+  'search:results': { term: string; total: number }
+}

package/app/composables/index.ts

@@ -0,0 +1,12 @@
+export * from './module'
+export * from './adapter/types'
+export * from './core/SearchManager'
+export * from './core/SearchContext'
+export * from './core/Filters'
+export * from './core/Facets'
+export * from './bridges/instantsearch'
+export * from './bridges/vue'
+export * from './bridges/react'
+export * from './bridges/searchkit'
+export * from './bridges/searchkit-server'
+export * from './utils/health'

package/app/composables/module.ts

@@ -0,0 +1,48 @@
+import { validateSearchConfig, type SearchModuleConfig } from './config/schema'
+import { SearchManager } from './core/SearchManager'
+
+// Minimal, runtime-agnostic module shim. The real runtime may provide
+// adapters via ctx.getAdapter('search'), in which case we create a SearchManager.
+export default {
+  id: 'search',
+  adapters: {},
+
+  async setup(ctx: any) {
+    const config: SearchModuleConfig | undefined = ctx?.config?.search
+    if (!config) return
+
+    // validate when possible
+    try {
+      validateSearchConfig(config)
+    } catch (e) {
+      // Ignore validation errors at runtime — config may be partial during startup.
+    }
+
+    const adapter = ctx?.getAdapter ? ctx.getAdapter('search') : undefined
+    if (adapter) {
+      ctx.searchManager = new SearchManager(adapter)
+    }
+
+    // Listen for app readiness or adapter registration when an event bus exists
+    const bus = ctx?.eventBus
+    if (bus && typeof bus.on === 'function') {
+      bus.on('app:ready', () => {
+        if (!ctx.searchManager) {
+          const runtimeAdapter = ctx.getAdapter('search')
+          if (runtimeAdapter) ctx.searchManager = new SearchManager(runtimeAdapter)
+        }
+      })
+
+      bus.on('adapter:registered', (payload: any) => {
+        try {
+          if (payload?.key === 'search' && !ctx.searchManager) {
+            const runtimeAdapter = ctx.getAdapter('search')
+            if (runtimeAdapter) ctx.searchManager = new SearchManager(runtimeAdapter)
+          }
+        } catch (e) {
+          /* noop */
+        }
+      })
+    }
+  }
+}

package/app/composables/types/api/global-search.ts

@@ -0,0 +1,8 @@
+export interface GlobalSearchResult {
+	id?: string;
+	title?: string;
+	type?: string;
+	description?: string;
+	image?: string;
+	url?: string;
+}

package/app/composables/types.d.ts

@@ -0,0 +1,12 @@
+declare module '#imports' {
+  export function useRuntimeConfig(): { public?: { searchUrl?: string } }
+}
+
+declare module '@searchkit/client' {
+  export class SearchkitClient {
+    constructor(config?: { url?: string; host?: string })
+    query(...args: unknown[]): unknown
+    fetch(...args: unknown[]): unknown
+  }
+  export type SearchkitClientConfig = { url?: string; host?: string }
+}