@meeovi/layer-search 1.0.6 → 1.0.7

package/dist/layers/search/app/composables/utils/health.js

@@ -0,0 +1,11 @@
+export async function checkAdapterHealth(adapter) {
+    try {
+        // perform a minimal search to verify connectivity
+        const res = await adapter.search({ term: '', page: 1, pageSize: 1, filters: {} });
+        return { ok: true, total: res?.total ?? null };
+    }
+    catch (e) {
+        return { ok: false, error: e?.message || String(e) };
+    }
+}
+export default checkAdapterHealth;

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

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

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

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

package/dist/layers/search/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/layers/search/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/nuxt.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("c12").InputConfig<import("@nuxt/schema").NuxtConfig, import("c12").ConfigLayerMeta>;
+export default _default;

package/dist/layers/search/nuxt.config.js

@@ -0,0 +1,7 @@
+import { defineNuxtConfig } from 'nuxt/config';
+export default defineNuxtConfig({
+    $meta: {
+        name: 'search',
+    },
+    runtimeConfig: {}
+});

package/dist/layers/search/test/runtime-adapter.spec.d.ts

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

package/dist/layers/search/test/runtime-adapter.spec.js

@@ -0,0 +1,49 @@
+import { createAlternateApp } from '../../../packages/core/src/runtime/app';
+import { defineAlternateAdapter } from '../../../packages/core/src/plugins/defineAdapter';
+import { defineAlternateModule } from '../../../packages/core/src/plugins/defineModule';
+import { AlternateContext } from '../../../packages/core/src/runtime/context';
+import { ModuleRegistry } from '../../../packages/core/src/plugins/registry';
+import { createEventBus } from '../../../packages/core/src/types/events';
+// Minimal mock search adapter shape matching core types
+const mockSearchAdapter = defineAlternateAdapter({
+    id: 'mock-search',
+    type: 'search',
+    async search() {
+        return { items: [], total: 0, page: 1, pageSize: 10 };
+    }
+});
+// A tiny test runner substitute so this file can be executed with `ts-node` or similar.
+async function run() {
+    // Build an app with no modules initially
+    const app = createAlternateApp({ config: { modules: [] }, modules: [] });
+    // Create event bus and registry manually to inspect behavior
+    const bus = createEventBus();
+    const registry = new ModuleRegistry(bus);
+    const ctx = new AlternateContext({}, registry);
+    // Register the search module implementation directly (import existing module)
+    const searchModule = require('../app/composables/module').default;
+    registry.registerModule(searchModule, ctx);
+    // At this point no adapter is registered yet, so searchManager should be undefined
+    if (ctx.searchManager) {
+        throw new Error('Expected searchManager to be undefined before adapter registration');
+    }
+    // Now register a module that provides the adapter
+    const providerModule = defineAlternateModule({
+        id: 'provider',
+        adapters: {
+            search: mockSearchAdapter
+        },
+        setup() { }
+    });
+    registry.registerModule(providerModule, ctx);
+    // After registration, registry should have emitted adapter:registered and search module
+    // should have created the SearchManager
+    if (!ctx.searchManager) {
+        throw new Error('Expected searchManager to be initialized after adapter registration');
+    }
+    console.log('OK: searchManager initialized on adapter registration');
+}
+run().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/nuxt.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("c12").InputConfig<import("@nuxt/schema").NuxtConfig, import("c12").ConfigLayerMeta>;
+export default _default;

package/dist/nuxt.config.js

@@ -0,0 +1,7 @@
+import { defineNuxtConfig } from 'nuxt/config';
+export default defineNuxtConfig({
+    $meta: {
+        name: 'search',
+    },
+    runtimeConfig: {}
+});

package/dist/packages/core/src/adapters/auth.d.ts

@@ -0,0 +1,9 @@
+import { BaseAdapterConfig } from './common';
+export interface AuthAdapterConfig extends BaseAdapterConfig {
+    provider: 'custom' | 'auth0' | 'cognito' | string;
+}
+export interface AuthAdapter {
+    login(payload: unknown): Promise<unknown>;
+    logout(): Promise<void>;
+    getSession(): Promise<unknown | null>;
+}

package/dist/packages/core/src/adapters/auth.js

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

package/dist/packages/core/src/adapters/cart.d.ts

@@ -0,0 +1,22 @@
+import { BaseAdapter, BaseAdapterConfig } from './common';
+export interface CartAdapterConfig extends BaseAdapterConfig {
+    provider: string;
+}
+export interface CartItem {
+    id: string;
+    productId: string;
+    quantity: number;
+    [key: string]: unknown;
+}
+export interface Cart<TItem extends CartItem = CartItem> {
+    id: string;
+    items: TItem[];
+    [key: string]: unknown;
+}
+export interface CartAdapter<TItem extends CartItem = CartItem> extends BaseAdapter<CartAdapterConfig> {
+    type: 'cart';
+    getCart(id: string): Promise<Cart<TItem> | null>;
+    addItem(cartId: string, item: TItem): Promise<Cart<TItem>>;
+    removeItem(cartId: string, itemId: string): Promise<Cart<TItem>>;
+    clearCart(cartId: string): Promise<Cart<TItem>>;
+}

package/dist/packages/core/src/adapters/cart.js

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

package/dist/packages/core/src/adapters/catalog.d.ts

@@ -0,0 +1,17 @@
+import { BaseAdapter, BaseAdapterConfig } from './common';
+export interface CatalogAdapterConfig extends BaseAdapterConfig {
+    provider: string;
+}
+export interface CatalogProduct {
+    id: string;
+    slug: string;
+    name: string;
+    price: number;
+    [key: string]: unknown;
+}
+export interface CatalogAdapter<TProduct extends CatalogProduct = CatalogProduct> extends BaseAdapter<CatalogAdapterConfig> {
+    type: 'catalog';
+    getProductById(id: string): Promise<TProduct | null>;
+    getProductBySlug(slug: string): Promise<TProduct | null>;
+    listProducts(params?: Record<string, unknown>): Promise<TProduct[]>;
+}

package/dist/packages/core/src/adapters/catalog.js

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

package/dist/packages/core/src/adapters/common.d.ts

@@ -0,0 +1,9 @@
+export interface BaseAdapterConfig {
+    enabled?: boolean;
+    timeoutMs?: number;
+}
+export interface BaseAdapter<TConfig extends BaseAdapterConfig = BaseAdapterConfig> {
+    id: string;
+    type: string;
+    config?: TConfig;
+}

package/dist/packages/core/src/adapters/common.js

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

package/dist/packages/core/src/adapters/lists.d.ts

@@ -0,0 +1,17 @@
+import { BaseAdapter, BaseAdapterConfig } from './common';
+export interface ListsAdapterConfig extends BaseAdapterConfig {
+    provider?: string;
+}
+export interface ListsAdapter extends BaseAdapter<ListsAdapterConfig> {
+    type: 'lists';
+    getList(id: string): Promise<any>;
+    listLists(params?: Record<string, any>): Promise<any[]>;
+    createList(data: Partial<any>): Promise<any>;
+    updateList(id: string, data: Partial<any>): Promise<any>;
+    deleteList(id: string): Promise<void>;
+    addItem(listId: string, item: Partial<any>): Promise<any>;
+    updateItem(listId: string, itemId: string, data: Partial<any>): Promise<any>;
+    deleteItem(listId: string, itemId: string): Promise<void>;
+    reorderItems?(listId: string, itemIds: string[]): Promise<void>;
+}
+export default ListsAdapter;

package/dist/packages/core/src/adapters/lists.js

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

package/dist/packages/core/src/adapters/search.d.ts

@@ -0,0 +1,21 @@
+import { BaseAdapter, BaseAdapterConfig } from './common';
+export interface SearchAdapterConfig extends BaseAdapterConfig {
+    provider: string;
+}
+export interface SearchQuery {
+    term: string;
+    filters?: Record<string, unknown>;
+    page?: number;
+    pageSize?: number;
+}
+export interface SearchResult<TItem = unknown> {
+    items: TItem[];
+    total: number;
+    page: number;
+    pageSize: number;
+}
+export interface SearchAdapter<TItem = unknown> extends BaseAdapter<SearchAdapterConfig> {
+    type: 'search';
+    search(query: SearchQuery): Promise<SearchResult<TItem>>;
+    suggest?(term: string): Promise<string[]>;
+}

package/dist/packages/core/src/adapters/search.js

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

package/dist/packages/core/src/plugins/defineAdapter.d.ts

@@ -0,0 +1,2 @@
+import type { BaseAdapter } from '../adapters/common';
+export declare function defineAlternateAdapter<T extends BaseAdapter<any>>(adapter: T): T;

package/dist/packages/core/src/plugins/defineAdapter.js

@@ -0,0 +1,3 @@
+export function defineAlternateAdapter(adapter) {
+    return adapter;
+}

package/dist/packages/core/src/plugins/defineModule.d.ts

@@ -0,0 +1,2 @@
+import { AlternateModule } from '../types/module';
+export declare function defineAlternateModule<T extends AlternateModule>(module: T): T;

package/dist/packages/core/src/plugins/defineModule.js

@@ -0,0 +1,3 @@
+export function defineAlternateModule(module) {
+    return module;
+}

package/dist/packages/core/src/plugins/registry.d.ts

@@ -0,0 +1,14 @@
+import { AlternateModule } from '../types/module';
+import { AlternateContext } from '../runtime/context';
+import { AlternateAdapterKey, AlternateAdapterMap, AlternateAdapterOf } from '../types/adapters';
+import { AlternateEventBus } from '../types/events';
+export declare class ModuleRegistry {
+    private modules;
+    private adapters;
+    private bus;
+    constructor(bus?: AlternateEventBus);
+    registerModule(module: AlternateModule, ctx: AlternateContext): void;
+    getAdapter<K extends AlternateAdapterKey>(key: K): AlternateAdapterOf<K> | undefined;
+    registerAdapter<K extends AlternateAdapterKey>(key: K, adapter: AlternateAdapterMap[K]): void;
+    runLifecycle(hook: keyof AlternateModule, ctx: AlternateContext): Promise<void>;
+}

package/dist/packages/core/src/plugins/registry.js

@@ -0,0 +1,46 @@
+export class ModuleRegistry {
+    modules = new Map();
+    adapters = new Map();
+    bus = null;
+    constructor(bus) {
+        if (bus)
+            this.bus = bus;
+    }
+    registerModule(module, ctx) {
+        if (this.modules.has(module.id))
+            return;
+        this.modules.set(module.id, module);
+        if (module.adapters) {
+            for (const [key, adapter] of Object.entries(module.adapters)) {
+                const typedKey = key;
+                this.registerAdapter(typedKey, adapter);
+            }
+        }
+        module.setup?.(ctx);
+    }
+    getAdapter(key) {
+        return this.adapters.get(key);
+    }
+    // Register an adapter at runtime. Emits `adapter:registered` so modules
+    // depending on adapters can react when new adapters become available.
+    registerAdapter(key, adapter) {
+        this.adapters.set(key, adapter);
+        if (this.bus) {
+            try {
+                // notify listeners asynchronously
+                this.bus.emit('adapter:registered', { key }).catch(() => { });
+            }
+            catch (e) {
+                // ignore emit errors
+            }
+        }
+    }
+    async runLifecycle(hook, ctx) {
+        for (const module of this.modules.values()) {
+            const fn = module[hook];
+            if (typeof fn === 'function') {
+                await fn.call(module, ctx);
+            }
+        }
+    }
+}

package/dist/packages/core/src/runtime/app.d.ts

@@ -0,0 +1,2 @@
+import type { AlternateApp, AlternateAppOptions } from '../types/app';
+export declare function createAlternateApp(options: AlternateAppOptions): AlternateApp;

package/dist/packages/core/src/runtime/app.js

@@ -0,0 +1,20 @@
+import { AlternateContext } from './context';
+import { ModuleRegistry } from '../plugins/registry';
+import { createEventBus } from '../types/events';
+import { setRuntimeContext } from './hooks';
+import { runAppLifecycle } from './lifecycle';
+export function createAlternateApp(options) {
+    const eventBus = createEventBus();
+    const registry = new ModuleRegistry(eventBus);
+    const context = new AlternateContext(options.config, registry);
+    setRuntimeContext(context, eventBus);
+    options.modules?.forEach((mod) => registry.registerModule(mod, context));
+    return {
+        context,
+        events: eventBus,
+        async start() {
+            await runAppLifecycle(registry, context, eventBus);
+            return context;
+        }
+    };
+}

package/dist/packages/core/src/runtime/context.d.ts

@@ -0,0 +1,9 @@
+import { AlternateConfig } from '../types/config';
+import { ModuleRegistry } from '../plugins/registry';
+import { AlternateAdapterKey, AlternateAdapterOf } from '../types/adapters';
+export declare class AlternateContext {
+    readonly config: AlternateConfig;
+    readonly modules: ModuleRegistry;
+    constructor(config: AlternateConfig, modules: ModuleRegistry);
+    getAdapter<K extends AlternateAdapterKey>(key: K): AlternateAdapterOf<K> | undefined;
+}

package/dist/packages/core/src/runtime/context.js

@@ -0,0 +1,11 @@
+export class AlternateContext {
+    config;
+    modules;
+    constructor(config, modules) {
+        this.config = config;
+        this.modules = modules;
+    }
+    getAdapter(key) {
+        return this.modules.getAdapter(key);
+    }
+}

package/dist/packages/core/src/runtime/hooks.d.ts

@@ -0,0 +1,5 @@
+import { AlternateContext } from './context';
+import { AlternateEventBus } from '../types/events';
+export declare function setRuntimeContext(ctx: AlternateContext, bus: AlternateEventBus): void;
+export declare function useAlternateContext(): AlternateContext;
+export declare function useAlternateEventBus(): AlternateEventBus;

package/dist/packages/core/src/runtime/hooks.js

@@ -0,0 +1,18 @@
+let currentContext = null;
+let currentEventBus = null;
+export function setRuntimeContext(ctx, bus) {
+    currentContext = ctx;
+    currentEventBus = bus;
+}
+export function useAlternateContext() {
+    if (!currentContext) {
+        throw new Error('[@meeovi/core] useAlternateContext() called before app initialization');
+    }
+    return currentContext;
+}
+export function useAlternateEventBus() {
+    if (!currentEventBus) {
+        throw new Error('[@meeovi/core] useAlternateEventBus() called before app initialization');
+    }
+    return currentEventBus;
+}

package/dist/packages/core/src/runtime/lifecycle.d.ts

@@ -0,0 +1,4 @@
+import { AlternateContext } from './context';
+import { ModuleRegistry } from '../plugins/registry';
+import { AlternateEventBus } from '../types/events';
+export declare function runAppLifecycle(registry: ModuleRegistry, ctx: AlternateContext, bus: AlternateEventBus): Promise<void>;

package/dist/packages/core/src/runtime/lifecycle.js

@@ -0,0 +1,5 @@
+export async function runAppLifecycle(registry, ctx, bus) {
+    // Example lifecycle sequence
+    await registry.runLifecycle('onAppInit', ctx);
+    bus.emit('app:ready', { context: ctx });
+}

package/dist/packages/core/src/types/adapters.d.ts

@@ -0,0 +1,14 @@
+import type { SearchAdapter } from '../adapters/search';
+import type { ListsAdapter } from '../adapters/lists';
+import type { CatalogAdapter } from '../adapters/catalog';
+import type { CartAdapter } from '../adapters/cart';
+import type { AuthAdapter } from '../adapters/auth';
+export interface AlternateAdapterMap {
+    search: SearchAdapter;
+    lists: ListsAdapter;
+    catalog: CatalogAdapter;
+    cart: CartAdapter;
+    auth: AuthAdapter;
+}
+export type AlternateAdapterKey = keyof AlternateAdapterMap;
+export type AlternateAdapterOf<K extends AlternateAdapterKey> = AlternateAdapterMap[K];

package/dist/packages/core/src/types/adapters.js

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

package/dist/packages/core/src/types/app.d.ts

@@ -0,0 +1,13 @@
+import { AlternateConfig } from './config';
+import { AlternateContext } from '../runtime/context';
+import { AlternateEventBus } from './events';
+import { AlternateModule } from './module';
+export interface AlternateApp {
+    context: AlternateContext;
+    events: AlternateEventBus;
+    start(): Promise<AlternateContext>;
+}
+export interface AlternateAppOptions {
+    config: AlternateConfig;
+    modules?: AlternateModule[];
+}

package/dist/packages/core/src/types/app.js

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

package/dist/packages/core/src/types/config.d.ts

@@ -0,0 +1,8 @@
+export interface AlternateConfig {
+    env: 'development' | 'production' | 'test';
+    appName?: string;
+    logger?: {
+        level?: 'debug' | 'info' | 'warn' | 'error';
+    };
+    [key: string]: unknown;
+}

package/dist/packages/core/src/types/config.js

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

package/dist/packages/core/src/types/events.d.ts

@@ -0,0 +1,20 @@
+import { AlternateAdapterKey } from './adapters';
+export interface AlternateEventMap {
+    'app:ready': {
+        context: unknown;
+    };
+    'app:error': {
+        error: unknown;
+    };
+    'adapter:registered': {
+        key: AlternateAdapterKey;
+    };
+}
+export type AlternateEventKey = keyof AlternateEventMap;
+export type AlternateEventHandler<K extends AlternateEventKey> = (payload: AlternateEventMap[K]) => void | Promise<void>;
+export interface AlternateEventBus {
+    on<K extends AlternateEventKey>(event: K, handler: AlternateEventHandler<K>): void;
+    off<K extends AlternateEventKey>(event: K, handler: AlternateEventHandler<K>): void;
+    emit<K extends AlternateEventKey>(event: K, payload: AlternateEventMap[K]): Promise<void>;
+}
+export declare function createEventBus(): AlternateEventBus;

package/dist/packages/core/src/types/events.js

@@ -0,0 +1,22 @@
+export function createEventBus() {
+    const handlers = new Map();
+    return {
+        on(event, handler) {
+            if (!handlers.has(event)) {
+                handlers.set(event, new Set());
+            }
+            handlers.get(event).add(handler);
+        },
+        off(event, handler) {
+            handlers.get(event)?.delete(handler);
+        },
+        async emit(event, payload) {
+            const set = handlers.get(event);
+            if (!set || set.size === 0)
+                return;
+            for (const handler of set) {
+                await handler(payload);
+            }
+        }
+    };
+}

package/dist/packages/core/src/types/module.d.ts

@@ -0,0 +1,15 @@
+import type { AlternateContext } from '../runtime/context';
+import type { AlternateAdapterKey, AlternateAdapterOf } from './adapters';
+export type AlternateModuleAdapters = Partial<{
+    [K in AlternateAdapterKey]: AlternateAdapterOf<K>;
+}>;
+export interface AlternateModuleLifecycle {
+    onAppInit?(ctx: AlternateContext): Promise<void> | void;
+    onBeforeRequest?(ctx: AlternateContext): Promise<void> | void;
+    onAfterRequest?(ctx: AlternateContext): Promise<void> | void;
+}
+export interface AlternateModule extends AlternateModuleLifecycle {
+    id: string;
+    adapters?: AlternateModuleAdapters;
+    setup?(ctx: AlternateContext): void | Promise<void>;
+}

package/dist/packages/core/src/types/module.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meeovi/layer-search",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Powerful search module for the Alternate Framework.",
   "main": "./nuxt.config.ts",
   "keywords": [
@@ -11,9 +11,6 @@
     "vue",
     "instantsearch"
   ],
-  "bin": {
-    "meeovi-search": "./dist/cli.js"
-  },
   "author": "Meeovi",
   "license": "MIT",
   "type": "module",
@@ -26,6 +23,7 @@
     "@types/react": "^19.2.9",
     "react": "^19.2.3",
     "searchkit": "^4.15.0",
+    "graphql": "^16.8.0",
     "typescript": "^5.9.3",
     "vue": "^3.2.47",
     "vue-instantsearch": "^4.22.8"
@@ -34,4 +32,11 @@
     "@types/node": "^25.0.10",
     "nuxt": "^4.3.0"
   }
+
+  ,"exports": {
+    ".": {
+      "import": "./app/composables/index.ts",
+      "require": "./app/composables/index.ts"
+    }
+  }
 }