graphile-search 1.1.0

package/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;

package/codecs/bm25-codec.js

@@ -0,0 +1,199 @@
+"use strict";
+/**
+ * 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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bm25CodecPreset = exports.Bm25CodecPlugin = exports.bm25ExtensionDetected = exports.bm25IndexStore = void 0;
+require("graphile-build-pg");
+const pg_sql2_1 = __importDefault(require("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
+ */
+exports.bm25IndexStore = new Map();
+/**
+ * Whether pg_textsearch extension was detected in the database.
+ */
+exports.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'
+`;
+exports.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: pg_sql2_1.default.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
+                exports.bm25IndexStore.clear();
+                try {
+                    const adaptorSettings = pgService.adaptorSettings;
+                    if (!adaptorSettings?.connectionString && !adaptorSettings?.pool) {
+                        return;
+                    }
+                    // Import pg dynamically for the discovery query
+                    const { Pool } = await Promise.resolve().then(() => __importStar(require('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) {
+                            exports.bm25ExtensionDetected = true;
+                            for (const row of result.rows) {
+                                const key = `${row.schema_name}.${row.table_name}.${row.column_name}`;
+                                exports.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
+                    exports.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 _;
+                },
+            },
+        },
+    },
+};
+exports.Bm25CodecPreset = {
+    plugins: [exports.Bm25CodecPlugin],
+};

package/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/codecs/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VectorCodecPreset = exports.VectorCodecPlugin = exports.bm25ExtensionDetected = exports.bm25IndexStore = exports.Bm25CodecPreset = exports.Bm25CodecPlugin = exports.createTsvectorCodecPlugin = exports.TsvectorCodecPreset = exports.TsvectorCodecPlugin = void 0;
+var tsvector_codec_1 = require("./tsvector-codec");
+Object.defineProperty(exports, "TsvectorCodecPlugin", { enumerable: true, get: function () { return tsvector_codec_1.TsvectorCodecPlugin; } });
+Object.defineProperty(exports, "TsvectorCodecPreset", { enumerable: true, get: function () { return tsvector_codec_1.TsvectorCodecPreset; } });
+Object.defineProperty(exports, "createTsvectorCodecPlugin", { enumerable: true, get: function () { return tsvector_codec_1.createTsvectorCodecPlugin; } });
+var bm25_codec_1 = require("./bm25-codec");
+Object.defineProperty(exports, "Bm25CodecPlugin", { enumerable: true, get: function () { return bm25_codec_1.Bm25CodecPlugin; } });
+Object.defineProperty(exports, "Bm25CodecPreset", { enumerable: true, get: function () { return bm25_codec_1.Bm25CodecPreset; } });
+Object.defineProperty(exports, "bm25IndexStore", { enumerable: true, get: function () { return bm25_codec_1.bm25IndexStore; } });
+Object.defineProperty(exports, "bm25ExtensionDetected", { enumerable: true, get: function () { return bm25_codec_1.bm25ExtensionDetected; } });
+var vector_codec_1 = require("./vector-codec");
+Object.defineProperty(exports, "VectorCodecPlugin", { enumerable: true, get: function () { return vector_codec_1.VectorCodecPlugin; } });
+Object.defineProperty(exports, "VectorCodecPreset", { enumerable: true, get: function () { return vector_codec_1.VectorCodecPreset; } });

package/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/codecs/operator-factories.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMatchesOperatorFactory = createMatchesOperatorFactory;
+exports.createTrgmOperatorFactories = createTrgmOperatorFactories;
+/**
+ * Creates the `matches` filter operator factory for full-text search.
+ * Declared here so it's registered via the declarative
+ * `connectionFilterOperatorFactories` API.
+ */
+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.
+ */
+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/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/codecs/tsvector-codec.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * 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
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TsvectorCodecPreset = exports.TsvectorCodecPlugin = void 0;
+exports.createTsvectorCodecPlugin = createTsvectorCodecPlugin;
+const graphql_1 = require("graphql");
+const pg_sql2_1 = __importDefault(require("pg-sql2"));
+/**
+ * Creates a TsvectorCodecPlugin with the given options.
+ *
+ * @param options - Plugin configuration
+ * @returns GraphileConfig.Plugin
+ */
+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: pg_sql2_1.default.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: pg_sql2_1.default.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', graphql_1.GraphQLString.name);
+                                setGraphQLTypeForPgCodec(codec, 'output', graphql_1.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.
+ */
+exports.TsvectorCodecPlugin = createTsvectorCodecPlugin();
+exports.TsvectorCodecPreset = {
+    plugins: [exports.TsvectorCodecPlugin],
+};

package/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;