graphile-search 1.1.0

package/codecs/vector-codec.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * VectorCodecPlugin
+ *
+ * Teaches PostGraphile v5 how to handle the pgvector `vector` type.
+ *
+ * Without this:
+ * - `vector(n)` columns are silently invisible in the schema
+ * - SQL functions with `vector` args are skipped entirely
+ *
+ * Wire format: PostgreSQL sends vector as text `[0.1,0.2,...,0.768]`
+ * JavaScript: number[]
+ * GraphQL: `Vector` scalar (serialized as [Float])
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VectorCodecPreset = exports.VectorCodecPlugin = void 0;
+require("graphile-build-pg");
+require("graphile-build");
+const pg_sql2_1 = __importDefault(require("pg-sql2"));
+exports.VectorCodecPlugin = {
+    name: 'VectorCodecPlugin',
+    version: '1.0.0',
+    description: 'Registers a codec for the pgvector `vector` type',
+    gather: {
+        hooks: {
+            async pgCodecs_findPgCodec(info, event) {
+                if (event.pgCodec)
+                    return;
+                const { pgType: type, serviceName } = event;
+                if (type.typname !== 'vector')
+                    return;
+                const typeNamespace = await info.helpers.pgIntrospection.getNamespace(serviceName, type.typnamespace);
+                if (!typeNamespace)
+                    return;
+                const schemaName = typeNamespace.nspname;
+                event.pgCodec = {
+                    name: 'vector',
+                    sqlType: pg_sql2_1.default.identifier(schemaName, 'vector'),
+                    // PG sends: [0.1,-0.2,...,0.768]  ->  number[]
+                    fromPg(value) {
+                        return value
+                            .replace(/^\[|\]$/g, '')
+                            .split(',')
+                            .map((v) => parseFloat(v.trim()));
+                    },
+                    // number[]  ->  [0.1,-0.2,...,0.768]
+                    toPg(value) {
+                        if (!Array.isArray(value))
+                            throw new Error('vector input must be an array of numbers');
+                        return `[${value.join(',')}]`;
+                    },
+                    attributes: undefined,
+                    executor: undefined,
+                    extensions: {
+                        oid: type._id,
+                        pg: { serviceName, schemaName, name: 'vector' },
+                    },
+                };
+            },
+        },
+    },
+    schema: {
+        hooks: {
+            init: {
+                before: ['PgCodecs'],
+                callback(_, build) {
+                    const { setGraphQLTypeForPgCodec } = build;
+                    build.registerScalarType('Vector', {}, () => ({
+                        description: 'A pgvector embedding — array of floats. ' +
+                            'Dimensions must match the column (e.g. 768 for nomic-embed-text).',
+                        serialize(value) {
+                            if (Array.isArray(value))
+                                return value;
+                            if (typeof value === 'string')
+                                return value.replace(/^\[|\]$/g, '').split(',').map((v) => parseFloat(v.trim()));
+                            throw new Error('Vector must be an array of numbers');
+                        },
+                        parseValue(value) {
+                            if (Array.isArray(value))
+                                return value;
+                            throw new Error('Vector must be an array of numbers');
+                        },
+                        parseLiteral(ast) {
+                            if (ast.kind === 'NullValue')
+                                return null;
+                            if (ast.kind === 'ListValue')
+                                return ast.values.map((v) => {
+                                    if (v.kind === 'FloatValue' || v.kind === 'IntValue')
+                                        return parseFloat(v.value);
+                                    throw new Error('Vector elements must be Float values');
+                                });
+                            if (ast.kind === 'StringValue')
+                                return ast.value.replace(/^\[|\]$/g, '').split(',').map((v) => parseFloat(v.trim()));
+                            throw new Error('Vector must be a list of floats or a string "[f1,f2,...]"');
+                        },
+                    }), 'VectorCodecPlugin registering Vector scalar');
+                    // Wire codec -> scalar for both input (mutations) and output (queries).
+                    // Without BOTH, PgAttributesPlugin silently drops the column.
+                    for (const codec of Object.values(build.input.pgRegistry.pgCodecs)) {
+                        if (codec.name === 'vector') {
+                            setGraphQLTypeForPgCodec(codec, 'input', 'Vector');
+                            setGraphQLTypeForPgCodec(codec, 'output', 'Vector');
+                        }
+                    }
+                    return _;
+                },
+            },
+        },
+    },
+};
+exports.VectorCodecPreset = {
+    plugins: [exports.VectorCodecPlugin],
+};

package/esm/adapters/bm25.d.ts

@@ -0,0 +1,32 @@
+/**
+ * BM25 Search Adapter
+ *
+ * Detects text columns with BM25 indexes (via pg_textsearch) and generates
+ * BM25 relevance scoring. Wraps the same SQL logic as graphile-bm25.
+ *
+ * Requires the Bm25CodecPlugin to be loaded first (for index discovery).
+ * The adapter reads from the bm25IndexStore populated during the gather phase.
+ */
+import type { SearchAdapter } from '../types';
+/**
+ * BM25 index info discovered during gather phase.
+ */
+export interface Bm25IndexInfo {
+    schemaName: string;
+    tableName: string;
+    columnName: string;
+    indexName: string;
+}
+export interface Bm25AdapterOptions {
+    /**
+     * Filter prefix for BM25 filter fields.
+     * @default 'bm25'
+     */
+    filterPrefix?: string;
+    /**
+     * External BM25 index store. If not provided, the adapter will attempt
+     * to read from the build object's `pgBm25IndexStore`.
+     */
+    bm25IndexStore?: Map<string, Bm25IndexInfo>;
+}
+export declare function createBm25Adapter(options?: Bm25AdapterOptions): SearchAdapter;

package/esm/adapters/bm25.js

@@ -0,0 +1,116 @@
+/**
+ * BM25 Search Adapter
+ *
+ * Detects text columns with BM25 indexes (via pg_textsearch) and generates
+ * BM25 relevance scoring. Wraps the same SQL logic as graphile-bm25.
+ *
+ * Requires the Bm25CodecPlugin to be loaded first (for index discovery).
+ * The adapter reads from the bm25IndexStore populated during the gather phase.
+ */
+import { bm25IndexStore as moduleBm25IndexStore } from '../codecs/bm25-codec';
+function isTextCodec(codec) {
+    const name = codec?.name;
+    return name === 'text' || name === 'varchar' || name === 'bpchar';
+}
+export function createBm25Adapter(options = {}) {
+    const { filterPrefix = 'bm25', bm25IndexStore } = options;
+    function getIndexStore(build) {
+        if (bm25IndexStore)
+            return bm25IndexStore;
+        // Try build.pgBm25IndexStore (set by standalone Bm25SearchPlugin's build hook)
+        const buildStore = build.pgBm25IndexStore;
+        if (buildStore && buildStore.size > 0)
+            return buildStore;
+        // Fall back to module-level store populated by Bm25CodecPlugin's gather phase
+        if (moduleBm25IndexStore && moduleBm25IndexStore.size > 0)
+            return moduleBm25IndexStore;
+        return undefined;
+    }
+    function getBm25IndexForAttribute(codec, attributeName, build) {
+        const store = getIndexStore(build);
+        if (!store)
+            return undefined;
+        const pg = codec?.extensions?.pg;
+        if (!pg)
+            return undefined;
+        const key = `${pg.schemaName}.${pg.name}.${attributeName}`;
+        return store.get(key);
+    }
+    return {
+        name: 'bm25',
+        scoreSemantics: {
+            metric: 'score',
+            lowerIsBetter: true,
+            range: null, // unbounded negative
+        },
+        filterPrefix,
+        supportsTextSearch: true,
+        buildTextSearchInput(text) {
+            // BM25 filter takes { query: string }
+            return { query: text };
+        },
+        detectColumns(codec, build) {
+            if (!codec?.attributes)
+                return [];
+            const columns = [];
+            for (const [attributeName, attribute] of Object.entries(codec.attributes)) {
+                if (!isTextCodec(attribute.codec))
+                    continue;
+                const bm25Index = getBm25IndexForAttribute(codec, attributeName, build);
+                if (!bm25Index)
+                    continue;
+                columns.push({ attributeName, adapterData: bm25Index });
+            }
+            return columns;
+        },
+        registerTypes(build) {
+            const { graphql: { GraphQLString, GraphQLFloat, GraphQLNonNull }, } = build;
+            // Register input type for BM25 search.
+            // Wrapped in try/catch because another plugin may have already
+            // registered 'Bm25SearchInput'. Graphile throws on duplicate
+            // registrations, so we catch and ignore.
+            try {
+                build.registerInputObjectType('Bm25SearchInput', {}, () => ({
+                    description: 'Input for BM25 ranked text search. Provide a search query string and optional score threshold.',
+                    fields: () => ({
+                        query: {
+                            type: new GraphQLNonNull(GraphQLString),
+                            description: 'The search query text. Uses pg_textsearch BM25 ranking.',
+                        },
+                        threshold: {
+                            type: GraphQLFloat,
+                            description: 'Maximum BM25 score threshold (negative values). Only rows with score <= threshold are returned.',
+                        },
+                    }),
+                }), 'UnifiedSearchPlugin (bm25 adapter) registering Bm25SearchInput type');
+            }
+            catch {
+                // Already registered — safe to ignore
+            }
+        },
+        getFilterTypeName(_build) {
+            return 'Bm25SearchInput';
+        },
+        buildFilterApply(sql, alias, column, filterValue, _build) {
+            if (filterValue == null)
+                return null;
+            const { query, threshold } = filterValue;
+            if (!query || typeof query !== 'string' || query.trim().length === 0)
+                return null;
+            const bm25Index = column.adapterData;
+            const columnExpr = sql `${alias}.${sql.identifier(column.attributeName)}`;
+            // Use quoteQualifiedIdentifier to produce the qualified index name
+            const qualifiedIndexName = `"${bm25Index.schemaName}"."${bm25Index.indexName}"`;
+            const bm25queryExpr = sql `to_bm25query(${sql.value(query)}, ${sql.value(qualifiedIndexName)})`;
+            const scoreExpr = sql `(${columnExpr} <@> ${bm25queryExpr})`;
+            let whereClause = null;
+            if (threshold !== undefined && threshold !== null) {
+                whereClause = sql `${scoreExpr} < ${sql.value(threshold)}`;
+            }
+            return {
+                whereClause,
+                scoreExpression: scoreExpr,
+            };
+        },
+    };
+}

package/esm/adapters/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Search Adapter Exports
+ *
+ * Each adapter implements the SearchAdapter interface for a specific
+ * search algorithm. They are plain objects — not Graphile plugins.
+ */
+export { createTsvectorAdapter } from './tsvector';
+export type { TsvectorAdapterOptions } from './tsvector';
+export { createBm25Adapter } from './bm25';
+export type { Bm25AdapterOptions, Bm25IndexInfo } from './bm25';
+export { createTrgmAdapter } from './trgm';
+export type { TrgmAdapterOptions } from './trgm';
+export { createPgvectorAdapter } from './pgvector';
+export type { PgvectorAdapterOptions } from './pgvector';

package/esm/adapters/index.js

@@ -0,0 +1,10 @@
+/**
+ * Search Adapter Exports
+ *
+ * Each adapter implements the SearchAdapter interface for a specific
+ * search algorithm. They are plain objects — not Graphile plugins.
+ */
+export { createTsvectorAdapter } from './tsvector';
+export { createBm25Adapter } from './bm25';
+export { createTrgmAdapter } from './trgm';
+export { createPgvectorAdapter } from './pgvector';

package/esm/adapters/pgvector.d.ts

@@ -0,0 +1,21 @@
+/**
+ * pgvector Search Adapter
+ *
+ * Detects vector columns and generates distance-based scoring using
+ * pgvector operators (<=> cosine, <-> L2, <#> inner product).
+ * Wraps the same SQL logic as graphile-pgvector but as a SearchAdapter.
+ */
+import type { SearchAdapter } from '../types';
+export interface PgvectorAdapterOptions {
+    /**
+     * Filter prefix for vector filter fields.
+     * @default 'vector'
+     */
+    filterPrefix?: string;
+    /**
+     * Default similarity metric.
+     * @default 'COSINE'
+     */
+    defaultMetric?: 'COSINE' | 'L2' | 'IP';
+}
+export declare function createPgvectorAdapter(options?: PgvectorAdapterOptions): SearchAdapter;

package/esm/adapters/pgvector.js

@@ -0,0 +1,122 @@
+/**
+ * pgvector Search Adapter
+ *
+ * Detects vector columns and generates distance-based scoring using
+ * pgvector operators (<=> cosine, <-> L2, <#> inner product).
+ * Wraps the same SQL logic as graphile-pgvector but as a SearchAdapter.
+ */
+/**
+ * pgvector distance operators.
+ */
+const METRIC_OPERATORS = {
+    COSINE: '<=>',
+    L2: '<->',
+    IP: '<#>',
+};
+function isVectorCodec(codec) {
+    return codec?.name === 'vector';
+}
+export function createPgvectorAdapter(options = {}) {
+    const { filterPrefix = 'vector', defaultMetric = 'COSINE' } = options;
+    return {
+        name: 'vector',
+        scoreSemantics: {
+            metric: 'distance',
+            lowerIsBetter: true,
+            range: null, // 0 to infinity
+        },
+        filterPrefix,
+        supportsTextSearch: false,
+        // pgvector requires a vector array, not plain text — no buildTextSearchInput
+        detectColumns(codec, _build) {
+            if (!codec?.attributes)
+                return [];
+            const columns = [];
+            for (const [attributeName, attribute] of Object.entries(codec.attributes)) {
+                if (isVectorCodec(attribute.codec)) {
+                    columns.push({ attributeName });
+                }
+            }
+            return columns;
+        },
+        registerTypes(build) {
+            const { graphql: { GraphQLList, GraphQLNonNull, GraphQLFloat }, } = build;
+            // Register types for vector search.
+            // Wrapped in try/catch because the standalone graphile-pgvector plugin may
+            // have already registered these types in its own init hook.
+            // Graphile throws on duplicate registrations, so we catch and ignore.
+            try {
+                build.registerEnumType('VectorMetric', {}, () => ({
+                    description: 'Similarity metric for vector search',
+                    values: {
+                        COSINE: {
+                            value: 'COSINE',
+                            description: 'Cosine distance (1 - cosine similarity). Range: 0 (identical) to 2 (opposite).',
+                        },
+                        L2: {
+                            value: 'L2',
+                            description: 'Euclidean (L2) distance. Range: 0 (identical) to infinity.',
+                        },
+                        IP: {
+                            value: 'IP',
+                            description: 'Negative inner product. Higher (less negative) = more similar.',
+                        },
+                    },
+                }), 'UnifiedSearchPlugin (pgvector adapter) registering VectorMetric enum');
+            }
+            catch {
+                // Already registered by standalone graphile-pgvector plugin — safe to ignore
+            }
+            try {
+                build.registerInputObjectType('VectorNearbyInput', {}, () => ({
+                    description: 'Input for vector similarity search. Provide a query vector, optional metric, and optional max distance threshold.',
+                    fields: () => {
+                        // getTypeByName is safe inside a thunk (fields callback) — called after init is complete
+                        const VectorMetricEnum = build.getTypeByName('VectorMetric');
+                        return {
+                            vector: {
+                                type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLFloat))),
+                                description: 'Query vector for similarity search.',
+                            },
+                            metric: {
+                                type: VectorMetricEnum,
+                                description: `Similarity metric to use (default: ${defaultMetric}).`,
+                            },
+                            distance: {
+                                type: GraphQLFloat,
+                                description: 'Maximum distance threshold. Only rows within this distance are returned.',
+                            },
+                        };
+                    },
+                }), 'UnifiedSearchPlugin (pgvector adapter) registering VectorNearbyInput type');
+            }
+            catch {
+                // Already registered by standalone graphile-pgvector plugin — safe to ignore
+            }
+        },
+        getFilterTypeName(_build) {
+            return 'VectorNearbyInput';
+        },
+        buildFilterApply(sql, alias, column, filterValue, _build) {
+            if (filterValue == null)
+                return null;
+            const { vector, metric, distance } = filterValue;
+            if (!vector || !Array.isArray(vector) || vector.length === 0)
+                return null;
+            const resolvedMetric = metric || defaultMetric;
+            const operator = METRIC_OPERATORS[resolvedMetric] || METRIC_OPERATORS.COSINE;
+            const vectorString = `[${vector.join(',')}]`;
+            const columnExpr = sql `${alias}.${sql.identifier(column.attributeName)}`;
+            const vectorExpr = sql `${sql.value(vectorString)}::vector`;
+            const distanceExpr = sql `(${columnExpr} ${sql.raw(operator)} ${vectorExpr})`;
+            let whereClause = null;
+            if (distance !== undefined && distance !== null) {
+                whereClause = sql `${distanceExpr} <= ${sql.value(distance)}`;
+            }
+            return {
+                whereClause,
+                scoreExpression: distanceExpr,
+            };
+        },
+    };
+}

package/esm/adapters/trgm.d.ts

@@ -0,0 +1,20 @@
+/**
+ * pg_trgm Search Adapter
+ *
+ * Detects text/varchar columns and generates trigram similarity scoring.
+ * Wraps the same SQL logic as graphile-trgm but as a SearchAdapter.
+ */
+import type { SearchAdapter } from '../types';
+export interface TrgmAdapterOptions {
+    /**
+     * Filter prefix for trgm filter fields.
+     * @default 'trgm'
+     */
+    filterPrefix?: string;
+    /**
+     * Default similarity threshold (0..1). Higher = stricter matching.
+     * @default 0.3
+     */
+    defaultThreshold?: number;
+}
+export declare function createTrgmAdapter(options?: TrgmAdapterOptions): SearchAdapter;

package/esm/adapters/trgm.js

@@ -0,0 +1,80 @@
+/**
+ * pg_trgm Search Adapter
+ *
+ * Detects text/varchar columns and generates trigram similarity scoring.
+ * Wraps the same SQL logic as graphile-trgm but as a SearchAdapter.
+ */
+function isTextCodec(codec) {
+    const name = codec?.name;
+    return name === 'text' || name === 'varchar' || name === 'bpchar';
+}
+export function createTrgmAdapter(options = {}) {
+    const { filterPrefix = 'trgm', defaultThreshold = 0.3 } = options;
+    return {
+        name: 'trgm',
+        scoreSemantics: {
+            metric: 'similarity',
+            lowerIsBetter: false,
+            range: [0, 1],
+        },
+        filterPrefix,
+        supportsTextSearch: true,
+        buildTextSearchInput(text) {
+            // trgm filter takes { value: string } — threshold uses adapter default
+            return { value: text };
+        },
+        detectColumns(codec, _build) {
+            if (!codec?.attributes)
+                return [];
+            const columns = [];
+            for (const [attributeName, attribute] of Object.entries(codec.attributes)) {
+                if (isTextCodec(attribute.codec)) {
+                    columns.push({ attributeName });
+                }
+            }
+            return columns;
+        },
+        registerTypes(build) {
+            const { graphql: { GraphQLString, GraphQLFloat, GraphQLNonNull }, } = build;
+            // Register input type for trgm search.
+            // Wrapped in try/catch because the standalone graphile-trgm plugin may
+            // have already registered 'TrgmSearchInput' in its own init hook.
+            // Graphile throws on duplicate registrations, so we catch and ignore.
+            try {
+                build.registerInputObjectType('TrgmSearchInput', {}, () => ({
+                    description: 'Input for pg_trgm fuzzy text matching. Provide a search value and optional similarity threshold.',
+                    fields: () => ({
+                        value: {
+                            type: new GraphQLNonNull(GraphQLString),
+                            description: 'The text to fuzzy-match against. Typos and misspellings are tolerated.',
+                        },
+                        threshold: {
+                            type: GraphQLFloat,
+                            description: `Minimum similarity threshold (0.0 to 1.0). Higher = stricter matching. Default is ${defaultThreshold}.`,
+                        },
+                    }),
+                }), 'UnifiedSearchPlugin (trgm adapter) registering TrgmSearchInput type');
+            }
+            catch {
+                // Already registered by standalone graphile-trgm plugin — safe to ignore
+            }
+        },
+        getFilterTypeName(_build) {
+            return 'TrgmSearchInput';
+        },
+        buildFilterApply(sql, alias, column, filterValue, _build) {
+            if (filterValue == null)
+                return null;
+            const { value, threshold } = filterValue;
+            if (!value || typeof value !== 'string' || value.trim().length === 0)
+                return null;
+            const th = threshold != null ? threshold : defaultThreshold;
+            const columnExpr = sql `${alias}.${sql.identifier(column.attributeName)}`;
+            const similarityExpr = sql `similarity(${columnExpr}, ${sql.value(value)})`;
+            return {
+                whereClause: sql `${similarityExpr} > ${sql.value(th)}`,
+                scoreExpression: similarityExpr,
+            };
+        },
+    };
+}

package/esm/adapters/tsvector.d.ts

@@ -0,0 +1,20 @@
+/**
+ * tsvector Search Adapter
+ *
+ * Detects tsvector columns and generates ts_rank-based scoring.
+ * Wraps the same SQL logic as graphile-tsvector but as a SearchAdapter.
+ */
+import type { SearchAdapter } from '../types';
+export interface TsvectorAdapterOptions {
+    /**
+     * Filter prefix for tsvector filter fields.
+     * @default 'fullText'
+     */
+    filterPrefix?: string;
+    /**
+     * PostgreSQL text search configuration (e.g. 'english', 'simple').
+     * @default 'english'
+     */
+    tsConfig?: string;
+}
+export declare function createTsvectorAdapter(options?: TsvectorAdapterOptions): SearchAdapter;

package/esm/adapters/tsvector.js

@@ -0,0 +1,57 @@
+/**
+ * tsvector Search Adapter
+ *
+ * Detects tsvector columns and generates ts_rank-based scoring.
+ * Wraps the same SQL logic as graphile-tsvector but as a SearchAdapter.
+ */
+function isTsvectorCodec(codec) {
+    return (codec?.extensions?.pg?.schemaName === 'pg_catalog' &&
+        codec?.extensions?.pg?.name === 'tsvector');
+}
+export function createTsvectorAdapter(options = {}) {
+    const { filterPrefix = 'tsv', tsConfig = 'english' } = options;
+    return {
+        name: 'tsv',
+        scoreSemantics: {
+            metric: 'rank',
+            lowerIsBetter: false,
+            range: [0, 1],
+        },
+        filterPrefix,
+        supportsTextSearch: true,
+        buildTextSearchInput(text) {
+            // tsvector filter takes a plain string
+            return text;
+        },
+        detectColumns(codec, _build) {
+            if (!codec?.attributes)
+                return [];
+            const columns = [];
+            for (const [attributeName, attribute] of Object.entries(codec.attributes)) {
+                if (isTsvectorCodec(attribute.codec)) {
+                    columns.push({ attributeName });
+                }
+            }
+            return columns;
+        },
+        registerTypes(_build) {
+            // tsvector uses plain GraphQL String — no custom types needed
+        },
+        getFilterTypeName(_build) {
+            return 'String';
+        },
+        buildFilterApply(sql, alias, column, filterValue, _build) {
+            if (filterValue == null)
+                return null;
+            const val = typeof filterValue === 'string' ? filterValue : String(filterValue);
+            if (val.trim().length === 0)
+                return null;
+            const tsquery = sql `websearch_to_tsquery(${sql.literal(tsConfig)}, ${sql.value(val)})`;
+            const columnExpr = sql `${alias}.${sql.identifier(column.attributeName)}`;
+            return {
+                whereClause: sql `${columnExpr} @@ ${tsquery}`,
+                scoreExpression: sql `ts_rank(${columnExpr}, ${tsquery})`,
+            };
+        },
+    };
+}

package/esm/codecs/bm25-codec.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Bm25CodecPlugin
+ *
+ * Teaches PostGraphile v5 how to handle the pg_textsearch `bm25query` type
+ * and discovers all BM25 indexes in the database.
+ *
+ * This plugin:
+ * 1. Creates a codec for bm25query via gather.hooks.pgCodecs_findPgCodec
+ * 2. Discovers all BM25 indexes via gather.hooks.pgIntrospection_introspection
+ *    by querying pg_index + pg_am + pg_class + pg_attribute
+ * 3. Stores discovered BM25 index info in a module-level Map for use by
+ *    the BM25 adapter during the schema build phase
+ */
+import 'graphile-build-pg';
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * Represents a discovered BM25 index in the database.
+ */
+export interface Bm25IndexInfo {
+    /** Schema name (e.g. 'public') */
+    schemaName: string;
+    /** Table name (e.g. 'documents') */
+    tableName: string;
+    /** Column name (e.g. 'content') */
+    columnName: string;
+    /** Index name (e.g. 'docs_idx') — needed for to_bm25query() */
+    indexName: string;
+}
+/**
+ * Module-level store for discovered BM25 indexes.
+ * Populated during the gather phase, read during the schema build phase.
+ *
+ * Key: "schemaName.tableName.columnName"
+ * Value: Bm25IndexInfo
+ */
+export declare const bm25IndexStore: Map<string, Bm25IndexInfo>;
+/**
+ * Whether pg_textsearch extension was detected in the database.
+ */
+export declare let bm25ExtensionDetected: boolean;
+export declare const Bm25CodecPlugin: GraphileConfig.Plugin;
+export declare const Bm25CodecPreset: GraphileConfig.Preset;