graphile-search 1.1.0

package/esm/codecs/bm25-codec.js

@@ -0,0 +1,160 @@
+/**
+ * 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 sql from 'pg-sql2';
+/**
+ * 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 const bm25IndexStore = new Map();
+/**
+ * Whether pg_textsearch extension was detected in the database.
+ */
+export let bm25ExtensionDetected = false;
+/**
+ * The SQL query that discovers BM25 indexes in the database.
+ * Joins pg_index -> pg_class -> pg_am to find all indexes using the 'bm25'
+ * access method, then resolves the schema, table, column, and index names.
+ */
+const BM25_DISCOVERY_SQL = `
+  SELECT
+    n.nspname  AS schema_name,
+    c.relname  AS table_name,
+    a.attname  AS column_name,
+    i.relname  AS index_name
+  FROM pg_index ix
+  JOIN pg_class i ON i.oid = ix.indexrelid
+  JOIN pg_am am ON am.oid = i.relam
+  JOIN pg_class c ON c.oid = ix.indrelid
+  JOIN pg_namespace n ON n.oid = c.relnamespace
+  JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = ANY(ix.indkey)
+  WHERE am.amname = 'bm25'
+`;
+export const Bm25CodecPlugin = {
+    name: 'Bm25CodecPlugin',
+    version: '1.0.0',
+    description: 'Registers a codec for the pg_textsearch bm25query type and discovers BM25 indexes',
+    gather: {
+        hooks: {
+            /**
+             * Register the bm25query codec when detected during type introspection.
+             */
+            async pgCodecs_findPgCodec(info, event) {
+                if (event.pgCodec)
+                    return;
+                const { pgType: type, serviceName } = event;
+                if (type.typname !== 'bm25query')
+                    return;
+                const typeNamespace = await info.helpers.pgIntrospection.getNamespace(serviceName, type.typnamespace);
+                if (!typeNamespace)
+                    return;
+                const schemaName = typeNamespace.nspname;
+                event.pgCodec = {
+                    name: 'bm25query',
+                    sqlType: sql.identifier(schemaName, 'bm25query'),
+                    // PG sends bm25query as text
+                    fromPg(value) {
+                        return value;
+                    },
+                    // string -> bm25query text
+                    toPg(value) {
+                        return value;
+                    },
+                    attributes: undefined,
+                    executor: null,
+                    extensions: {
+                        oid: type._id,
+                        pg: { serviceName, schemaName, name: 'bm25query' },
+                    },
+                };
+            },
+            /**
+             * After introspection completes, query for all BM25 indexes.
+             * Uses the pgService's adaptorSettings to create a direct pg.Pool
+             * connection and runs the BM25 discovery query.
+             */
+            async pgIntrospection_introspection(info, event) {
+                const { serviceName } = event;
+                // Get the pgService from the resolved preset
+                const pgService = info.resolvedPreset?.pgServices?.find((s) => (s.name ?? 'main') === serviceName);
+                if (!pgService)
+                    return;
+                // Clear previous entries for this introspection run
+                bm25IndexStore.clear();
+                try {
+                    const adaptorSettings = pgService.adaptorSettings;
+                    if (!adaptorSettings?.connectionString && !adaptorSettings?.pool) {
+                        return;
+                    }
+                    // Import pg dynamically for the discovery query
+                    const { Pool } = await import('pg');
+                    const existingPool = adaptorSettings.pool;
+                    const pool = existingPool ?? new Pool({
+                        connectionString: adaptorSettings.connectionString,
+                        max: 1,
+                    });
+                    const isOwnPool = !existingPool;
+                    try {
+                        const result = await pool.query(BM25_DISCOVERY_SQL);
+                        if (result.rows && result.rows.length > 0) {
+                            bm25ExtensionDetected = true;
+                            for (const row of result.rows) {
+                                const key = `${row.schema_name}.${row.table_name}.${row.column_name}`;
+                                bm25IndexStore.set(key, {
+                                    schemaName: row.schema_name,
+                                    tableName: row.table_name,
+                                    columnName: row.column_name,
+                                    indexName: row.index_name,
+                                });
+                            }
+                        }
+                    }
+                    finally {
+                        if (isOwnPool) {
+                            await pool.end();
+                        }
+                    }
+                }
+                catch {
+                    // pg_textsearch not installed or query failed — gracefully skip
+                    bm25ExtensionDetected = false;
+                }
+            },
+        },
+    },
+    schema: {
+        hooks: {
+            init: {
+                before: ['PgCodecs'],
+                callback(_, build) {
+                    const { setGraphQLTypeForPgCodec } = build;
+                    // Map bm25query codec to String for both input and output
+                    for (const codec of Object.values(build.input.pgRegistry.pgCodecs)) {
+                        if (codec.name === 'bm25query') {
+                            setGraphQLTypeForPgCodec(codec, 'input', build.graphql.GraphQLString.name);
+                            setGraphQLTypeForPgCodec(codec, 'output', build.graphql.GraphQLString.name);
+                        }
+                    }
+                    return _;
+                },
+            },
+        },
+    },
+};
+export const Bm25CodecPreset = {
+    plugins: [Bm25CodecPlugin],
+};

package/esm/codecs/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Codec Plugin Exports
+ *
+ * These plugins teach PostGraphile v5 how to handle custom PostgreSQL types
+ * used by the search adapters. They run during the gather phase to discover
+ * types and indexes before the schema build phase.
+ */
+export { TsvectorCodecPlugin, TsvectorCodecPreset, createTsvectorCodecPlugin, } from './tsvector-codec';
+export type { TsvectorCodecPluginOptions } from './tsvector-codec';
+export { Bm25CodecPlugin, Bm25CodecPreset, bm25IndexStore, bm25ExtensionDetected, } from './bm25-codec';
+export type { Bm25IndexInfo } from './bm25-codec';
+export { VectorCodecPlugin, VectorCodecPreset, } from './vector-codec';

package/esm/codecs/index.js

@@ -0,0 +1,10 @@
+/**
+ * Codec Plugin Exports
+ *
+ * These plugins teach PostGraphile v5 how to handle custom PostgreSQL types
+ * used by the search adapters. They run during the gather phase to discover
+ * types and indexes before the schema build phase.
+ */
+export { TsvectorCodecPlugin, TsvectorCodecPreset, createTsvectorCodecPlugin, } from './tsvector-codec';
+export { Bm25CodecPlugin, Bm25CodecPreset, bm25IndexStore, bm25ExtensionDetected, } from './bm25-codec';
+export { VectorCodecPlugin, VectorCodecPreset, } from './vector-codec';

package/esm/codecs/operator-factories.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Connection Filter Operator Factories for Search
+ *
+ * These factories register filter operators on the connection filter system
+ * for tsvector (matches) and pg_trgm (similarTo, wordSimilarTo).
+ *
+ * They are used in the ConstructivePreset's connectionFilterOperatorFactories
+ * array to wire search operators into the declarative filter system.
+ */
+import type { ConnectionFilterOperatorFactory } from 'graphile-connection-filter';
+/**
+ * Creates the `matches` filter operator factory for full-text search.
+ * Declared here so it's registered via the declarative
+ * `connectionFilterOperatorFactories` API.
+ */
+export declare function createMatchesOperatorFactory(fullTextScalarName: string, tsConfig: string): ConnectionFilterOperatorFactory;
+/**
+ * Creates the `similarTo` and `wordSimilarTo` filter operator factories
+ * for pg_trgm fuzzy text matching. Declared here so they're registered
+ * via the declarative `connectionFilterOperatorFactories` API.
+ */
+export declare function createTrgmOperatorFactories(): ConnectionFilterOperatorFactory;

package/esm/codecs/operator-factories.js

@@ -0,0 +1,80 @@
+/**
+ * Connection Filter Operator Factories for Search
+ *
+ * These factories register filter operators on the connection filter system
+ * for tsvector (matches) and pg_trgm (similarTo, wordSimilarTo).
+ *
+ * They are used in the ConstructivePreset's connectionFilterOperatorFactories
+ * array to wire search operators into the declarative filter system.
+ */
+/**
+ * Creates the `matches` filter operator factory for full-text search.
+ * Declared here so it's registered via the declarative
+ * `connectionFilterOperatorFactories` API.
+ */
+export function createMatchesOperatorFactory(fullTextScalarName, tsConfig) {
+    return (build) => {
+        const { sql, graphql: { GraphQLString } } = build;
+        const TYPES = build.dataplanPg?.TYPES;
+        return [{
+                typeNames: fullTextScalarName,
+                operatorName: 'matches',
+                spec: {
+                    description: 'Performs a full text search on the field.',
+                    resolveType: () => GraphQLString,
+                    resolveInputCodec: TYPES ? () => TYPES.text : undefined,
+                    resolve(sqlIdentifier, sqlValue, _input, _$where, _details) {
+                        return sql `${sqlIdentifier} @@ websearch_to_tsquery(${sql.literal(tsConfig)}, ${sqlValue})`;
+                    },
+                },
+            }];
+    };
+}
+/**
+ * Creates the `similarTo` and `wordSimilarTo` filter operator factories
+ * for pg_trgm fuzzy text matching. Declared here so they're registered
+ * via the declarative `connectionFilterOperatorFactories` API.
+ */
+export function createTrgmOperatorFactories() {
+    return (build) => {
+        const { sql } = build;
+        return [
+            {
+                typeNames: 'String',
+                operatorName: 'similarTo',
+                spec: {
+                    description: 'Fuzzy matches using pg_trgm trigram similarity. Tolerates typos and misspellings.',
+                    resolveType: () => build.getTypeByName('TrgmSearchInput'),
+                    resolve(sqlIdentifier, _sqlValue, input, _$where, _details) {
+                        if (input == null)
+                            return null;
+                        const { value, threshold } = input;
+                        if (!value || typeof value !== 'string' || value.trim().length === 0) {
+                            return null;
+                        }
+                        const th = threshold != null ? threshold : 0.3;
+                        return sql `similarity(${sqlIdentifier}, ${sql.value(value)}) > ${sql.value(th)}`;
+                    },
+                },
+            },
+            {
+                typeNames: 'String',
+                operatorName: 'wordSimilarTo',
+                spec: {
+                    description: 'Fuzzy matches using pg_trgm word_similarity. Finds the best matching substring within the column value.',
+                    resolveType: () => build.getTypeByName('TrgmSearchInput'),
+                    resolve(sqlIdentifier, _sqlValue, input, _$where, _details) {
+                        if (input == null)
+                            return null;
+                        const { value, threshold } = input;
+                        if (!value || typeof value !== 'string' || value.trim().length === 0) {
+                            return null;
+                        }
+                        const th = threshold != null ? threshold : 0.3;
+                        return sql `word_similarity(${sql.value(value)}, ${sqlIdentifier}) > ${sql.value(th)}`;
+                    },
+                },
+            },
+        ];
+    };
+}

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

@@ -0,0 +1,53 @@
+/**
+ * TsvectorCodecPlugin
+ *
+ * Teaches PostGraphile v5 how to handle PostgreSQL's tsvector and tsquery types.
+ * Without this, tsvector columns are invisible to the schema builder and the
+ * search plugin cannot generate condition fields.
+ *
+ * This plugin:
+ * 1. Creates codecs for tsvector/tsquery via gather.hooks.pgCodecs_findPgCodec
+ * 2. Registers a custom "FullText" scalar type for tsvector columns
+ * 3. Maps tsvector codec to the FullText scalar (isolating filter operators)
+ * 4. Maps tsquery codec to GraphQL String
+ * 5. Optionally hides tsvector columns from output types
+ */
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * Options for the TsvectorCodecPlugin.
+ */
+export interface TsvectorCodecPluginOptions {
+    /**
+     * Prefix for tsvector condition fields.
+     * @default 'tsv'
+     */
+    pgSearchPrefix?: string;
+    /**
+     * Whether to hide tsvector columns from output types.
+     * @default false
+     */
+    hideTsvectorColumns?: boolean;
+    /**
+     * Name of the custom GraphQL scalar for tsvector columns.
+     * @default 'FullText'
+     */
+    fullTextScalarName?: string;
+    /**
+     * PostgreSQL text search configuration used with `websearch_to_tsquery`.
+     * @default 'english'
+     */
+    tsConfig?: string;
+}
+/**
+ * Creates a TsvectorCodecPlugin with the given options.
+ *
+ * @param options - Plugin configuration
+ * @returns GraphileConfig.Plugin
+ */
+export declare function createTsvectorCodecPlugin(options?: TsvectorCodecPluginOptions): GraphileConfig.Plugin;
+/**
+ * Default static instance using default options.
+ * Maps tsvector to the "FullText" scalar.
+ */
+export declare const TsvectorCodecPlugin: GraphileConfig.Plugin;
+export declare const TsvectorCodecPreset: GraphileConfig.Preset;

package/esm/codecs/tsvector-codec.js

@@ -0,0 +1,155 @@
+/**
+ * TsvectorCodecPlugin
+ *
+ * Teaches PostGraphile v5 how to handle PostgreSQL's tsvector and tsquery types.
+ * Without this, tsvector columns are invisible to the schema builder and the
+ * search plugin cannot generate condition fields.
+ *
+ * This plugin:
+ * 1. Creates codecs for tsvector/tsquery via gather.hooks.pgCodecs_findPgCodec
+ * 2. Registers a custom "FullText" scalar type for tsvector columns
+ * 3. Maps tsvector codec to the FullText scalar (isolating filter operators)
+ * 4. Maps tsquery codec to GraphQL String
+ * 5. Optionally hides tsvector columns from output types
+ */
+import { GraphQLString } from 'graphql';
+import sql from 'pg-sql2';
+/**
+ * Creates a TsvectorCodecPlugin with the given options.
+ *
+ * @param options - Plugin configuration
+ * @returns GraphileConfig.Plugin
+ */
+export function createTsvectorCodecPlugin(options = {}) {
+    const { fullTextScalarName = 'FullText', hideTsvectorColumns = false, } = options;
+    return {
+        name: 'TsvectorCodecPlugin',
+        version: '1.0.0',
+        gather: {
+            hooks: {
+                async pgCodecs_findPgCodec(info, event) {
+                    if (event.pgCodec) {
+                        return;
+                    }
+                    const { pgType: type, serviceName } = event;
+                    const pgCatalog = await info.helpers.pgIntrospection.getNamespaceByName(serviceName, 'pg_catalog');
+                    if (!pgCatalog) {
+                        return;
+                    }
+                    if (type.typnamespace === pgCatalog._id && type.typname === 'tsvector') {
+                        event.pgCodec = {
+                            name: 'tsvector',
+                            sqlType: sql.identifier('pg_catalog', 'tsvector'),
+                            fromPg: (value) => value,
+                            toPg: (value) => value,
+                            attributes: undefined,
+                            executor: null,
+                            extensions: {
+                                oid: type._id,
+                                pg: {
+                                    serviceName,
+                                    schemaName: 'pg_catalog',
+                                    name: 'tsvector',
+                                },
+                            },
+                        };
+                        return;
+                    }
+                    if (type.typnamespace === pgCatalog._id && type.typname === 'tsquery') {
+                        event.pgCodec = {
+                            name: 'tsquery',
+                            sqlType: sql.identifier('pg_catalog', 'tsquery'),
+                            fromPg: (value) => value,
+                            toPg: (value) => value,
+                            attributes: undefined,
+                            executor: null,
+                            extensions: {
+                                oid: type._id,
+                                pg: {
+                                    serviceName,
+                                    schemaName: 'pg_catalog',
+                                    name: 'tsquery',
+                                },
+                            },
+                        };
+                        return;
+                    }
+                },
+            },
+        },
+        schema: {
+            hooks: {
+                // Must run before PgCodecsPlugin's init (to avoid "unknown codec" warning)
+                // and before PgConnectionArgFilterPlugin's init (which creates filter
+                // types like FullTextFilter based on codec→GraphQL type mappings).
+                init: {
+                    before: ['PgCodecs', 'PgConnectionArgFilterPlugin'],
+                    callback(_, build) {
+                        const { setGraphQLTypeForPgCodec } = build;
+                        // Register a custom scalar type for tsvector columns.
+                        // This ensures filter operators like `matches` only appear on
+                        // tsvector filters, not on all String filters.
+                        build.registerScalarType(fullTextScalarName, {}, () => ({
+                            description: 'A full-text search tsvector value represented as a string.',
+                            serialize(value) {
+                                return String(value);
+                            },
+                            parseValue(value) {
+                                if (typeof value === 'string') {
+                                    return value;
+                                }
+                                throw new Error(`${fullTextScalarName} must be a string`);
+                            },
+                            parseLiteral(lit) {
+                                if (lit.kind === 'NullValue')
+                                    return null;
+                                if (lit.kind !== 'StringValue') {
+                                    throw new Error(`${fullTextScalarName} must be a string`);
+                                }
+                                return lit.value;
+                            },
+                        }), `TsvectorCodecPlugin registering ${fullTextScalarName} scalar`);
+                        for (const codec of Object.values(build.input.pgRegistry.pgCodecs)) {
+                            if (codec.name === 'tsvector') {
+                                setGraphQLTypeForPgCodec(codec, 'input', fullTextScalarName);
+                                setGraphQLTypeForPgCodec(codec, 'output', fullTextScalarName);
+                            }
+                            else if (codec.name === 'tsquery') {
+                                setGraphQLTypeForPgCodec(codec, 'input', GraphQLString.name);
+                                setGraphQLTypeForPgCodec(codec, 'output', GraphQLString.name);
+                            }
+                        }
+                        return _;
+                    },
+                },
+            },
+            ...(hideTsvectorColumns
+                ? {
+                    entityBehavior: {
+                        pgCodecAttribute: {
+                            inferred: {
+                                after: ['postInferred'],
+                                provides: ['hideTsvectorColumns'],
+                                callback(behavior, [codec, attributeName]) {
+                                    const attr = codec.attributes?.[attributeName];
+                                    if (attr?.codec?.name === 'tsvector') {
+                                        return [behavior, '-select'];
+                                    }
+                                    return behavior;
+                                },
+                            },
+                        },
+                    },
+                }
+                : {}),
+        },
+    };
+}
+/**
+ * Default static instance using default options.
+ * Maps tsvector to the "FullText" scalar.
+ */
+export const TsvectorCodecPlugin = createTsvectorCodecPlugin();
+export const TsvectorCodecPreset = {
+    plugins: [TsvectorCodecPlugin],
+};

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

@@ -0,0 +1,18 @@
+/**
+ * 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])
+ */
+import 'graphile-build-pg';
+import 'graphile-build';
+import type { GraphileConfig } from 'graphile-config';
+export declare const VectorCodecPlugin: GraphileConfig.Plugin;
+export declare const VectorCodecPreset: GraphileConfig.Preset;

package/esm/codecs/vector-codec.js

@@ -0,0 +1,110 @@
+/**
+ * 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])
+ */
+import 'graphile-build-pg';
+import 'graphile-build';
+import sql from 'pg-sql2';
+export const 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: sql.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 _;
+                },
+            },
+        },
+    },
+};
+export const VectorCodecPreset = {
+    plugins: [VectorCodecPlugin],
+};

package/esm/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * graphile-search — Unified PostGraphile v5 Search Plugin
+ *
+ * Abstracts tsvector, BM25, pg_trgm, and pgvector behind a single
+ * adapter-based architecture with a composite `searchScore` field.
+ *
+ * @example
+ * ```typescript
+ * import { UnifiedSearchPreset } from 'graphile-search';
+ *
+ * // Use all 4 adapters with defaults:
+ * const preset = {
+ *   extends: [
+ *     UnifiedSearchPreset(),
+ *   ],
+ * };
+ *
+ * // Or customize per-adapter:
+ * const preset = {
+ *   extends: [
+ *     UnifiedSearchPreset({
+ *       tsvector: { filterPrefix: 'fullText', tsConfig: 'english' },
+ *       bm25: true,
+ *       trgm: { defaultThreshold: 0.2 },
+ *       pgvector: { defaultMetric: 'L2' },
+ *       searchScoreWeights: { bm25: 0.5, trgm: 0.3, tsv: 0.2 },
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+export { createUnifiedSearchPlugin } from './plugin';
+export { UnifiedSearchPreset } from './preset';
+export type { UnifiedSearchPresetOptions } from './preset';
+export type { SearchAdapter, SearchableColumn, ScoreSemantics, FilterApplyResult, UnifiedSearchOptions, } from './types';
+export { createTsvectorAdapter, createBm25Adapter, createTrgmAdapter, createPgvectorAdapter, } from './adapters';
+export type { TsvectorAdapterOptions, Bm25AdapterOptions, TrgmAdapterOptions, PgvectorAdapterOptions, } from './adapters';
+export { TsvectorCodecPlugin, TsvectorCodecPreset, createTsvectorCodecPlugin, Bm25CodecPlugin, Bm25CodecPreset, bm25IndexStore, VectorCodecPlugin, VectorCodecPreset, } from './codecs';
+export type { TsvectorCodecPluginOptions, Bm25IndexInfo, } from './codecs';
+export { createMatchesOperatorFactory, createTrgmOperatorFactories, } from './codecs/operator-factories';