@meeovi/layer-search 1.0.6 → 1.0.7

package/dist/layers/search/app/composables/bridges/searchkit-server.js

@@ -0,0 +1,44 @@
+import { graphql, buildSchema } from 'graphql';
+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) {
+    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) {
+    const root = {
+        search: async ({ term, page, pageSize, filters }) => {
+            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);
+            }
+            const res = await manager.search();
+            return {
+                items: res.items,
+                total: res.total,
+                page: res.page,
+                pageSize: res.pageSize
+            };
+        }
+    };
+    return async function handler(req, res) {
+        const { query, variables } = req.body || {};
+        const result = await graphql({ schema, source: query, rootValue: root, variableValues: variables });
+        res.json(result);
+    };
+}
+export default createSearchkitGraphQLHandler;

package/dist/layers/search/app/composables/bridges/searchkit.d.ts

@@ -0,0 +1,21 @@
+import type { SearchManager } from '../core/SearchManager';
+type InstantSearchRequest = {
+    indexName: string;
+    params: Record<string, any>;
+};
+type InstantSearchResult = {
+    results: {
+        hits: any[];
+        nbHits: number;
+        page: number;
+        hitsPerPage: number;
+    };
+};
+export declare function createSearchkitBridge(manager: SearchManager): {
+    search(requests: InstantSearchRequest[]): Promise<InstantSearchResult[]>;
+    searchForFacetValues(indexName: string, params: any): Promise<{
+        facetHits: any;
+        exhaustiveFacetsCount: boolean;
+    }>;
+};
+export default createSearchkitBridge;

package/dist/layers/search/app/composables/bridges/searchkit.js

@@ -0,0 +1,60 @@
+function mapRequestToQuery(params, existing) {
+    const q = 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) => s.split(':'));
+        q.filters = Object.fromEntries(entries.map(([k, v]) => [k, v.replace(/^"|"$/g, '')]));
+    }
+    return q;
+}
+export function createSearchkitBridge(manager) {
+    return {
+        // InstantSearch client "search" method
+        async search(requests) {
+            // Support single-index or multi-index by mapping each request to a search call
+            const results = [];
+            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;
+                }
+                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, params) {
+            // 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) => ({ value: item[params.attribute], count: 0 })),
+                exhaustiveFacetsCount: true
+            };
+        }
+    };
+}
+export default createSearchkitBridge;

package/dist/layers/search/app/composables/bridges/vue.d.ts

@@ -0,0 +1,9 @@
+export declare function useSearch(): {
+    query: import("vue").Ref<string, string>;
+    page: import("vue").Ref<number, number>;
+    pageSize: import("vue").Ref<number, number>;
+    results: import("vue").ComputedRef<any[]>;
+    total: import("vue").ComputedRef<number>;
+    loading: import("vue").ComputedRef<boolean>;
+    search: () => Promise<void>;
+};

package/dist/layers/search/app/composables/bridges/vue.js

@@ -0,0 +1,31 @@
+import { ref, computed } from 'vue';
+import { useAlternateContext } from '@meeovi/core';
+export function useSearch() {
+    const ctx = useAlternateContext();
+    const manager = ctx.searchManager;
+    const query = ref(manager.context.state.query);
+    const page = ref(manager.context.state.page);
+    const pageSize = ref(manager.context.state.pageSize);
+    const results = ref([]);
+    const total = ref(0);
+    const loading = ref(false);
+    async function run() {
+        loading.value = true;
+        manager.context.setQuery(query.value);
+        manager.context.setPage(page.value);
+        manager.context.setPageSize(pageSize.value);
+        const res = await manager.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/dist/layers/search/app/composables/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/layers/search/app/composables/cli.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createAlternateApp } from '@meeovi/core';
+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';
+    const app = createAlternateApp({
+        config: {
+            env: 'production',
+            search: {
+                defaultProvider,
+                providers: {
+                    opensearch: {
+                        endpoint: process.env.OPENSEARCH_ENDPOINT,
+                        index: process.env.OPENSEARCH_INDEX
+                    },
+                    meilisearch: {
+                        host: process.env.MEILI_HOST,
+                        index: process.env.MEILI_INDEX,
+                        apiKey: process.env.MEILI_KEY
+                    }
+                }
+            }
+        },
+        modules: [searchModule]
+    });
+    const ctx = await app.start();
+    const search = ctx.getAdapter('search');
+    if (!search) {
+        console.error('No search adapter registered');
+        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/dist/layers/search/app/composables/config/schema.d.ts

@@ -0,0 +1,5 @@
+export interface SearchModuleConfig {
+    defaultProvider: 'opensearch' | 'meilisearch';
+    providers: Record<string, unknown>;
+}
+export declare function validateSearchConfig(config: SearchModuleConfig): void;

package/dist/layers/search/app/composables/config/schema.js

@@ -0,0 +1,8 @@
+export function validateSearchConfig(config) {
+    if (!config.defaultProvider) {
+        throw new Error('[@meeovi/search] Missing defaultProvider');
+    }
+    if (!config.providers[config.defaultProvider]) {
+        throw new Error(`[@meeovi/search] Provider "${config.defaultProvider}" not found in config.providers`);
+    }
+}

package/dist/layers/search/app/composables/config.d.ts

@@ -0,0 +1,7 @@
+export interface SearchConfig {
+    searchProvider: string;
+    searchUrl?: string;
+    apiKey?: string;
+}
+export declare function setSearchConfig(newConfig: Partial<SearchConfig>): void;
+export declare function getSearchConfig(): SearchConfig;

package/dist/layers/search/app/composables/config.js

@@ -0,0 +1,11 @@
+let config = {
+    searchProvider: 'searchkit',
+    searchUrl: '',
+    apiKey: ''
+};
+export function setSearchConfig(newConfig) {
+    config = { ...config, ...newConfig };
+}
+export function getSearchConfig() {
+    return config;
+}

package/dist/layers/search/app/composables/core/Facets.d.ts

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

package/dist/layers/search/app/composables/core/Facets.js

@@ -0,0 +1,8 @@
+export const Facets = {
+    terms(field) {
+        return { type: 'terms', field };
+    },
+    range(field, ranges) {
+        return { type: 'range', field, ranges };
+    }
+};

package/dist/layers/search/app/composables/core/Filters.d.ts

@@ -0,0 +1,18 @@
+export declare const Filters: {
+    term(field: string, value: string): {
+        type: string;
+        field: string;
+        value: string;
+    };
+    range(field: string, min?: number, max?: number): {
+        type: string;
+        field: string;
+        min: number | undefined;
+        max: number | undefined;
+    };
+    boolean(field: string, value: boolean): {
+        type: string;
+        field: string;
+        value: boolean;
+    };
+};

package/dist/layers/search/app/composables/core/Filters.js

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

package/dist/layers/search/app/composables/core/Normalizers.js

@@ -0,0 +1 @@
+"use strict";

package/dist/layers/search/app/composables/core/Pipeline.d.ts

@@ -0,0 +1,8 @@
+export declare class SearchPipeline {
+    private before;
+    private after;
+    useBefore(fn: (query: any) => any): void;
+    useAfter(fn: (result: any) => any): void;
+    runBefore(query: any): any;
+    runAfter(result: any): any;
+}

package/dist/layers/search/app/composables/core/Pipeline.js

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

package/dist/layers/search/app/composables/core/QueryBuilder.d.ts

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

package/dist/layers/search/app/composables/core/QueryBuilder.js

@@ -0,0 +1,15 @@
+export class QueryBuilder {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    build() {
+        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/dist/layers/search/app/composables/core/SearchContext.d.ts

@@ -0,0 +1,18 @@
+export interface SearchContextState {
+    query: string;
+    page: number;
+    pageSize: number;
+    sort?: string;
+    filters: Record<string, any>;
+}
+export declare class SearchContext {
+    state: SearchContextState;
+    constructor(initial?: Partial<SearchContextState>);
+    setQuery(query: string): void;
+    setPage(page: number): void;
+    setPageSize(size: number): void;
+    setSort(sort: string | undefined): void;
+    setFilter(key: string, value: any): void;
+    removeFilter(key: string): void;
+    reset(): void;
+}

package/dist/layers/search/app/composables/core/SearchContext.js

@@ -0,0 +1,38 @@
+export class SearchContext {
+    state;
+    constructor(initial) {
+        this.state = {
+            query: '',
+            page: 1,
+            pageSize: 20,
+            filters: {},
+            ...initial
+        };
+    }
+    setQuery(query) {
+        this.state.query = query;
+    }
+    setPage(page) {
+        this.state.page = page;
+    }
+    setPageSize(size) {
+        this.state.pageSize = size;
+    }
+    setSort(sort) {
+        this.state.sort = sort;
+    }
+    setFilter(key, value) {
+        this.state.filters[key] = value;
+    }
+    removeFilter(key) {
+        delete this.state.filters[key];
+    }
+    reset() {
+        this.state = {
+            query: '',
+            page: 1,
+            pageSize: 20,
+            filters: {}
+        };
+    }
+}

package/dist/layers/search/app/composables/core/SearchManager.d.ts

@@ -0,0 +1,10 @@
+import type { SearchAdapter } from '@meeovi/core';
+import { SearchContext, type SearchContextState } from './SearchContext';
+import { SearchPipeline } from './Pipeline';
+export declare class SearchManager<TItem = any> {
+    context: SearchContext;
+    pipeline: SearchPipeline;
+    adapter: SearchAdapter<TItem>;
+    constructor(adapter: SearchAdapter<TItem>, initial?: Partial<SearchContextState>);
+    search(): Promise<any>;
+}

package/dist/layers/search/app/composables/core/SearchManager.js

@@ -0,0 +1,20 @@
+import { SearchContext } from './SearchContext';
+import { QueryBuilder } from './QueryBuilder';
+import { SearchPipeline } from './Pipeline';
+export class SearchManager {
+    context;
+    pipeline;
+    adapter;
+    constructor(adapter, initial) {
+        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);
+        return this.pipeline.runAfter(result);
+    }
+}

package/dist/layers/search/app/composables/events.d.ts

@@ -0,0 +1,11 @@
+declare module '@meeovi/core/dist/types/events' {
+    interface AlternateEventMap {
+        'search:query': {
+            term: string;
+        };
+        'search:results': {
+            term: string;
+            total: number;
+        };
+    }
+}

package/dist/layers/search/app/composables/events.js

@@ -0,0 +1 @@
+"use strict";

package/dist/layers/search/app/composables/index.d.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/dist/layers/search/app/composables/index.js

@@ -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/dist/layers/search/app/composables/module.d.ts

@@ -0,0 +1,17 @@
+import { type AlternateContext } from '@meeovi/core';
+import { type SearchModuleConfig } from './config/schema';
+import type { MeeoviSearchItem } from './adapter/types';
+declare module '@meeovi/core' {
+    interface AlternateConfig {
+        search?: SearchModuleConfig;
+    }
+    interface AlternateContext {
+        searchManager?: import('./core/SearchManager').SearchManager<MeeoviSearchItem>;
+    }
+}
+declare const _default: {
+    id: string;
+    adapters: {};
+    setup(ctx: AlternateContext): Promise<void>;
+};
+export default _default;

package/dist/layers/search/app/composables/module.js

@@ -0,0 +1,73 @@
+import { defineAlternateModule, useAlternateEventBus } from '@meeovi/core';
+import { validateSearchConfig } from './config/schema';
+import { createOpenSearchAdapter } from './adapter/opensearch';
+import { createMeilisearchAdapter } from './adapter/meilisearch';
+import { SearchManager } from './core/SearchManager';
+export default defineAlternateModule({
+    id: 'search',
+    adapters: {},
+    async setup(ctx) {
+        const bus = useAlternateEventBus();
+        const config = ctx.config.search;
+        if (!config)
+            return;
+        validateSearchConfig(config);
+        if (config.defaultProvider === 'opensearch') {
+            const providerConfig = config.providers.opensearch;
+            if (providerConfig) {
+                this.adapters = {
+                    search: createOpenSearchAdapter(providerConfig)
+                };
+            }
+        }
+        if (config.defaultProvider === 'meilisearch') {
+            const providerConfig = config.providers.meilisearch;
+            if (providerConfig) {
+                this.adapters = {
+                    search: createMeilisearchAdapter(providerConfig)
+                };
+            }
+        }
+        const adapter = ctx.getAdapter('search');
+        if (adapter) {
+            ctx.searchManager = new SearchManager(adapter);
+        }
+        // Ensure search manager exists now if adapter already registered
+        if (!ctx.searchManager && ctx.getAdapter('search')) {
+            const runtimeAdapter = ctx.getAdapter('search');
+            if (runtimeAdapter) {
+                ctx.searchManager = new SearchManager(runtimeAdapter);
+            }
+        }
+        // Listen for app readiness and for runtime adapter registrations so
+        // new adapters (registered by other modules) will auto-create the
+        // search manager when they become available.
+        bus.on('app:ready', () => {
+            if (!ctx.searchManager) {
+                const runtimeAdapter = ctx.getAdapter('search');
+                if (runtimeAdapter) {
+                    ctx.searchManager = new SearchManager(runtimeAdapter);
+                }
+            }
+            console.info('[@meeovi/search] Search module initialized');
+        });
+        // Optional runtime event: if other modules emit `adapter:registered`
+        // with a `{ key }` payload, respond and initialize when the `search`
+        // adapter becomes available.
+        // This is defensive — the core registry does not emit this by default,
+        // but some runtimes may choose to.
+        bus.on('adapter:registered', (payload) => {
+            try {
+                if (payload?.key === 'search' && !ctx.searchManager) {
+                    const runtimeAdapter = ctx.getAdapter('search');
+                    if (runtimeAdapter) {
+                        ctx.searchManager = new SearchManager(runtimeAdapter);
+                    }
+                }
+            }
+            catch (e) {
+                /* noop */
+            }
+        });
+    }
+});

package/dist/layers/search/app/composables/types/api/global-search.d.ts

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

package/dist/layers/search/app/composables/types/api/global-search.js

@@ -0,0 +1 @@
+export {};

package/dist/layers/search/app/composables/utils/health.d.ts

@@ -0,0 +1,11 @@
+import type { SearchAdapter } from '@meeovi/core';
+export declare function checkAdapterHealth(adapter: SearchAdapter<any>): Promise<{
+    ok: boolean;
+    total: number;
+    error?: undefined;
+} | {
+    ok: boolean;
+    error: any;
+    total?: undefined;
+}>;
+export default checkAdapterHealth;