@nebutra/search 0.1.0 → 0.1.1

package/dist/providers/meilisearch.js

@@ -0,0 +1,279 @@
+import { logger } from "@nebutra/logger";
+import { MeiliSearch } from "meilisearch";
+// =============================================================================
+// Meilisearch Provider — Developer-friendly, typo-tolerant search
+// =============================================================================
+export class MeilisearchProvider {
+    name = "meilisearch";
+    client;
+    constructor(config) {
+        const url = config?.url ?? process.env.MEILISEARCH_URL ?? "http://localhost:7700";
+        const _apiKey = config?.apiKey ?? process.env.MEILISEARCH_API_KEY;
+        const timeout = config?.timeout ?? 30000;
+        logger.info("[search:meilisearch] Initializing", { url });
+        const clientConfig = {
+            host: url,
+            timeout,
+        };
+        if (_apiKey) {
+            clientConfig.apiKey = _apiKey;
+        }
+        this.client = new MeiliSearch(clientConfig);
+    }
+    async indexDocument(index, doc) {
+        try {
+            const indexWithTenant = this._getTenantIndex(index, doc.tenantId);
+            await this.client.index(indexWithTenant).addDocuments([doc]);
+            logger.debug("[search:meilisearch] Indexed document", {
+                index: indexWithTenant,
+                docId: doc.id,
+            });
+        }
+        catch (error) {
+            logger.error("[search:meilisearch] 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 for proper filtering
+            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 to their own index
+            for (const [tenantId, tenantDocs] of byTenant.entries()) {
+                const indexWithTenant = this._getTenantIndex(index, tenantId);
+                await this.client
+                    .index(indexWithTenant)
+                    .addDocuments(tenantDocs);
+                logger.debug("[search:meilisearch] Indexed batch", {
+                    index: indexWithTenant,
+                    count: tenantDocs.length,
+                });
+            }
+        }
+        catch (error) {
+            logger.error("[search:meilisearch] Failed to index batch", {
+                index,
+                count: docs.length,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async search(index, query) {
+        try {
+            const indexWithTenant = this._getTenantIndex(index, query.tenantId);
+            const page = query.page ?? 1;
+            const hitsPerPage = Math.min(query.hitsPerPage ?? 20, 100);
+            const offset = (page - 1) * hitsPerPage;
+            // Build filter string for Meilisearch
+            let filter;
+            if (query.filters || query.tenantId) {
+                const filterParts = [];
+                // Add tenant filter if present
+                if (query.tenantId) {
+                    filterParts.push(`tenantId = "${query.tenantId}"`);
+                }
+                // Add additional filters
+                if (query.filters) {
+                    for (const [key, value] of Object.entries(query.filters)) {
+                        if (typeof value === "string") {
+                            filterParts.push(`${key} = "${value}"`);
+                        }
+                        else if (typeof value === "number") {
+                            filterParts.push(`${key} = ${value}`);
+                        }
+                        else if (typeof value === "boolean") {
+                            filterParts.push(`${key} = ${value}`);
+                        }
+                    }
+                }
+                if (filterParts.length > 0) {
+                    filter = filterParts.join(" AND ");
+                }
+            }
+            const startMs = performance.now();
+            const searchParams = {
+                offset,
+                limit: hitsPerPage,
+                highlightPreTag: "<mark>",
+                highlightPostTag: "</mark>",
+            };
+            if (filter !== undefined)
+                searchParams.filter = filter;
+            if (query.facets !== undefined)
+                searchParams.facets = query.facets;
+            if (query.sort !== undefined)
+                searchParams.sort = query.sort;
+            if (query.highlightFields !== undefined)
+                searchParams.attributesToHighlight = query.highlightFields;
+            const result = await this.client.index(indexWithTenant).search(query.query, searchParams);
+            const processingTimeMs = performance.now() - startMs;
+            const hits = (result.hits || []).map((hit) => ({
+                doc: hit,
+                score: hit._rankingScore ?? 1,
+                highlights: hit._formatted ?? undefined,
+            }));
+            const totalHits = result.estimatedTotalHits ?? 0;
+            const totalPages = Math.ceil(totalHits / hitsPerPage);
+            logger.debug("[search:meilisearch] Search completed", {
+                index: indexWithTenant,
+                query: query.query,
+                hits: hits.length,
+                totalHits,
+                processingTimeMs,
+            });
+            return {
+                hits,
+                totalHits,
+                processingTimeMs,
+                facetDistribution: result.facetDistribution ?? {},
+                page,
+                hitsPerPage,
+                totalPages,
+            };
+        }
+        catch (error) {
+            logger.error("[search:meilisearch] Search failed", {
+                index,
+                query: query.query,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async deleteDocument(index, docId, tenantId) {
+        try {
+            const indexWithTenant = this._getTenantIndex(index, tenantId);
+            await this.client.index(indexWithTenant).deleteDocument(docId);
+            logger.debug("[search:meilisearch] Deleted document", {
+                index: indexWithTenant,
+                docId,
+            });
+        }
+        catch (error) {
+            logger.error("[search:meilisearch] Failed to delete document", {
+                index,
+                docId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async deleteByFilter(index, filters) {
+        try {
+            // Build filter string
+            const filterParts = [];
+            for (const [key, value] of Object.entries(filters)) {
+                if (typeof value === "string") {
+                    filterParts.push(`${key} = "${value}"`);
+                }
+                else if (typeof value === "number") {
+                    filterParts.push(`${key} = ${value}`);
+                }
+                else if (typeof value === "boolean") {
+                    filterParts.push(`${key} = ${value}`);
+                }
+            }
+            const filter = filterParts.join(" AND ");
+            // Meilisearch doesn't have a direct deleteByFilter, so we search then delete
+            const result = await this.client.index(index).search("", {
+                filter,
+                limit: 10000,
+            });
+            if (result.hits.length > 0) {
+                const docIds = result.hits.map((hit) => hit.id);
+                await this.client.index(index).deleteDocuments(docIds);
+                logger.debug("[search:meilisearch] Deleted documents by filter", {
+                    index,
+                    filters,
+                    deletedCount: docIds.length,
+                });
+            }
+        }
+        catch (error) {
+            logger.error("[search:meilisearch] Failed to delete by filter", {
+                index,
+                filters,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async createIndex(index, settings) {
+        try {
+            // Meilisearch creates indices on-demand, so we update settings instead
+            await this._applySettings(index, settings);
+            logger.info("[search:meilisearch] Index created/configured", { index });
+        }
+        catch (error) {
+            logger.error("[search:meilisearch] Failed to create index", {
+                index,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async updateSettings(index, settings) {
+        try {
+            await this._applySettings(index, settings);
+            logger.info("[search:meilisearch] Settings updated", { index });
+        }
+        catch (error) {
+            logger.error("[search:meilisearch] Failed to update settings", {
+                index,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    async close() {
+        logger.info("[search:meilisearch] Closing connection");
+        // Meilisearch doesn't require explicit connection cleanup
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+    _getTenantIndex(baseIndex, tenantId) {
+        if (tenantId) {
+            return `${baseIndex}__${tenantId}`;
+        }
+        return baseIndex;
+    }
+    async _applySettings(index, settings) {
+        const indexObj = this.client.index(index);
+        if (settings.searchableAttributes) {
+            await indexObj.updateSearchableAttributes(settings.searchableAttributes);
+        }
+        if (settings.filterableAttributes) {
+            await indexObj.updateFilterableAttributes(settings.filterableAttributes);
+        }
+        if (settings.facetableAttributes) {
+            // Note: updateFacetedSearch doesn't exist on Index, skip this step
+            // await indexObj.updateFacetedSearch({ facets: settings.facetableAttributes });
+        }
+        if (settings.sortableAttributes) {
+            await indexObj.updateSortableAttributes(settings.sortableAttributes);
+        }
+        if (settings.rankingRules) {
+            await indexObj.updateRankingRules(settings.rankingRules);
+        }
+        if (settings.synonyms) {
+            await indexObj.updateSynonyms(settings.synonyms);
+        }
+        if (settings.primaryKey) {
+            // Primary key cannot be changed after index creation in Meilisearch
+            // This is a no-op for existing indices
+        }
+    }
+}

package/dist/providers/pgvector.d.ts

@@ -0,0 +1,24 @@
+import type { IndexSettings, PgvectorConfig, SearchDocument, SearchProvider, SearchQuery, SearchResult } from "../types";
+export declare class PgvectorProvider implements SearchProvider {
+    readonly name: "pgvector";
+    private pool;
+    private embeddingDim;
+    private tablePrefix;
+    private bootstrappedTables;
+    private bootstrappedExtension;
+    constructor(config?: PgvectorConfig);
+    private tableName;
+    private ensureExtension;
+    private ensureTable;
+    private extractText;
+    private embeddingLiteral;
+    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>;
+}
+//# sourceMappingURL=pgvector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pgvector.d.ts","sourceRoot":"","sources":["../../src/providers/pgvector.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,cAAc,EAEd,cAAc,EACd,WAAW,EACX,YAAY,EACb,MAAM,UAAU,CAAC;AA+BlB,qBAAa,gBAAiB,YAAW,cAAc;IACrD,QAAQ,CAAC,IAAI,EAAG,UAAU,CAAU;IAEpC,OAAO,CAAC,IAAI,CAAO;IACnB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,qBAAqB,CAAS;gBAE1B,MAAM,CAAC,EAAE,cAAc;IAoBnC,OAAO,CAAC,SAAS;YAKH,eAAe;YAcf,WAAW;IAgCzB,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,gBAAgB;IAUlB,aAAa,CAAC,CAAC,SAAS,cAAc,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB7E,cAAc,CAAC,CAAC,SAAS,cAAc,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAWjF,MAAM,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,EACpD,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,WAAW,GACjB,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IA8ErB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAa9E,cAAc,CAClB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GACjD,OAAO,CAAC,IAAI,CAAC;IAwBV,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAOnE,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAKvE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAM7B"}

package/dist/providers/pgvector.js

@@ -0,0 +1,249 @@
+import { logger } from "@nebutra/logger";
+import { Pool } from "pg";
+// =============================================================================
+// pgvector Provider — Postgres + pgvector hybrid search
+// =============================================================================
+// Each index is one Postgres table:
+//   <prefix>_<index> (id text PK, tenant_id text, doc jsonb,
+//                    text tsvector, embedding vector(<dim>))
+//
+// Documents may carry an optional `_embedding: number[]` field — present →
+// query can do cosine-distance vector search; absent → BM25 keyword search
+// via tsvector + plainto_tsquery.
+//
+// Multi-tenancy: every row carries `tenant_id`; queries that pass
+// `query.tenantId` add a WHERE clause. Without tenantId the query scans
+// the whole table — appropriate for system-wide search but consumers must
+// be aware.
+// =============================================================================
+const SAFE_NAME_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function assertSafeIdentifier(name, kind) {
+    if (!SAFE_NAME_RE.test(name)) {
+        throw new Error(`[search:pgvector] Unsafe ${kind} name: ${name}`);
+    }
+}
+export class PgvectorProvider {
+    name = "pgvector";
+    pool;
+    embeddingDim;
+    tablePrefix;
+    bootstrappedTables = new Set();
+    bootstrappedExtension = false;
+    constructor(config) {
+        const connectionString = config?.connectionString ?? process.env.DATABASE_URL;
+        if (!connectionString) {
+            throw new Error("[search:pgvector] DATABASE_URL not set and no `connectionString` passed in config.");
+        }
+        this.pool = new Pool({ connectionString });
+        this.embeddingDim = config?.embeddingDim ?? 1536;
+        this.tablePrefix = config?.tablePrefix ?? "nebutra_search";
+        assertSafeIdentifier(this.tablePrefix, "tablePrefix");
+        logger.info("[search:pgvector] Provider initialised", {
+            embeddingDim: this.embeddingDim,
+            tablePrefix: this.tablePrefix,
+        });
+    }
+    // ── Table & extension bootstrap ─────────────────────────────────────────
+    tableName(index) {
+        assertSafeIdentifier(index, "index");
+        return `${this.tablePrefix}_${index}`;
+    }
+    async ensureExtension(client) {
+        if (this.bootstrappedExtension)
+            return;
+        try {
+            await client.query("CREATE EXTENSION IF NOT EXISTS vector");
+            this.bootstrappedExtension = true;
+        }
+        catch (error) {
+            logger.error("[search:pgvector] CREATE EXTENSION vector failed — install the pgvector extension on your Postgres or grant CREATE EXTENSION rights", { error: error instanceof Error ? error.message : String(error) });
+            throw error;
+        }
+    }
+    async ensureTable(index) {
+        if (this.bootstrappedTables.has(index))
+            return;
+        const table = this.tableName(index);
+        const client = await this.pool.connect();
+        try {
+            await this.ensureExtension(client);
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS ${table} (
+          id          TEXT PRIMARY KEY,
+          tenant_id   TEXT,
+          doc         JSONB NOT NULL,
+          text        TSVECTOR,
+          embedding   VECTOR(${this.embeddingDim}),
+          updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+        )
+      `);
+            await client.query(`CREATE INDEX IF NOT EXISTS ${table}_tenant_idx ON ${table} (tenant_id)`);
+            await client.query(`CREATE INDEX IF NOT EXISTS ${table}_text_idx ON ${table} USING GIN (text)`);
+            // ivfflat needs ANALYZE for good performance; lists=100 is a reasonable default.
+            await client.query(`CREATE INDEX IF NOT EXISTS ${table}_embed_idx ON ${table} USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100)`);
+            this.bootstrappedTables.add(index);
+        }
+        finally {
+            client.release();
+        }
+    }
+    // ── Upsert ──────────────────────────────────────────────────────────────
+    extractText(doc) {
+        const parts = [];
+        for (const [k, v] of Object.entries(doc)) {
+            if (k === "_embedding" || k === "id" || k === "tenantId")
+                continue;
+            if (typeof v === "string")
+                parts.push(v);
+            else if (typeof v === "number" || typeof v === "boolean")
+                parts.push(String(v));
+        }
+        return parts.join(" ");
+    }
+    embeddingLiteral(embedding) {
+        if (!embedding || embedding.length === 0)
+            return null;
+        if (embedding.length !== this.embeddingDim) {
+            throw new Error(`[search:pgvector] Embedding length ${embedding.length} ≠ configured dim ${this.embeddingDim}`);
+        }
+        return `[${embedding.join(",")}]`;
+    }
+    async indexDocument(index, doc) {
+        await this.ensureTable(index);
+        const table = this.tableName(index);
+        const text = this.extractText(doc);
+        const embedding = doc._embedding;
+        await this.pool.query(`
+      INSERT INTO ${table} (id, tenant_id, doc, text, embedding, updated_at)
+      VALUES ($1, $2, $3::jsonb, to_tsvector('english', $4), $5::vector, NOW())
+      ON CONFLICT (id) DO UPDATE SET
+        tenant_id = EXCLUDED.tenant_id,
+        doc       = EXCLUDED.doc,
+        text      = EXCLUDED.text,
+        embedding = EXCLUDED.embedding,
+        updated_at = NOW()
+      `, [doc.id, doc.tenantId ?? null, JSON.stringify(doc), text, this.embeddingLiteral(embedding)]);
+    }
+    async indexDocuments(index, docs) {
+        if (docs.length === 0)
+            return;
+        // Simple sequential upsert; pg supports COPY for bulk but the API surface
+        // is heavier. Sequential keeps the implementation small and predictable.
+        for (const doc of docs) {
+            await this.indexDocument(index, doc);
+        }
+    }
+    // ── Search ──────────────────────────────────────────────────────────────
+    async search(index, query) {
+        await this.ensureTable(index);
+        const table = this.tableName(index);
+        const start = Date.now();
+        const page = query.page ?? 1;
+        const hitsPerPage = Math.min(query.hitsPerPage ?? 20, 100);
+        const offset = (page - 1) * hitsPerPage;
+        // Embedding-aware: callers can pass `filters._embedding` as a vector
+        // (encoded as comma-separated string) OR use plain text query for BM25.
+        const embeddingFilter = query.filters?._embedding;
+        const useVector = typeof embeddingFilter === "string" && embeddingFilter.startsWith("[");
+        const whereParts = [];
+        const params = [];
+        let p = 0;
+        if (query.tenantId) {
+            params.push(query.tenantId);
+            whereParts.push(`tenant_id = $${++p}`);
+        }
+        // Apply other simple equality filters from query.filters (skip _embedding).
+        for (const [k, v] of Object.entries(query.filters ?? {})) {
+            if (k === "_embedding")
+                continue;
+            assertSafeIdentifier(k, "filter key");
+            params.push(v);
+            whereParts.push(`(doc ->> '${k}') = $${++p}::text`);
+        }
+        let orderBy;
+        let selectScore;
+        if (useVector) {
+            params.push(embeddingFilter);
+            const embedParam = ++p;
+            selectScore = `1 - (embedding <=> $${embedParam}::vector) AS score`;
+            orderBy = `embedding <=> $${embedParam}::vector ASC`;
+            whereParts.push(`embedding IS NOT NULL`);
+        }
+        else {
+            params.push(query.query);
+            const queryParam = ++p;
+            selectScore = `ts_rank(text, plainto_tsquery('english', $${queryParam})) AS score`;
+            orderBy = `score DESC`;
+            whereParts.push(`text @@ plainto_tsquery('english', $${queryParam})`);
+        }
+        const whereSql = whereParts.length > 0 ? `WHERE ${whereParts.join(" AND ")}` : "";
+        const countResult = await this.pool.query(`SELECT COUNT(*)::text AS count FROM ${table} ${whereSql}`, params);
+        const totalHits = Number.parseInt(countResult.rows[0]?.count ?? "0", 10);
+        params.push(hitsPerPage, offset);
+        const result = await this.pool.query(`SELECT doc, ${selectScore} FROM ${table} ${whereSql} ORDER BY ${orderBy} LIMIT $${++p} OFFSET $${++p}`, params);
+        const hits = result.rows.map((row) => ({
+            doc: row.doc,
+            score: Math.max(0, Math.min(1, Number(row.score) || 0)),
+        }));
+        return {
+            hits,
+            totalHits,
+            processingTimeMs: Date.now() - start,
+            page,
+            hitsPerPage,
+            totalPages: Math.max(1, Math.ceil(totalHits / hitsPerPage)),
+        };
+    }
+    // ── Delete ──────────────────────────────────────────────────────────────
+    async deleteDocument(index, docId, tenantId) {
+        await this.ensureTable(index);
+        const table = this.tableName(index);
+        if (tenantId) {
+            await this.pool.query(`DELETE FROM ${table} WHERE id = $1 AND tenant_id = $2`, [
+                docId,
+                tenantId,
+            ]);
+        }
+        else {
+            await this.pool.query(`DELETE FROM ${table} WHERE id = $1`, [docId]);
+        }
+    }
+    async deleteByFilter(index, filters) {
+        await this.ensureTable(index);
+        const table = this.tableName(index);
+        const whereParts = [];
+        const params = [];
+        let p = 0;
+        for (const [k, v] of Object.entries(filters)) {
+            if (k === "tenantId") {
+                params.push(v);
+                whereParts.push(`tenant_id = $${++p}`);
+                continue;
+            }
+            assertSafeIdentifier(k, "filter key");
+            params.push(v);
+            whereParts.push(`(doc ->> '${k}') = $${++p}::text`);
+        }
+        if (whereParts.length === 0) {
+            throw new Error("[search:pgvector] deleteByFilter requires at least one filter");
+        }
+        await this.pool.query(`DELETE FROM ${table} WHERE ${whereParts.join(" AND ")}`, params);
+    }
+    // ── Index Management ────────────────────────────────────────────────────
+    async createIndex(index, _settings) {
+        // pgvector doesn't have a separate "create index" concept beyond table
+        // bootstrap; settings like searchableAttributes are implicit (everything
+        // string-typed is concatenated into the tsvector by extractText()).
+        await this.ensureTable(index);
+    }
+    async updateSettings(_index, _settings) {
+        // No-op: pgvector schema is fixed at table creation. Customize by editing
+        // the table after bootstrap if needed (add columns, adjust GIN indexes).
+    }
+    async close() {
+        await this.pool.end();
+        this.bootstrappedTables.clear();
+        this.bootstrappedExtension = false;
+        logger.info("[search:pgvector] Provider closed");
+    }
+}

package/dist/providers/typesense.d.ts

@@ -0,0 +1,22 @@
+import type { IndexSettings, SearchDocument, SearchProvider, SearchQuery, SearchResult, TypesenseConfig } from "../types";
+export declare class TypesenseProvider implements SearchProvider {
+    readonly name = "typesense";
+    private client;
+    constructor(config?: TypesenseConfig);
+    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 _getCollectionName;
+    private _prepareDocument;
+    private _buildSchema;
+    private _getQueryByFields;
+    private _parseHostFromUrl;
+    private _parsePortFromUrl;
+    private _parseProtocolFromUrl;
+}
+//# sourceMappingURL=typesense.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typesense.d.ts","sourceRoot":"","sources":["../../src/providers/typesense.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,cAAc,EACd,WAAW,EACX,YAAY,EACZ,eAAe,EAChB,MAAM,UAAU,CAAC;AAMlB,qBAAa,iBAAkB,YAAW,cAAc;IACtD,QAAQ,CAAC,IAAI,eAAe;IAC5B,OAAO,CAAC,MAAM,CAAU;gBAEZ,MAAM,CAAC,EAAE,eAAe;IAoB9B,aAAa,CAAC,CAAC,SAAS,cAAc,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAmB7E,cAAc,CAAC,CAAC,SAAS,cAAc,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAsCjF,MAAM,CAAC,CAAC,SAAS,cAAc,GAAG,cAAc,EACpD,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,WAAW,GACjB,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAqHrB,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;IA0CV,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBlE,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBtE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAO5B,OAAO,CAAC,kBAAkB;IAO1B,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,YAAY;IA+BpB,OAAO,CAAC,iBAAiB;IAKzB,OAAO,CAAC,iBAAiB;IASzB,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,qBAAqB;CAQ9B"}