uql-orm 0.21.0 → 0.23.0

package/dist/type/entity.d.ts

@@ -1,7 +1,7 @@
 import type { IndexType } from '../schema/types.js';
 import type { FilterOptions } from './query.js';
 import type { QueryRaw } from './queryRaw.js';
-import type { Json, Scalar, Type, Unpacked } from './utility.js';
+import type { DistributiveOmit, Json, Scalar, Type, Unpacked } from './utility.js';
 import type { VectorDistance, VectorIndexOptions, VectorIndexType } from './vector.js';
 /**
  * Allow to customize the name of the property that identifies an entity
@@ -175,14 +175,36 @@ export type JsonColumnType = 'json' | 'jsonb';
  * SQL binary/blob column types
  */
 export type BlobColumnType = 'blob' | 'bytea';
+/**
+ * SQL boolean column types
+ */
+export type BooleanColumnType = 'bool' | 'boolean';
+/**
+ * SQL vector column types
+ */
+export type VectorColumnType = 'vector' | 'halfvec' | 'sparsevec';
 /**
  * SQL column types supported by uql migrations
  */
-export type ColumnType = NumericColumnType | StringColumnType | DateColumnType | JsonColumnType | BlobColumnType | 'bool' | 'boolean' | 'vector' | 'halfvec' | 'sparsevec';
+export type ColumnType = NumericColumnType | StringColumnType | DateColumnType | JsonColumnType | BlobColumnType | BooleanColumnType | VectorColumnType;
 /**
  * Logical types for a field
  */
 export type FieldType = StringConstructor | NumberConstructor | BooleanConstructor | DateConstructor | BigIntConstructor | ColumnType;
+/**
+ * The {@link FieldType} values legal for a field declared as `V`.
+ *
+ * This is what makes an explicit `type` an improvement over the reflected one it replaces: the
+ * annotation is checked against the property's real TypeScript type, so `@Field({ type: String })` on
+ * a `number` no longer compiles into a silent TEXT column. `unknown` shapes fall through to the full
+ * {@link FieldType}, keeping genuinely untyped fields usable.
+ *
+ * JSON is matched on the `__json` brand rather than structurally, because {@link Json} intersects its
+ * payload (`Json<string>` really does extend `string`) and would otherwise land on the string arm.
+ * Both `Json<T>` and `Json<T>[]` have to be recognised, and the array check has to precede the scalar
+ * arms so a `number[]` vector is not read as a `number`.
+ */
+export type TypeFor<V, T = NonNullable<V>> = IsJson<T> extends true ? JsonColumnType : IsJson<NonNullable<Unpacked<T>>> extends true ? JsonColumnType : T extends readonly number[] ? VectorColumnType : T extends string ? StringConstructor | StringColumnType : T extends number ? NumberConstructor | NumericColumnType : T extends bigint ? BigIntConstructor | NumericColumnType : T extends boolean ? BooleanConstructor | BooleanColumnType : T extends Date ? DateConstructor | DateColumnType : T extends Uint8Array ? BlobColumnType : FieldType;
 /**
  * Configurable options for a field
  */
@@ -191,11 +213,13 @@ export type FieldOptions = {
     readonly isId?: true;
     readonly type?: FieldType;
     /**
-     * Set by `defineField` when `type` was inferred via reflection rather than
-     * given explicitly. Internal bookkeeping - do not set this from a decorator.
+     * Set by `defineField` when the field gave `references` but no `type`, so schema generation resolves
+     * the column from the referenced primary key rather than from whatever ended up in `type`. That is
+     * what keeps a `uuid` primary key from becoming TEXT on every foreign key pointing at it.
+     * Internal bookkeeping - do not set this from a decorator.
      * @internal
      */
-    readonly typeInferred?: boolean;
+    readonly typeFromReference?: boolean;
     /**
      * Dimensions for vector fields. Used in schema generation.
      * @example `@Field({ type: 'vector', dimensions: 1536 })`
@@ -270,6 +294,55 @@ export type FieldOptions = {
     readonly comment?: string;
 };
 export type OnFieldCallback = Scalar | QueryRaw | (() => Scalar | QueryRaw);
+/**
+ * The TypeScript types a field may be declared as, given the `type` it registers: the inverse of
+ * {@link TypeFor}.
+ *
+ * Both directions are needed because they are consumed at opposite ends. `defineEntity` keys its bulk
+ * `fields` by property name, so the property's type is already known and {@link TypeFor} narrows the
+ * `type` allowed. A decorator has it the other way round: `@Field({ type: String })` is checked before
+ * the class exists, so the only way to reach the property is to state what `type: String` implies and
+ * let the decorator's context position compare it against the real field. Neither can be derived from
+ * the other by inference, so `entityOptions.type-test.ts` asserts they agree instead.
+ */
+export type TsTypeOf<T> = T extends StringConstructor ? string : T extends NumberConstructor ? number : T extends BigIntConstructor ? bigint : T extends BooleanConstructor ? boolean : T extends DateConstructor ? Date : T extends StringColumnType ? string : T extends NumericColumnType ? number | bigint : T extends BooleanColumnType ? boolean : T extends DateColumnType ? Date : T extends JsonColumnType ? Json<unknown> | readonly Json<unknown>[] : T extends BlobColumnType ? Uint8Array : T extends VectorColumnType ? readonly number[] : unknown;
+/**
+ * {@link FieldOptions} for a field declared as `V`, with `type` required and checked by
+ * {@link TypeFor}.
+ *
+ * The second arm is load-bearing rather than a convenience: a foreign-key column may omit `type` so
+ * that schema generation resolves it from the referenced primary key instead, picking up that key's
+ * `columnType`, length and chained references. Forcing `type: Number` onto
+ * `@Field({ references: () => Company })` would silently downgrade a `uuid` key to TEXT on every
+ * column pointing at it.
+ */
+export type FieldOptionsFor<V> = (FieldOptions & {
+    readonly type: TypeFor<V>;
+}) | (FieldOptions & {
+    readonly references: EntityGetter;
+    readonly type?: TypeFor<V>;
+});
+/**
+ * The entity a relation field points at: `Company` for both `company?: Company` and
+ * `companies?: Company[]`.
+ */
+export type RelationTarget<V> = NonNullable<Unpacked<NonNullable<V>>>;
+/**
+ * {@link RelationOptions} for a relation field declared as `V`, with `entity` required and pinned to
+ * `V`'s own type, and the cardinality restricted to the ones that field shape can hold. Together those
+ * reject `@ManyToOne({ entity: () => Other })` on a `Company` field, and any to-many cardinality on a
+ * field that is not an array.
+ */
+export type RelationOptionsFor<V> = Omit<RelationOptions<RelationTarget<V>>, 'entity' | 'cardinality'> & {
+    readonly entity: EntityGetter<RelationTarget<V>>;
+    readonly cardinality: NonNullable<V> extends readonly unknown[] ? '1m' | 'mm' : '11' | 'm1';
+};
+/**
+ * The method names of an entity, so hook registrations name a method that exists.
+ */
+export type MethodKey<E> = {
+    readonly [K in keyof E]-?: NonNullable<E[K]> extends (...args: never[]) => unknown ? K : never;
+}[Key<E>];
 export type EntityGetter<E = any> = () => Type<E>;
 export type CascadeType = 'persist' | 'delete';
 export type RelationOptions<E = any> = {
@@ -299,20 +372,6 @@ export type RelationOneToOneOptions<E> = RelationOptionsOwner<E> | RelationOptio
 export type RelationOneToManyOptions<E> = RelationOptionsInverseSide<E> | RelationOptionsThroughOwner<E>;
 export type RelationManyToOneOptions<E> = RelationOptionsOwner<E>;
 export type RelationManyToManyOptions<E> = RelationOptionsThroughOwner<E> | RelationOptionsInverseSide<E>;
-/**
- * Wrapper type for relation type definitions in entities.
- * Used to circumvent ESM modules circular dependency issue caused by reflection metadata saving the type of the property.
- *
- * Usage example:
- * @Entity()
- * export default class User {
- *
- *     @OneToOne(() => Profile, profile => profile.user)
- *     profile: Relation<Profile>;
- *
- * }
- */
-export type Relation<T> = T;
 /**
  * Lifecycle hook event names.
  */
@@ -344,17 +403,70 @@ export type IndexTypeOptions = {
     distance?: never;
 };
 /**
- * Index metadata from @Index decorator.
+ * One entry of an index: a column name by default, `raw(...)` to index an expression, or an object
+ * when the entry needs more than a name.
+ *
+ * @example
+ * ```ts
+ * @Index(['tenantId', { column: 'createdAt', order: 'desc' }])   // keyset pagination
+ * @Index([raw('lower("email")')], { unique: true })              // case-insensitive uniqueness
+ * @Index([{ column: 'body', length: 64 }])                       // MySQL needs a prefix on TEXT
+ * @Index(['data'], { type: 'gin' })                              // JSONB containment
+ * ```
+ *
+ * `C` is the entity's `FieldKey` on the `@Index`/`defineEntity` paths, where the decorated class says
+ * which columns exist. It defaults to `string` for the migration builder's `table.index(...)`, which
+ * names raw table columns with no entity in scope.
+ */
+export type IndexColumnInput<C extends string = string> = C | QueryRaw | IndexColumnOptions<C>;
+/**
+ * What an index entry can carry besides the thing being indexed. Shared with the normalized
+ * `IndexColumnSchema`, so the authored and internal shapes cannot drift apart.
+ */
+export type IndexColumnModifiers = {
+    /**
+     * Index only the first `n` characters. MySQL and MariaDB *require* this to index a `TEXT`/`BLOB`
+     * column at all ("used in key specification without a key length"); no other engine accepts it.
+     */
+    readonly length?: number;
+    /** Stored sort order, which lets `ORDER BY ... DESC` pagination use the index. */
+    readonly order?: 'asc' | 'desc';
+    /** Where NULLs sort. Postgres only. */
+    readonly nulls?: 'first' | 'last';
+    /** Operator class, e.g. `jsonb_path_ops` for a smaller GIN index. Postgres only. */
+    readonly opsClass?: string;
+};
+export type IndexColumnOptions<C extends string = string> = IndexColumnModifiers & {
+    /** The column to index, or `raw(...)` for an expression. */
+    readonly column: C | QueryRaw;
+};
+/**
+ * One index entry, normalized: {@link IndexColumnInput}'s three authored shapes all reduce to this
+ * before any dialect or generator sees them, so rendering never re-parses the sugar.
+ */
+export type IndexColumnSchema = IndexColumnModifiers & {
+    /** A column name, or raw SQL when {@link expression} is set. */
+    readonly column: string;
+    /** Whether {@link column} is an expression to emit as-is rather than an identifier to quote. */
+    readonly expression?: boolean;
+};
+/**
+ * An index as stored in entity metadata: authored options with the columns normalized.
  */
 export type EntityIndexMeta = {
-    /** Column names in the index */
-    columns: string[];
+    /** The indexed columns, in order. */
+    columns: readonly IndexColumnSchema[];
     /** Custom index name */
     name?: string;
     /** Whether index is unique; omit or `false` for a non-unique index (default). */
     unique?: boolean;
     /** Partial index condition (WHERE clause) */
     where?: string;
+    /**
+     * Extra columns stored in the index but not part of its key, so a query reading only these is
+     * answered from the index alone. Postgres-wire only (`INCLUDE`).
+     */
+    include?: readonly string[];
 } & VectorIndexOptions & IndexTypeOptions;
 export type EntityMeta<E> = {
     readonly entity: Type<E>;
@@ -390,10 +502,26 @@ export type EntityOptions<E = unknown> = {
     /** Named, default-on `$where` filters (soft-delete is auto-registered from `@Field({ softDelete })`). */
     readonly filters?: Record<string, FilterOptions<E>>;
     /** Scalar fields; use `isId: true` on exactly one field for the primary key. */
-    readonly fields?: Record<string, FieldOptions>;
-    readonly relations?: Record<string, RelationOptions>;
-    readonly indexes?: readonly EntityIndexMeta[];
+    readonly fields?: {
+        readonly [K in FieldKey<E>]?: FieldOptionsFor<E[K]>;
+    };
+    readonly relations?: {
+        readonly [K in RelationKey<E>]?: RelationOptionsFor<E[K]>;
+    };
+    readonly indexes?: readonly EntityIndexInput<FieldKey<E>>[];
     /** Map hook events to method names on the entity class. */
-    readonly hooks?: Partial<Record<HookEvent, readonly string[]>>;
+    readonly hooks?: Partial<Record<HookEvent, readonly MethodKey<E>[]>>;
+};
+/**
+ * Everything an index carries beyond its columns, shared by `@Index`, `defineEntity` and the
+ * migration builder's `table.index(...)`. `DistributiveOmit` (not plain `Omit`) keeps `type`/
+ * `distance` a discriminated pair: omitting `distance` on a vector index type is a compile error.
+ */
+export type IndexOptions = DistributiveOmit<EntityIndexMeta, 'columns'>;
+/**
+ * An index as authored, before `defineIndex` normalizes its columns.
+ */
+export type EntityIndexInput<C extends string = string> = IndexOptions & {
+    readonly columns: readonly IndexColumnInput<C>[];
 };
 export {};

package/dist/type/migration.d.ts

@@ -1,7 +1,8 @@
+import type { VectorCast } from '../dialect/vectorCast.js';
 import type { FullColumnDefinition, TableDefinition, TableForeignKeyDefinition } from '../migrate/builder/types.js';
 import type { SchemaAST } from '../schema/schemaAST.js';
 import type { ForeignKeyAction, IndexNode, IndexType, TableNode } from '../schema/types.js';
-import type { EntityMeta, FieldOptions, LoggingOptions, NamingStrategy, SqlQuerier, Type, VectorIndexOptions } from './index.js';
+import type { EntityMeta, FieldOptions, IndexColumnSchema, LoggingOptions, SqlQuerier, Type, VectorIndexOptions } from './index.js';
 /**
  * Defines a migration using a simple object literal
  */
@@ -72,10 +73,6 @@ export interface MigratorOptions {
      * Entities to use for schema generation
      */
     readonly entities?: Type<unknown>[];
-    /**
-     * Naming strategy for database tables and columns
-     */
-    readonly namingStrategy?: NamingStrategy;
     /**
      * Default action for foreign key ON DELETE and ON UPDATE clauses.
      */
@@ -101,6 +98,13 @@ export interface MigrationResult {
  */
 export interface ColumnSchema {
     readonly name: string;
+    /**
+     * The engine's own type spelling, as introspection read it (`tinyint(1)`, `DATETIME`, `VARCHAR`).
+     * Deliberately not a {@link CanonicalType}: the diff has to compare what the engine would *store*,
+     * and several canonical types share one storage type per engine - an entity `boolean` is `TINYINT(1)`
+     * on MySQL and `INTEGER` on SQLite. Comparing canonical categories instead reports an alteration on
+     * every sync for those columns. Use `sqlToCanonical` to interpret it.
+     */
     readonly type: string;
     readonly nullable: boolean;
     readonly defaultValue?: unknown;
@@ -127,10 +131,20 @@ export interface TableSchema {
  */
 export interface IndexSchema extends VectorIndexOptions {
     readonly name: string;
-    readonly columns: string[];
+    readonly columns: readonly IndexColumnSchema[];
     readonly unique: boolean;
     /** Index type (btree, hnsw, ivfflat, etc.) */
     readonly type?: IndexType;
+    /** Partial index condition (WHERE clause) */
+    readonly where?: string;
+    /** Non-key columns stored in the index (Postgres-wire `INCLUDE`). */
+    readonly include?: readonly string[];
+    /**
+     * The indexed column's vector type, which pgvector's operator-class names are built from
+     * (`halfvec_cosine_ops`). Absent for a non-vector index, and for an index whose column types are
+     * unknown, where `vector` is assumed.
+     */
+    readonly vectorType?: VectorCast;
 }
 /**
  * Represents a foreign key constraint
@@ -171,10 +185,11 @@ export interface SchemaGenerator {
     generateCreateTable<E>(entity: Type<E>, options?: {
         ifNotExists?: boolean;
     }): string[];
-    /**
-     * Generate DROP TABLE statement for an entity
-     */
-    generateDropTable<E>(entity: Type<E>): string;
+    /** Generate DROP TABLE statement. */
+    generateDropTable(tableName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
     /**
      * Generate ALTER TABLE statements based on schema diff
      */
@@ -215,21 +230,19 @@ export interface SchemaGenerator {
     generateCreateIndexFromNode(index: IndexNode, options?: {
         ifNotExists?: boolean;
     }): string;
-    /** Generate DROP TABLE statement from a TableNode */
-    generateDropTableFromNode(table: TableNode, options?: {
-        ifExists?: boolean;
-    }): string;
     /** DDL from a `TableDefinition`, one string per `querier.run`. */
     generateCreateTableFromDefinition(table: TableDefinition, options?: {
         ifNotExists?: boolean;
     }): string[];
-    /** Generate DROP TABLE statement */
-    generateDropTableSql(tableName: string, options?: {
-        ifExists?: boolean;
-        cascade?: boolean;
-    }): string;
     /** Generate RENAME TABLE statement */
     generateRenameTableSql(oldName: string, newName: string): string;
+}
+/**
+ * The column and constraint DDL a migration builder emits, which only a SQL engine has. Split from
+ * {@link SchemaGenerator} because MongoDB used to satisfy these six by returning `''`: a document store
+ * has no `ADD COLUMN`, and an empty statement silently did nothing rather than saying so.
+ */
+export interface SqlDdlGenerator extends SchemaGenerator {
     /** Generate ADD COLUMN statement */
     generateAddColumnSql(tableName: string, column: FullColumnDefinition): string;
     /** Generate ALTER COLUMN statement */
@@ -238,10 +251,6 @@ export interface SchemaGenerator {
     generateDropColumnSql(tableName: string, columnName: string): string;
     /** Generate RENAME COLUMN statement */
     generateRenameColumnSql(tableName: string, oldName: string, newName: string): string;
-    /** Generate CREATE INDEX statement from IndexSchema */
-    generateCreateIndexSql(tableName: string, index: IndexSchema): string;
-    /** Generate DROP INDEX statement */
-    generateDropIndexSql(tableName: string, indexName: string): string;
     /** Generate ADD FOREIGN KEY statement */
     generateAddForeignKeySql(tableName: string, foreignKey: TableForeignKeyDefinition): string;
     /** Generate DROP FOREIGN KEY statement */

package/dist/type/querier.d.ts

@@ -120,6 +120,12 @@ export interface Querier extends UniversalQuerier {
      * release the querier to the pool.
      */
     release(): Promise<void>;
+    /**
+     * Releases the querier when an `await using` binding goes out of scope, so a unit of work cannot
+     * leak a connection on an early return or a throw.
+     * @example `await using querier = await pool.getQuerier();`
+     */
+    [Symbol.asyncDispose](): Promise<void>;
 }
 export interface SqlQuerier extends Querier {
     /**

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.
  *

package/dist/util/hook.util.js

@@ -1,4 +1,4 @@
-import { getMeta } from '../entity/decorator/index.js';
+import { getMeta } from '../entity/index.js';
 /**
  * Run all registered hooks for the given event on each payload.
  * Hooks are invoked with `this` bound to the payload via `call`,

package/dist/util/index.d.ts

@@ -2,6 +2,7 @@ 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';

package/dist/util/index.js

@@ -2,6 +2,7 @@ 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';

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/package.json

@@ -3,16 +3,17 @@
   "homepage": "https://uql-orm.dev",
   "description": "Extremely fast, type-safe TypeScript ORM - one API for every database",
   "license": "MIT",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "type": "module",
   "engines": {
-    "node": ">=20"
+    "node": ">=24"
   },
   "sideEffects": false,
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "browser": {
-    "./dist/context/context.js": "./dist/context/context.browser.js"
+    "./dist/context/context.js": "./dist/context/context.browser.js",
+    "./dist/querier/querierContext.js": "./dist/querier/querierContext.browser.js"
   },
   "bin": {
     "uql-migrate": "./dist/migrate/bin.js"
@@ -44,6 +45,8 @@
       "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",
@@ -66,15 +69,15 @@
     "@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": {
@@ -90,13 +93,16 @@
     "@nestjs/core": {
       "optional": true
     },
-    "better-sqlite3": {
+    "@tursodatabase/database": {
       "optional": true
     },
-    "express": {
+    "@tursodatabase/serverless": {
+      "optional": true
+    },
+    "better-sqlite3": {
       "optional": true
     },
-    "jiti": {
+    "express": {
       "optional": true
     },
     "mariadb": {
@@ -114,9 +120,6 @@
     "pg-query-stream": {
       "optional": true
     },
-    "reflect-metadata": {
-      "optional": true
-    },
     "rxjs": {
       "optional": true
     }
@@ -127,20 +130,22 @@
     "@nestjs/common": "^11.1.28",
     "@nestjs/core": "^11.1.28",
     "@nestjs/testing": "^11.1.28",
-    "@types/better-sqlite3": "^7.6.13",
+    "@tursodatabase/database": "^0.7.2",
+    "@tursodatabase/serverless": "^1.4.0",
+    "@types/better-sqlite3": "^9.6.0",
     "@types/express": "^5.0.6",
-    "@types/pg": "^8.20.0",
+    "@types/pg": "^8.20.3",
     "@types/ws": "^8.18.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",
+    "tsx": "^4.23.1",
     "ws": "^8.21.1"
   },
   "author": "Roger Padilla",
@@ -194,5 +199,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "1d056e8d5030fe70e3dc21a151db282e9e553dd9"
+  "gitHead": "3bfca5950ac564b8503fb2140726501b01825b9d"
 }

package/dist/entity/decorator/field.d.ts

@@ -1,2 +0,0 @@
-import type { FieldOptions } from '../../type/index.js';
-export declare function Field<E>(opts?: FieldOptions): (target: object, key: string) => void;

package/dist/entity/decorator/field.js

@@ -1,7 +0,0 @@
-import { defineField } from '../metadata/definition.js';
-export function Field(opts) {
-    return (target, key) => {
-        const entity = target.constructor;
-        defineField(entity, key, opts);
-    };
-}

package/dist/entity/decorator/filter.d.ts

@@ -1,7 +0,0 @@
-import type { FilterOptions, Type } from '../../type/index.js';
-/**
- * Registers a named, default-on `$where` filter on the entity, applied to every query
- * unless bypassed via `QueryOptions.filters`.
- * @example `@Filter('active', { condition: { status: 'active' }, default: false })`
- */
-export declare function Filter<E>(name: string, opts: FilterOptions<E>): (entity: Type<E>) => void;

package/dist/entity/decorator/filter.js

@@ -1,11 +0,0 @@
-import { defineFilter } from '../metadata/definition.js';
-/**
- * Registers a named, default-on `$where` filter on the entity, applied to every query
- * unless bypassed via `QueryOptions.filters`.
- * @example `@Filter('active', { condition: { status: 'active' }, default: false })`
- */
-export function Filter(name, opts) {
-    return (entity) => {
-        defineFilter(entity, name, opts);
-    };
-}

package/dist/entity/decorator/hook.d.ts

@@ -1,7 +0,0 @@
-export declare const BeforeInsert: () => MethodDecorator;
-export declare const AfterInsert: () => MethodDecorator;
-export declare const BeforeUpdate: () => MethodDecorator;
-export declare const AfterUpdate: () => MethodDecorator;
-export declare const BeforeDelete: () => MethodDecorator;
-export declare const AfterDelete: () => MethodDecorator;
-export declare const AfterLoad: () => MethodDecorator;

package/dist/entity/decorator/hook.js

@@ -1,14 +0,0 @@
-import { defineHook } from '../metadata/definition.js';
-function createHookDecorator(event) {
-    return () => (target, key) => {
-        const entity = target.constructor;
-        defineHook(entity, String(key), event);
-    };
-}
-export const BeforeInsert = createHookDecorator('beforeInsert');
-export const AfterInsert = createHookDecorator('afterInsert');
-export const BeforeUpdate = createHookDecorator('beforeUpdate');
-export const AfterUpdate = createHookDecorator('afterUpdate');
-export const BeforeDelete = createHookDecorator('beforeDelete');
-export const AfterDelete = createHookDecorator('afterDelete');
-export const AfterLoad = createHookDecorator('afterLoad');

package/dist/entity/decorator/id.d.ts

@@ -1,2 +0,0 @@
-import type { FieldOptions } from '../../type/index.js';
-export declare function Id<E>(opts?: FieldOptions): (target: object, key: string) => void;

package/dist/entity/decorator/id.js

@@ -1,7 +0,0 @@
-import { defineId } from '../metadata/definition.js';
-export function Id(opts = {}) {
-    return (target, key) => {
-        const entity = target.constructor;
-        defineId(entity, key, opts);
-    };
-}

package/dist/entity/decorator/index-decorator.d.ts

@@ -1,29 +0,0 @@
-import type { DistributiveOmit, EntityIndexMeta, Type } from '../../type/index.js';
-/**
- * Options for the @Index decorator - {@link EntityIndexMeta} minus `columns`, which the decorator
- * takes as its own positional argument. `DistributiveOmit` (not plain `Omit`) keeps `type`/`distance`
- * a discriminated pair - `EntityIndexMeta`'s vector-index invariant, that omitting `distance` on a
- * vector index type is a compile error.
- */
-export type IndexDecoratorOptions = DistributiveOmit<EntityIndexMeta, 'columns'>;
-/**
- * Define a composite index on an entity class.
- *
- * @example
- * ```ts
- * @Index(['lastName', 'firstName'], { name: 'idx_users_fullname' })
- * @Entity()
- * export class User {
- *   @Id() id?: number;
- *   @Field() firstName?: string;
- *   @Field() lastName?: string;
- * }
- *
- * // With unique and partial index
- * @Index(['email'], { unique: true })
- * @Index(['status'], { where: "status = 'active'" })
- * @Entity()
- * export class User { ... }
- * ```
- */
-export declare function Index<E>(columns: string[], options?: IndexDecoratorOptions): (target: Type<E>) => void;