uql-orm 0.87.0 → 0.89.0

package/dist/mssql/mssqlDialect.js

@@ -17,9 +17,7 @@ const MSSQL_FEATURES = {
     indexIfNotExists: true,
     schemas: true,
     dropTableCascade: false,
-    foreignKeyAlter: true,
-    primaryKeyAlter: true,
-    generatedColumnAdd: true,
+    rebuildsTables: false,
     // Extended properties are out-of-band metadata with their own procedures, not comments.
     commentSyntax: 'none',
     vectorIndexRequiresNotNull: false,
@@ -42,9 +40,8 @@ const MSSQL_FEATURES = {
         preamble: 'SET NOCOUNT ON;',
         assignsRow: false,
         body: 'inline',
-        guards: 'beginEnd',
+        fires: 'eachStatement',
         layout: 'tableFirst',
-        rows: 'set',
         scope: 'schema',
         before: false,
     },

package/dist/schema/indexDifferences.d.ts

@@ -30,7 +30,7 @@ export declare function pairIndexes<S extends ComparableIndex, T extends Compara
 /**
  * The indexes a table lacks, the ones it no longer needs, and the ones to rebuild, differing in what
  * `facets` let the engine report. Only an unpaired index uql named, or whose name the entity claims, is
- * dropped: any other may have been made outside the ORM.
+ * dropped: any other may have been made outside the ORM, so it is `kept`.
  */
 export declare function indexChanges<I extends IndexSchema>(table: string, declared: readonly I[], current: readonly IndexNode[], facets: ReadonlySet<IndexFacet>): {
     toAdd: I[];
@@ -39,6 +39,7 @@ export declare function indexChanges<I extends IndexSchema>(table: string, decla
         from: IndexNode;
         to: I;
     }[];
+    kept: IndexNode[];
 };
 /**
  * What two indexes differ by, comparing only what both sides state structurally: an expression, a JSON

package/dist/schema/indexDifferences.js

@@ -38,7 +38,7 @@ export function pairIndexes(source, target, normalizeName = (name) => name) {
 /**
  * The indexes a table lacks, the ones it no longer needs, and the ones to rebuild, differing in what
  * `facets` let the engine report. Only an unpaired index uql named, or whose name the entity claims, is
- * dropped: any other may have been made outside the ORM.
+ * dropped: any other may have been made outside the ORM, so it is `kept`.
  */
 export function indexChanges(table, declared, current, facets) {
     const { created, dropped, matched } = pairIndexes(declared, current);
@@ -47,6 +47,7 @@ export function indexChanges(table, declared, current, facets) {
     return {
         toAdd: created,
         toDrop: dropped.filter(owned),
+        kept: dropped.filter((index) => !owned(index)),
         toAlter: matched.flatMap(([to, from]) => (describeIndexDifferences(to, from, facets).length ? [{ from, to }] : [])),
     };
 }

package/dist/schema/schemaAST.js

@@ -9,6 +9,7 @@ export function createTableNode(name, schema, indexFacets = new Set()) {
         columns: new Map(),
         indexes: [],
         checks: [],
+        externalForeignKeys: [],
         incomingRelations: [],
         outgoingRelations: [],
     };

package/dist/schema/types.d.ts

@@ -1,4 +1,4 @@
-import type { IndexSchema, PrimaryKeySchema } from '../type/migration.js';
+import type { ForeignKeySchema, IndexSchema, PrimaryKeySchema, StoredDefinition } from '../type/migration.js';
 import type { IndexFacet } from './indexDifferences.js';
 /**
  * Type categories universal across SQL dialects.
@@ -123,6 +123,10 @@ export interface TableNode {
     readonly checks: CheckSchema[];
     /** Optional table comment */
     readonly comment?: string;
+    /** The statements the engine keeps for the table, where it keeps them; none on a table built from entities. */
+    definition?: readonly StoredDefinition[];
+    /** The foreign keys to tables this AST does not hold, which a rebuild keeps as they are. */
+    readonly externalForeignKeys: ForeignKeySchema[];
     /** Relationships pointing TO this table (other tables referencing this one) */
     incomingRelations: RelationshipNode[];
     /** Relationships pointing FROM this table (this table referencing others) */

package/dist/sqlite/sqliteDialect.d.ts

@@ -13,7 +13,6 @@ export declare class SqliteDialect extends AbstractSqlDialect {
     readonly commitTransactionCommand = "COMMIT";
     readonly rollbackTransactionCommand = "ROLLBACK";
     readonly isolationLevelStrategy = "none";
-    readonly alterColumnSyntax = "none";
     readonly booleanLiteral = "integer";
     /** SQLite's own cap on a function call before 3.48, which libSQL and `bun:sqlite`'s build still have. */
     readonly maxFunctionArgs: number;

package/dist/sqlite/sqliteDialect.js

@@ -21,9 +21,7 @@ export const SQLITE_FEATURES = {
     indexIfNotExists: true,
     schemas: false, // SQLite's namespaces are attached database files, not declared objects
     dropTableCascade: false,
-    foreignKeyAlter: false, // SQLite does not support adding FKs to existing tables
-    primaryKeyAlter: false, // nor changing a key: the only route is rebuilding the table
-    generatedColumnAdd: false, // accepted in a CREATE TABLE, rejected in an ALTER
+    rebuildsTables: true,
     commentSyntax: 'none',
     vectorIndexRequiresNotNull: false,
     vectorSupportsLength: true,
@@ -45,9 +43,8 @@ export const SQLITE_FEATURES = {
         preamble: '',
         assignsRow: false,
         body: 'inline',
-        guards: 'clause',
+        fires: 'eachRowWhen',
         layout: 'timingFirst',
-        rows: 'row',
         scope: 'schema',
         before: true,
     },
@@ -62,7 +59,6 @@ export class SqliteDialect extends AbstractSqlDialect {
     commitTransactionCommand = 'COMMIT';
     rollbackTransactionCommand = 'ROLLBACK';
     isolationLevelStrategy = 'none';
-    alterColumnSyntax = 'none';
     booleanLiteral = 'integer';
     /** SQLite's own cap on a function call before 3.48, which libSQL and `bun:sqlite`'s build still have. */
     maxFunctionArgs = 127;

package/dist/type/dialect.d.ts

@@ -87,18 +87,12 @@ export interface DialectFeatures {
      */
     readonly schemas: boolean;
     readonly dropTableCascade: boolean;
-    readonly foreignKeyAlter: boolean;
     /**
-     * Whether a table's primary key can be changed on an existing table. False on SQLite, whose only
-     * route is rebuilding the table - so a migration that would change one is refused by name rather
-     * than emitting DDL the engine rejects.
+     * Whether the engine changes a column, a key or a foreign key, or adds a stored generated column, only
+     * by rebuilding the table, as SQLite does: a generated migration copies the table into a new one, and
+     * the migration builder refuses the change by name.
      */
-    readonly primaryKeyAlter: boolean;
-    /**
-     * Whether a stored generated column can be added to an existing table. SQLite takes one only in a
-     * `CREATE TABLE`, so a sync that would add one is refused by name.
-     */
-    readonly generatedColumnAdd: boolean;
+    readonly rebuildsTables: boolean;
     /** Where a comment goes: in the declaration (MySQL family), a `COMMENT ON` of its own (Postgres family), or nowhere. */
     readonly commentSyntax: 'inline' | 'statement' | 'none';
     /**
@@ -192,16 +186,12 @@ export interface TriggerFeatures {
      */
     readonly body: 'function' | 'inline';
     /**
-     * How it states which rows it fires for: `UPDATE OF` beside a `WHEN` (`'clause'`), or, where there is
-     * no usable `WHEN` - the MySQL family, CockroachDB, SQL Server - the same condition wrapping the body,
-     * as `IF c THEN ... END IF;` (`'thenEndIf'`) or T-SQL's `IF c BEGIN ... END` (`'beginEnd'`).
-     */
-    readonly guards: 'clause' | 'thenEndIf' | 'beginEnd';
-    /**
-     * Whether it fires once per row, with a row on each side, or once per statement over the set it
-     * touched. SQL Server is the only one here that is set-based, reading `inserted` and `deleted`.
+     * How it fires, and so how it keeps to the rows `of` and `where` select: once per row, behind
+     * `UPDATE OF` and a `WHEN` (`'eachRowWhen'`) or, with no usable `WHEN` (the MySQL family, CockroachDB),
+     * an `IF c THEN ... END IF;` around the body (`'eachRowIf'`); or once per statement (`'eachStatement'`,
+     * SQL Server), narrowing the `inserted` and `deleted` tables its writes read.
      */
-    readonly rows: 'row' | 'set';
+    readonly fires: 'eachRowWhen' | 'eachRowIf' | 'eachStatement';
     /**
      * Where a trigger's name is unique, and so what a `DROP` has to name: per table on the Postgres
      * family, which spells `DROP TRIGGER x ON t`, and per schema everywhere else, which spells
@@ -232,6 +222,14 @@ export interface TriggerFeatures {
      */
     readonly before: boolean;
 }
+/**
+ * The rows a set-based trigger's writes read: the tables `from` names, `inserted` and the like, narrowed
+ * by `where` to the ones the trigger selects.
+ */
+export type TriggerRows = {
+    readonly from: string;
+    readonly where?: string;
+};
 /** Where DDL's SQL sits: the row a trigger's predicate reads, as its prefix, and a set-based body's rows. */
 export type DdlRenderOptions = Pick<QueryComparisonOptions, 'escapedPrefix' | 'operand'> & Pick<QueryRawRenderOptions, 'rows'>;
 /**
@@ -282,8 +280,8 @@ export interface SqlQueryDialect {
     update<E>(ctx: QueryContext, entity: Type<E>, q: QuerySearch<E>, payload: UpdatePayload<E>, opts?: QueryRenderOptions): void;
     /** An upsert of one record or many by their conflict paths. */
     upsert<E>(ctx: QueryContext, entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E | E[]): void;
-    /** A write in a trigger's body; `rows` is where a set-based engine's body reads its rows from. */
-    triggerWrite(ctx: QueryContext, write: TriggerWrite, rows?: string): void;
+    /** A write in a trigger's body; `rows` are what a set-based engine's body reads, narrowed to the ones it fires for. */
+    triggerWrite(ctx: QueryContext, write: TriggerWrite, rows?: TriggerRows): void;
     /** A delete of the records the query matches, a soft delete where the entity has one. */
     delete<E>(ctx: QueryContext, entity: Type<E>, q: QuerySearch<E>, opts?: QueryRenderOptions): void;
     /**

package/dist/type/migration.d.ts

@@ -122,7 +122,20 @@ export interface TableSchema {
     readonly primaryKey?: PrimaryKeySchema;
     readonly indexes?: IndexSchema[];
     readonly foreignKeys?: ForeignKeySchema[];
+    /** The statements the engine keeps for the table, where it keeps them: SQLite's `sqlite_master`. */
+    readonly definition?: readonly StoredDefinition[];
 }
+/** A statement exactly as the engine keeps it, which only it can say all of: a `CHECK`, an index over an expression. */
+export type StoredDefinition = {
+    readonly kind: 'table' | 'index' | 'trigger';
+    readonly name: string;
+    readonly sql: string;
+};
+/** One side of a rebuilt table: its `CREATE TABLE` and what goes back on it, and the columns holding stored values, under this side's names. */
+export type RebuiltTable = {
+    readonly statements: readonly string[];
+    readonly columns: readonly string[];
+};
 /**
  * Represents an index in a database table
  */
@@ -216,6 +229,14 @@ export interface SchemaDiff {
     readonly foreignKeys?: readonly Change<ForeignKeySchema>[];
     /** Columns renamed in place, `from` the database's name `to` the entity's, which the other changes already use. */
     readonly renamedColumns?: readonly Rename[];
+    /**
+     * The table copied into a new one, which is how an engine that {@link DialectFeatures.rebuildsTables}
+     * applies the changes above. Its column renames are carried by the copy.
+     */
+    readonly rebuild?: {
+        readonly from: RebuiltTable;
+        readonly to: RebuiltTable;
+    };
 }
 /**
  * What every sync entry point takes: `safe` keeps it additive, `drop` lets it remove a column, and

package/dist/type/queryRaw.d.ts

@@ -1,4 +1,4 @@
-import type { QueryContext, RelationAggregateSpec, SqlQueryDialect } from './dialect.js';
+import type { QueryContext, RelationAggregateSpec, SqlQueryDialect, TriggerRows } from './dialect.js';
 import type { Type } from './utility.js';
 /** What a `raw` callback receives. See {@link QueryRawFn}. */
 export type QueryRawRenderOptions = {
@@ -16,10 +16,10 @@ export type QueryRawRenderOptions = {
      */
     entity?: Type<unknown>;
     /**
-     * The `FROM` a set-based trigger's body reads its rows through, `FROM inserted` and the like, which a
-     * write in it names. Absent where the body reads `NEW` and `OLD` bare, and outside a trigger.
+     * The rows a set-based trigger's writes read. Absent where the body reads `NEW` and `OLD` bare, and
+     * outside a trigger.
      */
-    rows?: string;
+    rows?: TriggerRows;
 };
 /** {@link QueryRawRenderOptions} as the callers along the way fill them in, every one still optional. */
 export type QueryRawFnOptions = Partial<QueryRawRenderOptions>;
@@ -83,3 +83,10 @@ export declare class RelationAggregate<V = unknown, Storable extends boolean = b
     /** What it reads, kept beside the SQL so a read decodes the value the way the target's field does. */
     spec: RelationAggregateSpec, value: QueryRawFn);
 }
+/**
+ * A write `insertInto`, `updateTable` or `deleteFrom` renders, or several joined in one `raw`. It reads a
+ * set-based trigger's rows through {@link QueryRawRenderOptions.rows}, which is how `of` and `where` narrow
+ * them there; SQL of its own reads `inserted` and `deleted` whole.
+ */
+export declare class TriggerWriteRaw extends QueryRaw {
+}

package/dist/type/queryRaw.js

@@ -57,3 +57,10 @@ export class RelationAggregate extends QueryRaw {
         this.spec = spec;
     }
 }
+/**
+ * A write `insertInto`, `updateTable` or `deleteFrom` renders, or several joined in one `raw`. It reads a
+ * set-based trigger's rows through {@link QueryRawRenderOptions.rows}, which is how `of` and `where` narrow
+ * them there; SQL of its own reads `inserted` and `deleted` whole.
+ */
+export class TriggerWriteRaw extends QueryRaw {
+}

package/dist/type/queryWhere.d.ts

@@ -1,4 +1,4 @@
-import type { FieldKey, JsonFieldPaths, JsonFieldPathValue, RelationKey, RelationTarget } from './entity.js';
+import type { FieldKey, FieldKeyOf, JsonFieldPaths, JsonFieldPathValue, RelationKey, RelationTarget } from './entity.js';
 import type { QuerySelect } from './query.js';
 import type { QueryRaw, RawFor } from './queryRaw.js';
 import type { AtLeastOne, ExpandScalar, IsMany, QueryComparableScalar, Scalar } from './utility.js';
@@ -12,9 +12,9 @@ export type QueryTextSearchOptions<E> = {
      */
     $value: string;
     /**
-     * the fields to search, `{ title: true, body: true }`, in the order a MySQL `FULLTEXT` index lists them.
+     * the string fields to search, `{ title: true, body: true }`, in the order a MySQL `FULLTEXT` index lists them.
      */
-    $fields?: QuerySelect<E>;
+    $fields?: QuerySelect<E, FieldKeyOf<E, string>>;
     /**
      * The language the search is parsed in (e.g. `'english'`, or `'simple'` for no stemming), else that of
      * the fulltext index over its fields: the Postgres family's text-search config, MongoDB's `$language`.
@@ -28,18 +28,28 @@ export type QueryTextSearchOptions<E> = {
  * reported on its key: ids go through `{ id: 1 }` or the by-id methods.
  */
 export type QueryWhere<E, Raw = QueryRaw, K extends keyof E = FieldKey<E> | RelationKey<E>> = QueryWhereRootOperator<E, Raw> & {
-    [P in K]?: P extends FieldKey<E> ? QueryWhereFieldValue<E[P], Raw> : QueryWhere<RelationTarget<E[P]>, Raw> | QueryRelationSizeFilter;
+    [P in K]?: P extends FieldKey<E> ? QueryWhereFieldValue<E[P], Raw> : QueryWhereRelation<RelationTarget<E[P]>, Raw>;
 } & ([JsonFieldPaths<E>] extends [never] ? unknown : {
     [P in JsonFieldPaths<E>]?: QueryWhereFieldValue<JsonFieldPathValue<E, P>, Raw>;
 });
 /**
- * Filter a to-many relation by its row count.
+ * Filter a to-many relation by its row count, and by nothing beside it: the target's keys and the root
+ * operators are refused, as the engine refuses them at run time.
  * @example { users: { $size: 2 } }
  * @example { users: { $size: { $gte: 2 } } }
  */
-export type QueryRelationSizeFilter = {
+export type QueryRelationSizeFilter<T = object> = {
     readonly $size: number | QuerySizeComparisonOps;
+} & {
+    readonly [K in (keyof T & string) | keyof QueryWhereRootOperator<object>]?: never;
 };
+/**
+ * A relation key's filter: a where over the target's rows, or its row count, never both. A target keyed
+ * by an index signature declares no keys to refuse, so there the run-time check alone answers a mix.
+ */
+export type QueryWhereRelation<T, Raw = QueryRaw> = string extends keyof T ? QueryWhere<T, Raw> | QueryRelationSizeFilter : (QueryWhere<T, Raw> & {
+    readonly $size?: never;
+}) | QueryRelationSizeFilter<T>;
 export type QueryWhereRootOperator<E, Raw = QueryRaw> = {
     /**
      * joins query clauses with a logical `AND`, returns records that match all the clauses.

package/dist/util/index.d.ts

@@ -7,7 +7,7 @@ export * from './ddlExpression.util.js';
 export * from './logger.js';
 export * from './object.util.js';
 export * from './raw.js';
-export * from './triggerWrite.js';
+export { deleteFrom, insertInto, updateTable } from './triggerWrite.js';
 export * from './rowKey.util.js';
 export * from './relationQuery.util.js';
 export * from './sql.util.js';

package/dist/util/index.js

@@ -7,7 +7,7 @@ export * from './ddlExpression.util.js';
 export * from './logger.js';
 export * from './object.util.js';
 export * from './raw.js';
-export * from './triggerWrite.js';
+export { deleteFrom, insertInto, updateTable } from './triggerWrite.js';
 export * from './rowKey.util.js';
 export * from './relationQuery.util.js';
 export * from './sql.util.js';

package/dist/util/raw.js

@@ -1,5 +1,5 @@
 import { getMeta } from '../entity/metadata/definition.js';
-import { ColumnRef, QueryRaw, RAW_TEXT, RelationAggregate, } from '../type/index.js';
+import { ColumnRef, QueryRaw, RAW_TEXT, RelationAggregate, TriggerWriteRaw, } from '../type/index.js';
 import { aggregateOf, isInlinedExpression } from './field.util.js';
 import { entityName, hasKeys } from './object.util.js';
 import { UqlUsageError } from './uqlError.js';
@@ -7,7 +7,9 @@ export function raw(value, ...rest) {
     if (!isTemplateStrings(value)) {
         return new QueryRaw(value);
     }
-    return new QueryRaw((opts) => {
+    // Writes joined by whitespace alone are still only writes, so a set-based trigger narrows each one.
+    const writes = rest.length > 0 && rest.every((v) => v instanceof TriggerWriteRaw) && value.every((part) => !part.trim());
+    return new (writes ? TriggerWriteRaw : QueryRaw)((opts) => {
         const { ctx } = opts;
         ctx.append(value[0]);
         rest.forEach((interpolated, i) => {

package/dist/util/triggerWrite.d.ts

@@ -1,4 +1,4 @@
-import type { EntityPredicate, QueryRaw, Type, UpdatePayload, WritableKey, WriteRow } from '../type/index.js';
+import { type EntityPredicate, type QueryRaw, type TriggerWrite, type Type, type UpdatePayload, type WritableKey, type WriteRow } from '../type/index.js';
 /**
  * A row inserted by a trigger's body, into any table: `insertInto(PostAudit, { postId: newRow.id })`.
  * Each value is a literal or SQL, a row's ref most often, and every engine renders it, SQL Server's
@@ -13,3 +13,5 @@ export declare function updateTable<E extends object>(entity: Type<E>, q: {
 export declare function deleteFrom<E extends object>(entity: Type<E>, q: {
     readonly $where: EntityPredicate<E>;
 }): QueryRaw;
+/** A write in a trigger's body, as every helper here and a stamp render one. */
+export declare function written(write: TriggerWrite): QueryRaw;

package/dist/util/triggerWrite.js

@@ -1,4 +1,4 @@
-import { raw } from './raw.js';
+import { TriggerWriteRaw, } from '../type/index.js';
 /**
  * A row inserted by a trigger's body, into any table: `insertInto(PostAudit, { postId: newRow.id })`.
  * Each value is a literal or SQL, a row's ref most often, and every engine renders it, SQL Server's
@@ -15,6 +15,7 @@ export function updateTable(entity, q, set) {
 export function deleteFrom(entity, q) {
     return written({ kind: 'delete', entity, where: q.$where });
 }
-function written(write) {
-    return raw(({ ctx, dialect, rows }) => dialect.triggerWrite(ctx, write, rows));
+/** A write in a trigger's body, as every helper here and a stamp render one. */
+export function written(write) {
+    return new TriggerWriteRaw(({ ctx, dialect, rows }) => dialect.triggerWrite(ctx, write, rows));
 }

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "JSON-native TypeScript ORM for Bun, Browsers, Edge, Deno, Node, Workers. Supports PostgreSQL, PGlite, MySQL, MariaDB, SQLite, CockroachDB, SQL Server, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
   "license": "MIT",
-  "version": "0.87.0",
+  "version": "0.89.0",
   "type": "module",
   "engines": {
     "node": ">=24"

package/skills/uql-orm/SKILL.md

@@ -84,7 +84,7 @@ export class Post {
   an update must carry the version it read (a compile error otherwise), and one against a row someone else moved on throws `UqlOptimisticLockError` (kind `optimisticLock`, HTTP 409). Its updates name one row by its id; save and upsert are refused.
 - `@Field({ computed })` is a value the database produces, on a `readonly` property: SQL over the row, ``(u) => raw`${u.first} || ' ' || ${u.last}` ``, or a relation aggregate, `(order) => order.items.count()`.
   `stored: true` makes the SQL a generated column; `stored: ['insert', 'update']` makes it a stamp, a trigger writing it on those events whoever writes the row (``computed: raw`CURRENT_TIMESTAMP` ``), where `onUpdate` covers only uql's own writes.
-- `@Trigger({ on: 'afterUpdate', of: (post) => [post.status], where: { $old: { status: 'draft' } }, run })` is a trigger the database fires (`defineEntity`'s `triggers` or `defineTrigger` without decorators); `where` holds a `$where` predicate per row it names, or SQL off the rows. `run` takes `(newRow, oldRow)`, each only where the event has it (no `oldRow` on insert, no `newRow` on delete), and returns the body: `insertInto(Audit, { postId: newRow.id })`, `updateTable(Audit, { $where: { postId: newRow.id } }, { status: newRow.status })` or `deleteFrom(Audit, { $where: { postId: oldRow.id } })`, typed by the entity written and rendered on every engine (no `onInsert`/`onUpdate` fills, so an insert names each field uql fills on insert unless its column has a `defaultValue`; `$where` reads the entity's own fields; no entity filters, security ones included, so a soft-delete entity is hard-deleted; an update or delete naming no rows is refused; no `$inc`/`$mul`/`$push` on SQL Server), several joined in one `raw`. Anything else is `raw` SQL over the refs, one body for every engine or `{ postgres, mssql, ... }` where they differ (SQL Server fires per statement, reading `inserted`/`deleted` as tables, with no `before*` and no `where`). MongoDB has none, and refuses a write to an entity declaring one.
+- `@Trigger({ on: 'afterUpdate', of: (post) => [post.status], where: { $old: { status: 'draft' } }, run })` is a trigger the database fires (`defineEntity`'s `triggers` or `defineTrigger` without decorators); `where` holds a `$where` predicate per row it names, or SQL off the rows. `run` takes `(newRow, oldRow)`, each only where the event has it (no `oldRow` on insert, no `newRow` on delete), and returns the body: `insertInto(Audit, { postId: newRow.id })`, `updateTable(Audit, { $where: { postId: newRow.id } }, { status: newRow.status })` or `deleteFrom(Audit, { $where: { postId: oldRow.id } })`, typed by the entity written and rendered on every engine (no `onInsert`/`onUpdate` fills, so an insert names each field uql fills on insert unless its column has a `defaultValue`; `$where` reads the entity's own fields; no entity filters, security ones included, so a soft-delete entity is hard-deleted; an update or delete naming no rows is refused; no `$inc`/`$mul`/`$push` on SQL Server), several joined in one `raw`. Anything else is `raw` SQL over the refs, one body for every engine or `{ postgres, mssql, ... }` where they differ (SQL Server fires per statement, reading `inserted`/`deleted` as tables, with no `before*`; `of` and `where` narrow what the write helpers read there, so SQL of its own is refused beside them). MongoDB has none, and refuses a write to an entity declaring one.
 - `defineEntity` defines the same entity without decorators: https://uql-orm.dev/entities/imperative.md
 
 ## Queries
@@ -154,7 +154,7 @@ transaction. A querier from `pool.getQuerier()` is yours to release: bind it wit
 ## Migrations
 
 `npx uql-migrate` reads `uql.config.ts`. `sync` creates what the entities imply (development only);
-`generate:entities` writes the diff as a migration file to review, renaming a column its field was renamed from and printing `renameTable` for a table that may have been; `up` applies migrations; `generate:from-db`
+`generate:entities` writes the diff as a migration file to review, renaming a column its field was renamed from, printing `renameTable` for a table that may have been, rebuilding a SQLite table for what it cannot alter, and refusing a required column with no default on a table holding rows; `up` applies migrations; `generate:from-db`
 writes entity classes from an existing database; `drift:check` fails when the database no longer matches.
 Triggers are part of the diff: uql installs its own under `_uql_`-prefixed names and never touches another.