@meeovi/layer-search 1.0.6 → 1.0.7

package/dist/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/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/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/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/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/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/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/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/app/composables/core/Normalizers.js

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

package/dist/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/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/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/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/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/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/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/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/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/app/composables/events.js

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

package/dist/app/composables/index.d.ts

@@ -0,0 +1,9 @@
+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';

package/dist/app/composables/index.js

@@ -0,0 +1,9 @@
+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';

package/dist/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/app/composables/module.js

@@ -0,0 +1,39 @@
+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);
+        }
+        bus.on('app:ready', () => {
+            console.info('[@meeovi/search] Search module initialized');
+        });
+    }
+});

package/dist/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/app/composables/types/api/global-search.js

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

package/dist/app/composables/utils/normalizers.d.ts

@@ -0,0 +1 @@
+export declare function normalizeOpenSearchHit(hit: any): any;

package/dist/app/composables/utils/normalizers.js

@@ -0,0 +1,6 @@
+export function normalizeOpenSearchHit(hit) {
+    return {
+        id: hit._id,
+        ...hit._source
+    };
+}

package/dist/app/utils/search/client.d.ts

@@ -0,0 +1,3 @@
+import type { SearchClient } from 'instantsearch.js';
+export declare function getIndexName(): string;
+export declare function getSearchClient(): SearchClient;

package/dist/app/utils/search/client.js

@@ -0,0 +1,31 @@
+export function getIndexName() {
+    return (process.env.NUXT_PUBLIC_SEARCH_INDEX ||
+        process.env.SEARCH_INDEX ||
+        'default');
+}
+export function getSearchClient() {
+    const host = process.env.NUXT_PUBLIC_SEARCHKIT_HOST || process.env.SEARCHKIT_HOST;
+    if (!host) {
+        throw new Error('Searchkit host not configured via SEARCHKIT_HOST or NUXT_PUBLIC_SEARCHKIT_HOST');
+    }
+    // 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.
+    try {
+        return createClient({ host });
+    }
+    catch (e) {
+        // rethrow with context
+        throw new Error('Failed to create Searchkit client: ' + (e?.message || e));
+    }
+}

package/dist/layers/search/app/composables/adapter/meilisearch.d.ts

@@ -0,0 +1,8 @@
+import { type SearchAdapterConfig } from '@meeovi/core';
+interface MeiliConfig extends SearchAdapterConfig {
+    host: string;
+    apiKey?: string;
+    index: string;
+}
+export declare function createMeilisearchAdapter(config: MeiliConfig): import("@meeovi/core").AlternateAdapter<SearchAdapterConfig>;
+export {};

package/dist/layers/search/app/composables/adapter/meilisearch.js

@@ -0,0 +1,36 @@
+import { defineAlternateAdapter } from '@meeovi/core';
+export function createMeilisearchAdapter(config) {
+    const headers = {
+        'Content-Type': 'application/json'
+    };
+    if (config.apiKey) {
+        headers['Authorization'] = `Bearer ${config.apiKey}`;
+    }
+    const adapter = {
+        id: 'search:meilisearch',
+        type: 'search',
+        config,
+        async search(query) {
+            const params = new URLSearchParams({
+                q: query.term,
+                offset: String((query.page - 1) * query.pageSize),
+                limit: String(query.pageSize)
+            });
+            const res = await fetch(`${config.host}/indexes/${config.index}/search?${params}`, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({
+                    filter: Object.entries(query.filters).map(([field, value]) => `${field} = ${value}`)
+                })
+            });
+            const json = await res.json();
+            return {
+                items: json.hits,
+                total: json.estimatedTotalHits ?? json.hits.length,
+                page: query.page,
+                pageSize: query.pageSize
+            };
+        }
+    };
+    return defineAlternateAdapter(adapter);
+}

package/dist/layers/search/app/composables/adapter/mock.d.ts

@@ -0,0 +1,3 @@
+import { type SearchAdapterConfig } from '@meeovi/core';
+import type { MeeoviSearchItem } from './types';
+export declare function createMockSearchAdapter(items?: MeeoviSearchItem[]): import("@meeovi/core").AlternateAdapter<SearchAdapterConfig>;

package/dist/layers/search/app/composables/adapter/mock.js

@@ -0,0 +1,19 @@
+import { defineAlternateAdapter } from '@meeovi/core';
+export function createMockSearchAdapter(items = []) {
+    const cfg = { provider: 'mock' };
+    const adapter = {
+        id: 'search:mock',
+        type: 'search',
+        config: cfg,
+        async search(query) {
+            const filtered = items.filter((item) => item.title.toLowerCase().includes(query.term.toLowerCase()));
+            return {
+                items: filtered,
+                total: filtered.length,
+                page: 1,
+                pageSize: filtered.length
+            };
+        }
+    };
+    return defineAlternateAdapter(adapter);
+}

package/dist/layers/search/app/composables/adapter/opensearch.d.ts

@@ -0,0 +1,8 @@
+import { type SearchAdapterConfig } from '@meeovi/core';
+interface OpenSearchConfig extends SearchAdapterConfig {
+    endpoint: string;
+    index: string;
+    apiKey?: string;
+}
+export declare function createOpenSearchAdapter(config: OpenSearchConfig): import("@meeovi/core").AlternateAdapter<SearchAdapterConfig>;
+export {};

package/dist/layers/search/app/composables/adapter/opensearch.js

@@ -0,0 +1,46 @@
+import { defineAlternateAdapter } from '@meeovi/core';
+import { normalizeOpenSearchHit } from '../utils/normalizers';
+export function createOpenSearchAdapter(config) {
+    const adapter = {
+        id: 'search:opensearch',
+        type: 'search',
+        config,
+        async search(query) {
+            const body = {
+                query: {
+                    bool: {
+                        must: [
+                            {
+                                multi_match: {
+                                    query: query.term,
+                                    fields: ['title^3', 'description', 'tags']
+                                }
+                            }
+                        ],
+                        filter: Object.entries(query.filters).map(([field, value]) => ({
+                            term: { [field]: value }
+                        }))
+                    }
+                },
+                from: (query.page - 1) * query.pageSize,
+                size: query.pageSize
+            };
+            const res = await fetch(`${config.endpoint}/${config.index}/_search`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {})
+                },
+                body: JSON.stringify(body)
+            });
+            const json = await res.json();
+            return {
+                items: json.hits.hits.map(normalizeOpenSearchHit),
+                total: json.hits.total.value,
+                page: query.page,
+                pageSize: query.pageSize
+            };
+        }
+    };
+    return defineAlternateAdapter(adapter);
+}

package/dist/layers/search/app/composables/adapter/types.d.ts

@@ -0,0 +1,12 @@
+import type { SearchAdapter, SearchResult } from '@meeovi/core';
+import type { BuiltSearchQuery } from '../core/QueryBuilder';
+export interface MeeoviSearchItem {
+    id: string;
+    title: string;
+    description?: string;
+    price?: number;
+    [key: string]: unknown;
+}
+export type MeeoviSearchAdapter = SearchAdapter<MeeoviSearchItem> & {
+    search(query: BuiltSearchQuery): Promise<SearchResult<MeeoviSearchItem>>;
+};

package/dist/layers/search/app/composables/adapter/types.js

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

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

@@ -0,0 +1,4 @@
+import type { SearchManager } from '../core/SearchManager';
+export declare function createInstantSearchBridge(manager: SearchManager): {
+    searchFunction(helper: any): Promise<void>;
+};

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

@@ -0,0 +1,17 @@
+export function createInstantSearchBridge(manager) {
+    return {
+        searchFunction(helper) {
+            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) => {
+                helper.setResults({
+                    hits: result.items,
+                    nbHits: result.total,
+                    page: result.page - 1,
+                    hitsPerPage: result.pageSize
+                });
+            });
+        }
+    };
+}

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

@@ -0,0 +1,12 @@
+export declare function useReactSearch(): {
+    query: string;
+    setQuery: import("react").Dispatch<import("react").SetStateAction<string>>;
+    page: number;
+    setPage: import("react").Dispatch<import("react").SetStateAction<number>>;
+    pageSize: number;
+    setPageSize: import("react").Dispatch<import("react").SetStateAction<number>>;
+    results: any[];
+    total: number;
+    loading: boolean;
+    search: () => Promise<void>;
+};

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

@@ -0,0 +1,34 @@
+import { useState, useCallback } from 'react';
+import { useAlternateContext } from '@meeovi/core';
+export function useReactSearch() {
+    const ctx = useAlternateContext();
+    const manager = ctx.searchManager;
+    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([]);
+    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/dist/layers/search/app/composables/bridges/searchkit-server.d.ts

@@ -0,0 +1,3 @@
+import type { SearchManager } from '../core/SearchManager';
+export declare function createSearchkitGraphQLHandler(manager: SearchManager): (req: any, res: any) => Promise<void>;
+export default createSearchkitGraphQLHandler;