@an5/adapters 0.2.10 → 0.2.13

package/dist/an5Adapter.js

@@ -17,6 +17,7 @@ const parseConnectionString_1 = require("./googlesheets/parseConnectionString");
 const SQLITE_FILE_SUFFIXES = ['.sqlite', '.sqlite3', '.db'];
 const nbase_1 = require("./nbase");
 const sql_1 = require("./base/sql");
+const vector_1 = require("./sqlite/vector");
 const metadata_1 = require("./base/metadata");
 var metadata_2 = require("./base/metadata");
 Object.defineProperty(exports, "setAdapterMetadata", { enumerable: true, get: function () { return metadata_2.setAdapterMetadata; } });
@@ -28,38 +29,60 @@ function sanitizeParamName(name) {
     const cleaned = String(name).replace(/[^A-Za-z0-9_]/g, '_');
     return /^[A-Za-z]/.test(cleaned) ? cleaned : `p_${cleaned}`;
 }
+/** Match only unique/primary-key violations, never general constraint errors. */
+function isDuplicateKeyError(error, dialect) {
+    if (!error || typeof error !== 'object')
+        return false;
+    const e = error;
+    if (dialect === 'postgres')
+        return e.code === '23505';
+    if (dialect === 'mysql')
+        return e.code === 'ER_DUP_ENTRY' || e.errno === 1062;
+    if (dialect === 'sqlite') {
+        return e.code === 'SQLITE_CONSTRAINT_UNIQUE' || e.code === 'SQLITE_CONSTRAINT_PRIMARYKEY'
+            || e.errcode === 2067 || e.errcode === 1555;
+    }
+    if (dialect === 'mssql') {
+        const number = e.number ?? e.originalError?.info?.number;
+        return number === 2601 || number === 2627;
+    }
+    return false;
+}
 function appendUpdateSet(sets, params, col, val, dialect) {
     const quoted = (0, sql_1.quote)(col, dialect);
     const safeCol = sanitizeParamName(col);
-    if (val && typeof val === 'object' && !(val instanceof Date)) {
+    // `TypedArray.prototype.set` is the copy method, not the update operator, so a
+    // vector written as a float32 BLOB must not be read as `{ set: ... }`.
+    const isLiteral = Array.isArray(val) || ArrayBuffer.isView(val) || val instanceof ArrayBuffer;
+    if (val && typeof val === 'object' && !(val instanceof Date) && !isLiteral) {
         if (val.increment !== undefined) {
-            sets.push(`${quoted} = ${quoted} + @s_${safeCol}_inc`);
-            params[`s_${safeCol}_inc`] = val.increment;
+            const p = (0, sql_1.bindParam)(params, `s_${safeCol}_inc`, val.increment);
+            sets.push(`${quoted} = ${quoted} + @${p}`);
             return;
         }
         if (val.decrement !== undefined) {
-            sets.push(`${quoted} = ${quoted} - @s_${safeCol}_dec`);
-            params[`s_${safeCol}_dec`] = val.decrement;
+            const p = (0, sql_1.bindParam)(params, `s_${safeCol}_dec`, val.decrement);
+            sets.push(`${quoted} = ${quoted} - @${p}`);
             return;
         }
         if (val.multiply !== undefined) {
-            sets.push(`${quoted} = ${quoted} * @s_${safeCol}_mul`);
-            params[`s_${safeCol}_mul`] = val.multiply;
+            const p = (0, sql_1.bindParam)(params, `s_${safeCol}_mul`, val.multiply);
+            sets.push(`${quoted} = ${quoted} * @${p}`);
             return;
         }
         if (val.divide !== undefined) {
-            sets.push(`${quoted} = ${quoted} / @s_${safeCol}_div`);
-            params[`s_${safeCol}_div`] = val.divide;
+            const p = (0, sql_1.bindParam)(params, `s_${safeCol}_div`, val.divide);
+            sets.push(`${quoted} = ${quoted} / @${p}`);
             return;
         }
         if (val.set !== undefined) {
-            sets.push(`${quoted} = @s_${safeCol}_set`);
-            params[`s_${safeCol}_set`] = val.set;
+            const p = (0, sql_1.bindParam)(params, `s_${safeCol}_set`, val.set);
+            sets.push(`${quoted} = @${p}`);
             return;
         }
     }
-    sets.push(`${quoted} = @s_${safeCol}`);
-    params[`s_${safeCol}`] = val;
+    const p = (0, sql_1.bindParam)(params, `s_${safeCol}`, val);
+    sets.push(`${quoted} = @${p}`);
 }
 function selectedAggregateFields(fields) {
     if (!fields || typeof fields !== 'object')
@@ -324,6 +347,21 @@ class An5Adapter {
             return this.sheetsAdapter.exec(query, params);
         return (await this.requireEngine()).exec(query, params);
     }
+    /**
+     * The SQLite engine's vector hooks, or null when this is not a SQLite adapter.
+     * `vectorSearch` needs them to load sqlite-vec and register the distance
+     * functions; a connection with no hooks still searches in memory.
+     */
+    async sqliteVectorSupport() {
+        if (this.sheetsAdapter)
+            return null;
+        const engine = await this.requireEngine();
+        return engine.dialect === 'sqlite' ? (engine.vectorSupport ?? null) : null;
+    }
+    /** `vectorStrategy` from the config, so a project can pin one strategy. */
+    get vectorStrategy() {
+        return this._engineConfig?.vectorStrategy;
+    }
     /** INTERNAL: used by AdapterTableClient for DML statements needing row count */
     async _executeRaw(query, params) {
         return (await this.requireEngine()).executeRaw(query, params);
@@ -636,6 +674,15 @@ class AdapterTableClient {
     }
     get dialect() { return this.adapter.dialect; }
     get tableName() {
+        const t = this.mappedTableName;
+        if (t.startsWith('[') || t.startsWith('"') || t.startsWith('`'))
+            return t;
+        if (t.includes('.'))
+            return t.split('.').map(p => (0, sql_1.quote)(p, this.dialect)).join('.');
+        return (0, sql_1.quote)(t, this.dialect);
+    }
+    /** The table name this model maps to, before any quoting is applied. */
+    get mappedTableName() {
         const name = this.modelName;
         let t = name;
         const modelToTable = (0, metadata_1.getModelToTable)();
@@ -651,11 +698,16 @@ class AdapterTableClient {
                     t = modelToTable[lower];
             }
         }
-        if (t.startsWith('[') || t.startsWith('"') || t.startsWith('`'))
-            return t;
-        if (t.includes('.'))
-            return t.split('.').map(p => (0, sql_1.quote)(p, this.dialect)).join('.');
-        return (0, sql_1.quote)(t, this.dialect);
+        return t;
+    }
+    /**
+     * The bare table name, for helpers that take a string literal. `@@map` values
+     * may be pre-quoted or schema-qualified, neither of which `pragma_table_info`
+     * accepts, so the last segment is unwrapped here.
+     */
+    get rawTableName() {
+        const last = this.mappedTableName.split('.').pop() ?? this.mappedTableName;
+        return last.replace(/^[\s]*[\[\]"`]+|[\[\]"`]+[\s]*$/g, '');
     }
     get nolock() {
         return this.dialect === 'mssql' ? ' WITH (NOLOCK)' : '';
@@ -674,6 +726,58 @@ class AdapterTableClient {
     async doExecuteRaw(query, params) {
         return this.adapter._executeRaw(query, params);
     }
+    /**
+     * Encode every `VECTOR(n)` value on its way into SQLite.
+     *
+     * The column holds a float32 BLOB, which is a third of the size of the JSON
+     * text it replaces and is what sqlite-vec reads. Values that already arrived
+     * as text or bytes are left alone, so rows written by an older version stay
+     * readable.
+     */
+    encodeVectorFields(data) {
+        if (this.dialect !== 'sqlite')
+            return data;
+        const fields = (0, metadata_1.getFieldsForModel)(this.modelName);
+        const vectorFields = Object.keys(fields).filter((name) => (0, vector_1.isVectorField)(fields[name]));
+        if (vectorFields.length === 0)
+            return data;
+        const { encodeVector } = require('./sqlite/vector');
+        const out = { ...data };
+        for (const name of vectorFields) {
+            const value = out[name];
+            if ((0, vector_1.needsVectorEncoding)(value)) {
+                const parsed = Array.from(value);
+                if (parsed.length > 0)
+                    out[name] = encodeVector(parsed);
+            }
+        }
+        return out;
+    }
+    /** Decode `VECTOR(n)` columns back into `number[]` after a read. */
+    decodeVectorFields(rows) {
+        if (this.dialect !== 'sqlite' || !Array.isArray(rows) || rows.length === 0)
+            return rows;
+        const fields = (0, metadata_1.getFieldsForModel)(this.modelName);
+        const vectorFields = Object.keys(fields).filter((name) => (0, vector_1.isVectorField)(fields[name]));
+        if (vectorFields.length === 0)
+            return rows;
+        return rows.map((row) => {
+            if (!row || typeof row !== 'object')
+                return row;
+            let changed = false;
+            const out = { ...row };
+            for (const name of vectorFields) {
+                if (!(name in out))
+                    continue;
+                const decoded = (0, vector_1.decodeVector)(out[name]);
+                if (decoded) {
+                    out[name] = decoded;
+                    changed = true;
+                }
+            }
+            return changed ? out : row;
+        });
+    }
     async findMany(args) {
         const params = {};
         const whereCtx = this.whereContext();
@@ -717,7 +821,8 @@ class AdapterTableClient {
                     query += ` WHERE ${whereSql}`;
                 if (orderSql)
                     query += ` ${orderSql}`;
-                query += ` LIMIT ${take ?? 'ALL'} OFFSET ${skip}`;
+                const limit = take ?? (this.dialect === 'sqlite' ? '-1' : this.dialect === 'mysql' ? '18446744073709551615' : 'ALL');
+                query += ` LIMIT ${limit} OFFSET ${skip}`;
             }
             else {
                 // mssql requires ORDER BY before OFFSET/FETCH
@@ -738,7 +843,7 @@ class AdapterTableClient {
             if (orderSql)
                 query += ` ${orderSql}`;
         }
-        const rows = await this.doExec(query, params);
+        const rows = this.decodeVectorFields(await this.doExec(query, params));
         if (args?.include) {
             await resolveIncludes(this.modelName, rows, args.include, this.adapter);
         }
@@ -779,10 +884,8 @@ class AdapterTableClient {
             }
         }
         const fields = (0, metadata_1.getFieldsForModel)(this.modelName);
-        const idFieldName = Object.prototype.hasOwnProperty.call(fields, 'id')
-            ? 'id'
-            : Object.keys(fields).find((name) => name.endsWith('_id') || name.endsWith('Id') || name.toLowerCase() === 'id');
-        const data = { ...rawData };
+        const idFieldName = (0, metadata_1.resolveIdField)(fields);
+        const data = this.encodeVectorFields(rawData);
         if (idFieldName) {
             const fieldDef = fields[idFieldName];
             const rawType = typeof fieldDef === 'string' ? fieldDef : (fieldDef?.ts || fieldDef?.sql || fieldDef?.type || '');
@@ -836,27 +939,33 @@ class AdapterTableClient {
         if (firstRow === undefined)
             return { count: 0 };
         const firstCols = Object.keys(firstRow).filter(k => firstRow[k] !== undefined);
-        // Bulk INSERT for the common case (same columns, no skipDuplicates)
-        if (firstCols.length > 0 && !args.skipDuplicates) {
+        const sameColumns = args.data.every(row => {
+            const cols = Object.keys(row).filter(k => row[k] !== undefined);
+            return cols.length === firstCols.length && firstCols.every(col => cols.includes(col));
+        });
+        const fields = (0, metadata_1.getFieldsForModel)(this.modelName);
+        const idFieldName = (0, metadata_1.resolveIdField)(fields);
+        const idDef = idFieldName ? fields[idFieldName] : undefined;
+        const idType = typeof idDef === 'string' ? idDef : (idDef?.ts || idDef?.sql || idDef?.type || '');
+        const generatesId = ['string', 'uuid', 'uniqueidentifier', 'nvarchar', 'varchar', 'text'].includes(String(idType).toLowerCase());
+        const needsGeneratedId = idFieldName && generatesId && args.data.some(row => !row[idFieldName]);
+        // Rows needing generated IDs follow create's default handling.
+        if (firstCols.length > 0 && sameColumns && !needsGeneratedId && !args.skipDuplicates) {
             const params = {};
             const rowPlaceholders = [];
             for (let r = 0; r < args.data.length; r++) {
                 const row = args.data[r];
+                const encoded = this.encodeVectorFields(row);
                 const vals = firstCols.map(col => {
                     const p = `r${r}_${col}`;
-                    params[p] = row[col] ?? null;
+                    params[p] = encoded[col] ?? null;
                     return `@${p}`;
                 });
                 rowPlaceholders.push(`(${vals.join(', ')})`);
             }
             const query = `INSERT INTO ${this.tableName} (${firstCols.map(c => (0, sql_1.quote)(c, this.dialect)).join(', ')}) VALUES ${rowPlaceholders.join(', ')}`;
-            try {
-                await this.doExecuteRaw(query, params);
-                return { count: args.data.length };
-            }
-            catch {
-                // fallback below if bulk fails (e.g. mixed column sets)
-            }
+            await this.doExecuteRaw(query, params);
+            return { count: args.data.length };
         }
         // Row-by-row fallback
         let count = 0;
@@ -866,7 +975,7 @@ class AdapterTableClient {
                 count++;
             }
             catch (e) {
-                if (!args.skipDuplicates)
+                if (!args.skipDuplicates || !isDuplicateKeyError(e, this.dialect))
                     throw e;
             }
         }
@@ -882,13 +991,14 @@ class AdapterTableClient {
                 delete rawData[key];
             }
         }
+        const data = this.encodeVectorFields(rawData);
         const setCols = Object.keys(rawData).filter(k => rawData[k] !== undefined);
         if (setCols.length > 0) {
             const params = {};
             const whereSql = (0, sql_1.parseWhere)(this.modelName, args.where, params, this.dialect, 'w_', this.whereContext());
             const sets = [];
             for (const col of setCols) {
-                appendUpdateSet(sets, params, col, rawData[col], this.dialect);
+                appendUpdateSet(sets, params, col, data[col], this.dialect);
             }
             if (sets.length > 0) {
                 const query = `UPDATE ${this.tableName} SET ${sets.join(', ')}${whereSql ? ` WHERE ${whereSql}` : ''}`;
@@ -940,10 +1050,11 @@ class AdapterTableClient {
     async updateMany(args) {
         const params = {};
         const whereSql = (0, sql_1.parseWhere)(this.modelName, args.where, params, this.dialect, 'w_', this.whereContext());
+        const data = this.encodeVectorFields(args.data);
         const setCols = Object.keys(args.data).filter(k => args.data[k] !== undefined);
         const sets = [];
         for (const col of setCols) {
-            appendUpdateSet(sets, params, col, args.data[col], this.dialect);
+            appendUpdateSet(sets, params, col, data[col], this.dialect);
         }
         if (sets.length === 0)
             return { count: 0 };
@@ -1046,7 +1157,7 @@ class AdapterTableClient {
     }
     async groupBy(args) {
         const params = {};
-        const whereSql = (0, sql_1.parseWhere)(this.modelName, args?.where, params, this.dialect);
+        const whereSql = (0, sql_1.parseWhere)(this.modelName, args?.where, params, this.dialect, '', this.whereContext());
         const byFields = normalizeByFields(args?.by);
         if (byFields.length === 0)
             throw new Error("groupBy requires 'by' fields");
@@ -1076,9 +1187,8 @@ class AdapterTableClient {
             const skip = toNonNegativeInt(args?.skip);
             const take = toNonNegativeInt(args?.take, 1);
             if (this.dialect === 'postgres' || this.dialect === 'mysql' || this.dialect === 'sqlite') {
-                if (hasTake)
-                    query += ` LIMIT ${take}`;
-                query += ` OFFSET ${skip}`;
+                const limit = hasTake ? take : (this.dialect === 'sqlite' ? '-1' : this.dialect === 'mysql' ? '18446744073709551615' : 'ALL');
+                query += ` LIMIT ${limit} OFFSET ${skip}`;
             }
             else {
                 query += ` OFFSET ${skip} ROWS`;
@@ -1285,6 +1395,30 @@ class AdapterTableClient {
                     throw err;
             }
         }
+        else if (this.dialect === 'sqlite') {
+            // SQLite has no vector type, so the ranking runs through sqlite-vec, a
+            // driver function, or json_each — whichever this connection supports.
+            const whereSql = (0, sql_1.parseWhere)(this.modelName, args.where, params, this.dialect, '', this.whereContext());
+            const support = await this.adapter.sqliteVectorSupport?.() ?? null;
+            const ranked = await (0, vector_1.runSqliteVectorSearch)({
+                exec: (sql, p) => this.doExec(sql, p),
+                vectorSupport: support,
+                table: this.tableName,
+                rawTable: this.rawTableName,
+                column: col,
+                rawColumn: vectorField,
+                vector: args.vector,
+                metric,
+                take,
+                tail: whereSql ? ` WHERE ${whereSql}` : '',
+                params,
+                preference: this.adapter.vectorStrategy,
+            });
+            if (ranked)
+                return this.decodeVectorFields(ranked.rows);
+            // No in-database strategy: score the column in the client instead.
+            return this.scoreVectorsInMemory(args, metric, take, vectorField);
+        }
         else if (this.dialect === 'mssql') {
             const distFn = metric === 'cosine' ? 'cosine' : metric === 'euclidean' ? 'euclidean' : 'dot';
             const whereSql = (0, sql_1.parseWhere)(this.modelName, args.where, params, this.dialect, '', this.whereContext());
@@ -1311,35 +1445,26 @@ class AdapterTableClient {
             }
         }
         // 2. Fallback: in-memory similarity computation when native vector support is unavailable
+        return this.scoreVectorsInMemory(args, metric, take, vectorField);
+    }
+    /**
+     * Rank the vector column in the client. This is the last resort for every
+     * provider, and the only option on SQLite connections that offer neither
+     * sqlite-vec, a driver function nor JSON1.
+     *
+     * The whole table is loaded, so it is only reasonable for a table small
+     * enough to fit in memory.
+     */
+    async scoreVectorsInMemory(args, metric, take, vectorField = 'embedding') {
         const rows = await this.findMany({ where: args.where });
         const scored = [];
         for (const row of rows) {
-            const raw = row[vectorField];
-            if (!raw)
-                continue;
-            let vec = [];
-            try {
-                vec = typeof raw === 'string' ? JSON.parse(raw) : raw;
-            }
-            catch {
+            const vec = (0, vector_1.decodeVector)(row[vectorField]);
+            if (!vec)
                 continue;
-            }
-            if (!Array.isArray(vec) || vec.length !== args.vector.length)
+            const dist = (0, vector_1.vectorDistance)(args.vector, vec, metric);
+            if (dist === null)
                 continue;
-            let dot = 0, m1 = 0, m2 = 0;
-            for (let i = 0; i < args.vector.length; i++) {
-                const av = args.vector[i] ?? 0;
-                const bv = vec[i] ?? 0;
-                dot += av * bv;
-                m1 += av ** 2;
-                m2 += bv ** 2;
-            }
-            const cosine = m1 && m2 ? dot / (Math.sqrt(m1) * Math.sqrt(m2)) : 0;
-            const dist = metric === 'cosine'
-                ? 1 - cosine
-                : metric === 'dot'
-                    ? -dot
-                    : Math.sqrt(args.vector.reduce((s, v, i) => s + (v - (vec[i] ?? 0)) ** 2, 0));
             scored.push({ row, dist });
         }
         scored.sort((a, b) => a.dist - b.dist);

package/dist/base/metadata.d.ts

@@ -11,6 +11,8 @@ export interface ModelFieldMeta {
     isId?: boolean;
     [key: string]: any;
 }
+/** Prefer schema primary-key metadata; retain name inference for legacy clients. */
+export declare function resolveIdField(fields: Record<string, any>): string | undefined;
 export interface AdapterMetadata {
     modelToTable?: Record<string, string>;
     modelFields?: Record<string, any>;

package/dist/base/metadata.js

@@ -1,11 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveIdField = resolveIdField;
 exports.setAdapterMetadata = setAdapterMetadata;
 exports.getModelToTable = getModelToTable;
 exports.getFieldsForModel = getFieldsForModel;
 exports.getRelationMap = getRelationMap;
 exports.getRelationsForModel = getRelationsForModel;
 exports.createAdapterProxy = createAdapterProxy;
+/** Prefer schema primary-key metadata; retain name inference for legacy clients. */
+function resolveIdField(fields) {
+    const primaryKey = Object.keys(fields).find(name => fields[name]?.isId === true);
+    if (primaryKey)
+        return primaryKey;
+    if (Object.prototype.hasOwnProperty.call(fields, 'id'))
+        return 'id';
+    return Object.keys(fields).find(name => name.endsWith('_id') || name.endsWith('Id') || name.toLowerCase() === 'id');
+}
 let modelToTable = {};
 let modelFields = {};
 let relationMap = {};

package/dist/base/sql.d.ts

@@ -3,6 +3,8 @@ import type { RelationDef } from './metadata';
 export declare function quote(name: string, dialect: Dialect): string;
 /** Quote a full table reference (may already be quoted, and may contain schema parts). */
 export declare function quoteTable(name: string, dialect: Dialect): string;
+/** Allocate parameters without overwriting values from sibling clauses. */
+export declare function bindParam(params: Record<string, any>, name: string, value: any): string;
 export interface WhereContext {
     /** Relations of the current model keyed by relation name. */
     relationMap?: Record<string, Record<string, RelationDef>>;

package/dist/base/sql.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.quote = quote;
 exports.quoteTable = quoteTable;
+exports.bindParam = bindParam;
 exports.parseWhere = parseWhere;
 exports.buildOrderBy = buildOrderBy;
 // ─── Quoting ───────────────────────────────────────────────────────────────────────
@@ -38,6 +39,15 @@ function sanitizeParamName(name) {
     const cleaned = String(name).replace(/[^A-Za-z0-9_]/g, '_');
     return /^[A-Za-z]/.test(cleaned) ? cleaned : `p_${cleaned}`;
 }
+/** Allocate parameters without overwriting values from sibling clauses. */
+function bindParam(params, name, value) {
+    let candidate = name;
+    let suffix = 1;
+    while (Object.prototype.hasOwnProperty.call(params, candidate))
+        candidate = `${name}_${suffix++}`;
+    params[candidate] = value;
+    return candidate;
+}
 function normalizeSortDirection(dir) {
     return typeof dir === 'string' && dir.toUpperCase() === 'DESC' ? 'DESC' : 'ASC';
 }
@@ -119,15 +129,12 @@ function parseWhere(modelName, where, params, dialect, prefix = '', ctx) {
                         conditions.push(`${col} IS NOT NULL`);
                     }
                     else if (v.not && typeof v.not === 'object' && !(v.not instanceof Date) && !Array.isArray(v.not)) {
-                        const nestedParams = {};
-                        const nestedSql = parseWhere(modelName, { [key]: v.not }, nestedParams, dialect, `${prefix}${key}_not_`, ctx);
-                        Object.assign(params, nestedParams);
+                        const nestedSql = parseWhere(modelName, { [key]: v.not }, params, dialect, `${prefix}${key}_not_`, ctx);
                         if (nestedSql)
                             conditions.push(`NOT (${nestedSql})`);
                     }
                     else {
-                        const p = `${pname}_not`;
-                        params[p] = v.not;
+                        const p = bindParam(params, `${pname}_not`, v.not);
                         conditions.push(`${col} <> @${p}`);
                     }
                 }
@@ -136,49 +143,41 @@ function parseWhere(modelName, where, params, dialect, prefix = '', ctx) {
                         conditions.push(`${col} IS NULL`);
                     }
                     else {
-                        const p = `${pname}_eq`;
-                        params[p] = v.equals;
+                        const p = bindParam(params, `${pname}_eq`, v.equals);
                         conditions.push(`${col} = @${p}`);
                     }
                 }
                 if (v.contains !== undefined) {
-                    const p = `${pname}_co`;
-                    params[p] = `%${v.contains}%`;
+                    const p = bindParam(params, `${pname}_co`, `%${v.contains}%`);
                     conditions.push(`${col} LIKE @${p}`);
                 }
                 if (v.startsWith !== undefined) {
-                    const p = `${pname}_sw`;
-                    params[p] = `${v.startsWith}%`;
+                    const p = bindParam(params, `${pname}_sw`, `${v.startsWith}%`);
                     conditions.push(`${col} LIKE @${p}`);
                 }
                 if (v.endsWith !== undefined) {
-                    const p = `${pname}_ew`;
-                    params[p] = `%${v.endsWith}`;
+                    const p = bindParam(params, `${pname}_ew`, `%${v.endsWith}`);
                     conditions.push(`${col} LIKE @${p}`);
                 }
                 if (v.gte !== undefined) {
-                    const p = `${pname}_gte`;
-                    params[p] = v.gte;
+                    const p = bindParam(params, `${pname}_gte`, v.gte);
                     conditions.push(`${col} >= @${p}`);
                 }
                 if (v.lte !== undefined) {
-                    const p = `${pname}_lte`;
-                    params[p] = v.lte;
+                    const p = bindParam(params, `${pname}_lte`, v.lte);
                     conditions.push(`${col} <= @${p}`);
                 }
                 if (v.gt !== undefined) {
-                    const p = `${pname}_gt`;
-                    params[p] = v.gt;
+                    const p = bindParam(params, `${pname}_gt`, v.gt);
                     conditions.push(`${col} > @${p}`);
                 }
                 if (v.lt !== undefined) {
-                    const p = `${pname}_lt`;
-                    params[p] = v.lt;
+                    const p = bindParam(params, `${pname}_lt`, v.lt);
                     conditions.push(`${col} < @${p}`);
                 }
                 if (v.in !== undefined) {
                     if (Array.isArray(v.in) && v.in.length > 0) {
-                        const ps = v.in.map((x, i) => { const p = `${pname}_in${i}`; params[p] = x; return `@${p}`; });
+                        const ps = v.in.map((x, i) => { const p = bindParam(params, `${pname}_in${i}`, x); return `@${p}`; });
                         conditions.push(`${col} IN (${ps.join(', ')})`);
                     }
                     else {
@@ -187,7 +186,7 @@ function parseWhere(modelName, where, params, dialect, prefix = '', ctx) {
                 }
                 if (v.notIn !== undefined) {
                     if (Array.isArray(v.notIn) && v.notIn.length > 0) {
-                        const ps = v.notIn.map((x, i) => { const p = `${pname}_notin${i}`; params[p] = x; return `@${p}`; });
+                        const ps = v.notIn.map((x, i) => { const p = bindParam(params, `${pname}_notin${i}`, x); return `@${p}`; });
                         conditions.push(`${col} NOT IN (${ps.join(', ')})`);
                     }
                     else {
@@ -196,8 +195,8 @@ function parseWhere(modelName, where, params, dialect, prefix = '', ctx) {
                 }
             }
             else {
-                params[pname] = value;
-                conditions.push(`${col} = @${pname}`);
+                const p = bindParam(params, pname, value);
+                conditions.push(`${col} = @${p}`);
             }
         }
     }

package/dist/base/types.d.ts

@@ -1,3 +1,4 @@
+import type { SqliteVectorSupport, VectorStrategyPreference } from '../sqlite/vector';
 export type Dialect = 'mssql' | 'postgres' | 'mysql' | 'sqlite' | 'googlesheets';
 export interface An5AdapterConfig {
     connectionString?: string;
@@ -7,6 +8,17 @@ export interface An5AdapterConfig {
      * run in NBase while the rows stay in `connectionString`'s database.
      */
     nbase?: string;
+    /**
+     * Path to sqlite-vec or the AN5 native vector extension. On SQLite it is loaded before the
+     * vector capabilities are probed, so `vectorSearch` ranks inside the database
+     * instead of loading the table into memory. Other providers ignore it.
+     */
+    sqliteVec?: string;
+    /**
+     * Pin the SQLite vector search strategy. `auto` (the default) probes for
+     * sqlite-vec, a driver function and JSON1, and uses the first that works.
+     */
+    vectorStrategy?: VectorStrategyPreference;
     engine?: QueryEngine;
     db?: any;
     driver?: any;
@@ -27,4 +39,6 @@ export interface QueryEngine {
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     beginTransaction(): Promise<TransactionHandle>;
+    /** SQLite only: extension loading and distance-function registration. */
+    vectorSupport?: SqliteVectorSupport;
 }