tina4-nodejs 3.13.12 → 3.13.16

package/CLAUDE.md

@@ -1,10 +1,10 @@
-# CLAUDE.md — AI Developer Guide for tina4-nodejs (v3.13.12)
+# CLAUDE.md — AI Developer Guide for tina4-nodejs (v3.13.16)
 
 > This file helps AI assistants (Claude, Copilot, Cursor, etc.) understand and work on this codebase effectively.
 
 ## What This Project Is
 
-Tina4 for Node.js/TypeScript v3.13.12 — The Intelligent Native Application 4ramework. A convention-over-configuration structural paradigm. The developer writes TypeScript; Tina4 is invisible infrastructure.
+Tina4 for Node.js/TypeScript v3.13.16 — The Intelligent Native Application 4ramework. A convention-over-configuration structural paradigm. The developer writes TypeScript; Tina4 is invisible infrastructure.
 
 The philosophy: zero ceremony, batteries included, file system as source of truth.
 
@@ -53,7 +53,7 @@ tina4-nodejs/
         seeder.ts        # Database seeding (seedTable, seedOrm)
         sqlTranslation.ts # Cross-engine SQL translator + query cache
     swagger/    # OpenAPI spec generator, Swagger UI
-    twig/       # Optional Twig template engine
+    frond/      # Zero-dependency Twig-compatible template engine
   test/
     run-all.ts       # Test runner — executes all 43 test files
     integration.ts   # Full integration test
@@ -70,7 +70,7 @@ This is an **npm workspaces monorepo**. All packages are in `packages/*`.
 - **Runtime:** Node.js 20+ (ESM only, `"type": "module"` everywhere)
 - **HTTP:** Native `node:http` — no Express, no Fastify
 - **Database:** SQLite via `node:sqlite` (default), with adapters for Postgres, MySQL, MSSQL/SQL Server, and Firebird
-- **Templates:** Twig via `twig` npm package (optional)
+- **Templates:** Frond — built-in zero-dependency Twig-compatible engine (`@tina4/frond`)
 - **Dev tooling:** `tsx` for runtime TS execution, `esbuild` for builds
 - **Testing:** 43 test files via `tsx test/run-all.ts`
 
@@ -110,10 +110,10 @@ The HTTP foundation. Handles request/response lifecycle, route matching, middlew
 - `static.ts` — Serves files from `public/` with MIME type detection
 - `types.ts` — All shared type definitions (`Tina4Request`, `Tina4Response`, `RouteHandler`, etc.)
 - `events.ts` — Observer-pattern event system (`Events.on`, `emit`, `once`, `off`, `clear`)
-- `ai.ts` — AI coding tool detection and context scaffolding (`detectAi`, `installAiContext`, `aiStatusReport`)
+- `ai.ts` — AI coding tool context installer (`AI_TOOLS`, `isInstalled`, `showMenu`, `installSelected`, `installAll`, `generateContext`)
 - `errorOverlay.ts` — Rich debug error page for dev mode (`renderErrorOverlay`, `renderProductionError`, `isDebugMode`)
 - `htmlElement.ts` — Programmatic HTML builder (`HtmlElement`, `htmlElement`, `addHtmlHelpers`)
-- `testing.ts` — Inline testing framework (`tests`, `assertEqual`, `assertThrows`, `runAllTests`)
+- `testing.ts` — Inline testing framework (`tests`, `assertEqual`, `assertRaises`, `runAll`)
 - `fakeData.ts` — Core fake data generator (names, emails, addresses, UUIDs, etc.)
 - `constants.ts` — HTTP status codes (`HTTP_OK`, `HTTP_NOT_FOUND`, etc.) and content types (`APPLICATION_JSON`, `TEXT_HTML`, etc.)
 - `devAdmin.ts` — Dev toolbar (fixed bottom bar injected into HTML pages) and admin dashboard at `/_dev/`
@@ -152,7 +152,7 @@ Database layer with auto-CRUD generation, seeding, fake data, and SQL translatio
 - `fakeData.ts` — ORM-aware fake data extending core (adds `forField()` with column-name heuristics)
 - `seeder.ts` — Database seeding (`seedTable` for raw SQL, `seedOrm` for model-based)
 - `sqlTranslation.ts` — Cross-engine SQL translator (`SQLTranslator`) and TTL query cache (`QueryCache`)
-- **Instance methods:** `save(): this|null` (fluent, null on failure), `delete()`, `forceDelete()`, `restore()`, `load(sql, params?, include?): boolean`, `validate(): string[]`, `toDict(include?)`, `toAssoc(include?)`, `toObject()`, `toArray(): unknown[]`, `toList()`, `toJson(include?)`, `hasOne(class, fk)`, `hasMany(class, fk, limit?, offset?)`, `belongsTo(class, fk)`
+- **Instance methods:** `save(): this|false` (fluent, false on failure), `delete()`, `forceDelete()`, `restore()`, `load(sql, params?, include?): boolean`, `validate(): string[]`, `toDict(include?)`, `toAssoc(include?)`, `toObject()`, `toArray(): unknown[]`, `toList()`, `toJson(include?)`, `hasOne(class, fk)`, `hasMany(class, fk, limit?, offset?)`, `belongsTo(class, fk)`
 - **Static methods:** `find(id, include?)`, `findById(id, include?)`, `findOrFail(id)`, `create(data)`, `all(where?, params?, include?)`, `select(sql, params?)`, `selectOne(sql, params?, include?)`, `where(conditions, params?, limit?, offset?, include?)`, `count(conditions?, params?)`, `withTrashed(conditions?, params?, limit?, offset?)`, `scope(name, filterSql, params?)` (registers reusable method), `createTable()`, `query()`, `_processForeignKeys()`, `_applyFkRegistry()`
 - **Foreign key auto-wire:** Declare a field with `type: "foreignKey"` and `references: "ModelName"` to auto-wire both `belongsTo` on the declaring model and `hasMany` on the referenced model. Optional `relatedName` overrides the has-many key. Models must be registered via `BaseModel.registerModel(name, class)` for name-based resolution. Example: `user_id: { type: "foreignKey", references: "User" }` → `post.belongsTo(User, "user_id")` and `user.hasMany(Post, "user_id")` both resolve without extra wiring.
 - QueryBuilder supports `toMongo()` for generating MongoDB query documents from the same fluent API
@@ -240,7 +240,7 @@ req.cookies: Record<string, string>       // parsed from Cookie header
 req.contentType: string                   // from content-type header
 req.query: Record<string, string>         // query string params
 response.xml(content, status?): Tina4Response
-response.stream(generator, contentType?: string, status?: number): void  // SSE/streaming
+response.stream(source: AsyncIterable<string | Buffer>, contentType?: string): Promise<Tina4Response>  // SSE/streaming
 ```
 
 ### Queue
@@ -258,12 +258,11 @@ Auto-generates OpenAPI 3.0 docs.
 - `generator.ts` — Produces OpenAPI spec from route table + model definitions
 - `ui.ts` — Serves Swagger UI HTML (CDN-based) at `/swagger` and spec at `/swagger/openapi.json`
 
-### @tina4/twig (`packages/twig/`)
-Optional server-side template rendering.
+### @tina4/frond (`packages/frond/`)
+Built-in zero-dependency Twig-compatible template engine (the only template engine; there is no `twig` npm dependency).
 
 **Key files:**
-- `engine.ts` — Wraps the `twig` npm package, `renderTemplate(path, data)`
-- `middleware.ts` — Adds `res.render(template, data)` to response objects
+- `engine.ts` — The `Frond` class: `render(path, data)`, `renderString(template, data)`, filters/globals/tests, sandbox mode
 
 ### tina4 CLI (`packages/cli/`)
 Developer-facing CLI commands.
@@ -305,26 +304,29 @@ Events.clear();
 
 ## Module: AI (`packages/core/src/ai.ts`)
 
-Detects AI coding tools (Claude Code, Cursor, Copilot, Windsurf, Aider, Cline, Codex) by checking for their config files/directories. Can scaffold a universal Tina4 context document into each tool's expected location.
+Installs Tina4 context files for AI coding tools (Claude Code, Cursor, Copilot, Windsurf, Aider, Cline, Codex). `AI_TOOLS` is the ordered list of known tools; the installer writes a marker-bracketed Tina4 skill block into each tool's context file, preserving existing content.
 
 ```typescript
-import { detectAi, installAiContext, aiStatusReport } from "@tina4/core";
+import { AI_TOOLS, isInstalled, showMenu, installSelected, installAll, generateContext } from "@tina4/core";
 
-// Detect which AI tools are present in a project directory
-const tools = detectAi(".");
-// → [{ name: "claude-code", description: "Claude Code (Anthropic CLI)",
-//       configFile: "CLAUDE.md", status: "detected" }, ...]
+// The known tools (name, description, contextFile, configDir)
+AI_TOOLS;  // → [{ name: "claude-code", description: "Claude Code", contextFile: "CLAUDE.md", configDir: ".claude" }, ...]
 
-// Install context files for all detected tools (creates CLAUDE.md, .cursorules, etc.)
-const created = installAiContext(".", { force: false });
-// → ["CLAUDE.md", ".cursorules"]
+// Check whether a tool's context file already exists in a project directory
+isInstalled(".", AI_TOOLS[0]);  // → boolean
 
-// Install for ALL known tools, not just detected ones
-import { installAllAiContext } from "@tina4/core";
-installAllAiContext(".", true);  // force overwrite
+// Show the interactive numbered menu and read the user's selection (returns a Promise)
+const selection = await showMenu(".");
 
-// Print a human-readable status report
-console.log(aiStatusReport("."));
+// Install context files for a selection ("1,2,3" or "all") — returns created/updated paths
+const created = installSelected(".", selection);
+// → ["CLAUDE.md", ".cursorules", ...]
+
+// Install for ALL known tools, non-interactive
+installAll(".");
+
+// Generate the context document string for a specific tool (defaults to "claude-code")
+const doc = generateContext("cursor");
 ```
 
 ## Module: Error Overlay (`packages/core/src/errorOverlay.ts`)
@@ -384,16 +386,16 @@ Void tags (`br`, `hr`, `img`, `input`, `meta`, etc.) render without closing tags
 
 ## Module: Inline Testing (`packages/core/src/testing.ts`)
 
-Attach test assertions directly to functions. Tests are registered globally and run with `runAllTests()`. No external test runner needed.
+Attach test assertions directly to functions. Tests are registered globally and run with `runAll()`. No external test runner needed.
 
 ```typescript
-import { tests, assertEqual, assertThrows, assertTrue, assertFalse, runAllTests, resetTests } from "@tina4/core";
+import { tests, assertEqual, assertRaises, assertTrue, assertFalse, runAll, reset } from "@tina4/core";
 
 // Decorate a function with inline tests
 const add = tests(
   assertEqual([5, 3], 8),        // add(5, 3) === 8
   assertEqual([0, 0], 0),        // add(0, 0) === 0
-  assertThrows(Error, [null]),   // add(null) throws Error
+  assertRaises(Error, [null]),   // add(null) throws Error
 )(function add(a: number, b: number | null = null): number {
   if (b === null) throw new Error("b required");
   return a + b;
@@ -403,7 +405,7 @@ const add = tests(
 add(2, 3);  // 5
 
 // Run all registered tests
-const results = runAllTests({ quiet: false, failfast: false });
+const results = runAll({ quiet: false, failfast: false });
 // → { passed: 3, failed: 0, errors: 0, details: [...] }
 
 // Additional assertion types
@@ -411,7 +413,7 @@ assertTrue([someArgs]);   // result is truthy
 assertFalse([someArgs]);  // result is falsy
 
 // Reset registry between test runs
-resetTests();
+reset();
 ```
 
 ## Module: Seeder / FakeData (`packages/orm/src/seeder.ts`, `packages/orm/src/fakeData.ts`)
@@ -600,7 +602,7 @@ db.pool
 Active-Record base class. Models live in `src/models/` and are auto-discovered. Use `static fields` (not decorators) — same convention across all four frameworks.
 
 ```typescript
-import { BaseModel, ormBind } from "@tina4/orm";
+import { BaseModel, initDatabase, setAdapter } from "@tina4/orm";
 
 export default class User extends BaseModel {
   static tableName = "users";
@@ -614,7 +616,7 @@ export default class User extends BaseModel {
 
 // Instance methods (chainable where it makes sense)
 const user = new User({ email: "alice@example.com" });
-user.save();              // returns this on success, null on failure
+user.save();              // returns this on success, false on failure
 user.delete();            // soft-delete if enabled, otherwise hard
 user.forceDelete();       // bypasses soft-delete
 user.restore();           // clears soft-delete marker
@@ -643,7 +645,11 @@ User.createTable();
 User.query(): QueryBuilder;
 BaseModel.registerModel(name, class);     // for foreignKey name resolution
 
-ormBind(db);   // bind a Database instance for all models in the registry
+// Models bind to the active adapter, not a Database wrapper. initDatabase() sets it
+// automatically; setAdapter() lets you bind one explicitly. Models read it via getAdapter().
+await initDatabase({ url: "sqlite:///app.db" });   // sets the active adapter for all models
+// or, with an adapter you constructed yourself:
+setAdapter(adapter);
 ```
 
 **Soft delete:** set `static softDelete = true`. Adds an `is_deleted` INTEGER column (0/1). `delete()` flips the flag, `forceDelete()` removes the row, `restore()` clears it.
@@ -726,7 +732,7 @@ frond.sandbox(["upper"], ["if"], ["x"]);   // allowed: filters, tags, vars
 frond.unsandbox();
 ```
 
-- **SafeString** — filters can return `new SafeString(value)` to bypass auto-escaping.
+- **Safe output** — Frond's built-in `raw`/`safe`-style filters (and the `{% autoescape %}` controls) mark output as already-escaped so it bypasses auto-escaping. The internal `SafeString` wrapper backing this is not exported from `@tina4/frond` (only `Frond`, `FilterFn`, `TestFn` are public).
 - **Fragment caching** — `{% cache "key" 300 %}...{% endcache %}` caches block output for TTL seconds.
 - **Raw blocks** — `{% raw %}...{% endraw %}` outputs literal template syntax.
 - **Pre-compiled regexes** + token caching (cleared on file mtime change in dev mode) for ~2.8x render improvement over the naive path.
@@ -1056,7 +1062,7 @@ When adding new features, add a corresponding `test/<feature>.test.ts` file.
 ## v3 Features Summary
 
 - **45 built-in features**, zero third-party dependencies
-- **1,812 tests** passing across all modules
+- **3,644 tests** passing across all modules
 - **Race-safe `getNextId()`** with atomic sequence table (`tina4_sequences`) for SQLite/MySQL/MSSQL; PostgreSQL auto-creates sequences
 - **Frond template engine optimizations**: pre-compiled regexes, lazy loop context (copy-on-write), filter chain caching, path split caching, inline common filters (11-15% speedup)
 - **Production server auto-detect**: `npx tina4nodejs serve --production` auto-uses cluster mode

package/package.json

@@ -3,7 +3,7 @@
 
 
 
-  "version": "3.13.12",
+  "version": "3.13.16",
 
   "type": "module",
   "description": "Tina4 for Node.js/TypeScript \u2014 54 built-in features, zero dependencies",

package/packages/cli/src/commands/migrate.ts

@@ -32,6 +32,7 @@ export async function runMigrations(migrationDir?: string): Promise<void> {
   let recordMigration: typeof import("../../../orm/src/index.js").recordMigration;
   let getNextBatch: typeof import("../../../orm/src/index.js").getNextBatch;
   let getAdapter: typeof import("../../../orm/src/index.js").getAdapter;
+  let adapterExecute: typeof import("../../../orm/src/index.js").adapterExecute;
 
   try {
     const orm = await import("../../../orm/src/index.js");
@@ -41,6 +42,7 @@ export async function runMigrations(migrationDir?: string): Promise<void> {
     recordMigration = orm.recordMigration;
     getNextBatch = orm.getNextBatch;
     getAdapter = orm.getAdapter;
+    adapterExecute = orm.adapterExecute;
   } catch {
     console.error("  Error: @tina4/orm is required to run migrations.");
     process.exit(1);
@@ -57,7 +59,7 @@ export async function runMigrations(migrationDir?: string): Promise<void> {
     process.exit(1);
   }
 
-  ensureMigrationTable();
+  await ensureMigrationTable();
 
   // Collect .sql files, excluding .down.sql, sorted by numeric prefix
   const files = readdirSync(dir)
@@ -79,13 +81,13 @@ export async function runMigrations(migrationDir?: string): Promise<void> {
     return;
   }
 
-  const batch = getNextBatch();
+  const batch = await getNextBatch();
   let applied = 0;
 
   for (const file of files) {
     const name = file.replace(/\.sql$/, "");
 
-    if (isMigrationApplied(name)) {
+    if (await isMigrationApplied(name)) {
       continue;
     }
 
@@ -100,7 +102,7 @@ export async function runMigrations(migrationDir?: string): Promise<void> {
 
     for (const stmt of statements) {
       try {
-        adapter.execute(stmt);
+        await adapterExecute(adapter, stmt);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         console.error(`  Error in ${file}: ${msg}`);
@@ -108,7 +110,7 @@ export async function runMigrations(migrationDir?: string): Promise<void> {
       }
     }
 
-    recordMigration(name, batch);
+    await recordMigration(name, batch);
     applied++;
   }
 

package/packages/cli/src/commands/migrateRollback.ts

@@ -44,9 +44,9 @@ export async function migrateRollback(migrationDir?: string): Promise<void> {
     process.exit(1);
   }
 
-  ensureMigrationTable();
+  await ensureMigrationTable();
 
-  const lastBatch = getLastBatchMigrations();
+  const lastBatch = await getLastBatchMigrations();
   if (lastBatch.length === 0) {
     console.log("  Nothing to rollback — no migrations have been applied.");
     return;
@@ -54,7 +54,7 @@ export async function migrateRollback(migrationDir?: string): Promise<void> {
 
   console.log(`  Rolling back batch ${lastBatch[0].batch} (${lastBatch.length} migration(s))...`);
 
-  const rolledBack = rollbackFn(dir);
+  const rolledBack = await rollbackFn(dir);
 
   if (rolledBack.length === 0) {
     console.log("  Nothing was rolled back.");

package/packages/core/src/logger.ts

@@ -190,7 +190,9 @@ export class Log {
       rotateKeep = isNaN(n) || n < 1 ? DEFAULT_ROTATE_KEEP : n;
     }
 
-    const levelEnv = (process.env.TINA4_LOG_LEVEL ?? "DEBUG").toUpperCase();
+    // v3.13.14: default level INFO (was DEBUG) — parity with Python/PHP/Ruby;
+    // surfaces request/startup/warn/error without debug noise in deploys.
+    const levelEnv = (process.env.TINA4_LOG_LEVEL ?? "INFO").toUpperCase();
     const minLevel = LEVEL_PRIORITY[levelEnv as LogLevel] ?? 0;
 
     const fmt = (process.env.TINA4_LOG_FORMAT ?? "text").trim().toLowerCase();
@@ -385,16 +387,27 @@ export class Log {
     const dataPart = data !== undefined ? ` ${JSON.stringify(data)}` : "";
     const humanLine = `${entry.timestamp} [${paddedLevel}]${reqPart}${fnPart} ${message}${dataPart}`;
 
-    // Build the file-format line based on TINA4_LOG_FORMAT
-    const fileLine = cfg.format === "json" ? JSON.stringify(entry) : humanLine;
+    // Build the file-format line. v3.13.14: production always emits JSON
+    // (parity with Python/Ruby) so log aggregators get structured lines;
+    // TINA4_LOG_FORMAT=json forces it in dev too.
+    const fileLine =
+      cfg.format === "json" || Log.isProduction() ? JSON.stringify(entry) : humanLine;
 
     const shouldLog = (LEVEL_PRIORITY[level] ?? 0) >= cfg.minLevel;
 
-    // Console output. TINA4_LOG_OUTPUT="file" disables stdout entirely;
-    // anything else (stdout, both) prints to console in dev, suppresses in prod.
-    if (shouldLog && cfg.output !== "file" && !Log.isProduction()) {
-      const color = COLORS[level];
-      console.log(`${color}${humanLine}${RESET}`);
+    // Console output. v3.13.14: stdout is NOT suppressed in production —
+    // containers read PID 1 stdout (docker logs / k8s) and the old
+    // `!isProduction()` gate meant deployed apps logged nothing. In
+    // production we print the clean structured line (JSON, no ANSI) so it
+    // stays parseable; in dev we keep the coloured human-readable line.
+    // TINA4_LOG_OUTPUT="file" still opts out of stdout entirely.
+    if (shouldLog && cfg.output !== "file") {
+      if (Log.isProduction()) {
+        console.log(fileLine);
+      } else {
+        const color = COLORS[level];
+        console.log(`${color}${humanLine}${RESET}`);
+      }
     }
 
     // File output: always teed for dev (legacy behaviour), and either always

package/packages/core/src/middleware.ts

@@ -1,5 +1,19 @@
 import type { Tina4Request, Tina4Response, Middleware } from "./types.js";
 import { validToken, getPayload } from "./auth.js";
+import { Log } from "./logger.js";
+import { isTruthy } from "./dotenv.js";
+
+/**
+ * Whether to emit a per-request log line (v3.13.14). TINA4_LOG_REQUESTS is
+ * the explicit control (true/false); when unset, request logging follows
+ * dev mode (on under TINA4_DEBUG, off in production). Same contract across
+ * all four frameworks.
+ */
+function requestLoggingEnabled(): boolean {
+  const val = process.env.TINA4_LOG_REQUESTS;
+  if (val !== undefined && val !== "") return isTruthy(val);
+  return isTruthy(process.env.TINA4_DEBUG);
+}
 
 export class MiddlewareChain {
   private middlewares: Middleware[] = [];
@@ -588,18 +602,25 @@ export class CsrfMiddleware {
   }
 }
 
-// Built-in request logger middleware (function form — kept for backwards compat)
+// Built-in request logger middleware.
+//
+// v3.13.14: routes through the Tina4 Log (was a bare console.log) so the
+// line gets the same timestamp/level treatment as every other log — human
+// in dev, structured JSON in production — and is gated by
+// requestLoggingEnabled() (on by default in dev, opt-in in prod via
+// TINA4_LOG_REQUESTS). Line format matches Python/PHP/Ruby:
+//   METHOD /path -> STATUS (Nms)
 export function requestLogger(): Middleware {
   return (req, res, next) => {
     const start = Date.now();
 
     res.raw.on("finish", () => {
+      if (!requestLoggingEnabled()) return;
       const duration = Date.now() - start;
       const status = res.raw.statusCode;
       const method = req.method ?? "?";
       const url = req.url ?? "/";
-      const color = status >= 400 ? "\x1b[31m" : status >= 300 ? "\x1b[33m" : "\x1b[32m";
-      console.log(`  ${color}${status}\x1b[0m ${method} ${url} \x1b[90m${duration}ms\x1b[0m`);
+      Log.info(`${method} ${url} -> ${status} (${duration}ms)`);
     });
 
     next();

package/packages/core/src/server.ts

@@ -832,7 +832,7 @@ ${reset}
       }
       if (models.length > 0) {
         console.log(`\n  Models discovered:`);
-        orm.syncModels(models);
+        await orm.syncModels(models);
         for (const { definition } of models) {
           console.log(`    \x1b[35m${definition.tableName}\x1b[0m (${Object.keys(definition.fields).length} fields)`);
         }

package/packages/orm/src/adapters/mssql.ts

@@ -344,14 +344,18 @@ export class MssqlAdapter implements DatabaseAdapter {
   }
 
   async columnsAsync(table: string): Promise<ColumnInfo[]> {
+    // v3.13.14 (#48): honour a schema-qualified name ("dbo.widget"); a bare
+    // name matches in any schema (NULL guard skips the schema filter).
+    const [schema, tbl] = SQLTranslator.splitSchema(table);
     const rows = await this.queryAsync<{
       COLUMN_NAME: string;
       DATA_TYPE: string;
       IS_NULLABLE: string;
       COLUMN_DEFAULT: string | null;
     }>(
-      "SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = ?",
-      [table],
+      "SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT FROM INFORMATION_SCHEMA.COLUMNS " +
+        "WHERE TABLE_NAME = ? AND (? IS NULL OR TABLE_SCHEMA = ?)",
+      [tbl, schema, schema],
     );
     return rows.map((r) => ({
       name: r.COLUMN_NAME,
@@ -378,9 +382,13 @@ export class MssqlAdapter implements DatabaseAdapter {
   }
 
   async tableExistsAsync(name: string): Promise<boolean> {
+    // v3.13.14 (#48): honour a schema-qualified name ("dbo.widget"); a bare
+    // name matches in any schema (NULL guard skips the schema filter).
+    const [schema, tbl] = SQLTranslator.splitSchema(name);
     const rows = await this.queryAsync<{ cnt: number }>(
-      "SELECT COUNT(*) AS cnt FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = ?",
-      [name],
+      "SELECT COUNT(*) AS cnt FROM INFORMATION_SCHEMA.TABLES " +
+        "WHERE TABLE_NAME = ? AND (? IS NULL OR TABLE_SCHEMA = ?)",
+      [tbl, schema, schema],
     );
     return (rows[0]?.cnt ?? 0) > 0;
   }

package/packages/orm/src/adapters/mysql.ts

@@ -262,13 +262,17 @@ export class MysqlAdapter implements DatabaseAdapter {
   }
 
   async columnsAsync(table: string): Promise<ColumnInfo[]> {
+    // v3.13.14 (#48): a qualified name ("db.table") must back-quote each part
+    // separately, otherwise the dot is read as part of one identifier.
+    const [schema, tbl] = SQLTranslator.splitSchema(table);
+    const target = schema ? `\`${schema}\`.\`${tbl}\`` : `\`${tbl}\``;
     const rows = await this.queryAsync<{
       Field: string;
       Type: string;
       Null: string;
       Default: string | null;
       Key: string;
-    }>(`DESCRIBE \`${table}\``);
+    }>(`DESCRIBE ${target}`);
     return rows.map((r) => ({
       name: r.Field,
       type: r.Type,
@@ -294,9 +298,14 @@ export class MysqlAdapter implements DatabaseAdapter {
   }
 
   async tableExistsAsync(name: string): Promise<boolean> {
-    const rows = await this.queryAsync<Record<string, string>>(
-      `SHOW TABLES LIKE ?`,
-      [name],
+    // v3.13.14 (#48): MySQL's "schema" is the database. A qualified name
+    // ("otherdb.table") checks that catalog; a bare name defaults to the
+    // connection's current database via DATABASE().
+    const [schema, tbl] = SQLTranslator.splitSchema(name);
+    const rows = await this.queryAsync<Record<string, unknown>>(
+      "SELECT 1 FROM information_schema.tables " +
+        "WHERE table_schema = COALESCE(?, DATABASE()) AND table_name = ?",
+      [schema, tbl],
     );
     return rows.length > 0;
   }

package/packages/orm/src/adapters/postgres.ts

@@ -249,10 +249,16 @@ export class PostgresAdapter implements DatabaseAdapter {
   }
 
   async tablesAsync(): Promise<string[]> {
-    const rows = await this.queryAsync<{ tablename: string }>(
-      "SELECT tablename FROM pg_tables WHERE schemaname = 'public'",
+    // v3.13.14 (#48): list every user schema; public tables stay bare, others
+    // are returned schema-qualified.
+    const rows = await this.queryAsync<{ schemaname: string; tablename: string }>(
+      "SELECT schemaname, tablename FROM pg_tables " +
+        "WHERE schemaname NOT IN ('pg_catalog', 'information_schema') " +
+        "ORDER BY schemaname, tablename",
+    );
+    return rows.map((r) =>
+      r.schemaname === "public" ? r.tablename : `${r.schemaname}.${r.tablename}`,
     );
-    return rows.map((r) => r.tablename);
   }
 
   columns(table: string): ColumnInfo[] {
@@ -260,14 +266,16 @@ export class PostgresAdapter implements DatabaseAdapter {
   }
 
   async columnsAsync(table: string): Promise<ColumnInfo[]> {
+    // v3.13.14 (#48): honour a schema-qualified name; default to public.
+    const [schema, tbl] = SQLTranslator.splitSchema(table);
     const rows = await this.queryAsync<{
       column_name: string;
       data_type: string;
       is_nullable: string;
       column_default: string | null;
     }>(
-      "SELECT column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_name = $1",
-      [table],
+      "SELECT column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_name = $1 AND table_schema = $2",
+      [tbl, schema ?? "public"],
     );
     return rows.map((r) => ({
       name: r.column_name,
@@ -294,11 +302,13 @@ export class PostgresAdapter implements DatabaseAdapter {
   }
 
   async tableExistsAsync(name: string): Promise<boolean> {
-    const row = await this.fetchOneAsync<{ exists: boolean }>(
-      "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = 'public' AND table_name = $1) AS exists",
+    // v3.13.14 (#48): to_regclass resolves a (possibly schema-qualified)
+    // relation name and search_path like a FROM clause; null if absent.
+    const row = await this.fetchOneAsync<{ oid: string | null }>(
+      "SELECT to_regclass($1) AS oid",
       [name],
     );
-    return row?.exists ?? false;
+    return (row?.oid ?? null) !== null;
   }
 
   createTable(name: string, columns: Record<string, FieldDefinition>): void {

package/packages/orm/src/adapters/sqlite.ts

@@ -2,6 +2,12 @@ import { DatabaseSync } from "node:sqlite";
 import { mkdirSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import type { DatabaseAdapter, DatabaseResult, ColumnInfo, FieldDefinition } from "../types.js";
+import { SQLTranslator } from "../sqlTranslation.js";
+
+/** A safe-to-interpolate SQL identifier (no quoting/escaping needed). */
+function isIdentifier(str: string): boolean {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(str);
+}
 
 /**
  * Resolve a SQLite path argument against the project root (cwd).
@@ -209,7 +215,14 @@ export class SQLiteAdapter implements DatabaseAdapter {
   }
 
   columns(table: string): ColumnInfo[] {
-    const rows = this.db.prepare(`PRAGMA table_info("${table}")`).all() as Array<{
+    // v3.13.14 (#48): a SQLite "schema" is an ATTACH alias ("extra.widget").
+    // PRAGMA accepts a schema prefix when both parts are plain identifiers.
+    const [schema, tbl] = SQLTranslator.splitSchema(table);
+    const pragma =
+      schema && isIdentifier(schema) && isIdentifier(tbl)
+        ? `PRAGMA ${schema}.table_info("${tbl}")`
+        : `PRAGMA table_info("${table}")`;
+    const rows = this.db.prepare(pragma).all() as Array<{
       name: string; type: string; notnull: number; dflt_value: unknown; pk: number;
     }>;
     return rows.map((r) => ({
@@ -221,7 +234,14 @@ export class SQLiteAdapter implements DatabaseAdapter {
   close(): void { this.db.close(); }
 
   tableExists(name: string): boolean {
-    const result = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(name);
+    // v3.13.14 (#48): a SQLite "schema" is an ATTACH alias ("extra.widget").
+    // Query that database's own sqlite_master when the prefix is a plain
+    // identifier; otherwise treat the whole string as a bare table name.
+    const [schema, tbl] = SQLTranslator.splitSchema(name);
+    const master = schema && isIdentifier(schema) ? `${schema}.sqlite_master` : "sqlite_master";
+    const result = this.db
+      .prepare(`SELECT name FROM ${master} WHERE type='table' AND name=?`)
+      .get(tbl);
     return !!result;
   }