tina4-nodejs 3.13.97 → 3.13.99

package/types/orm/src/cachedDatabase.d.ts

@@ -144,8 +144,21 @@ export declare class CachedDatabaseAdapter implements DatabaseAdapter {
     private backendSetRows;
     private backendGetOne;
     private backendSetOne;
+    /** ADR-0044 required capability — delegates to the wrapped adapter. */
+    connect(): void | Promise<void>;
+    /** ADR-0044 required capability — delegates to the wrapped adapter. */
+    getDatabaseType(): string;
+    /**
+     * ADR-0044 required capability — a native boolean, readable and writable.
+     * A getter/setter pair (not a plain field) so it genuinely delegates to the
+     * wrapped adapter rather than drifting out of sync with its real setting.
+     */
+    get autocommit(): boolean;
+    set autocommit(value: boolean);
+    get supportsAtomicBatch(): boolean;
+    set supportsAtomicBatch(value: boolean);
     execute(sql: string, params?: unknown[]): unknown;
-    executeMany(sql: string, paramsList: unknown[][]): {
+    executeMany(sql: string, paramsList: unknown[][]): import("./types.js").DatabaseResult | {
         totalAffected: number;
         lastId?: number | bigint;
     };
@@ -173,6 +186,19 @@ export declare class CachedDatabaseAdapter implements DatabaseAdapter {
     fetchOneAsync<T = Record<string, unknown>>(sql: string, params?: unknown[], noCache?: boolean): Promise<T | null>;
     queryAsync<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
     executeAsync(sql: string, params?: unknown[]): Promise<unknown>;
+    /**
+     * ADR-0044: the async passthrough executeMany() itself was missing (unlike
+     * its executeAsync/insertAsync siblings above), so adapterExecuteMany()'s
+     * `(adapter as any).executeManyAsync` check found nothing on THIS wrapper
+     * and fell through to the synchronous executeMany() below — which forwards
+     * to the wrapped adapter's OWN sync executeMany(), the throwing "Use
+     * executeManyAsync()" stub on every async-native adapter (Postgres/MySQL/
+     * MSSQL/Firebird/Mongo). Real bug, caught by executeManyFacadeTxn.test.ts.
+     */
+    executeManyAsync(sql: string, paramsList: unknown[][]): Promise<import("./types.js").DatabaseResult | {
+        totalAffected: number;
+        lastId?: number | bigint;
+    }>;
     insertAsync(table: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<DatabaseResult>;
     updateAsync(table: string, data: Record<string, unknown>, filter: Record<string, unknown> | string, params?: unknown[]): Promise<DatabaseResult>;
     deleteAsync(table: string, filter: Record<string, unknown> | string | Record<string, unknown>[], params?: unknown[]): Promise<DatabaseResult>;

package/types/orm/src/database.d.ts

@@ -31,6 +31,32 @@ export declare function adapterFetch<T = Record<string, unknown>>(adapter: Datab
 export declare function adapterQuery<T = Record<string, unknown>>(adapter: DatabaseAdapter, sql: string, params?: unknown[]): Promise<T[]>;
 export declare function adapterFetchOne<T = Record<string, unknown>>(adapter: DatabaseAdapter, sql: string, params?: unknown[]): Promise<T | null>;
 export declare function adapterExecute(adapter: DatabaseAdapter, sql: string, params?: unknown[]): Promise<unknown>;
+/**
+ * ADR-0044: the adapter-level batch primitive, called exactly once by
+ * Database#executeMany (never looped) — one aggregate DatabaseResult for the
+ * whole batch. Normalises whichever native shape an adapter returns: SQLite's
+ * `{success, affectedRows, lastId}` (the shared write shape already used by
+ * insert/update/delete) or an async-native adapter's `{totalAffected, lastId}`
+ * (pre-ADR-0044 shape, not yet unified per-adapter — normalised HERE at the
+ * one chokepoint every public write flows through, so the facade's contract
+ * is uniform without touching each of the five adapter files' internals).
+ */
+export declare function adapterExecuteMany(adapter: DatabaseAdapter, sql: string, paramsList: unknown[][]): Promise<import("./types.js").DatabaseResult>;
+/**
+ * Insert one row (or a batch) through the adapter's OWN native insert path
+ * (each adapter's `buildInsert()`/`Dialect`, feature 3's SQL builder
+ * consolidation) instead of hand-built SQL. This is the ONLY correct way to
+ * insert into a caller-named table/columns: Firebird's Dialect quotes only
+ * when it has to (an unquoted identifier folds to UPPERCASE, so quoting a
+ * lower-case name makes it unfindable — SQL error -204 "Table unknown"),
+ * while PostgreSQL/MSSQL/SQLite quote unconditionally. A caller that hand-
+ * quotes with one fixed style (e.g. always `"col"`) works on three engines
+ * and silently breaks on the fourth. seedTable()/seedOrm() route through
+ * this so their engine portability matches insert()/insertAsync()'s, which
+ * the write-path + provider contract suites already prove on all four real
+ * engines (features 9/10/11/12).
+ */
+export declare function adapterInsert(adapter: DatabaseAdapter, table: string, data: Record<string, unknown>): Promise<unknown>;
 export declare function adapterStartTransaction(adapter: DatabaseAdapter): Promise<void>;
 export declare function adapterCommit(adapter: DatabaseAdapter): Promise<void>;
 export declare function adapterRollback(adapter: DatabaseAdapter): Promise<void>;
@@ -394,7 +420,19 @@ export declare class Database {
      * `try/catch` and convert, rather than testing the return value.
      */
     execute(sql: string, params?: unknown[]): Promise<boolean | unknown>;
-    /** Insert one row (object) or a batch of rows (array of objects) into a table. */
+    /**
+     * Insert one row (object) or a batch of rows (array of objects) into a table.
+     *
+     * FAIL LOUD, matching update()/delete()/truncate(): a real driver failure
+     * (e.g. a NOT NULL / UNIQUE constraint violation) throws rather than
+     * resolving to `{ success: false, affectedRows: 0 }`. The async adapters
+     * (Postgres/MySQL/MSSQL/Firebird) already throw directly from insertAsync();
+     * SQLiteAdapter.insert() is the one adapter that CATCHES the driver error
+     * and returns a `{ success: false, error }` result instead (its own
+     * documented contract for the synchronous path) — assertWrote is what
+     * converts that into the same thrown DatabaseException every other engine
+     * already produces, exactly as it already does for update/delete/truncate.
+     */
     insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<DatabaseWriteResult>;
     /**
      * The table's primary-key column, introspected once and cached.
@@ -487,16 +525,28 @@ export declare class Database {
         nullable?: boolean;
         default?: unknown;
         primaryKey?: boolean;
+        primaryKeyPosition?: number | null;
     }[]>;
     /**
-     * Execute a SQL statement with multiple parameter sets (batch insert/update).
-     * Wraps all executions in a single transaction for atomicity and performance.
+     * Execute a SQL statement with multiple parameter sets as ONE aggregate
+     * batch (ADR-0044). Wraps the single delegated call in a transaction for
+     * atomicity — never loops #execute itself.
+     *
+     * BREAKING (ADR-0044, pre-3.14.0): used to return one result PER ROW
+     * (`unknown[]`, callers indexed into it) built by the FACADE looping
+     * execute()/adapterExecute() per chunk or per row. It now delegates to the
+     * adapter's OWN executeMany/executeManyAsync exactly once (DBA-D02: facade
+     * delegates once, never a facade row loop) and returns the SAME shared
+     * DatabaseResult shape insert()/update()/delete() already return
+     * ({success, affectedRows, lastId}) — affectedRows is the total ROW count,
+     * never the number of chunks/statements. A caller that indexed into the old
+     * per-row array must switch to inspecting the aggregate result.
      *
      * @param sql - The SQL statement with parameter placeholders.
-     * @param paramSets - Array of parameter arrays, one per execution.
-     * @returns Array of results from each execution.
+     * @param paramSets - Array of parameter arrays, one per row.
+     * @returns The aggregate DatabaseResult for the whole batch.
      */
-    executeMany(sql: string, paramSets?: unknown[][]): Promise<unknown[]>;
+    executeMany(sql: string, paramSets?: unknown[][]): Promise<DatabaseWriteResult>;
     /** Return the last execute() error message, or null. */
     getError(): string | null;
     /**

package/types/orm/src/index.d.ts

@@ -1,14 +1,15 @@
 export type { FieldType, FieldDefinition, ModelDefinition, DatabaseAdapter, DatabaseResult as DatabaseWriteResult, ColumnInfo, QueryOptions, RelationshipDefinition, } from "./types.js";
+export { REQUIRED_ADAPTER_CAPABILITIES, NOT_REQUIRED_ON_ADAPTER } from "./types.js";
 export { DatabaseResult } from "./databaseResult.js";
 export type { ColumnInfoResult } from "./databaseResult.js";
 export { Database, initDatabase, getAdapter, setAdapter, bindDatabase, createAdapterFromUrl, closeDatabase, parseDatabaseUrl, setNamedAdapter, getNamedAdapter, resolveDbPool, stripTrailingSemicolons, wrapWithCache, resetRequestCaches } from "./database.js";
-export { adapterFetch, adapterQuery, adapterFetchOne, adapterExecute, adapterStartTransaction, adapterCommit, adapterRollback, adapterTableExists, adapterTables, adapterColumns, adapterCreateTable, extractLastInsertId, } from "./database.js";
+export { adapterFetch, adapterQuery, adapterFetchOne, adapterExecute, adapterInsert, adapterStartTransaction, adapterCommit, adapterRollback, adapterTableExists, adapterTables, adapterColumns, adapterCreateTable, extractLastInsertId, } from "./database.js";
 export type { DatabaseConfig } from "./database.js";
 export { DatabaseUrl, redactCredentials } from "./databaseUrl.js";
 export type { DatabaseEngine } from "./databaseUrl.js";
 export { discoverModels } from "./model.js";
 export type { DiscoveredModel } from "./model.js";
-export { syncModels, ensureMigrationTable, getNextBatch, isMigrationApplied, recordMigration, applyMigration, rollback, getAppliedMigrations, getLastBatchMigrations, removeMigrationRecord, migrate, createMigration, status, Migration, splitStatements, parseSetTerm, normalizeQuotes, sortMigrationFiles, shouldSkipCreateTable, } from "./migration.js";
+export { syncModels, ensureMigrationTable, getNextBatch, isMigrationApplied, recordMigration, applyMigration, rollback, getAppliedMigrations, getLastBatchMigrations, removeMigrationRecord, migrate, createMigration, status, Migration, splitStatements, parseSetTerm, normalizeQuotes, sortMigrationFiles, shouldSkipCreateTable, shouldSkipForFirebird, } from "./migration.js";
 export type { MigrationResult, MigrationStatus } from "./migration.js";
 export { AutoCrud, generateCrudRoutes, crudEligibleModels } from "./autoCrud.js";
 export type { AutoCrudOptions } from "./autoCrud.js";

package/types/orm/src/migration.d.ts

@@ -1,5 +1,14 @@
 import type { DatabaseAdapter } from "./types.js";
 import type { DiscoveredModel } from "./model.js";
+/**
+ * If stmt is an ALTER TABLE ... ADD on Firebird and the column already exists,
+ * returns a skip reason string. Returns null if the statement should execute normally.
+ *
+ * Exported (like its shouldSkipCreateTable sibling) so it can be driven
+ * directly against a REAL Firebird connection in
+ * test/migrationContract.test.ts -- no fake adapter needed.
+ */
+export declare function shouldSkipForFirebird(db: DatabaseAdapter, stmt: string): Promise<string | null>;
 /**
  * Make CREATE TABLE idempotent on engines lacking IF NOT EXISTS.
  *
@@ -53,17 +62,26 @@ export declare function removeMigrationRecord(name: string): Promise<void>;
 /**
  * Rollback the last batch of migrations using .down.sql files.
  *
- * For each migration in the last batch (in reverse order):
- * 1. Looks for a corresponding .down.sql file on disk
- * 2. If found, reads and executes the SQL statements
- * 3. If not found, logs a warning
- * 4. Deletes the tracking record either way
+ * FAIL-SAFE (MIG-DEC-02, reuses the Python reference model): for each
+ * migration in the last batch (in reverse order), the down artifact must
+ * actually run before the tracking record is removed. A MISSING .down.sql
+ * (or, on the legacy Map API, no registered down function) or a FAILING down
+ * statement now THROWS instead of logging a warning/error and still deleting
+ * the record — the old behaviour was the exact MIG-ROLLBACK-DROPS-LEDGER bug:
+ * the schema stayed applied but the ledger row vanished, silently untracked.
+ * The DELETE runs inside the SAME transaction as the down statements, so a
+ * partially-executed down (some statements ran, a later one failed) rolls
+ * back too — no half-reversed schema left behind either.
  *
  * @param migrationsDir - Directory containing migration files (default: "migrations")
  * @param delimiter - SQL statement delimiter (default: ";")
  * @returns Array of the down-migration files that were run, e.g.
  *   "000001_create_users.down.sql". (The legacy down-FUNCTION Map API returns the
  *   bare migration name instead, since no .down.sql file is involved there.)
+ * @throws When a migration in the batch has no down artifact, or its down
+ *   statement(s) fail — the batch stops at that migration; earlier
+ *   migrations in the SAME call that already rolled back stay rolled back
+ *   (each is its own transaction).
  *
  * NOTE on return form (intentional, cross-framework): migration return values reflect
  * WHAT each method acted on, so the forms differ by method and that is by design (not

package/types/orm/src/query.d.ts

@@ -10,5 +10,8 @@ export declare function buildQuery(tableName: string, options: QueryOptions, ext
     sql: string;
     countSql: string;
     params: unknown[];
+    limit: number;
+    offset: number;
+    page: number;
 };
 export declare function parseQueryString(query: Record<string, string>): QueryOptions;

package/types/orm/src/seeder.d.ts

@@ -21,7 +21,18 @@ export interface SeedOptions {
     overrides?: Record<string, unknown>;
     /** Delete every existing row in the target before seeding (P2). */
     clear?: boolean;
-    /** PRNG seed for reproducible FakeData output (P3). */
+    /**
+     * PRNG seed for reproducible FakeData output (P3). Honoured by seedOrm and
+     * seedModels, which build and seed their own FakeData internally.
+     *
+     * NOT honoured by seedTable (SEED-TABLE-SEED-INERT, SEED-DEC-01, ratified
+     * 2026-08-11 — same principle as the no-op ForeignKeyField on_delete):
+     * seedTable has no generators of its own to seed — fieldMap callables are
+     * opaque — so this used to be a silent no-op there. Passing it to seedTable
+     * now THROWS instead. Build your own `new FakeData(seed)` and close over it
+     * in fieldMap: `const fake = new FakeData(42); seedTable(db, table, count,
+     * { name: () => fake.name() })`.
+     */
     seed?: number;
     /** Re-raise on the first failed row instead of skipping it (P1). */
     strict?: boolean;
@@ -63,8 +74,10 @@ export declare function autoFieldMap(db: DatabaseAdapter, table: string, fake?:
  *                   (or a static value). If not provided, no rows are inserted.
  * @param overrides - (legacy positional) Static values applied to every row.
  *                   Prefer `opts.overrides`.
- * @param opts - Seed options: `{ overrides, clear, seed, strict }`.
+ * @param opts - Seed options: `{ overrides, clear, strict }`. `opts.seed` is
+ *   NOT honoured here (see {@link SeedOptions.seed}) and throws if supplied.
  * @returns A SeedSummary `{ seeded, failed, errors }`.
+ * @throws {Error} If `opts.seed` is defined (SEED-TABLE-SEED-INERT removal).
  *
  * @example
  *   const fake = new FakeData();

package/types/orm/src/sqlTranslator.d.ts

@@ -31,18 +31,31 @@ export declare class SQLTranslator {
      * Does NOT convert if OFFSET is present (TOP doesn't support it).
      */
     static limitToTop(sql: string): string;
+    /** Replace string literals, quoted identifiers and comments with opaque
+     * `\x00N\x00` tokens (doubled-quote escapes handled). */
+    private static maskLiterals;
+    /** Inverse of maskLiterals. */
+    private static restoreLiterals;
+    private static readonly PRIMARY;
     /**
-     * Convert || concatenation to CONCAT() for MySQL/MSSQL.
+     * Convert `||` string concatenation to `CONCAT(...)` for MySQL/MSSQL.
      *
-     * 'a' || 'b' || 'c'  →  CONCAT('a', 'b', 'c')
+     * Rewrites ONLY `||` operators joining expression operands OUTSIDE any string
+     * literal or comment, and only the operand chain — never the whole statement:
+     *   SELECT a || b FROM t   ->  SELECT CONCAT(a, b) FROM t
+     *   WHERE data = 'a||b'    ->  WHERE data = 'a||b'   (literal untouched)
      */
     static concatPipesToFunc(sql: string): string;
     /**
-     * Convert TRUE/FALSE to 1/0 for engines without boolean type (Firebird).
+     * Convert bare TRUE/FALSE to 1/0 for engines without a boolean type. A
+     * TRUE/FALSE INSIDE a string literal is data and is left untouched
+     * (`WHERE label = 'TRUE'` is preserved).
      */
     static booleanToInt(sql: string): string;
     /**
-     * Convert ILIKE to LOWER() LIKE LOWER() for engines without ILIKE.
+     * Convert `col ILIKE pattern` to `LOWER(col) LIKE LOWER(pattern)` for engines
+     * without ILIKE. The pattern operand is captured whole (a multi-word
+     * `'%two words%'` survives) and an ILIKE INSIDE a string literal is untouched.
      */
     static ilikeToLike(sql: string): string;
     /**

package/types/orm/src/types.d.ts

@@ -1,4 +1,4 @@
-export type FieldType = "string" | "integer" | "number" | "numeric" | "boolean" | "datetime" | "text" | "json" | "foreignKey";
+export type FieldType = "string" | "integer" | "number" | "numeric" | "decimal" | "boolean" | "datetime" | "text" | "json" | "foreignKey";
 export interface FieldDefinition {
     type: FieldType;
     primaryKey?: boolean;
@@ -10,6 +10,15 @@ export interface FieldDefinition {
     min?: number;
     max?: number;
     pattern?: string;
+    /**
+     * For type "decimal": the fixed precision/scale of a real DECIMAL(p, s)
+     * column. `number`/`numeric` stay a floating type (the documented money
+     * guidance); a `decimal` field keeps the declared scale in the COLUMN, so
+     * createTable emits DECIMAL(precision, scale) — identical on
+     * PostgreSQL/MySQL/MSSQL/Firebird/SQLite. Default 10 / 2 when omitted.
+     */
+    precision?: number;
+    scale?: number;
     /** For type "foreignKey": the referenced model name (string) */
     references?: string;
     /** For type "foreignKey": override the has-many property name on the referenced model */
@@ -50,6 +59,12 @@ export interface ColumnInfo {
     nullable?: boolean;
     default?: unknown;
     primaryKey?: boolean;
+    /**
+     * ADR-0044 amendment (Feature 5 Decision 7, 2026-08-10): null for a
+     * non-key column; for a composite key this is the 1-based DECLARED
+     * PRIMARY KEY (...) order, not table-column order.
+     */
+    primaryKeyPosition?: number | null;
 }
 export interface DatabaseResult {
     success: boolean;
@@ -57,44 +72,88 @@ export interface DatabaseResult {
     lastId?: number | bigint | string;
     error?: string;
 }
+/**
+ * ADR-0044 (feature 3, plan/v3/fixtures/adapter_contract.json): the exact
+ * fourteen adapter capabilities every DatabaseAdapter implementation must
+ * provide (DBA-S01). Kept as data so the conformance suite can check it
+ * without a second hand-maintained copy of the list.
+ */
+export declare const REQUIRED_ADAPTER_CAPABILITIES: readonly ["connect", "close", "getDatabaseType", "execute", "executeMany", "fetch", "fetchOne", "startTransaction", "commit", "rollback", "autocommit", "getTables", "getColumns", "tableExists"];
+/**
+ * ADR-0044 NOT_REQUIRED_ON_ADAPTER (DBA-S03): engine-neutral composition that
+ * the adapter CONTRACT does not require. Node keeps these as REQUIRED
+ * TypeScript interface members anyway (unlike Python/PHP/Ruby's stricter
+ * runtime reflection) because `database.ts`/`cachedDatabase.ts` call them
+ * directly at dozens of sites with no optional-chaining guard, so making them
+ * TS-optional ripples into a much larger refactor than this pass covers;
+ * this constant records the ADR's INTENT for the conformance suite to check
+ * even though the compiler will not enforce their absence.
+ */
+export declare const NOT_REQUIRED_ON_ADAPTER: readonly ["query", "insert", "update", "delete", "truncate", "fetchAll", "createTable", "addColumn", "lastInsertId", "error", "sqlTranslation"];
 export interface DatabaseAdapter {
+    /** Connect (ADR-0044 canonical lifecycle name). May be sync or async. */
+    connect(): void | Promise<void>;
+    /** Return the canonical, credential-free engine name ("sqlite", "postgres", ...). */
+    getDatabaseType(): string;
     /** Execute a statement (INSERT, UPDATE, DELETE, DDL). */
     execute(sql: string, params?: unknown[]): unknown;
-    /** Execute a single SQL statement with multiple parameter sets (batch). */
-    executeMany(sql: string, paramsList: unknown[][]): {
+    /**
+     * Execute a single SQL statement with multiple parameter sets as ONE
+     * aggregate result (ADR-0044). The shared write shape `DatabaseResult`
+     * ({success, affectedRows, lastId?}) is the target; the pre-ADR-0044 async
+     * adapters (Postgres/MySQL/MSSQL/Firebird/Mongo) still return their
+     * original `{totalAffected, lastId?}` shape internally today — the union
+     * covers both while `adapterExecuteMany()` in database.ts normalises
+     * whichever shape it receives at the one chokepoint every public batch
+     * write flows through.
+     */
+    executeMany(sql: string, paramsList: unknown[][]): DatabaseResult | {
         totalAffected: number;
         lastId?: number | bigint;
     };
-    /** Query rows. */
-    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): T[];
-    /** Fetch rows with optional pagination (limit/skip). */
+    /** Fetch rows with optional pagination (limit/skip). Native list, no envelope. */
     fetch<T = Record<string, unknown>>(sql: string, params?: unknown[], limit?: number, skip?: number): T[];
-    /** Fetch a single row or null. */
+    /** Fetch a single row or null. No pagination count probe. */
     fetchOne<T = Record<string, unknown>>(sql: string, params?: unknown[]): T | null;
-    /** Insert one or more rows into a table, returns result with lastId. */
-    insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): DatabaseResult;
-    /** Update rows in a table matching filter (object or string WHERE), returns affected row count. */
-    update(table: string, data: Record<string, unknown>, filter: Record<string, unknown> | string, params?: unknown[]): DatabaseResult;
-    /** Delete rows from a table matching filter (object, string WHERE, or array of objects). */
-    delete(table: string, filter: Record<string, unknown> | string | Record<string, unknown>[], params?: unknown[]): DatabaseResult;
     /** Start a transaction. */
     startTransaction(): void;
     /** Commit the current transaction. */
     commit(): void;
     /** Rollback the current transaction. */
     rollback(): void;
+    /**
+     * Native boolean, readable and writable. A plain field is the idiomatic JS
+     * shape for "readable and writable" — no getter/setter ceremony needed.
+     */
+    autocommit: boolean;
+    /**
+     * ADR-0044 / DBA-P02: whether this adapter's deployment can guarantee an
+     * atomic multi-row batch write. Every built-in adapter defaults true (see
+     * each adapter's field initializer); a deployment that genuinely cannot (a
+     * standalone MongoDB without a replica set is the motivating real case)
+     * sets this false so executeMany rejects BEFORE the first write.
+     */
+    supportsAtomicBatch?: boolean;
     /** List all tables in the database. */
     getTables(): string[];
     /** List columns with types for a table. */
     getColumns(table: string): ColumnInfo[];
-    /** Get the last inserted id (auto-increment integer, or a UUID/string PK). */
-    lastInsertId(): number | bigint | string | null;
     /** Close the connection. */
     close(): void;
     /** Check if a table exists. */
     tableExists(name: string): boolean;
-    /** Create a table from field definitions. */
+    /** Insert one or more rows into a table, returns result with lastId. */
+    insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): DatabaseResult;
+    /** Update rows in a table matching filter (object or string WHERE), returns affected row count. */
+    update(table: string, data: Record<string, unknown>, filter: Record<string, unknown> | string, params?: unknown[]): DatabaseResult;
+    /** Delete rows from a table matching filter (object, string WHERE, or array of objects). */
+    delete(table: string, filter: Record<string, unknown> | string | Record<string, unknown>[], params?: unknown[]): DatabaseResult;
+    /** Query rows (legacy convenience, superseded by fetch). */
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): T[];
+    /** Create a table from field definitions (legacy, DDL composition lives above the adapter). */
     createTable(name: string, columns: Record<string, FieldDefinition>): void;
+    /** Get the last inserted id (legacy — prefer DatabaseResult.lastId from execute/executeMany). */
+    lastInsertId(): number | bigint | string | null;
     /** Get raw column info (legacy, used by migration). */
     getTableColumns?(name: string): Array<{
         name: string;

package/packages/core/src/errorOverlay.test.ts

@@ -1,122 +0,0 @@
-/**
- * Tests for errorOverlay module.
- */
-
-import { renderErrorOverlay, renderProductionError, isDebugMode } from "./errorOverlay.js";
-
-let passed = 0;
-let failed = 0;
-
-function assert(condition: boolean, message: string): void {
-  if (condition) {
-    passed++;
-  } else {
-    failed++;
-    console.error(`  FAIL: ${message}`);
-  }
-}
-
-function assertIncludes(html: string, needle: string, label: string): void {
-  assert(html.includes(needle), `${label}: expected HTML to include "${needle}"`);
-}
-
-function assertNotIncludes(html: string, needle: string, label: string): void {
-  assert(!html.includes(needle), `${label}: expected HTML NOT to include "${needle}"`);
-}
-
-function makeError(): Error {
-  try {
-    throw new TypeError("something broke");
-  } catch (e) {
-    return e as Error;
-  }
-}
-
-// ── renderErrorOverlay ──
-
-const err = makeError();
-const html = renderErrorOverlay(err);
-
-assert(typeof html === "string", "returns a string");
-assert(html.startsWith("<!DOCTYPE html>"), "starts with DOCTYPE");
-assertIncludes(html, "TypeError", "contains exception type");
-assertIncludes(html, "something broke", "contains exception message");
-assertIncludes(html, "errorOverlay.test", "contains file path");
-assertIncludes(html, "&#x25b6;", "contains error line marker");
-assertIncludes(html, "Stack Trace", "contains stack trace section");
-assertIncludes(html, "<details", "uses details element");
-assertIncludes(html, "open", "stack trace open by default");
-assertIncludes(html, "Environment", "contains environment section");
-assertIncludes(html, "Tina4 Node.js", "contains framework name");
-assertIncludes(html, "TINA4_DEBUG", "contains debug reference");
-
-// With request
-const htmlWithReq = renderErrorOverlay(err, {
-  method: "GET",
-  url: "/api/users",
-  headers: { host: "localhost" },
-});
-assertIncludes(htmlWithReq, "GET", "request method shown");
-assertIncludes(htmlWithReq, "/api/users", "request URL shown");
-assertIncludes(htmlWithReq, "localhost", "request header shown");
-assertIncludes(htmlWithReq, "Request Details", "request section present");
-
-// Without request
-assertNotIncludes(html, "Request Details", "no request section when no request");
-
-// XSS escaping
-const xssErr = new Error('<script>alert("xss")</script>');
-const xssHtml = renderErrorOverlay(xssErr);
-assertNotIncludes(xssHtml, "<script>", "escapes script tags");
-assertIncludes(xssHtml, "&lt;script&gt;", "HTML-encodes script tags");
-
-// ── renderProductionError ──
-
-const prodHtml = renderProductionError();
-assert(prodHtml.startsWith("<!DOCTYPE html>"), "production: starts with DOCTYPE");
-assertIncludes(prodHtml, "500", "production: contains 500");
-assertIncludes(prodHtml, "Internal Server Error", "production: default message");
-assertNotIncludes(prodHtml, "Stack Trace", "production: no stack trace");
-
-const prod404 = renderProductionError(404, "Not Found");
-assertIncludes(prod404, "404", "production 404: contains code");
-assertIncludes(prod404, "Not Found", "production 404: contains message");
-
-// ── isDebugMode ──
-
-const origDebug = process.env.TINA4_DEBUG;
-
-process.env.TINA4_DEBUG = "true";
-assert(isDebugMode() === true, "isDebugMode: true => true");
-
-process.env.TINA4_DEBUG = "false";
-assert(isDebugMode() === false, "isDebugMode: false => false");
-
-process.env.TINA4_DEBUG = "TRUE";
-assert(isDebugMode() === true, "isDebugMode: TRUE (uppercase) => true (case insensitive)");
-
-process.env.TINA4_DEBUG = "1";
-assert(isDebugMode() === true, "isDebugMode: 1 => true");
-
-process.env.TINA4_DEBUG = "yes";
-assert(isDebugMode() === true, "isDebugMode: yes => true");
-
-process.env.TINA4_DEBUG = "on";
-assert(isDebugMode() === true, "isDebugMode: on => true");
-
-process.env.TINA4_DEBUG = "0";
-assert(isDebugMode() === false, "isDebugMode: 0 => false");
-
-delete process.env.TINA4_DEBUG;
-assert(isDebugMode() === false, "isDebugMode: unset => false");
-
-// Restore
-if (origDebug !== undefined) {
-  process.env.TINA4_DEBUG = origDebug;
-}
-
-// ── Summary ──
-console.log(`\nerrorOverlay tests: ${passed} passed, ${failed} failed`);
-if (failed > 0) {
-  process.exit(1);
-}