uql-orm 0.20.2 → 0.22.0

package/dist/type/vector.d.ts

@@ -5,9 +5,12 @@ import type { IndexType } from '../schema/types.js';
  * - `l2` - Euclidean distance
  * - `inner` - inner (dot) product
  * - `l1` - Manhattan distance
- * - `hamming` - for binary vectors
+ *
+ * @remarks Hamming distance is absent because no engine can express it over a float vector column:
+ * pgvector's `<~>`/`bit_hamming_ops` and sqlite-vec's `vec_distance_hamming` both require a *bit*
+ * vector, which no field type maps to. It would be a value that compiles and always throws.
  */
-export type VectorDistance = 'cosine' | 'l2' | 'inner' | 'l1' | 'hamming';
+export type VectorDistance = 'cosine' | 'l2' | 'inner' | 'l1';
 /**
  * Vector similarity search options - used inside `$sort` on vector fields.
  *
@@ -52,4 +55,3 @@ export type VectorIndexOptions = {
 };
 /** Index types whose emitted DDL depends on the distance metric. */
 export type VectorIndexType = Extract<IndexType, 'hnsw' | 'ivfflat' | 'vector'>;
-//# sourceMappingURL=vector.d.ts.map

package/dist/type/vector.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=vector.js.map

package/dist/util/dialect.util.d.ts

@@ -1,4 +1,4 @@
-import { type CascadeType, type EntityMeta, type FieldKey, type FieldOptions, type JsonUpdateOp, type OnFieldCallback, type QueryAggMap, type QueryAggregateOp, type QueryExclude, type QueryGroupMap, type QueryOptions, QueryRaw, type QuerySelect, type QuerySelectValue, type QuerySortMap, type QueryVectorSearch, type QueryWhere, type QueryWhereMap, type RelationKey } from '../type/index.js';
+import { type CascadeType, type EntityMeta, type FieldKey, type FieldOptions, type JsonUpdateOp, type OnFieldCallback, type QueryAggMap, type QueryAggregateOp, type QueryExclude, type QueryGroupMap, type QueryOptions, QueryRaw, type QuerySelect, type QuerySelectValue, type QuerySizeComparisonOps, type QuerySortMap, type QueryVectorSearch, type QueryWhere, type QueryWhereMap, type RelationKey } from '../type/index.js';
 export type CallbackKey = keyof Pick<FieldOptions, 'onInsert' | 'onUpdate'>;
 export declare function filterFieldKeys<E>(meta: EntityMeta<E>, payload: E, callbackKey: CallbackKey): FieldKey<E>[];
 /**
@@ -76,9 +76,15 @@ export type ParsedGroupEntry = {
     /** `true` for a flat distinct op (`$countDistinct`, ...) → `COUNT(DISTINCT field)`. */
     readonly distinct: boolean;
 };
+/**
+ * The `$size` of a relation condition (`{ comments: { $size: { $gte: 2 } } }`), or `undefined` when the
+ * condition constrains the target's fields instead. Shared so every dialect agrees on which of the two
+ * a relation key means, and so the ambiguous mix fails loudly: `{ $size: 2, name: 'x' }` used to fall
+ * through to field filtering and emit a condition on a `$size` *column*.
+ */
+export declare function parseRelationSize(val: unknown): number | QuerySizeComparisonOps | undefined;
 /**
  * Parse the `$group` (grouped columns) and `$agg` (computed aggregates) maps into structured
  * entries consumable by any dialect. Grouped columns come first, then computed columns.
  */
 export declare function parseGroupMap<E>(group?: QueryGroupMap<E>, agg?: QueryAggMap<E>): ParsedGroupEntry[];
-//# sourceMappingURL=dialect.util.d.ts.map

package/dist/util/dialect.util.js

@@ -253,6 +253,22 @@ function isIdValue(filter) {
         typeof filter.toHexString === 'function' ||
         Array.isArray(filter));
 }
+/**
+ * The `$size` of a relation condition (`{ comments: { $size: { $gte: 2 } } }`), or `undefined` when the
+ * condition constrains the target's fields instead. Shared so every dialect agrees on which of the two
+ * a relation key means, and so the ambiguous mix fails loudly: `{ $size: 2, name: 'x' }` used to fall
+ * through to field filtering and emit a condition on a `$size` *column*.
+ */
+export function parseRelationSize(val) {
+    if (!val || typeof val !== 'object' || !('$size' in val)) {
+        return undefined;
+    }
+    const siblings = getKeys(val).filter((key) => key !== '$size');
+    if (siblings.length) {
+        throw new TypeError(`$size on a relation cannot be combined with other conditions: ${siblings.join(', ')}`);
+    }
+    return val.$size;
+}
 /**
  * Parse the `$group` (grouped columns) and `$agg` (computed aggregates) maps into structured
  * entries consumable by any dialect. Grouped columns come first, then computed columns.
@@ -281,4 +297,3 @@ export function parseGroupMap(group, agg) {
     }
     return entries;
 }
-//# sourceMappingURL=dialect.util.js.map

package/dist/util/field.util.d.ts

@@ -11,4 +11,3 @@ export declare function isJsonType(type: unknown): boolean;
  * Checks if a field should be treated as auto-incrementing.
  */
 export declare function isAutoIncrement(field: FieldOptions, isPrimaryKey: boolean): boolean;
-//# sourceMappingURL=field.util.d.ts.map

package/dist/util/field.util.js

@@ -54,4 +54,3 @@ export function isAutoIncrement(field, isPrimaryKey) {
     const isNumeric = isNumericType(field.type);
     return isPrimaryKey && isNumeric && !field.onInsert && !field.columnType;
 }
-//# sourceMappingURL=field.util.js.map

package/dist/util/filters.util.d.ts

@@ -8,4 +8,3 @@ import type { QueryOptions } from '../type/index.js';
  * @example `querier.findMany(User, {}, withDeleted())`
  */
 export declare function withDeleted(): QueryOptions;
-//# sourceMappingURL=filters.util.d.ts.map

package/dist/util/filters.util.js

@@ -9,4 +9,3 @@
 export function withDeleted() {
     return { filters: { softDelete: false } };
 }
-//# sourceMappingURL=filters.util.js.map

package/dist/util/hook.util.d.ts

@@ -12,4 +12,3 @@ export type HookContext = {
  * so mutations go directly to the original object.
  */
 export declare function runHooks<E extends object>(entity: Type<E>, event: HookEvent, payloads: E[], ctx: HookContext): Promise<void>;
-//# sourceMappingURL=hook.util.d.ts.map

package/dist/util/hook.util.js

@@ -17,4 +17,3 @@ export async function runHooks(entity, event, payloads, ctx) {
         }
     }
 }
-//# sourceMappingURL=hook.util.js.map

package/dist/util/index.d.ts

@@ -2,10 +2,10 @@ export * from './dialect.util.js';
 export * from './field.util.js';
 export * from './filters.util.js';
 export * from './hook.util.js';
+export * from './indexColumn.util.js';
 export * from './logger.js';
 export * from './object.util.js';
 export * from './raw.js';
 export * from './relationQuery.util.js';
 export * from './sql.util.js';
 export * from './string.util.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/util/index.js

@@ -2,10 +2,10 @@ export * from './dialect.util.js';
 export * from './field.util.js';
 export * from './filters.util.js';
 export * from './hook.util.js';
+export * from './indexColumn.util.js';
 export * from './logger.js';
 export * from './object.util.js';
 export * from './raw.js';
 export * from './relationQuery.util.js';
 export * from './sql.util.js';
 export * from './string.util.js';
-//# sourceMappingURL=index.js.map

package/dist/util/indexColumn.util.d.ts

@@ -0,0 +1,6 @@
+import { type IndexColumnInput, type IndexColumnSchema } from '../type/index.js';
+/**
+ * Reduces an authored index entry to its normalized form, so the three shapes users write - a column
+ * name, `raw(expression)`, or an options object - reach the dialects as one.
+ */
+export declare function normalizeIndexColumn(entry: IndexColumnInput): IndexColumnSchema;

package/dist/util/indexColumn.util.js

@@ -0,0 +1,26 @@
+import { QueryRaw, RAW_VALUE } from '../type/index.js';
+/**
+ * Reduces an authored index entry to its normalized form, so the three shapes users write - a column
+ * name, `raw(expression)`, or an options object - reach the dialects as one.
+ */
+export function normalizeIndexColumn(entry) {
+    if (typeof entry === 'string') {
+        return { column: entry };
+    }
+    if (entry instanceof QueryRaw) {
+        return { column: rawSql(entry), expression: true };
+    }
+    const { column, ...rest } = entry;
+    return column instanceof QueryRaw ? { ...rest, column: rawSql(column), expression: true } : { ...rest, column };
+}
+/**
+ * An index expression is DDL, evaluated once at creation time, so it cannot take the dialect-aware
+ * callback form of `raw()` - there is no query context to hand it.
+ */
+function rawSql(value) {
+    const sql = value[RAW_VALUE];
+    if (typeof sql !== 'string') {
+        throw new TypeError('an index expression needs raw() with a string, not a function');
+    }
+    return sql;
+}

package/dist/util/logger.d.ts

@@ -63,4 +63,3 @@ export interface ErrorEmittingPool {
  * swallowed pool error is exactly the failure mode this guards against.
  */
 export declare function attachPoolErrorHandler(pool: ErrorEmittingPool, message: string): void;
-//# sourceMappingURL=logger.d.ts.map

package/dist/util/logger.js

@@ -144,4 +144,3 @@ export function attachPoolErrorHandler(pool, message) {
         logger.logError(message, err);
     });
 }
-//# sourceMappingURL=logger.js.map

package/dist/util/object.util.d.ts

@@ -25,4 +25,3 @@ export declare function getKeys<T extends object>(obj: T): (keyof T & string)[];
 export declare function getFieldKeys<E>(fields: {
     [K in FieldKey<E>]?: FieldOptions;
 }): FieldKey<E>[];
-//# sourceMappingURL=object.util.d.ts.map

package/dist/util/object.util.js

@@ -64,4 +64,3 @@ export function getKeys(obj) {
 export function getFieldKeys(fields) {
     return getKeys(fields).filter((field) => fields[field].eager ?? true);
 }
-//# sourceMappingURL=object.util.js.map

package/dist/util/raw.d.ts

@@ -15,4 +15,3 @@ import { QueryRaw, type QueryRawFn, type Scalar } from '../type/index.js';
  * @returns a QueryRaw instance
  */
 export declare function raw(value: Scalar | QueryRawFn, alias?: string): QueryRaw;
-//# sourceMappingURL=raw.d.ts.map

package/dist/util/raw.js

@@ -17,4 +17,3 @@ import { QueryRaw } from '../type/index.js';
 export function raw(value, alias) {
     return new QueryRaw(value, alias);
 }
-//# sourceMappingURL=raw.js.map

package/dist/util/relationQuery.util.d.ts

@@ -22,4 +22,3 @@ export declare function parseRelationQueryValue<E extends object = object>(value
 /** Parses the relation payload for `relKey` */
 export declare function parseRelationAtKey<E>(relKey: RelationKey<E>, populate?: QueryPopulate<E>): ParsedRelationQuery;
 export declare function forEachRequestedRelation<E extends object>(meta: EntityMeta<E>, populate: QueryPopulate<E> | undefined, fn: (relKey: RelationKey<E>, rawValue: unknown) => void): void;
-//# sourceMappingURL=relationQuery.util.d.ts.map

package/dist/util/relationQuery.util.js

@@ -98,4 +98,3 @@ function isValidRelationQueryShape(query) {
     }
     return hasKnownKey;
 }
-//# sourceMappingURL=relationQuery.util.js.map

package/dist/util/sql.util.d.ts

@@ -66,4 +66,3 @@ export declare function buildUpdateResult(payload: BuildUpdateResultPayload): Qu
  * Checks if a value is of a primary key type (string, number, or bigint).
  */
 export declare function isPrimaryKey(val: unknown): val is PrimaryKey;
-//# sourceMappingURL=sql.util.d.ts.map

package/dist/util/sql.util.js

@@ -155,4 +155,3 @@ function sequentialIds(first, count, step) {
 export function isPrimaryKey(val) {
     return typeof val === 'string' || typeof val === 'number' || typeof val === 'bigint';
 }
-//# sourceMappingURL=sql.util.js.map

package/dist/util/sqlLiteral.d.ts

@@ -0,0 +1,19 @@
+/**
+ * SQL string literal escaping for `Dialect.escape`, in two flavors: ANSI single-quote doubling
+ * (Postgres, SQLite) and MySQL backslash escaping (MySQL, MariaDB). Only the quoting step differs.
+ *
+ * **Security.** UQL never calls `Dialect.escape` itself, so this is the hand-written-SQL hatch; prefer
+ * bound parameters. Two limits are inherent to inline MySQL literals (`sqlstring` and `sql-escaper`
+ * share them): escaping breaks under the server's `NO_BACKSLASH_ESCAPES` mode, and under a charset
+ * whose trailing byte can be `0x5C` (GBK, Big5, SJIS). `toSqlString()` values are emitted raw.
+ *
+ * PostgreSQL **array** literals (`{...}` with double-quoted elements and their own escape rules)
+ * are separate from this helper; see {@link PostgresDialect} (array text format when
+ * `nativeArrays` is false) - do not "unify" that path with this function.
+ */
+/** Doubles every single quote in `val`, the ANSI escaping shared by string literals and JSON path keys. */
+export declare function escapeSingleQuotes(val: string): string;
+/** Escape `value` for Postgres, SQLite and related dialects (single-quote doubling). */
+export declare const escapeAnsiSqlLiteral: (value: unknown) => string;
+/** Escape `value` for MySQL and MariaDB (backslash escaping). */
+export declare const escapeMysqlSqlLiteral: (value: unknown) => string;

package/dist/util/sqlLiteral.js

@@ -0,0 +1,108 @@
+/**
+ * SQL string literal escaping for `Dialect.escape`, in two flavors: ANSI single-quote doubling
+ * (Postgres, SQLite) and MySQL backslash escaping (MySQL, MariaDB). Only the quoting step differs.
+ *
+ * **Security.** UQL never calls `Dialect.escape` itself, so this is the hand-written-SQL hatch; prefer
+ * bound parameters. Two limits are inherent to inline MySQL literals (`sqlstring` and `sql-escaper`
+ * share them): escaping breaks under the server's `NO_BACKSLASH_ESCAPES` mode, and under a charset
+ * whose trailing byte can be `0x5C` (GBK, Big5, SJIS). `toSqlString()` values are emitted raw.
+ *
+ * PostgreSQL **array** literals (`{...}` with double-quoted elements and their own escape rules)
+ * are separate from this helper; see {@link PostgresDialect} (array text format when
+ * `nativeArrays` is false) - do not "unify" that path with this function.
+ */
+const SINGLE_QUOTE = /'/g;
+/** Doubles every single quote in `val`, the ANSI escaping shared by string literals and JSON path keys. */
+export function escapeSingleQuotes(val) {
+    return val.replace(SINGLE_QUOTE, "''");
+}
+const ansiStringLiteral = (val) => `'${escapeSingleQuotes(val)}'`;
+// MySQL/MariaDB backslash-escape rather than doubling the quote. Mirrors the `sqlstring` map it replaced.
+// biome-ignore lint/suspicious/noControlCharactersInRegex: MySQL string literals must escape NUL, backspace and SUB
+const MYSQL_SPECIALS = /[\0\b\t\n\r\x1a"'\\]/g;
+const MYSQL_ESCAPES = {
+    '\0': '\\0',
+    '\b': '\\b',
+    '\t': '\\t',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\x1a': '\\Z',
+    '"': '\\"',
+    "'": "\\'",
+    '\\': '\\\\',
+};
+const mysqlStringLiteral = (val) => `'${val.replace(MYSQL_SPECIALS, (char) => MYSQL_ESCAPES[char])}'`;
+const pad = (value, len) => String(value).padStart(len, '0');
+function isByteSource(val) {
+    return (typeof Buffer !== 'undefined' && Buffer.isBuffer(val)) || val instanceof Uint8Array;
+}
+const HEX_BYTES = Array.from({ length: 256 }, (_, byte) => byte.toString(16).padStart(2, '0'));
+/** Native hex encoder where available (~130x faster on 4 KB); lookup table for browsers. */
+function bytesToHexLiteral(bytes) {
+    if (typeof Buffer !== 'undefined') {
+        return `X'${Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString('hex')}'`;
+    }
+    let hex = '';
+    for (let i = 0; i < bytes.length; i++)
+        hex += HEX_BYTES[bytes[i]];
+    return `X'${hex}'`;
+}
+/**
+ * A factory, not a function taking `escapeString` as an argument: threading it through every call
+ * measured 1.1-1.5x slower. Rejects unsupported types rather than stringifying them into SQL.
+ */
+function createEscaper(escapeString) {
+    /** `YYYY-MM-DD HH:mm:ss.mmm` in local time, wrapped as a quoted literal. */
+    const dateLiteral = (date) => escapeString(`${pad(date.getFullYear(), 4)}-${pad(date.getMonth() + 1, 2)}-${pad(date.getDate(), 2)} ${pad(date.getHours(), 2)}:${pad(date.getMinutes(), 2)}:${pad(date.getSeconds(), 2)}.${pad(date.getMilliseconds(), 3)}`);
+    const sqlList = (arr) => {
+        let sql = '';
+        for (let i = 0; i < arr.length; i++) {
+            const val = arr[i];
+            if (i > 0)
+                sql += ', ';
+            sql += Array.isArray(val) ? `(${sqlList(val)})` : escapeValue(val);
+        }
+        return sql;
+    };
+    const escapeValue = (value) => {
+        if (value === undefined || value === null) {
+            return 'NULL';
+        }
+        switch (typeof value) {
+            case 'boolean':
+                return value ? 'true' : 'false';
+            case 'number':
+                return Number.isFinite(value) ? String(value) : 'NULL';
+            case 'bigint':
+                return String(value);
+            case 'string':
+                return escapeString(value);
+            case 'symbol':
+            case 'function':
+                throw new TypeError('escapeSqlLiteral: symbol and function values are not supported; use bound parameters.');
+            case 'object': {
+                if (value instanceof Date) {
+                    return Number.isNaN(value.getTime()) ? 'NULL' : dateLiteral(value);
+                }
+                if (Array.isArray(value)) {
+                    return sqlList(value);
+                }
+                if (isByteSource(value)) {
+                    return bytesToHexLiteral(value);
+                }
+                if ('toSqlString' in value && typeof value.toSqlString === 'function') {
+                    return String(value.toSqlString());
+                }
+                throw new TypeError('escapeSqlLiteral: plain objects are not supported; use bound parameters or JSON.stringify + a string column.');
+            }
+            default:
+                // Unreachable today; throwing keeps a future JS type from silently becoming SQL.
+                throw new TypeError(`escapeSqlLiteral: unsupported value type '${typeof value}'; use bound parameters.`);
+        }
+    };
+    return escapeValue;
+}
+/** Escape `value` for Postgres, SQLite and related dialects (single-quote doubling). */
+export const escapeAnsiSqlLiteral = createEscaper(ansiStringLiteral);
+/** Escape `value` for MySQL and MariaDB (backslash escaping). */
+export const escapeMysqlSqlLiteral = createEscaper(mysqlStringLiteral);

package/dist/util/string.util.d.ts

@@ -26,4 +26,3 @@ export declare function singularize(name: string): string;
  * @example 'category' -> 'categories'
  */
 export declare function pluralize(name: string): string;
-//# sourceMappingURL=string.util.d.ts.map

package/dist/util/string.util.js

@@ -90,4 +90,3 @@ export function pluralize(name) {
     }
     return name + 's';
 }
-//# sourceMappingURL=string.util.js.map

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "uql-orm",
   "homepage": "https://uql-orm.dev",
-  "description": "Fast, type-safe TypeScript ORM - one API for every database",
+  "description": "Extremely fast, type-safe TypeScript ORM - one API for every database",
   "license": "MIT",
-  "version": "0.20.2",
+  "version": "0.22.0",
   "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "sideEffects": false,
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "browser": {
@@ -40,57 +44,71 @@
       "default": "./dist/browser/uql-browser.min.js"
     },
     "./libsql": "./dist/libsql/index.js",
+    "./turso": "./dist/turso/index.js",
+    "./turso/local": "./dist/turso/local.js",
     "./neon": "./dist/neon/index.js",
     "./d1": "./dist/d1/index.js",
-    "./bunSql": "./dist/bunSql/index.js"
+    "./bunSql": "./dist/bunSql/index.js",
+    "./package.json": "./package.json"
   },
   "files": [
     "dist",
-    "README.md",
-    "CHANGELOG.md"
+    "README.md"
   ],
   "scripts": {
-    "prepack": "bun run verify-dist.ts && cp ../../README.md . && cp ../../CHANGELOG.md .",
-    "postpack": "rm README.md CHANGELOG.md",
-    "verify.package": "bun run build && bun run verify-dist.ts",
+    "prepack": "bun run verify-dist.ts && cp ../../README.md .",
+    "postpack": "rm README.md",
     "compile.browser": "bun build src/browser/index.ts --minify --sourcemap=linked --format=esm --target=browser --outdir=dist/browser --entry-naming 'uql-browser.min.[ext]'",
-    "build": "bun run clean && tsc -b tsconfig.build.json && bun run compile.browser",
+    "build": "bun run clean && tsc -b tsconfig.build.json && bun run compile.browser && bun run verify-dist.ts",
     "start": "tsc --watch",
     "clean": "rimraf dist .tsconfig.tsbuildinfo"
   },
-  "dependencies": {
-    "jiti": "^2.7.0",
-    "reflect-metadata": "^0.2.2",
-    "sqlstring": "^2.3.3",
-    "tslib": "^2.8.1"
-  },
   "peerDependencies": {
     "@libsql/client": ">=0.6.0",
     "@neondatabase/serverless": ">=0.9.0",
     "@nestjs/common": ">=10.0.0",
     "@nestjs/core": ">=10.0.0",
+    "@tursodatabase/database": ">=0.7.0",
+    "@tursodatabase/serverless": ">=1.0.0",
     "better-sqlite3": ">=9.0.0",
     "express": ">=5.0.0",
+    "jiti": ">=2.0.0",
     "mariadb": ">=3.0.0",
     "mongodb": ">=6.0.0",
     "mysql2": ">=3.0.0",
     "pg": ">=8.0.0",
     "pg-query-stream": ">=4.0.0",
+    "reflect-metadata": ">=0.2.0",
     "rxjs": ">=7.0.0"
   },
   "peerDependenciesMeta": {
+    "@libsql/client": {
+      "optional": true
+    },
+    "@neondatabase/serverless": {
+      "optional": true
+    },
     "@nestjs/common": {
       "optional": true
     },
     "@nestjs/core": {
       "optional": true
     },
-    "rxjs": {
+    "@tursodatabase/database": {
+      "optional": true
+    },
+    "@tursodatabase/serverless": {
+      "optional": true
+    },
+    "better-sqlite3": {
       "optional": true
     },
     "express": {
       "optional": true
     },
+    "jiti": {
+      "optional": true
+    },
     "mariadb": {
       "optional": true
     },
@@ -106,13 +124,10 @@
     "pg-query-stream": {
       "optional": true
     },
-    "better-sqlite3": {
+    "reflect-metadata": {
       "optional": true
     },
-    "@libsql/client": {
-      "optional": true
-    },
-    "@neondatabase/serverless": {
+    "rxjs": {
       "optional": true
     }
   },
@@ -122,25 +137,30 @@
     "@nestjs/common": "^11.1.28",
     "@nestjs/core": "^11.1.28",
     "@nestjs/testing": "^11.1.28",
+    "@tursodatabase/database": "^0.7.2",
+    "@tursodatabase/serverless": "^1.4.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/express": "^5.0.6",
-    "@types/pg": "^8.20.0",
-    "@types/sqlstring": "^2.3.2",
+    "@types/pg": "^8.20.1",
     "@types/ws": "^8.18.1",
-    "better-sqlite3": "^13.0.1",
+    "better-sqlite3": "^13.0.2",
     "express": "^5.2.1",
+    "jiti": "^2.7.0",
     "mariadb": "^3.5.3",
     "mongodb": "^7.5.0",
     "mysql2": "^3.23.2",
     "pg": "^8.22.0",
     "pg-query-stream": "^4.16.0",
+    "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.2",
+    "sqlite-vec": "^0.1.9",
     "ws": "^8.21.1"
   },
   "author": "Roger Padilla",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/rogerpadilla/uql.git"
+    "url": "git+https://github.com/rogerpadilla/uql.git",
+    "directory": "packages/uql-orm"
   },
   "bugs": {
     "url": "https://github.com/rogerpadilla/uql/issues"
@@ -167,15 +187,25 @@
     "cockroachdb-orm",
     "mongodb",
     "mongodb-orm",
+    "libsql",
+    "turso",
+    "neon",
+    "d1",
+    "cloudflare",
+    "bun",
+    "edge",
     "entity",
     "dao",
     "transaction",
     "repository",
     "service",
-    "migrations"
+    "migrations",
+    "vector-search",
+    "nestjs",
+    "express"
   ],
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "a544bc7addddc9728b348fe564b94805a61d3c3e"
+  "gitHead": "0804fc0205c1f629e497df020835a17b63aed0e8"
 }