uql-orm 0.21.0 → 0.23.0

package/dist/querier/querierContext.js

@@ -0,0 +1,42 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+/**
+ * The querier `@Transactional()` opened for the current async flow.
+ *
+ * Separate from the `UqlContext` storage in `context/context.ts` on purpose: that one is remapped to a
+ * synchronous browser shim which cannot propagate across `await`, and a querier handle must. Nothing in
+ * a browser bundle opens a transaction, so this stays server-only and `verify-dist` keeps it out of the
+ * browser-facing graph.
+ */
+const querierStorage = new AsyncLocalStorage();
+/** Runs `callback` with `querier` as the ambient one, for the whole async flow beneath it. */
+export function withQuerierContext(querier, callback) {
+    return querierStorage.run(querier, callback);
+}
+/**
+ * The querier of the enclosing `@Transactional()` method.
+ *
+ * This is what replaced `@InjectQuerier()`: the standard decorator spec has no parameter decorators, so
+ * the querier can no longer be injected into an argument and is read from the ambient flow instead.
+ *
+ * @example
+ * ```ts
+ * class UserService {
+ *   @Transactional()
+ *   async register(data: Partial<User>) {
+ *     await currentQuerier().insertOne(User, data);
+ *   }
+ * }
+ * ```
+ */
+export function currentQuerier() {
+    const querier = querierStorage.getStore();
+    if (!querier) {
+        throw new TypeError('currentQuerier() found no active querier. Call it inside a @Transactional() method, or take a querier ' +
+            'from the pool yourself with `await using querier = await pool.getQuerier()`.');
+    }
+    return querier;
+}
+/** The ambient querier, or `undefined` outside a transaction. For callers that can work without one. */
+export function currentQuerierIfAny() {
+    return querierStorage.getStore();
+}

package/dist/querier/queryError.d.ts

@@ -0,0 +1,22 @@
+import type { LoggerWrapper } from '../util/logger.js';
+/**
+ * A driver error enriched with context by {@link enrichError}. `query` is always attached; `values`
+ * only when the querier's logger is configured to surface them (see {@link enrichError}) - they can
+ * carry sensitive data (PII, tokens, etc.) and would otherwise leak into whatever error-tracking
+ * pipeline (Sentry, console.error, ...) serializes the error, without the developer opting in.
+ */
+export interface QueryError extends Error {
+    query?: string;
+    values?: unknown[];
+}
+/**
+ * Tags `err` with the query it failed on (as {@link QueryError}) and hands it back for the caller to
+ * throw. `values` is only attached when `logger?.willLogValues()` is true, i.e. the app already has
+ * query values surfacing somewhere (query-level or slow-query logging), so attaching them here does not
+ * introduce a new leak surface. Shared by every query call site (timed queries, streams, transaction
+ * statements) so the logic lives in one place.
+ *
+ * Returns rather than throws so `throw enrichError(...)` reads as the control flow it is, which also
+ * means callers need no `never` annotation and no unreachable-code suppression.
+ */
+export declare function enrichError(err: unknown, logger: LoggerWrapper | undefined, query: string, values?: unknown[]): unknown;

package/dist/querier/queryError.js

@@ -0,0 +1,20 @@
+/**
+ * Tags `err` with the query it failed on (as {@link QueryError}) and hands it back for the caller to
+ * throw. `values` is only attached when `logger?.willLogValues()` is true, i.e. the app already has
+ * query values surfacing somewhere (query-level or slow-query logging), so attaching them here does not
+ * introduce a new leak surface. Shared by every query call site (timed queries, streams, transaction
+ * statements) so the logic lives in one place.
+ *
+ * Returns rather than throws so `throw enrichError(...)` reads as the control flow it is, which also
+ * means callers need no `never` annotation and no unreachable-code suppression.
+ */
+export function enrichError(err, logger, query, values) {
+    if (err instanceof Error) {
+        const queryError = err;
+        queryError.query ??= query;
+        if (values !== undefined && logger?.willLogValues()) {
+            queryError.values ??= values;
+        }
+    }
+    return err;
+}

package/dist/querier/transactional.d.ts

@@ -0,0 +1,26 @@
+import type { IsolationLevel, QuerierPool } from '../type/index.js';
+export type TransactionalOptions = {
+    /** `required` opens a transaction when none is active; `supported` joins one but never starts one. */
+    readonly propagation?: 'supported' | 'required';
+    readonly pool?: QuerierPool;
+    readonly isolationLevel?: IsolationLevel;
+};
+/**
+ * Wraps the method in a transaction and publishes its querier for {@link currentQuerier} to pick up.
+ *
+ * @remarks Replaces the `@InjectQuerier()` parameter that used to receive the querier. The standard
+ * decorator spec has no parameter decorators, and the separate TC39 proposal for them is still Stage 1,
+ * so the querier travels through async-local storage instead. A nested call joins the transaction
+ * already in flight rather than opening a second one.
+ *
+ * @example
+ * ```ts
+ * class UserService {
+ *   @Transactional()
+ *   async register(data: Partial<User>) {
+ *     await currentQuerier().insertOne(User, data);
+ *   }
+ * }
+ * ```
+ */
+export declare function Transactional({ propagation, pool, isolationLevel }?: TransactionalOptions): <This, Args extends unknown[], R>(original: (this: This, ...args: Args) => Promise<R>, context: ClassMethodDecoratorContext<This>) => (this: This, ...args: Args) => Promise<R>;

package/dist/querier/transactional.js

@@ -0,0 +1,43 @@
+import { getQuerierPool } from '../options.js';
+import { currentQuerierIfAny, withQuerierContext } from './querierContext.js';
+/**
+ * Wraps the method in a transaction and publishes its querier for {@link currentQuerier} to pick up.
+ *
+ * @remarks Replaces the `@InjectQuerier()` parameter that used to receive the querier. The standard
+ * decorator spec has no parameter decorators, and the separate TC39 proposal for them is still Stage 1,
+ * so the querier travels through async-local storage instead. A nested call joins the transaction
+ * already in flight rather than opening a second one.
+ *
+ * @example
+ * ```ts
+ * class UserService {
+ *   @Transactional()
+ *   async register(data: Partial<User>) {
+ *     await currentQuerier().insertOne(User, data);
+ *   }
+ * }
+ * ```
+ */
+export function Transactional({ propagation = 'required', pool, isolationLevel } = {}) {
+    return (original, context) => {
+        // Checked at decoration time rather than on the first call: a synchronous method cannot be wrapped in
+        // a transaction, and finding that out at startup beats finding out mid-request.
+        if (original.constructor.name !== 'AsyncFunction') {
+            throw new TypeError(`@Transactional() needs an async method, but '${String(context.name)}' is not one.`);
+        }
+        return async function (...args) {
+            // Already inside a transactional flow: join it and let the outermost call own commit and release.
+            if (currentQuerierIfAny()) {
+                return original.apply(this, args);
+            }
+            // `withQuerier` releases; `transaction` commits or rolls back. `supported` joins a transaction but
+            // never starts one, so it takes only the first half.
+            return (pool ?? getQuerierPool()).withQuerier((querier) => {
+                const run = () => original.apply(this, args);
+                return withQuerierContext(querier, () => propagation === 'supported'
+                    ? run()
+                    : querier.transaction(run, isolationLevel ? { isolationLevel } : undefined));
+            });
+        };
+    };
+}

package/dist/schema/canonicalType.d.ts

@@ -7,15 +7,27 @@
  * - TypeScript types (for entity generation)
  */
 import type { AbstractDialect } from '../dialect/abstractDialect.js';
+import type { VectorCast } from '../dialect/vectorCast.js';
 import type { ColumnType, FieldOptions } from '../type/entity.js';
 import type { CanonicalType, TypeCategory } from './types.js';
-/** Type guard for all vector-family categories. */
-export declare function isVectorCategory(category: TypeCategory): boolean;
+/** Whether a category is one of the vector types, narrowing it to the cast pgvector names use. */
+export declare function isVectorCategory(category: TypeCategory | undefined): category is VectorCast;
 /**
  * Parse a SQL type string into a canonical type.
  * Handles complex types like VARCHAR(255), DECIMAL(10,2), etc.
  */
 export declare function sqlToCanonical(sqlType: string): CanonicalType;
+/**
+ * The canonical type for a column an engine reported, merging the metadata columns it reports beside
+ * the type name (`character_maximum_length` and friends) over whatever the name itself carried. This is
+ * the one place a SQL type string is parsed: everything downstream compares and renders canonical
+ * types, so no consumer has to know that `TINYINT(1)` means boolean on MySQL.
+ */
+export declare function canonicalColumnType(sqlType: string, reported?: {
+    length?: number;
+    precision?: number;
+    scale?: number;
+}): CanonicalType;
 /**
  * Convert a canonical type to a SQL type string for a specific dialect instance.
  */

package/dist/schema/canonicalType.js

@@ -9,7 +9,7 @@
 // ============================================================================
 // Vector Category Helpers
 // ============================================================================
-/** Type guard for all vector-family categories. */
+/** Whether a category is one of the vector types, narrowing it to the cast pgvector names use. */
 export function isVectorCategory(category) {
     return category === 'vector' || category === 'halfvec' || category === 'sparsevec';
 }
@@ -86,7 +86,15 @@ const SQL_TO_CANONICAL = {
     halfvec: { category: 'halfvec' },
     sparsevec: { category: 'sparsevec' },
 };
-const PG_TYPE_MAP = {
+/**
+ * pgvector is the only engine with three vector column types, so every other dialect maps all three
+ * canonical categories onto the single type it does have (see {@link MULTI_VECTOR_TYPE_DIALECTS}, the
+ * dialect-side half of the same fact).
+ */
+function withVectorType(scalars, vector) {
+    return { ...scalars, vector, halfvec: vector, sparsevec: vector };
+}
+const PG_SCALAR_MAP = {
     integer: 'INTEGER',
     float: 'REAL',
     decimal: 'NUMERIC',
@@ -98,22 +106,18 @@ const PG_TYPE_MAP = {
     json: 'JSONB',
     uuid: 'UUID',
     blob: 'BYTEA',
+};
+const PG_TYPE_MAP = {
+    ...PG_SCALAR_MAP,
     vector: 'VECTOR',
     halfvec: 'HALFVEC',
     sparsevec: 'SPARSEVEC',
 };
-// CockroachDB's VECTOR type is native (no extension), but it has no HALFVEC/SPARSEVEC types at
-// all - verified live: `CREATE TABLE t (v HALFVEC(3))` is a syntax error, not just unsupported at
-// runtime. Falls back to VECTOR, same as MariaDB (see its own halfvec/sparsevec below).
-const CRDB_TYPE_MAP = {
-    ...PG_TYPE_MAP,
-    halfvec: 'VECTOR',
-    sparsevec: 'VECTOR',
-};
 const CANONICAL_TO_SQL = {
     postgres: PG_TYPE_MAP,
-    cockroachdb: CRDB_TYPE_MAP,
-    mysql: {
+    // CockroachDB's VECTOR is native, no extension needed.
+    cockroachdb: withVectorType(PG_SCALAR_MAP, 'VECTOR'),
+    mysql: withVectorType({
         integer: 'INT',
         float: 'FLOAT',
         decimal: 'DECIMAL',
@@ -125,11 +129,11 @@ const CANONICAL_TO_SQL = {
         json: 'JSON',
         uuid: 'CHAR(36)',
         blob: 'BLOB',
-        vector: 'JSON', // MySQL doesn't have native vector type
-        halfvec: 'JSON',
-        sparsevec: 'JSON',
-    },
-    sqlite: {
+    }, 
+    // MySQL 9.x does have a `VECTOR` type, but no distance function outside HeatWave and no vector
+    // index, so JSON keeps the column queryable with the JSON operators and needs no conversion.
+    'JSON'),
+    sqlite: withVectorType({
         integer: 'INTEGER',
         float: 'REAL',
         decimal: 'REAL',
@@ -141,11 +145,8 @@ const CANONICAL_TO_SQL = {
         json: 'TEXT',
         uuid: 'TEXT',
         blob: 'BLOB',
-        vector: 'TEXT',
-        halfvec: 'TEXT',
-        sparsevec: 'TEXT',
-    },
-    mariadb: {
+    }, 'TEXT'),
+    mariadb: withVectorType({
         integer: 'INT',
         float: 'FLOAT',
         decimal: 'DECIMAL',
@@ -157,12 +158,9 @@ const CANONICAL_TO_SQL = {
         json: 'JSON',
         uuid: 'CHAR(36)',
         blob: 'BLOB',
-        vector: 'VECTOR',
-        halfvec: 'VECTOR', // MariaDB only supports VECTOR; no native halfvec/sparsevec
-        sparsevec: 'VECTOR',
-    },
+    }, 'VECTOR'),
     // MongoDB uses BSON types, not SQL types. These are placeholders for compatibility.
-    mongodb: {
+    mongodb: withVectorType({
         integer: 'int',
         float: 'double',
         decimal: 'decimal128',
@@ -174,10 +172,7 @@ const CANONICAL_TO_SQL = {
         json: 'object',
         uuid: 'binData',
         blob: 'binData',
-        vector: 'array',
-        halfvec: 'array',
-        sparsevec: 'array',
-    },
+    }, 'array'),
 };
 /**
  * Size variant modifiers for SQL types.
@@ -318,6 +313,21 @@ export function sqlToCanonical(sqlType) {
     }
     return result;
 }
+/**
+ * The canonical type for a column an engine reported, merging the metadata columns it reports beside
+ * the type name (`character_maximum_length` and friends) over whatever the name itself carried. This is
+ * the one place a SQL type string is parsed: everything downstream compares and renders canonical
+ * types, so no consumer has to know that `TINYINT(1)` means boolean on MySQL.
+ */
+export function canonicalColumnType(sqlType, reported = {}) {
+    const base = sqlToCanonical(sqlType);
+    return {
+        ...base,
+        length: reported.length ?? base.length,
+        precision: reported.precision ?? base.precision,
+        scale: reported.scale ?? base.scale,
+    };
+}
 /**
  * Convert a canonical type to a SQL type string for a specific dialect instance.
  */

package/dist/schema/index.d.ts

@@ -22,4 +22,4 @@ export type { BuildFromEntitiesOptions } from './schemaASTBuilder.js';
 export { SchemaASTBuilder } from './schemaASTBuilder.js';
 export type { DiffOptions } from './schemaASTDiffer.js';
 export { diffSchemas, SchemaASTDiffer } from './schemaASTDiffer.js';
-export type { CanonicalType, ColumnDiff, ColumnNode, ConflictResolution, DetectedRelation, Drift, DriftReport, DriftSeverity, DriftStatus, DriftType, ForeignKeyAction, IndexDiff, IndexNode, IndexSource, IndexSyncStatus, IndexType, RelationshipDiff, RelationshipNode, RelationshipSource, RelationshipType, SchemaAST as ISchemaAST, SchemaDiffResult, SizeVariant, SyncDirection, SyncOptions, TableDiff, TableNode, TypeCategory, ValidationError, ValidationErrorType, } from './types.js';
+export type { CanonicalType, ColumnDiff, ColumnNode, Drift, DriftReport, DriftSeverity, DriftStatus, DriftType, ForeignKeyAction, IndexDiff, IndexNode, IndexSource, IndexSyncStatus, IndexType, RelationshipDiff, RelationshipNode, RelationshipSource, RelationshipType, SchemaAST as ISchemaAST, SchemaDiffResult, SizeVariant, TableDiff, TableNode, TypeCategory, ValidationError, ValidationErrorType, } from './types.js';

package/dist/schema/schemaASTBuilder.d.ts

@@ -54,7 +54,7 @@ export declare class SchemaASTBuilder {
      * foreign key column whose type doesn't match the UUID primary key it
      * references, which Postgres (and most databases) reject outright.
      *
-     * `field.typeInferred` (set by `defineField`, see entity/metadata/definition.ts)
+     * `field.typeFromReference` (set by `defineField`, see entity/metadata/definition.ts)
      * is what distinguishes "no type was given" from "the decorator explicitly set
      * a type" - including explicit constructor overrides like `type: BigInt`, which
      * a value-based check (e.g. `typeof field.type === 'string'`) would miss since
@@ -71,7 +71,14 @@ export declare class SchemaASTBuilder {
      */
     private addRelationshipsFromEntity;
     /**
-     * Add indexes from field options.
+     * Add indexes from field options (`@Field({ index })`) and from `@Index([...])`, which have nothing
+     * in common beyond their target table.
      */
     private addIndexesFromEntity;
+    /**
+     * One `@Index([...])`. Its entries keep the authored form (expression, prefix length, order) with
+     * names resolved, so the generator renders exactly what was declared; `columns` is the resolvable
+     * subset, which is what diffing and introspection compare.
+     */
+    private addCompositeIndex;
 }

package/dist/schema/schemaASTBuilder.js

@@ -74,7 +74,7 @@ export class SchemaASTBuilder {
      * foreign key column whose type doesn't match the UUID primary key it
      * references, which Postgres (and most databases) reject outright.
      *
-     * `field.typeInferred` (set by `defineField`, see entity/metadata/definition.ts)
+     * `field.typeFromReference` (set by `defineField`, see entity/metadata/definition.ts)
      * is what distinguishes "no type was given" from "the decorator explicitly set
      * a type" - including explicit constructor overrides like `type: BigInt`, which
      * a value-based check (e.g. `typeof field.type === 'string'`) would miss since
@@ -82,7 +82,7 @@ export class SchemaASTBuilder {
      * `columnType` remains the unambiguous, always-respected explicit override.
      */
     resolveColumnCanonicalType(field, seen = new Set()) {
-        const hasExplicitType = !!field.columnType || !field.typeInferred;
+        const hasExplicitType = !!field.columnType || !field.typeFromReference;
         if (!hasExplicitType && field.references && !seen.has(field.references)) {
             seen.add(field.references);
             const referencedMeta = getMeta(field.references());
@@ -160,8 +160,12 @@ export class SchemaASTBuilder {
             const relatedTable = this.ast.getTable(relatedTableName);
             if (!relatedTable)
                 continue;
-            // Only create FK for owning side (m1 and owner side of 11)
-            if (relation.cardinality === 'm1' || (relation.cardinality === '11' && relation.references)) {
+            // Only the owning side gets the FK. `mappedBy` marks the inverse side of a one-to-one, whose
+            // `references` describe how to join back (its own primary key against the owner's FK column) -
+            // reading those as a foreign key emitted a reversed constraint (`User(id) REFERENCES
+            // user_profile(creatorId)`), which SQLite rejects outright as a foreign key mismatch.
+            const ownsForeignKey = relation.cardinality === 'm1' || (relation.cardinality === '11' && !!relation.references && !relation.mappedBy);
+            if (ownsForeignKey) {
                 const references = relation.references ?? [{ local: `${key}Id`, foreign: relatedMeta.id }];
                 const localPropName = references[0].local;
                 const foreignPropName = references[0].foreign;
@@ -192,67 +196,72 @@ export class SchemaASTBuilder {
         }
     }
     /**
-     * Add indexes from field options.
+     * Add indexes from field options (`@Field({ index })`) and from `@Index([...])`, which have nothing
+     * in common beyond their target table.
      */
     addIndexesFromEntity(entity, meta, resolveTableName, resolveColumnName) {
         const tableName = resolveTableName(entity, meta);
         const table = this.ast.getTable(tableName);
         if (!table)
             return;
-        // 1. Single column indexes from @Field({ index: true })
-        const indexFields = meta.fields;
-        for (const key of Object.keys(indexFields)) {
-            const field = indexFields[key];
+        for (const key of Object.keys(meta.fields)) {
+            const field = meta.fields[key];
             if (!field?.index)
                 continue;
-            const columnName = resolveColumnName(key, field);
-            const column = table.columns.get(columnName);
+            const column = table.columns.get(resolveColumnName(key, field));
             if (!column)
                 continue;
-            const indexName = typeof field.index === 'string' ? field.index : `idx_${tableName}_${columnName}`;
-            const indexNode = {
-                name: indexName,
+            this.ast.addIndex({
+                name: typeof field.index === 'string' ? field.index : `idx_${tableName}_${column.name}`,
                 table,
                 columns: [column],
                 unique: field.unique ?? false,
                 source: 'entity',
                 syncStatus: 'entity_only',
-            };
-            this.ast.addIndex(indexNode);
+            });
         }
-        // 2. Composite indexes from @Index([...])
-        if (meta.indexes) {
-            for (const idxMeta of meta.indexes) {
-                const columns = [];
-                for (const propName of idxMeta.columns) {
-                    const field = meta.fields[propName];
-                    if (!field)
-                        continue;
-                    const colName = resolveColumnName(propName, field);
-                    const column = table.columns.get(colName);
-                    if (column) {
-                        columns.push(column);
-                    }
-                }
-                if (columns.length > 0) {
-                    const indexName = idxMeta.name ?? `idx_${tableName}_${columns.map((c) => c.name).join('_')}`;
-                    const indexNode = {
-                        name: indexName,
-                        table,
-                        columns,
-                        unique: idxMeta.unique ?? false,
-                        type: idxMeta.type,
-                        where: idxMeta.where,
-                        distance: idxMeta.distance,
-                        m: idxMeta.m,
-                        efConstruction: idxMeta.efConstruction,
-                        lists: idxMeta.lists,
-                        source: 'entity',
-                        syncStatus: 'entity_only',
-                    };
-                    this.ast.addIndex(indexNode);
-                }
-            }
+        for (const idxMeta of meta.indexes ?? []) {
+            this.addCompositeIndex(table, meta, idxMeta, resolveColumnName);
         }
     }
+    /**
+     * One `@Index([...])`. Its entries keep the authored form (expression, prefix length, order) with
+     * names resolved, so the generator renders exactly what was declared; `columns` is the resolvable
+     * subset, which is what diffing and introspection compare.
+     */
+    addCompositeIndex(table, meta, idxMeta, resolveColumnName) {
+        // An entry survives if it is an expression (nothing to resolve) or names a column that exists;
+        // an index left with none is dropped, the same as one naming only unknown columns always was.
+        const entries = idxMeta.columns
+            .map((entry) => {
+            if (entry.expression)
+                return entry;
+            const field = meta.fields[entry.column];
+            const column = field && resolveColumnName(entry.column, field);
+            return column && table.columns.has(column) ? { ...entry, column } : undefined;
+        })
+            .filter((entry) => entry !== undefined);
+        if (!entries.length)
+            return;
+        const columns = entries
+            .map((entry) => (entry.expression ? undefined : table.columns.get(entry.column)))
+            .filter((column) => column !== undefined);
+        const named = columns.length ? columns.map((column) => column.name) : entries.map((_, at) => `expr${at}`);
+        this.ast.addIndex({
+            name: idxMeta.name ?? `idx_${table.name}_${named.join('_')}`,
+            table,
+            columns,
+            entries,
+            include: idxMeta.include,
+            unique: idxMeta.unique ?? false,
+            type: idxMeta.type,
+            where: idxMeta.where,
+            distance: idxMeta.distance,
+            m: idxMeta.m,
+            efConstruction: idxMeta.efConstruction,
+            lists: idxMeta.lists,
+            source: 'entity',
+            syncStatus: 'entity_only',
+        });
+    }
 }

package/dist/schema/types.d.ts

@@ -4,7 +4,8 @@
  * A unified graph representation of database schema with relationships as first-class citizens.
  * Enables reliable diffing, smart relation detection, and dialect-agnostic schema operations.
  */
-import type { VectorIndexOptions } from '../type/vector.js';
+import type { IndexColumnSchema } from '../type/entity.js';
+import type { IndexSchema } from '../type/migration.js';
 /**
  * Type categories universal across SQL dialects.
  * These represent logical/semantic types, not specific SQL types.
@@ -148,24 +149,21 @@ export interface RelationshipNode {
  * Index node in the schema graph.
  * Represents a database index on one or more columns.
  */
-export type IndexNode = {
-    /** Index name */
-    readonly name: string;
+export type IndexNode = Omit<IndexSchema, 'columns'> & {
     /** Reference to the table this index belongs to */
     readonly table: TableNode;
-    /** Columns included in the index (order matters) */
+    /** Columns included in the index (order matters). Empty for an index over expressions only. */
     readonly columns: ColumnNode[];
-    /** Whether this is a unique index */
-    readonly unique: boolean;
-    /** Index algorithm/type */
-    readonly type?: IndexType;
-    /** Partial index condition (WHERE clause) */
-    readonly where?: string;
+    /**
+     * The index as authored, with names resolved: expressions, prefix lengths and per-column order that
+     * a `ColumnNode` cannot represent. The generator renders these; `columns` is what diffing compares.
+     */
+    readonly entries?: readonly IndexColumnSchema[];
     /** Where this index was defined */
     readonly source?: IndexSource;
     /** Current sync status */
     readonly syncStatus?: IndexSyncStatus;
-} & VectorIndexOptions;
+};
 /**
  * Root of the schema graph.
  * Contains all tables, relationships, and provides graph operations.
@@ -258,27 +256,6 @@ export interface ValidationError {
     readonly relationship?: RelationshipNode;
     readonly tables?: TableNode[];
 }
-/**
- * A detected/inferred relationship with confidence score.
- */
-export interface DetectedRelation {
-    readonly type: RelationshipType;
-    readonly from: {
-        readonly table: TableNode;
-        readonly columns: ColumnNode[];
-    };
-    readonly to: {
-        readonly table: TableNode;
-        readonly columns: ColumnNode[];
-    };
-    readonly through?: TableNode;
-    /** Confidence level (0-1) */
-    readonly confidence: number;
-    /** How this relation was detected */
-    readonly source: RelationshipSource;
-    /** Suggested constraint name */
-    readonly suggestedName?: string;
-}
 /**
  * Severity level for schema drift issues.
  */
@@ -320,28 +297,3 @@ export interface DriftReport {
         readonly info: number;
     };
 }
-/**
- * Direction for schema synchronization.
- */
-export type SyncDirection = 'bidirectional' | 'entity-to-db' | 'db-to-entity';
-/**
- * Strategy for resolving conflicts in bidirectional sync.
- */
-export type ConflictResolution = 'prompt' | 'entity-wins' | 'db-wins' | 'skip';
-/**
- * Options for sync operations.
- */
-export interface SyncOptions {
-    /** Direction of synchronization */
-    readonly direction?: SyncDirection;
-    /** How to resolve conflicts (for bidirectional) */
-    readonly conflictResolution?: ConflictResolution;
-    /** Prevent destructive changes (DROP, type narrowing) */
-    readonly safe?: boolean;
-    /** Include indexes in sync */
-    readonly includeIndexes?: boolean;
-    /** Include foreign keys in sync */
-    readonly includeForeignKeys?: boolean;
-    /** Dry run - report changes without applying */
-    readonly dryRun?: boolean;
-}

package/dist/sqlite/abstractSqliteQuerier.d.ts

@@ -1,3 +1,49 @@
 import { AbstractSqlQuerier } from '../querier/index.js';
+/**
+ * Values every SQLite driver accepts as a bound parameter.
+ *
+ * @remarks No `boolean`: SQLite has no boolean storage class, and both `better-sqlite3` ("SQLite3 can
+ * only bind numbers, strings, bigints, buffers, and null") and `node:sqlite` reject one outright. The
+ * dialect already binds booleans as integers (`booleanLiteral: 'integer'`), so nothing reaches a
+ * driver as one; leaving `boolean` here only invited a runtime throw that is now a compile error.
+ */
+export type SqliteBindValue = null | string | number | bigint | Uint8Array;
+/** Header a SQLite driver returns for a statement without a `RETURNING` clause. */
+export type SqliteRunResult = {
+    changes: number;
+    lastInsertRowid: number | bigint;
+};
+/** Bound parameters reach a driver as `unknown[]` from the compiler; every driver types them narrowly. */
+export declare function toSqliteBindValues(values?: unknown[]): SqliteBindValue[];
+/**
+ * A prepared statement from a driver with better-sqlite3 semantics. `better-sqlite3` and `bun:sqlite`
+ * answer synchronously, `@tursodatabase/database` with promises, and {@link PreparedSqliteQuerier}
+ * awaits either.
+ */
+export type SqlitePreparedStatement = {
+    /** True for any statement returning rows, including one with a `RETURNING` clause. */
+    readonly reader: boolean;
+    all(...values: SqliteBindValue[]): unknown[] | Promise<unknown[]>;
+    run(...values: SqliteBindValue[]): SqliteRunResult | Promise<SqliteRunResult>;
+    iterate(...values: SqliteBindValue[]): Iterable<unknown> | AsyncIterable<unknown>;
+};
 export declare abstract class AbstractSqliteQuerier extends AbstractSqlQuerier {
+    /**
+     * SQLite drivers hold a single shared handle rather than a connection from a pool, so releasing
+     * a querier returns nothing; it only asserts the unit of work was finished. Drivers owning a
+     * closable per-querier connection override this.
+     */
+    internalRelease(): Promise<void>;
+}
+/**
+ * Querier for the SQLite drivers that expose prepared statements: `better-sqlite3`, `bun:sqlite`
+ * (through `adaptBunSqlite`) and the embedded Turso engine. They differ only in whether preparing and
+ * stepping are synchronous, which `await` and `for await` absorb, so the read/write/stream logic -
+ * including the `reader` rule below, whose loss silently drops inserted ids - is written once.
+ */
+export declare abstract class PreparedSqliteQuerier extends AbstractSqliteQuerier {
+    protected abstract prepare(query: string): SqlitePreparedStatement | Promise<SqlitePreparedStatement>;
+    internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
+    internalStream<T>(query: string, values?: unknown[]): AsyncGenerator<Awaited<T>, void, unknown>;
+    internalRun(query: string, values?: unknown[]): Promise<import("../type/query.js").QueryUpdateResult>;
 }