@nebutra/search 0.1.0 → 0.1.1

package/dist/factory.d.ts

@@ -0,0 +1,39 @@
+import type { SearchConfig, SearchProvider } from "./types";
+/**
+ * Create a search provider instance.
+ *
+ * @example
+ * ```ts
+ * // Auto-detect from environment
+ * const search = await createSearch();
+ *
+ * // Explicit Meilisearch
+ * const search = await createSearch({
+ *   provider: "meilisearch",
+ *   url: "http://localhost:7700",
+ * });
+ *
+ * // Explicit Algolia
+ * const search = await createSearch({
+ *   provider: "algolia",
+ *   appId: "YOUR_APP_ID",
+ *   searchKey: "YOUR_SEARCH_KEY",
+ *   adminKey: "YOUR_ADMIN_KEY",
+ * });
+ * ```
+ */
+export declare function createSearch(config?: SearchConfig): Promise<SearchProvider>;
+/**
+ * Get or create the default (singleton) search provider.
+ * Uses lazy initialisation so import-time side effects are avoided.
+ */
+export declare function getSearch(): Promise<SearchProvider>;
+/**
+ * Replace the default search provider (useful in tests).
+ */
+export declare function setSearch(provider: SearchProvider): void;
+/**
+ * Gracefully shut down the default search provider.
+ */
+export declare function closeSearch(): Promise<void>;
+//# sourceMappingURL=factory.d.ts.map

package/dist/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAsB,MAAM,SAAS,CAAC;AA4BhF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,YAAY,CAAC,MAAM,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC,CAmEjF;AAED;;;GAGG;AACH,wBAAsB,SAAS,IAAI,OAAO,CAAC,cAAc,CAAC,CAKzD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI,CAExD;AAED;;GAEG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAKjD"}

package/dist/factory.js

@@ -0,0 +1,138 @@
+import { logger } from "@nebutra/logger";
+// =============================================================================
+// Search Factory — Provider-agnostic search creation
+// =============================================================================
+// The factory resolves the correct provider at runtime based on:
+//   1. Explicit config passed to `createSearch()`
+//   2. `SEARCH_PROVIDER` environment variable
+//   3. Auto-detection based on available env vars
+//
+// This lets customers switch backends without changing application code.
+// =============================================================================
+let defaultProvider = null;
+/**
+ * Detect which provider to use based on available environment variables.
+ */
+function detectProvider() {
+    if (process.env.MEILISEARCH_URL)
+        return "meilisearch";
+    if (process.env.TYPESENSE_URL)
+        return "typesense";
+    if (process.env.ALGOLIA_APP_ID)
+        return "algolia";
+    // Only fall back to pgvector when DATABASE_URL is set — otherwise default to
+    // meilisearch (developer-friendly local default).
+    if (process.env.SEARCH_PROVIDER === "pgvector" && process.env.DATABASE_URL)
+        return "pgvector";
+    return "meilisearch";
+}
+/**
+ * Create a search provider instance.
+ *
+ * @example
+ * ```ts
+ * // Auto-detect from environment
+ * const search = await createSearch();
+ *
+ * // Explicit Meilisearch
+ * const search = await createSearch({
+ *   provider: "meilisearch",
+ *   url: "http://localhost:7700",
+ * });
+ *
+ * // Explicit Algolia
+ * const search = await createSearch({
+ *   provider: "algolia",
+ *   appId: "YOUR_APP_ID",
+ *   searchKey: "YOUR_SEARCH_KEY",
+ *   adminKey: "YOUR_ADMIN_KEY",
+ * });
+ * ```
+ */
+export async function createSearch(config) {
+    const providerType = config?.provider ??
+        process.env.SEARCH_PROVIDER ??
+        detectProvider();
+    logger.info("[search] Creating provider", { provider: providerType });
+    switch (providerType) {
+        case "meilisearch": {
+            const { MeilisearchProvider } = await import("./providers/meilisearch");
+            const meilisearchConfig = config;
+            const configObj = { provider: "meilisearch" };
+            if (meilisearchConfig?.url !== undefined)
+                configObj.url = meilisearchConfig.url;
+            if (meilisearchConfig?.apiKey !== undefined)
+                configObj.apiKey = meilisearchConfig.apiKey;
+            if (meilisearchConfig?.timeout !== undefined)
+                configObj.timeout = meilisearchConfig.timeout;
+            return new MeilisearchProvider(configObj);
+        }
+        case "typesense": {
+            const { TypesenseProvider } = await import("./providers/typesense");
+            const typesenseConfig = config;
+            const configObj = { provider: "typesense" };
+            if (typesenseConfig?.url !== undefined)
+                configObj.url = typesenseConfig.url;
+            if (typesenseConfig?.apiKey !== undefined)
+                configObj.apiKey = typesenseConfig.apiKey;
+            if (typesenseConfig?.timeout !== undefined)
+                configObj.timeout = typesenseConfig.timeout;
+            return new TypesenseProvider(configObj);
+        }
+        case "algolia": {
+            const { AlgoliaProvider } = await import("./providers/algolia");
+            const algoliaConfig = config;
+            const configObj = { provider: "algolia" };
+            if (algoliaConfig?.appId !== undefined)
+                configObj.appId = algoliaConfig.appId;
+            if (algoliaConfig?.searchKey !== undefined)
+                configObj.searchKey = algoliaConfig.searchKey;
+            if (algoliaConfig?.adminKey !== undefined)
+                configObj.adminKey = algoliaConfig.adminKey;
+            return new AlgoliaProvider(configObj);
+        }
+        case "pgvector": {
+            const { PgvectorProvider } = await import("./providers/pgvector");
+            const pgvectorConfig = config;
+            return new PgvectorProvider({
+                provider: "pgvector",
+                ...(pgvectorConfig?.connectionString !== undefined
+                    ? { connectionString: pgvectorConfig.connectionString }
+                    : {}),
+                ...(pgvectorConfig?.embeddingDim !== undefined
+                    ? { embeddingDim: pgvectorConfig.embeddingDim }
+                    : {}),
+                ...(pgvectorConfig?.tablePrefix !== undefined
+                    ? { tablePrefix: pgvectorConfig.tablePrefix }
+                    : {}),
+            });
+        }
+        default:
+            throw new Error(`Unknown search provider: ${providerType}`);
+    }
+}
+/**
+ * Get or create the default (singleton) search provider.
+ * Uses lazy initialisation so import-time side effects are avoided.
+ */
+export async function getSearch() {
+    if (!defaultProvider) {
+        defaultProvider = await createSearch();
+    }
+    return defaultProvider;
+}
+/**
+ * Replace the default search provider (useful in tests).
+ */
+export function setSearch(provider) {
+    defaultProvider = provider;
+}
+/**
+ * Gracefully shut down the default search provider.
+ */
+export async function closeSearch() {
+    if (defaultProvider) {
+        await defaultProvider.close();
+        defaultProvider = null;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { closeSearch, createSearch, getSearch, setSearch } from "./factory";
+export { AlgoliaProvider } from "./providers/algolia";
+export { MeilisearchProvider } from "./providers/meilisearch";
+export { TypesenseProvider } from "./providers/typesense";
+export type { AlgoliaConfig, IndexSettings, MeilisearchConfig, SearchConfig, SearchDocument, SearchHit, SearchProvider, SearchProviderType, SearchQuery, SearchResult, TypesenseConfig, } from "./types";
+export { SearchDocumentSchema, SearchQuerySchema } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAG5E,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAG1D,YAAY,EACV,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,YAAY,EACZ,cAAc,EACd,SAAS,EACT,cAAc,EACd,kBAAkB,EAClB,WAAW,EACX,YAAY,EACZ,eAAe,GAChB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,22 @@
+// =============================================================================
+// @nebutra/search — Provider-agnostic full-text search
+// =============================================================================
+// Supports:
+//   - Meilisearch        (self-hosted, developer-friendly)
+//   - Typesense          (self-hosted, geo + instant faceting)
+//   - Algolia            (managed SaaS, zero-ops)
+//
+// Usage:
+//   import { getSearch } from "@nebutra/search";
+//
+//   const search = await getSearch();  // auto-detects provider
+//   await search.indexDocument("products", { id: "123", name: "Widget" });
+//   const results = await search.search("products", { query: "widget" });
+// =============================================================================
+// ── Factory ─────────────────────────────────────────────────────────────────
+export { closeSearch, createSearch, getSearch, setSearch } from "./factory";
+// ── Providers (tree-shakable direct imports) ────────────────────────────────
+export { AlgoliaProvider } from "./providers/algolia";
+export { MeilisearchProvider } from "./providers/meilisearch";
+export { TypesenseProvider } from "./providers/typesense";
+export { SearchDocumentSchema, SearchQuerySchema } from "./types";

package/dist/providers/algolia.d.ts

@@ -0,0 +1,20 @@
+import type { AlgoliaConfig, IndexSettings, SearchDocument, SearchProvider, SearchQuery, SearchResult } from "../types";
+export declare class AlgoliaProvider implements SearchProvider {
+    readonly name = "algolia";
+    private searchClient;
+    private adminClient;
+    constructor(config?: AlgoliaConfig);
+    indexDocument<T extends SearchDocument>(index: string, doc: T): Promise<void>;
+    indexDocuments<T extends SearchDocument>(index: string, docs: T[]): Promise<void>;
+    search<T extends SearchDocument = SearchDocument>(index: string, query: SearchQuery): Promise<SearchResult<T>>;
+    deleteDocument(index: string, docId: string, tenantId?: string): Promise<void>;
+    deleteByFilter(index: string, filters: Record<string, string | number | boolean>): Promise<void>;
+    createIndex(index: string, settings: IndexSettings): Promise<void>;
+    updateSettings(index: string, settings: IndexSettings): Promise<void>;
+    close(): Promise<void>;
+    private _getIndexName;
+    private _prepareRecord;
+    private _unprepareRecord;
+    private _applySettings;
+}
+//# sourceMappingURL=algolia.d.ts.map

package/dist/providers/algolia.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"algolia.d.ts","sourceRoot":"","sources":["../../src/providers/algolia.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EACb,cAAc,EACd,cAAc,EACd,WAAW,EACX,YAAY,EACb,MAAM,UAAU,CAAC;AAMlB,qBAAa,eAAgB,YAAW,cAAc;IACpD,QAAQ,CAAC,IAAI,aAAa;IAC1B,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,WAAW,CAAM;gBAEb,MAAM,CAAC,EAAE,aAAa;IAuB5B,aAAa,CAAC,CAAC,SAAS,cAAc,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAoB7E,cAAc,CAAC,CAAC,SAAS,cAAc,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAoCjF,MAAM,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,EACpD,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,WAAW,GACjB,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAyFrB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmB9E,cAAc,CAClB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GACjD,OAAO,CAAC,IAAI,CAAC;IA0CV,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBlE,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAerE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAO5B,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,gBAAgB;YAQV,cAAc;CA2B7B"}

package/dist/providers/algolia.js

@@ -0,0 +1,297 @@
+import { logger } from "@nebutra/logger";
+import { algoliasearch } from "algoliasearch";
+// =============================================================================
+// Algolia Provider — Managed SaaS, global CDN, zero-ops
+// =============================================================================
+export class AlgoliaProvider {
+    name = "algolia";
+    searchClient;
+    adminClient;
+    constructor(config) {
+        const _appId = config?.appId ?? process.env.ALGOLIA_APP_ID;
+        const searchKey = config?.searchKey ?? process.env.ALGOLIA_SEARCH_KEY;
+        const adminKey = config?.adminKey ?? process.env.ALGOLIA_ADMIN_KEY;
+        if (!_appId) {
+            throw new Error("[search:algolia] Missing ALGOLIA_APP_ID environment variable");
+        }
+        if (!searchKey) {
+            throw new Error("[search:algolia] Missing ALGOLIA_SEARCH_KEY environment variable");
+        }
+        if (!adminKey) {
+            throw new Error("[search:algolia] Missing ALGOLIA_ADMIN_KEY environment variable");
+        }
+        this.searchClient = algoliasearch(_appId, searchKey);
+        this.adminClient = algoliasearch(_appId, adminKey);
+        logger.info("[search:algolia] Initializing", { appId: _appId });
+    }
+    async indexDocument(index, doc) {
+        try {
+            const indexName = this._getIndexName(index, doc.tenantId);
+            const algoliaIndex = this.adminClient.initIndex(indexName);
+            const record = this._prepareRecord(doc);
+            await algoliaIndex.saveObject(record);
+            logger.debug("[search:algolia] Indexed document", {
+                index: indexName,
+                docId: doc.id,
+            });
+        }
+        catch (error) {
+            logger.error("[search:algolia] Failed to index document", {
+                index,
+                docId: doc.id,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async indexDocuments(index, docs) {
+        if (docs.length === 0)
+            return;
+        try {
+            // Group documents by tenant
+            const byTenant = new Map();
+            for (const doc of docs) {
+                const tenant = doc.tenantId;
+                if (!byTenant.has(tenant)) {
+                    byTenant.set(tenant, []);
+                }
+                byTenant.get(tenant)?.push(doc);
+            }
+            // Index each tenant's documents
+            for (const [tenantId, tenantDocs] of byTenant.entries()) {
+                const indexName = this._getIndexName(index, tenantId);
+                const algoliaIndex = this.adminClient.initIndex(indexName);
+                const records = tenantDocs.map((doc) => this._prepareRecord(doc));
+                await algoliaIndex.saveObjects(records);
+                logger.debug("[search:algolia] Indexed batch", {
+                    index: indexName,
+                    count: tenantDocs.length,
+                });
+            }
+        }
+        catch (error) {
+            logger.error("[search:algolia] Failed to index batch", {
+                index,
+                count: docs.length,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async search(index, query) {
+        try {
+            const indexName = this._getIndexName(index, query.tenantId);
+            const algoliaIndex = this.searchClient.initIndex(indexName);
+            const page = query.page ?? 1;
+            const hitsPerPage = Math.min(query.hitsPerPage ?? 20, 100);
+            // Build facet filters
+            const facetFilters = [];
+            if (query.filters) {
+                for (const [key, value] of Object.entries(query.filters)) {
+                    if (typeof value === "string") {
+                        facetFilters.push(`${key}:${value}`);
+                    }
+                    else if (typeof value === "number") {
+                        facetFilters.push(`${key}:${value}`);
+                    }
+                    else if (typeof value === "boolean") {
+                        facetFilters.push(`${key}:${value}`);
+                    }
+                }
+            }
+            if (query.tenantId) {
+                facetFilters.push(`tenantId:${query.tenantId}`);
+            }
+            const startMs = performance.now();
+            const result = await algoliaIndex.search(query.query, {
+                page: page - 1, // Algolia uses 0-based pagination
+                hitsPerPage,
+                facets: query.facets,
+                facetFilters,
+                typoTolerance: query.typoTolerance !== false,
+                highlightPreTag: "<mark>",
+                highlightPostTag: "</mark>",
+                attributesToHighlight: query.highlightFields,
+                attributesToSnippet: query.highlightFields ? undefined : undefined,
+            });
+            const processingTimeMs = performance.now() - startMs;
+            const hits = result.hits.map((hit) => ({
+                doc: this._unprepareRecord(hit),
+                score: hit._rankingInfo?.nbExactMatches ?? hit._score ?? 1,
+                highlights: hit._highlightResult
+                    ? Object.fromEntries(Object.entries(hit._highlightResult).map(([key, val]) => [
+                        key,
+                        val.value,
+                    ]))
+                    : undefined,
+            }));
+            const totalPages = Math.ceil(result.nbHits / hitsPerPage);
+            const facetDistribution = {};
+            if (result.facets) {
+                for (const [facetName, facetValues] of Object.entries(result.facets)) {
+                    facetDistribution[facetName] = facetValues;
+                }
+            }
+            logger.debug("[search:algolia] Search completed", {
+                index: indexName,
+                query: query.query,
+                hits: hits.length,
+                totalHits: result.nbHits,
+                processingTimeMs,
+            });
+            return {
+                hits,
+                totalHits: result.nbHits,
+                processingTimeMs,
+                facetDistribution: (Object.keys(facetDistribution).length > 0 ? facetDistribution : undefined) ?? {},
+                page,
+                hitsPerPage,
+                totalPages,
+            };
+        }
+        catch (error) {
+            logger.error("[search:algolia] Search failed", {
+                index,
+                query: query.query,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async deleteDocument(index, docId, tenantId) {
+        try {
+            const indexName = this._getIndexName(index, tenantId);
+            const algoliaIndex = this.adminClient.initIndex(indexName);
+            await algoliaIndex.deleteObject(docId);
+            logger.debug("[search:algolia] Deleted document", {
+                index: indexName,
+                docId,
+            });
+        }
+        catch (error) {
+            logger.error("[search:algolia] Failed to delete document", {
+                index,
+                docId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async deleteByFilter(index, filters) {
+        try {
+            const indexName = this._getIndexName(index);
+            const algoliaIndex = this.adminClient.initIndex(indexName);
+            // Build facet filters
+            const facetFilters = [];
+            for (const [key, value] of Object.entries(filters)) {
+                if (typeof value === "string") {
+                    facetFilters.push(`${key}:${value}`);
+                }
+                else if (typeof value === "number") {
+                    facetFilters.push(`${key}:${value}`);
+                }
+                else if (typeof value === "boolean") {
+                    facetFilters.push(`${key}:${value}`);
+                }
+            }
+            // Search for matching documents
+            const result = await this.searchClient.initIndex(indexName).search("", {
+                facetFilters,
+                hitsPerPage: 10000,
+            });
+            if (result.hits.length > 0) {
+                const docIds = result.hits.map((hit) => hit.objectID);
+                await algoliaIndex.deleteObjects(docIds);
+                logger.debug("[search:algolia] Deleted documents by filter", {
+                    index: indexName,
+                    filters,
+                    deletedCount: docIds.length,
+                });
+            }
+        }
+        catch (error) {
+            logger.error("[search:algolia] Failed to delete by filter", {
+                index,
+                filters,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async createIndex(index, settings) {
+        try {
+            const indexName = this._getIndexName(index);
+            const algoliaIndex = this.adminClient.initIndex(indexName);
+            // Apply settings
+            await this._applySettings(algoliaIndex, settings);
+            logger.info("[search:algolia] Index created/configured", { index: indexName });
+        }
+        catch (error) {
+            logger.error("[search:algolia] Failed to create index", {
+                index,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async updateSettings(index, settings) {
+        try {
+            const indexName = this._getIndexName(index);
+            const algoliaIndex = this.adminClient.initIndex(indexName);
+            await this._applySettings(algoliaIndex, settings);
+            logger.info("[search:algolia] Settings updated", { index: indexName });
+        }
+        catch (error) {
+            logger.error("[search:algolia] Failed to update settings", {
+                index,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async close() {
+        logger.info("[search:algolia] Closing connection");
+        // Algolia doesn't require explicit connection cleanup
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+    _getIndexName(baseIndex, tenantId) {
+        if (tenantId) {
+            return `${baseIndex}__${tenantId}`;
+        }
+        return baseIndex;
+    }
+    _prepareRecord(doc) {
+        return {
+            objectID: doc.id,
+            ...doc,
+        };
+    }
+    _unprepareRecord(record) {
+        const { objectID, ...rest } = record;
+        return {
+            id: objectID,
+            ...rest,
+        };
+    }
+    async _applySettings(index, settings) {
+        const algoliaSettings = {};
+        if (settings.searchableAttributes) {
+            algoliaSettings.searchableAttributes = settings.searchableAttributes;
+        }
+        if (settings.filterableAttributes) {
+            algoliaSettings.filterableAttributes = settings.filterableAttributes;
+        }
+        if (settings.facetableAttributes) {
+            algoliaSettings.facets = settings.facetableAttributes;
+        }
+        if (settings.rankingRules) {
+            algoliaSettings.ranking = settings.rankingRules;
+        }
+        if (settings.synonyms) {
+            // Algolia uses different synonym format, skip for now
+        }
+        if (Object.keys(algoliaSettings).length > 0) {
+            await index.setSettings(algoliaSettings);
+        }
+    }
+}

package/dist/providers/meilisearch.d.ts

@@ -0,0 +1,17 @@
+import type { IndexSettings, MeilisearchConfig, SearchDocument, SearchProvider, SearchQuery, SearchResult } from "../types";
+export declare class MeilisearchProvider implements SearchProvider {
+    readonly name = "meilisearch";
+    private client;
+    constructor(config?: MeilisearchConfig);
+    indexDocument<T extends SearchDocument>(index: string, doc: T): Promise<void>;
+    indexDocuments<T extends SearchDocument>(index: string, docs: T[]): Promise<void>;
+    search<T extends SearchDocument = SearchDocument>(index: string, query: SearchQuery): Promise<SearchResult<T>>;
+    deleteDocument(index: string, docId: string, tenantId?: string): Promise<void>;
+    deleteByFilter(index: string, filters: Record<string, string | number | boolean>): Promise<void>;
+    createIndex(index: string, settings: IndexSettings): Promise<void>;
+    updateSettings(index: string, settings: IndexSettings): Promise<void>;
+    close(): Promise<void>;
+    private _getTenantIndex;
+    private _applySettings;
+}
+//# sourceMappingURL=meilisearch.d.ts.map

package/dist/providers/meilisearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meilisearch.d.ts","sourceRoot":"","sources":["../../src/providers/meilisearch.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,WAAW,EACX,YAAY,EACb,MAAM,UAAU,CAAC;AAMlB,qBAAa,mBAAoB,YAAW,cAAc;IACxD,QAAQ,CAAC,IAAI,iBAAiB;IAC9B,OAAO,CAAC,MAAM,CAAc;gBAEhB,MAAM,CAAC,EAAE,iBAAiB;IAiBhC,aAAa,CAAC,CAAC,SAAS,cAAc,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB7E,cAAc,CAAC,CAAC,SAAS,cAAc,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAoCjF,MAAM,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,EACpD,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,WAAW,GACjB,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAuFrB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB9E,cAAc,CAClB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GACjD,OAAO,CAAC,IAAI,CAAC;IAyCV,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAclE,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAarE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAO5B,OAAO,CAAC,eAAe;YAOT,cAAc;CAiC7B"}